agent-shim 8.2.0 → 8.3.0

package/dist/cli.cjs

@@ -7566,10 +7566,10 @@ var require_util2 = __commonJS({
       }
       return obj;
     }
-    function errorRequest(client, request6, err) {
+    function errorRequest(client, request7, err) {
       try {
-        request6.onError(err);
-        assert2(request6.aborted);
+        request7.onError(err);
+        assert2(request7.aborted);
       } catch (err2) {
         client.emit("error", err2);
       }
@@ -8243,7 +8243,7 @@ var require_request = __commonJS({
         return this;
       }
     };
-    function processHeader(request6, key, val) {
+    function processHeader(request7, key, val) {
       if (val && (typeof val === "object" && !Array.isArray(val))) {
         throw new InvalidArgumentError2(`invalid ${key} header`);
       } else if (val === void 0) {
@@ -8290,24 +8290,24 @@ var require_request = __commonJS({
         }
       }
       if (headerName === "host") {
-        if (request6.host !== null) {
+        if (request7.host !== null) {
           throw new InvalidArgumentError2("duplicate host header");
         }
         if (typeof val !== "string") {
           throw new InvalidArgumentError2("invalid host header");
         }
-        request6.host = val;
+        request7.host = val;
       } else if (headerName === "content-length") {
-        if (request6.contentLength !== null) {
+        if (request7.contentLength !== null) {
           throw new InvalidArgumentError2("duplicate content-length header");
         }
         if (!isValidContentLengthHeaderValue(val)) {
           throw new InvalidArgumentError2("invalid content-length header");
         }
-        request6.contentLength = parseInt(val, 10);
-      } else if (request6.contentType === null && headerName === "content-type") {
-        request6.contentType = val;
-        request6.headers.push(key, val);
+        request7.contentLength = parseInt(val, 10);
+      } else if (request7.contentType === null && headerName === "content-type") {
+        request7.contentType = val;
+        request7.headers.push(key, val);
       } else if (headerName === "transfer-encoding" || headerName === "keep-alive" || headerName === "upgrade") {
         throw new InvalidArgumentError2(`invalid ${headerName} header`);
       } else if (headerName === "connection") {
@@ -8321,13 +8321,13 @@ var require_request = __commonJS({
             throw new InvalidArgumentError2("invalid connection header");
           }
           if (trimmed === "close") {
-            request6.reset = true;
+            request7.reset = true;
           }
         }
       } else if (headerName === "expect") {
         throw new NotSupportedError("expect header not supported");
       } else {
-        request6.headers.push(key, val);
+        request7.headers.push(key, val);
       }
     }
     module2.exports = Request;
@@ -10920,11 +10920,11 @@ var require_util3 = __commonJS({
     function normalizeBinaryStringToUtf8(value) {
       return Buffer.from(value, "binary").toString("utf8");
     }
-    function requestCurrentURL(request6) {
-      return request6.urlList[request6.urlList.length - 1];
+    function requestCurrentURL(request7) {
+      return request7.urlList[request7.urlList.length - 1];
     }
-    function requestBadPort(request6) {
-      const url2 = requestCurrentURL(request6);
+    function requestBadPort(request7) {
+      const url2 = requestCurrentURL(request7);
       if (urlIsHttpHttpsScheme(url2) && badPortsSet.has(url2.port)) {
         return "blocked";
       }
@@ -10962,10 +10962,10 @@ var require_util3 = __commonJS({
       }
       return policy;
     }
-    function setRequestReferrerPolicyOnRedirect(request6, actualResponse) {
+    function setRequestReferrerPolicyOnRedirect(request7, actualResponse) {
       const policy = parseReferrerPolicy(actualResponse);
       if (policy !== "") {
-        request6.referrerPolicy = policy;
+        request7.referrerPolicy = policy;
       }
     }
     function crossOriginResourcePolicyCheck() {
@@ -10982,33 +10982,33 @@ var require_util3 = __commonJS({
       header = httpRequest.mode;
       httpRequest.headersList.set("sec-fetch-mode", header, true);
     }
-    function appendRequestOriginHeader(request6) {
-      let serializedOrigin = request6.origin;
+    function appendRequestOriginHeader(request7) {
+      let serializedOrigin = request7.origin;
       if (serializedOrigin === "client" || serializedOrigin === void 0) {
         return;
       }
-      if (request6.responseTainting === "cors" || request6.mode === "websocket") {
-        request6.headersList.append("origin", serializedOrigin, true);
-      } else if (request6.method !== "GET" && request6.method !== "HEAD") {
-        switch (request6.referrerPolicy) {
+      if (request7.responseTainting === "cors" || request7.mode === "websocket") {
+        request7.headersList.append("origin", serializedOrigin, true);
+      } else if (request7.method !== "GET" && request7.method !== "HEAD") {
+        switch (request7.referrerPolicy) {
           case "no-referrer":
             serializedOrigin = null;
             break;
           case "no-referrer-when-downgrade":
           case "strict-origin":
           case "strict-origin-when-cross-origin":
-            if (request6.origin && urlHasHttpsScheme(request6.origin) && !urlHasHttpsScheme(requestCurrentURL(request6))) {
+            if (request7.origin && urlHasHttpsScheme(request7.origin) && !urlHasHttpsScheme(requestCurrentURL(request7))) {
               serializedOrigin = null;
             }
             break;
           case "same-origin":
-            if (!sameOrigin(request6, requestCurrentURL(request6))) {
+            if (!sameOrigin(request7, requestCurrentURL(request7))) {
               serializedOrigin = null;
             }
             break;
           default:
         }
-        request6.headersList.append("origin", serializedOrigin, true);
+        request7.headersList.append("origin", serializedOrigin, true);
       }
     }
     function coarsenTime(timestamp, crossOriginIsolatedCapability) {
@@ -11062,18 +11062,18 @@ var require_util3 = __commonJS({
         referrerPolicy: policyContainer.referrerPolicy
       };
     }
-    function determineRequestsReferrer(request6) {
-      const policy = request6.referrerPolicy;
+    function determineRequestsReferrer(request7) {
+      const policy = request7.referrerPolicy;
       assert2(policy);
       let referrerSource = null;
-      if (request6.referrer === "client") {
+      if (request7.referrer === "client") {
         const globalOrigin = getGlobalOrigin();
         if (!globalOrigin || globalOrigin.origin === "null") {
           return "no-referrer";
         }
         referrerSource = new URL(globalOrigin);
-      } else if (webidl.is.URL(request6.referrer)) {
-        referrerSource = request6.referrer;
+      } else if (webidl.is.URL(request7.referrer)) {
+        referrerSource = request7.referrer;
       }
       let referrerURL = stripURLForReferrer(referrerSource);
       const referrerOrigin = stripURLForReferrer(referrerSource, true);
@@ -11091,14 +11091,14 @@ var require_util3 = __commonJS({
         case "unsafe-url":
           return referrerURL;
         case "strict-origin": {
-          const currentURL = requestCurrentURL(request6);
+          const currentURL = requestCurrentURL(request7);
           if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
             return "no-referrer";
           }
           return referrerOrigin;
         }
         case "strict-origin-when-cross-origin": {
-          const currentURL = requestCurrentURL(request6);
+          const currentURL = requestCurrentURL(request7);
           if (sameOrigin(referrerURL, currentURL)) {
             return referrerURL;
           }
@@ -11108,17 +11108,17 @@ var require_util3 = __commonJS({
           return referrerOrigin;
         }
         case "same-origin":
-          if (sameOrigin(request6, referrerURL)) {
+          if (sameOrigin(request7, referrerURL)) {
             return referrerURL;
           }
           return "no-referrer";
         case "origin-when-cross-origin":
-          if (sameOrigin(request6, referrerURL)) {
+          if (sameOrigin(request7, referrerURL)) {
             return referrerURL;
           }
           return referrerOrigin;
         case "no-referrer-when-downgrade": {
-          const currentURL = requestCurrentURL(request6);
+          const currentURL = requestCurrentURL(request7);
           if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
             return "no-referrer";
           }
@@ -11185,7 +11185,7 @@ var require_util3 = __commonJS({
       if (url2.protocol === "blob:") return true;
       return isOriginPotentiallyTrustworthy(url2.origin);
     }
-    function tryUpgradeRequestToAPotentiallyTrustworthyURL(request6) {
+    function tryUpgradeRequestToAPotentiallyTrustworthyURL(request7) {
     }
     function sameOrigin(A, B) {
       if (A.origin === B.origin && A.origin === "null") {
@@ -11564,7 +11564,7 @@ var require_util3 = __commonJS({
       }
       return gettingDecodingSplitting(value);
     }
-    function hasAuthenticationEntry(request6) {
+    function hasAuthenticationEntry(request7) {
       return false;
     }
     function includesCredentials(url2) {
@@ -12792,11 +12792,11 @@ var require_client_h1 = __commonJS({
           util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket)));
           return -1;
         }
-        const request6 = client[kQueue][client[kRunningIdx]];
-        if (!request6) {
+        const request7 = client[kQueue][client[kRunningIdx]];
+        if (!request7) {
           return -1;
         }
-        request6.onResponseStarted();
+        request7.onResponseStarted();
         return 0;
       }
       /**
@@ -12858,9 +12858,9 @@ var require_client_h1 = __commonJS({
         assert2(!socket.destroyed);
         assert2(!this.paused);
         assert2((headers.length & 1) === 0);
-        const request6 = client[kQueue][client[kRunningIdx]];
-        assert2(request6);
-        assert2(request6.upgrade || request6.method === "CONNECT");
+        const request7 = client[kQueue][client[kRunningIdx]];
+        assert2(request7);
+        assert2(request7.upgrade || request7.method === "CONNECT");
         this.statusCode = 0;
         this.statusText = "";
         this.shouldKeepAlive = false;
@@ -12877,7 +12877,7 @@ var require_client_h1 = __commonJS({
         client[kQueue][client[kRunningIdx]++] = null;
         client.emit("disconnect", client[kUrl], [client], new InformationalError("upgrade"));
         try {
-          request6.onUpgrade(statusCode, headers, socket);
+          request7.onUpgrade(statusCode, headers, socket);
         } catch (err) {
           util.destroy(socket, err);
         }
@@ -12898,8 +12898,8 @@ var require_client_h1 = __commonJS({
           util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket)));
           return -1;
         }
-        const request6 = client[kQueue][client[kRunningIdx]];
-        if (!request6) {
+        const request7 = client[kQueue][client[kRunningIdx]];
+        if (!request7) {
           return -1;
         }
         assert2(!this.upgrade);
@@ -12908,23 +12908,23 @@ var require_client_h1 = __commonJS({
           util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket)));
           return -1;
         }
-        if (upgrade && !request6.upgrade) {
+        if (upgrade && !request7.upgrade) {
           util.destroy(socket, new SocketError("bad upgrade", util.getSocketInfo(socket)));
           return -1;
         }
         assert2(this.timeoutType === TIMEOUT_HEADERS);
         this.statusCode = statusCode;
         this.shouldKeepAlive = shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD.
-        request6.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive";
+        request7.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive";
         if (this.statusCode >= 200) {
-          const bodyTimeout = request6.bodyTimeout != null ? request6.bodyTimeout : client[kBodyTimeout];
+          const bodyTimeout = request7.bodyTimeout != null ? request7.bodyTimeout : client[kBodyTimeout];
           this.setTimeout(bodyTimeout, TIMEOUT_BODY);
         } else if (this.timeout) {
           if (this.timeout.refresh) {
             this.timeout.refresh();
           }
         }
-        if (request6.method === "CONNECT") {
+        if (request7.method === "CONNECT") {
           assert2(client[kRunning] === 1);
           this.upgrade = true;
           return 2;
@@ -12955,11 +12955,11 @@ var require_client_h1 = __commonJS({
         } else {
           socket[kReset] = true;
         }
-        const pause = request6.onHeaders(statusCode, headers, this.resume, statusText) === false;
-        if (request6.aborted) {
+        const pause = request7.onHeaders(statusCode, headers, this.resume, statusText) === false;
+        if (request7.aborted) {
           return -1;
         }
-        if (request6.method === "HEAD") {
+        if (request7.method === "HEAD") {
           return 1;
         }
         if (statusCode < 200) {
@@ -12980,8 +12980,8 @@ var require_client_h1 = __commonJS({
         if (socket.destroyed) {
           return -1;
         }
-        const request6 = client[kQueue][client[kRunningIdx]];
-        assert2(request6);
+        const request7 = client[kQueue][client[kRunningIdx]];
+        assert2(request7);
         assert2(this.timeoutType === TIMEOUT_BODY);
         if (this.timeout) {
           if (this.timeout.refresh) {
@@ -12994,7 +12994,7 @@ var require_client_h1 = __commonJS({
           return -1;
         }
         this.bytesRead += buf.length;
-        if (request6.onData(buf) === false) {
+        if (request7.onData(buf) === false) {
           return constants.ERROR.PAUSED;
         }
         return 0;
@@ -13012,8 +13012,8 @@ var require_client_h1 = __commonJS({
         }
         assert2(statusCode >= 100);
         assert2((this.headers.length & 1) === 0);
-        const request6 = client[kQueue][client[kRunningIdx]];
-        assert2(request6);
+        const request7 = client[kQueue][client[kRunningIdx]];
+        assert2(request7);
         this.statusCode = 0;
         this.statusText = "";
         this.bytesRead = 0;
@@ -13025,11 +13025,11 @@ var require_client_h1 = __commonJS({
         if (statusCode < 200) {
           return 0;
         }
-        if (request6.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) {
+        if (request7.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) {
           util.destroy(socket, new ResponseContentLengthMismatchError());
           return -1;
         }
-        request6.onComplete(headers);
+        request7.onComplete(headers);
         client[kQueue][client[kRunningIdx]++] = null;
         socket[kSocketUsed] = client[kPending] === 0;
         if (socket[kWriting]) {
@@ -13098,8 +13098,8 @@ var require_client_h1 = __commonJS({
       return {
         version: "h1",
         defaultPipelining: 1,
-        write(request6) {
-          return writeH1(client, request6);
+        write(request7) {
+          return writeH1(client, request7);
         },
         resume() {
           resumeH1(client);
@@ -13126,18 +13126,18 @@ var require_client_h1 = __commonJS({
          * @param {import('../core/request.js')} request
          * @returns {boolean}
          */
-        busy(request6) {
+        busy(request7) {
           if (socket[kWriting] || socket[kReset] || socket[kBlocking] || socket[kIdleSocketValidation] === 1) {
             return true;
           }
-          if (request6) {
-            if (client[kRunning] > 0 && !request6.idempotent) {
+          if (request7) {
+            if (client[kRunning] > 0 && !request7.idempotent) {
               return true;
             }
-            if (client[kRunning] > 0 && (request6.upgrade || request6.method === "CONNECT")) {
+            if (client[kRunning] > 0 && (request7.upgrade || request7.method === "CONNECT")) {
               return true;
             }
-            if (client[kRunning] > 0 && util.bodyLength(request6.body) !== 0 && (util.isStream(request6.body) || util.isAsyncIterable(request6.body) || util.isFormDataLike(request6.body))) {
+            if (client[kRunning] > 0 && util.bodyLength(request7.body) !== 0 && (util.isStream(request7.body) || util.isAsyncIterable(request7.body) || util.isFormDataLike(request7.body))) {
               return true;
             }
           }
@@ -13191,13 +13191,13 @@ var require_client_h1 = __commonJS({
         assert2(client[kPending] === 0);
         const requests = client[kQueue].splice(client[kRunningIdx]);
         for (let i2 = 0; i2 < requests.length; i2++) {
-          const request6 = requests[i2];
-          util.errorRequest(client, request6, err);
+          const request7 = requests[i2];
+          util.errorRequest(client, request7, err);
         }
       } else if (client[kRunning] > 0 && err.code !== "UND_ERR_INFO") {
-        const request6 = client[kQueue][client[kRunningIdx]];
+        const request7 = client[kQueue][client[kRunningIdx]];
         client[kQueue][client[kRunningIdx]++] = null;
-        util.errorRequest(client, request6, err);
+        util.errorRequest(client, request7, err);
       }
       client[kPendingIdx] = client[kRunningIdx];
       assert2(client[kRunning] === 0);
@@ -13265,8 +13265,8 @@ var require_client_h1 = __commonJS({
           }
         } else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) {
           if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) {
-            const request6 = client[kQueue][client[kRunningIdx]];
-            const headersTimeout = request6.headersTimeout != null ? request6.headersTimeout : client[kHeadersTimeout];
+            const request7 = client[kQueue][client[kRunningIdx]];
+            const headersTimeout = request7.headersTimeout != null ? request7.headersTimeout : client[kHeadersTimeout];
             socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS);
           }
         }
@@ -13275,26 +13275,26 @@ var require_client_h1 = __commonJS({
     function shouldSendContentLength(method) {
       return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
     }
-    function writeH1(client, request6) {
-      const { method, path: path41, host, upgrade, blocking, reset } = request6;
-      let { body, headers, contentLength } = request6;
+    function writeH1(client, request7) {
+      const { method, path: path41, host, upgrade, blocking, reset } = request7;
+      let { body, headers, contentLength } = request7;
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
       if (util.isFormDataLike(body)) {
         if (!extractBody) {
           extractBody = require_body().extractBody;
         }
         const [bodyStream, contentType] = extractBody(body);
-        if (request6.contentType == null) {
+        if (request7.contentType == null) {
           headers.push("content-type", contentType);
         }
         body = bodyStream.stream;
         contentLength = bodyStream.length;
-      } else if (util.isBlobLike(body) && request6.contentType == null) {
+      } else if (util.isBlobLike(body) && request7.contentType == null) {
         const contentType = body.type;
         if (contentType) {
           const contentTypeValue = `${contentType}`;
           if (!util.isValidHeaderValue(contentTypeValue)) {
-            util.errorRequest(client, request6, new InvalidArgumentError2("invalid content-type header"));
+            util.errorRequest(client, request7, new InvalidArgumentError2("invalid content-type header"));
             return false;
           }
           headers.push("content-type", contentTypeValue);
@@ -13306,14 +13306,14 @@ var require_client_h1 = __commonJS({
       const bodyLength = util.bodyLength(body);
       contentLength = bodyLength ?? contentLength;
       if (contentLength === null) {
-        contentLength = request6.contentLength;
+        contentLength = request7.contentLength;
       }
       if (contentLength === 0 && !expectsPayload) {
         contentLength = null;
       }
-      if (shouldSendContentLength(method) && contentLength > 0 && request6.contentLength !== null && request6.contentLength !== contentLength) {
+      if (shouldSendContentLength(method) && contentLength > 0 && request7.contentLength !== null && request7.contentLength !== contentLength) {
         if (client[kStrictContentLength]) {
-          util.errorRequest(client, request6, new RequestContentLengthMismatchError());
+          util.errorRequest(client, request7, new RequestContentLengthMismatchError());
           return false;
         }
         process.emitWarning(new RequestContentLengthMismatchError());
@@ -13321,19 +13321,19 @@ var require_client_h1 = __commonJS({
       const socket = client[kSocket];
       clearIdleSocketValidation(socket);
       const abort = (err) => {
-        if (request6.aborted || request6.completed) {
+        if (request7.aborted || request7.completed) {
           return;
         }
-        util.errorRequest(client, request6, err || new RequestAbortedError());
+        util.errorRequest(client, request7, err || new RequestAbortedError());
         util.destroy(body);
         util.destroy(socket, new InformationalError("aborted"));
       };
       try {
-        request6.onConnect(abort);
+        request7.onConnect(abort);
       } catch (err) {
-        util.errorRequest(client, request6, err);
+        util.errorRequest(client, request7, err);
       }
-      if (request6.aborted) {
+      if (request7.aborted) {
         return false;
       }
       if (method === "HEAD") {
@@ -13352,7 +13352,7 @@ var require_client_h1 = __commonJS({
         socket[kBlocking] = true;
       }
       if (socket.setTypeOfService) {
-        socket.setTypeOfService(request6.typeOfService);
+        socket.setTypeOfService(request7.typeOfService);
       }
       let header = `${method} ${path41} HTTP/1.1\r
 `;
@@ -13387,31 +13387,31 @@ upgrade: ${upgrade}\r
         }
       }
       if (channels.sendHeaders.hasSubscribers) {
-        channels.sendHeaders.publish({ request: request6, headers: header, socket });
+        channels.sendHeaders.publish({ request: request7, headers: header, socket });
       }
       if (!body || bodyLength === 0) {
-        writeBuffer(abort, null, client, request6, socket, contentLength, header, expectsPayload);
+        writeBuffer(abort, null, client, request7, socket, contentLength, header, expectsPayload);
       } else if (util.isBuffer(body)) {
-        writeBuffer(abort, body, client, request6, socket, contentLength, header, expectsPayload);
+        writeBuffer(abort, body, client, request7, socket, contentLength, header, expectsPayload);
       } else if (util.isBlobLike(body)) {
         if (typeof body.stream === "function") {
-          writeIterable(abort, body.stream(), client, request6, socket, contentLength, header, expectsPayload);
+          writeIterable(abort, body.stream(), client, request7, socket, contentLength, header, expectsPayload);
         } else {
-          writeBlob(abort, body, client, request6, socket, contentLength, header, expectsPayload);
+          writeBlob(abort, body, client, request7, socket, contentLength, header, expectsPayload);
         }
       } else if (util.isStream(body)) {
-        writeStream(abort, body, client, request6, socket, contentLength, header, expectsPayload);
+        writeStream(abort, body, client, request7, socket, contentLength, header, expectsPayload);
       } else if (util.isIterable(body)) {
-        writeIterable(abort, body, client, request6, socket, contentLength, header, expectsPayload);
+        writeIterable(abort, body, client, request7, socket, contentLength, header, expectsPayload);
       } else {
         assert2(false);
       }
       return true;
     }
-    function writeStream(abort, body, client, request6, socket, contentLength, header, expectsPayload) {
+    function writeStream(abort, body, client, request7, socket, contentLength, header, expectsPayload) {
       assert2(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
       let finished = false;
-      const writer = new AsyncWriter({ abort, socket, request: request6, contentLength, client, expectsPayload, header });
+      const writer = new AsyncWriter({ abort, socket, request: request7, contentLength, client, expectsPayload, header });
       const onData = function(chunk) {
         if (finished) {
           return;
@@ -13477,7 +13477,7 @@ upgrade: ${upgrade}\r
         setImmediate(onClose);
       }
     }
-    function writeBuffer(abort, body, client, request6, socket, contentLength, header, expectsPayload) {
+    function writeBuffer(abort, body, client, request7, socket, contentLength, header, expectsPayload) {
       try {
         if (!body) {
           if (contentLength === 0) {
@@ -13497,18 +13497,18 @@ upgrade: ${upgrade}\r
 `, "latin1");
           socket.write(body);
           socket.uncork();
-          request6.onBodySent(body);
-          if (!expectsPayload && request6.reset !== false) {
+          request7.onBodySent(body);
+          if (!expectsPayload && request7.reset !== false) {
             socket[kReset] = true;
           }
         }
-        request6.onRequestSent();
+        request7.onRequestSent();
         client[kResume]();
       } catch (err) {
         abort(err);
       }
     }
-    async function writeBlob(abort, body, client, request6, socket, contentLength, header, expectsPayload) {
+    async function writeBlob(abort, body, client, request7, socket, contentLength, header, expectsPayload) {
       assert2(contentLength === body.size, "blob body must have content length");
       try {
         if (contentLength != null && contentLength !== body.size) {
@@ -13521,9 +13521,9 @@ upgrade: ${upgrade}\r
 `, "latin1");
         socket.write(buffer);
         socket.uncork();
-        request6.onBodySent(buffer);
-        request6.onRequestSent();
-        if (!expectsPayload && request6.reset !== false) {
+        request7.onBodySent(buffer);
+        request7.onRequestSent();
+        if (!expectsPayload && request7.reset !== false) {
           socket[kReset] = true;
         }
         client[kResume]();
@@ -13531,7 +13531,7 @@ upgrade: ${upgrade}\r
         abort(err);
       }
     }
-    async function writeIterable(abort, body, client, request6, socket, contentLength, header, expectsPayload) {
+    async function writeIterable(abort, body, client, request7, socket, contentLength, header, expectsPayload) {
       assert2(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined");
       let callback = null;
       function onDrain() {
@@ -13550,7 +13550,7 @@ upgrade: ${upgrade}\r
         }
       });
       socket.on("close", onDrain).on("drain", onDrain);
-      const writer = new AsyncWriter({ abort, socket, request: request6, contentLength, client, expectsPayload, header });
+      const writer = new AsyncWriter({ abort, socket, request: request7, contentLength, client, expectsPayload, header });
       try {
         for await (const chunk of body) {
           if (socket[kError]) {
@@ -13579,9 +13579,9 @@ upgrade: ${upgrade}\r
        * @param {boolean} arg.expectsPayload
        * @param {string} arg.header
        */
-      constructor({ abort, socket, request: request6, contentLength, client, expectsPayload, header }) {
+      constructor({ abort, socket, request: request7, contentLength, client, expectsPayload, header }) {
         this.socket = socket;
-        this.request = request6;
+        this.request = request7;
         this.contentLength = contentLength;
         this.client = client;
         this.bytesWritten = 0;
@@ -13595,7 +13595,7 @@ upgrade: ${upgrade}\r
        * @returns
        */
       write(chunk) {
-        const { socket, request: request6, contentLength, client, bytesWritten, expectsPayload, header } = this;
+        const { socket, request: request7, contentLength, client, bytesWritten, expectsPayload, header } = this;
         if (socket[kError]) {
           throw socket[kError];
         }
@@ -13614,7 +13614,7 @@ upgrade: ${upgrade}\r
         }
         socket.cork();
         if (bytesWritten === 0) {
-          if (!expectsPayload && request6.reset !== false) {
+          if (!expectsPayload && request7.reset !== false) {
             socket[kReset] = true;
           }
           if (contentLength === null) {
@@ -13634,7 +13634,7 @@ ${len.toString(16)}\r
         this.bytesWritten += len;
         const ret = socket.write(chunk);
         socket.uncork();
-        request6.onBodySent(chunk);
+        request7.onBodySent(chunk);
         if (!ret) {
           if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
             if (socket[kParser].timeout.refresh) {
@@ -13648,8 +13648,8 @@ ${len.toString(16)}\r
        * @returns {void}
        */
       end() {
-        const { socket, contentLength, client, bytesWritten, expectsPayload, header, request: request6 } = this;
-        request6.onRequestSent();
+        const { socket, contentLength, client, bytesWritten, expectsPayload, header, request: request7 } = this;
+        request7.onRequestSent();
         socket[kWriting] = false;
         if (socket[kError]) {
           throw socket[kError];
@@ -13829,8 +13829,8 @@ var require_client_h2 = __commonJS({
          * @param {import('../core/request.js')} request
          * @returns {boolean}
         */
-        write(request6) {
-          return writeH2(client, request6);
+        write(request7) {
+          return writeH2(client, request7);
         },
         /**
          * @returns {void}
@@ -13859,14 +13859,14 @@ var require_client_h2 = __commonJS({
          * @param {import('../core/request.js')} request
          * @returns {boolean}
         */
-        busy(request6) {
-          if (request6 != null) {
+        busy(request7) {
+          if (request7 != null) {
             if (client[kRunning] > 0) {
-              if (request6.idempotent === false) return true;
-              if ((request6.upgrade === "websocket" || request6.method === "CONNECT") && session[kRemoteSettings] === false) return true;
-              if (util.bodyLength(request6.body) !== 0 && (util.isStream(request6.body) || util.isAsyncIterable(request6.body) || util.isFormDataLike(request6.body))) return true;
+              if (request7.idempotent === false) return true;
+              if ((request7.upgrade === "websocket" || request7.method === "CONNECT") && session[kRemoteSettings] === false) return true;
+              if (util.bodyLength(request7.body) !== 0 && (util.isStream(request7.body) || util.isAsyncIterable(request7.body) || util.isFormDataLike(request7.body))) return true;
             } else {
-              return (request6.upgrade === "websocket" || request6.method === "CONNECT") && session[kRemoteSettings] === false;
+              return (request7.upgrade === "websocket" || request7.method === "CONNECT") && session[kRemoteSettings] === false;
             }
           }
           return false;
@@ -13942,15 +13942,15 @@ var require_client_h2 = __commonJS({
       this.destroy(err);
       util.destroy(this[kSocket], err);
     }
-    function completeRequest(client, request6, resetPendingIdx = false) {
+    function completeRequest(client, request7, resetPendingIdx = false) {
       const queue = client[kQueue];
       const runningIdx = client[kRunningIdx];
-      if (runningIdx < client[kPendingIdx] && queue[runningIdx] === request6) {
+      if (runningIdx < client[kPendingIdx] && queue[runningIdx] === request7) {
         queue[runningIdx] = null;
         client[kRunningIdx] = runningIdx + 1;
         return;
       }
-      const index = queue.indexOf(request6, runningIdx);
+      const index = queue.indexOf(request7, runningIdx);
       if (index === -1 || index >= client[kPendingIdx]) {
         return;
       }
@@ -13969,10 +13969,10 @@ var require_client_h2 = __commonJS({
       this[kHTTP2Session] = null;
       util.destroy(this[kSocket], err);
       if (client[kRunningIdx] < client[kQueue].length) {
-        const request6 = client[kQueue][client[kRunningIdx]];
+        const request7 = client[kQueue][client[kRunningIdx]];
         client[kQueue][client[kRunningIdx]++] = null;
-        if (request6 != null) {
-          util.errorRequest(client, request6, err);
+        if (request7 != null) {
+          util.errorRequest(client, request7, err);
         }
         client[kPendingIdx] = client[kRunningIdx];
       }
@@ -13995,9 +13995,9 @@ var require_client_h2 = __commonJS({
         assert2(client[kPending] === 0);
         const requests = client[kQueue].splice(client[kRunningIdx]);
         for (let i2 = 0; i2 < requests.length; i2++) {
-          const request6 = requests[i2];
-          if (request6 != null) {
-            util.errorRequest(client, request6, err);
+          const request7 = requests[i2];
+          if (request7 != null) {
+            util.errorRequest(client, request7, err);
           }
         }
       }
@@ -14029,14 +14029,14 @@ var require_client_h2 = __commonJS({
     function shouldSendContentLength(method) {
       return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
     }
-    function writeH2(client, request6) {
-      const headersTimeout = request6.headersTimeout ?? client[kHeadersTimeout];
-      const bodyTimeout = request6.bodyTimeout ?? client[kBodyTimeout];
+    function writeH2(client, request7) {
+      const headersTimeout = request7.headersTimeout ?? client[kHeadersTimeout];
+      const bodyTimeout = request7.bodyTimeout ?? client[kBodyTimeout];
       const session = client[kHTTP2Session];
-      const { method, path: path41, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request6;
-      let { body } = request6;
+      const { method, path: path41, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request7;
+      let { body } = request7;
       if (upgrade != null && upgrade !== "websocket") {
-        util.errorRequest(client, request6, new InvalidArgumentError2(`Custom upgrade "${upgrade}" not supported over HTTP/2`));
+        util.errorRequest(client, request7, new InvalidArgumentError2(`Custom upgrade "${upgrade}" not supported over HTTP/2`));
         return false;
       }
       const headers = {};
@@ -14070,33 +14070,33 @@ var require_client_h2 = __commonJS({
       headers[HTTP2_HEADER_AUTHORITY] = host || `${hostname3}${port ? `:${port}` : ""}`;
       headers[HTTP2_HEADER_METHOD] = method;
       const abort = (err) => {
-        if (request6.aborted || request6.completed) {
+        if (request7.aborted || request7.completed) {
           return;
         }
         err = err || new RequestAbortedError();
-        util.errorRequest(client, request6, err);
+        util.errorRequest(client, request7, err);
         if (stream != null) {
           stream.removeAllListeners("data");
           stream.close();
           client[kOnError](err);
-          completeRequest(client, request6);
+          completeRequest(client, request7);
           client[kResume]();
         }
         util.destroy(body, err);
       };
       try {
-        request6.onConnect(abort);
+        request7.onConnect(abort);
       } catch (err) {
-        util.errorRequest(client, request6, err);
+        util.errorRequest(client, request7, err);
       }
-      if (request6.aborted) {
+      if (request7.aborted) {
         return false;
       }
       if (upgrade || method === "CONNECT") {
         session.ref();
         if (upgrade === "websocket") {
           if (session[kEnableConnectProtocol] === false) {
-            util.errorRequest(client, request6, new InformationalError("HTTP/2: Extended CONNECT protocol not supported by server"));
+            util.errorRequest(client, request7, new InformationalError("HTTP/2: Extended CONNECT protocol not supported by server"));
             session.unref();
             return false;
           }
@@ -14112,9 +14112,9 @@ var require_client_h2 = __commonJS({
           stream[kHTTP2Stream] = true;
           stream.once("response", (headers2, _flags) => {
             const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2;
-            request6.onUpgrade(statusCode, parseH2Headers(realHeaders), stream);
+            request7.onUpgrade(statusCode, parseH2Headers(realHeaders), stream);
             ++session[kOpenStreams];
-            completeRequest(client, request6);
+            completeRequest(client, request7);
           });
           stream.on("error", () => {
             if (stream.rstCode === NGHTTP2_REFUSED_STREAM || stream.rstCode === NGHTTP2_CANCEL) {
@@ -14132,9 +14132,9 @@ var require_client_h2 = __commonJS({
         stream[kHTTP2Stream] = true;
         stream.on("response", (headers2) => {
           const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2;
-          request6.onUpgrade(statusCode, parseH2Headers(realHeaders), stream);
+          request7.onUpgrade(statusCode, parseH2Headers(realHeaders), stream);
           ++session[kOpenStreams];
-          completeRequest(client, request6);
+          completeRequest(client, request7);
         });
         stream.on("error", abort);
         stream.once("close", () => {
@@ -14159,14 +14159,14 @@ var require_client_h2 = __commonJS({
         contentLength = bodyStream.length;
       }
       if (contentLength == null) {
-        contentLength = request6.contentLength;
+        contentLength = request7.contentLength;
       }
       if (!expectsPayload) {
         contentLength = null;
       }
-      if (shouldSendContentLength(method) && contentLength > 0 && request6.contentLength != null && request6.contentLength !== contentLength) {
+      if (shouldSendContentLength(method) && contentLength > 0 && request7.contentLength != null && request7.contentLength !== contentLength) {
         if (client[kStrictContentLength]) {
-          util.errorRequest(client, request6, new RequestContentLengthMismatchError());
+          util.errorRequest(client, request7, new RequestContentLengthMismatchError());
           return false;
         }
         process.emitWarning(new RequestContentLengthMismatchError());
@@ -14182,7 +14182,7 @@ var require_client_h2 = __commonJS({
           header += `${key}: ${headers[key]}\r
 `;
         }
-        channels.sendHeaders.publish({ request: request6, headers: header, socket: session[kSocket] });
+        channels.sendHeaders.publish({ request: request7, headers: header, socket: session[kSocket] });
       }
       const shouldEndStream = method === "GET" || method === "HEAD" || body === null;
       if (expectContinue) {
@@ -14203,21 +14203,21 @@ var require_client_h2 = __commonJS({
       let responseReceived = false;
       stream.once("response", (headers2) => {
         const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2;
-        request6.onResponseStarted();
+        request7.onResponseStarted();
         responseReceived = true;
         stream.setTimeout(bodyTimeout);
-        if (request6.aborted) {
+        if (request7.aborted) {
           stream.removeAllListeners("data");
           return;
         }
-        if (request6.onHeaders(Number(statusCode), parseH2Headers(realHeaders), stream.resume.bind(stream), "") === false) {
+        if (request7.onHeaders(Number(statusCode), parseH2Headers(realHeaders), stream.resume.bind(stream), "") === false) {
           stream.pause();
         }
         stream.on("data", (chunk) => {
-          if (request6.aborted || request6.completed) {
+          if (request7.aborted || request7.completed) {
             return;
           }
-          if (request6.onData(chunk) === false) {
+          if (request7.onData(chunk) === false) {
             stream.pause();
           }
         });
@@ -14225,14 +14225,14 @@ var require_client_h2 = __commonJS({
       stream.once("end", () => {
         stream.removeAllListeners("data");
         if (responseReceived) {
-          if (!request6.aborted && !request6.completed) {
-            request6.onComplete({});
+          if (!request7.aborted && !request7.completed) {
+            request7.onComplete({});
           }
-          completeRequest(client, request6);
+          completeRequest(client, request7);
           client[kResume]();
         } else {
           abort(new InformationalError("HTTP/2: stream half-closed (remote)"));
-          completeRequest(client, request6, true);
+          completeRequest(client, request7, true);
           client[kResume]();
         }
       });
@@ -14242,7 +14242,7 @@ var require_client_h2 = __commonJS({
         if (session[kOpenStreams] === 0) {
           session.unref();
         }
-        if (!request6.aborted && !request6.completed) {
+        if (!request7.aborted && !request7.completed) {
           abort(new InformationalError("HTTP/2: stream closed before the response was complete"));
         }
       });
@@ -14267,11 +14267,11 @@ var require_client_h2 = __commonJS({
         abort(err);
       });
       stream.once("trailers", (trailers) => {
-        if (request6.aborted || request6.completed) {
+        if (request7.aborted || request7.completed) {
           return;
         }
         stream.removeAllListeners("data");
-        request6.onComplete(trailers);
+        request7.onComplete(trailers);
       });
       return true;
       function writeBodyH2() {
@@ -14281,7 +14281,7 @@ var require_client_h2 = __commonJS({
             stream,
             null,
             client,
-            request6,
+            request7,
             client[kSocket],
             contentLength,
             expectsPayload
@@ -14292,7 +14292,7 @@ var require_client_h2 = __commonJS({
             stream,
             body,
             client,
-            request6,
+            request7,
             client[kSocket],
             contentLength,
             expectsPayload
@@ -14304,7 +14304,7 @@ var require_client_h2 = __commonJS({
               stream,
               body.stream(),
               client,
-              request6,
+              request7,
               client[kSocket],
               contentLength,
               expectsPayload
@@ -14315,7 +14315,7 @@ var require_client_h2 = __commonJS({
               stream,
               body,
               client,
-              request6,
+              request7,
               client[kSocket],
               contentLength,
               expectsPayload
@@ -14329,7 +14329,7 @@ var require_client_h2 = __commonJS({
             stream,
             body,
             client,
-            request6,
+            request7,
             contentLength
           );
         } else if (util.isIterable(body)) {
@@ -14338,7 +14338,7 @@ var require_client_h2 = __commonJS({
             stream,
             body,
             client,
-            request6,
+            request7,
             client[kSocket],
             contentLength,
             expectsPayload
@@ -14348,7 +14348,7 @@ var require_client_h2 = __commonJS({
         }
       }
     }
-    function writeBuffer(abort, h2stream, body, client, request6, socket, contentLength, expectsPayload) {
+    function writeBuffer(abort, h2stream, body, client, request7, socket, contentLength, expectsPayload) {
       try {
         if (body != null && util.isBuffer(body)) {
           assert2(contentLength === body.byteLength, "buffer body must have content length");
@@ -14356,18 +14356,18 @@ var require_client_h2 = __commonJS({
           h2stream.write(body);
           h2stream.uncork();
           h2stream.end();
-          request6.onBodySent(body);
+          request7.onBodySent(body);
         }
         if (!expectsPayload) {
           socket[kReset] = true;
         }
-        request6.onRequestSent();
+        request7.onRequestSent();
         client[kResume]();
       } catch (error62) {
         abort(error62);
       }
     }
-    function writeStream(abort, socket, expectsPayload, h2stream, body, client, request6, contentLength) {
+    function writeStream(abort, socket, expectsPayload, h2stream, body, client, request7, contentLength) {
       assert2(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
       const pipe2 = pipeline(
         body,
@@ -14378,7 +14378,7 @@ var require_client_h2 = __commonJS({
             abort(err);
           } else {
             util.removeAllListeners(pipe2);
-            request6.onRequestSent();
+            request7.onRequestSent();
             if (!expectsPayload) {
               socket[kReset] = true;
             }
@@ -14388,10 +14388,10 @@ var require_client_h2 = __commonJS({
       );
       util.addListener(pipe2, "data", onPipeData);
       function onPipeData(chunk) {
-        request6.onBodySent(chunk);
+        request7.onBodySent(chunk);
       }
     }
-    async function writeBlob(abort, h2stream, body, client, request6, socket, contentLength, expectsPayload) {
+    async function writeBlob(abort, h2stream, body, client, request7, socket, contentLength, expectsPayload) {
       assert2(contentLength === body.size, "blob body must have content length");
       try {
         if (contentLength != null && contentLength !== body.size) {
@@ -14402,8 +14402,8 @@ var require_client_h2 = __commonJS({
         h2stream.write(buffer);
         h2stream.uncork();
         h2stream.end();
-        request6.onBodySent(buffer);
-        request6.onRequestSent();
+        request7.onBodySent(buffer);
+        request7.onRequestSent();
         if (!expectsPayload) {
           socket[kReset] = true;
         }
@@ -14412,7 +14412,7 @@ var require_client_h2 = __commonJS({
         abort(err);
       }
     }
-    async function writeIterable(abort, h2stream, body, client, request6, socket, contentLength, expectsPayload) {
+    async function writeIterable(abort, h2stream, body, client, request7, socket, contentLength, expectsPayload) {
       assert2(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined");
       let callback = null;
       function onDrain() {
@@ -14437,13 +14437,13 @@ var require_client_h2 = __commonJS({
             throw socket[kError];
           }
           const res = h2stream.write(chunk);
-          request6.onBodySent(chunk);
+          request7.onBodySent(chunk);
           if (!res) {
             await waitForDrain();
           }
         }
         h2stream.end();
-        request6.onRequestSent();
+        request7.onRequestSent();
         if (!expectsPayload) {
           socket[kReset] = true;
         }
@@ -14728,10 +14728,10 @@ var require_client = __commonJS({
         this.once("connect", cb);
       }
       [kDispatch](opts, handler) {
-        const request6 = new Request(this[kUrl].origin, opts, handler);
-        this[kQueue].push(request6);
+        const request7 = new Request(this[kUrl].origin, opts, handler);
+        this[kQueue].push(request7);
         if (this[kResuming]) {
-        } else if (util.bodyLength(request6.body) == null && util.isIterable(request6.body)) {
+        } else if (util.bodyLength(request7.body) == null && util.isIterable(request7.body)) {
           this[kResuming] = 1;
           queueMicrotask(() => resume(this));
         } else {
@@ -14755,9 +14755,9 @@ var require_client = __commonJS({
         return new Promise((resolve) => {
           const requests = this[kQueue].splice(this[kPendingIdx]);
           for (let i2 = 0; i2 < requests.length; i2++) {
-            const request6 = requests[i2];
-            if (request6 != null) {
-              util.errorRequest(this, request6, err);
+            const request7 = requests[i2];
+            if (request7 != null) {
+              util.errorRequest(this, request7, err);
             }
           }
           const callback = () => {
@@ -14782,9 +14782,9 @@ var require_client = __commonJS({
         assert2(client[kPendingIdx] === client[kRunningIdx]);
         const requests = client[kQueue].splice(client[kRunningIdx]);
         for (let i2 = 0; i2 < requests.length; i2++) {
-          const request6 = requests[i2];
-          if (request6 != null) {
-            util.errorRequest(client, request6, err);
+          const request7 = requests[i2];
+          if (request7 != null) {
+            util.errorRequest(client, request7, err);
           }
         }
         assert2(client[kSize] === 0);
@@ -14895,8 +14895,8 @@ var require_client = __commonJS({
       if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") {
         assert2(client[kRunning] === 0);
         while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
-          const request6 = client[kQueue][client[kPendingIdx]++];
-          util.errorRequest(client, request6, err);
+          const request7 = client[kQueue][client[kPendingIdx]++];
+          util.errorRequest(client, request7, err);
         }
       } else {
         onError(client, err);
@@ -14951,15 +14951,15 @@ var require_client = __commonJS({
         if (client[kRunning] >= (getPipelining(client) || 1)) {
           return;
         }
-        const request6 = client[kQueue][client[kPendingIdx]];
-        if (request6 === null) {
+        const request7 = client[kQueue][client[kPendingIdx]];
+        if (request7 === null) {
           return;
         }
-        if (client[kUrl].protocol === "https:" && client[kServerName] !== request6.servername) {
+        if (client[kUrl].protocol === "https:" && client[kServerName] !== request7.servername) {
           if (client[kRunning] > 0) {
             return;
           }
-          client[kServerName] = request6.servername;
+          client[kServerName] = request7.servername;
           client[kHTTPContext]?.destroy(new InformationalError("servername changed"), () => {
             client[kHTTPContext] = null;
             resume(client);
@@ -14975,10 +14975,10 @@ var require_client = __commonJS({
         if (client[kHTTPContext].destroyed) {
           return;
         }
-        if (client[kHTTPContext].busy(request6)) {
+        if (client[kHTTPContext].busy(request7)) {
           return;
         }
-        if (!request6.aborted && client[kHTTPContext].write(request6)) {
+        if (!request7.aborted && client[kHTTPContext].write(request7)) {
           client[kPendingIdx]++;
         } else {
           client[kQueue].splice(client[kPendingIdx], 1);
@@ -16030,13 +16030,13 @@ var require_socks5_client = __commonJS({
         }
         debug("starting handshake with", this.authMethods.length, "auth methods");
         this.state = STATES.HANDSHAKING;
-        const request6 = Buffer2.alloc(2 + this.authMethods.length);
-        request6[0] = SOCKS_VERSION;
-        request6[1] = this.authMethods.length;
+        const request7 = Buffer2.alloc(2 + this.authMethods.length);
+        request7[0] = SOCKS_VERSION;
+        request7[1] = this.authMethods.length;
         this.authMethods.forEach((method, i2) => {
-          request6[2 + i2] = method;
+          request7[2 + i2] = method;
         });
-        this.socket.write(request6);
+        this.socket.write(request7);
       }
       /**
        * Handle handshake response from server
@@ -16078,13 +16078,13 @@ var require_socks5_client = __commonJS({
         if (usernameBuffer.length > 255 || passwordBuffer.length > 255) {
           throw new InvalidArgumentError2("Username or password too long");
         }
-        const request6 = Buffer2.alloc(3 + usernameBuffer.length + passwordBuffer.length);
-        request6[0] = 1;
-        request6[1] = usernameBuffer.length;
-        usernameBuffer.copy(request6, 2);
-        request6[2 + usernameBuffer.length] = passwordBuffer.length;
-        passwordBuffer.copy(request6, 3 + usernameBuffer.length);
-        this.socket.write(request6);
+        const request7 = Buffer2.alloc(3 + usernameBuffer.length + passwordBuffer.length);
+        request7[0] = 1;
+        request7[1] = usernameBuffer.length;
+        usernameBuffer.copy(request7, 2);
+        request7[2 + usernameBuffer.length] = passwordBuffer.length;
+        passwordBuffer.copy(request7, 3 + usernameBuffer.length);
+        this.socket.write(request7);
       }
       /**
        * Handle authentication response
@@ -16119,22 +16119,22 @@ var require_socks5_client = __commonJS({
         }
         debug("connecting to", address, port);
         this.state = STATES.CONNECTING;
-        const request6 = this.buildConnectRequest(COMMANDS.CONNECT, address, port);
-        this.socket.write(request6);
+        const request7 = this.buildConnectRequest(COMMANDS.CONNECT, address, port);
+        this.socket.write(request7);
       }
       /**
        * Build a SOCKS5 request
        */
       buildConnectRequest(command, address, port) {
         const { type: addressType, buffer: addressBuffer } = parseAddress(address);
-        const request6 = Buffer2.alloc(4 + addressBuffer.length + 2);
-        request6[0] = SOCKS_VERSION;
-        request6[1] = command;
-        request6[2] = 0;
-        request6[3] = addressType;
-        addressBuffer.copy(request6, 4);
-        request6.writeUInt16BE(port, 4 + addressBuffer.length);
-        return request6;
+        const request7 = Buffer2.alloc(4 + addressBuffer.length + 2);
+        request7[0] = SOCKS_VERSION;
+        request7[1] = command;
+        request7[2] = 0;
+        request7[3] = addressType;
+        addressBuffer.copy(request7, 4);
+        request7.writeUInt16BE(port, 4 + addressBuffer.length);
+        return request7;
       }
       /**
        * Handle CONNECT response
@@ -17803,10 +17803,10 @@ var require_api_request = __commonJS({
         }
       }
     };
-    function request6(opts, callback) {
+    function request7(opts, callback) {
       if (callback === void 0) {
         return new Promise((resolve, reject) => {
-          request6.call(this, opts, (err, data) => {
+          request7.call(this, opts, (err, data) => {
             return err ? reject(err) : resolve(data);
           });
         });
@@ -17822,7 +17822,7 @@ var require_api_request = __commonJS({
         queueMicrotask(() => callback(err, { opaque }));
       }
     }
-    module2.exports = request6;
+    module2.exports = request7;
     module2.exports.RequestHandler = RequestHandler;
   }
 });
@@ -19805,8 +19805,8 @@ var require_snapshot_recorder = __commonJS({
         if (this.isUrlExcluded(requestOpts)) {
           return;
         }
-        const request6 = formatRequestKey(requestOpts, this.#headerFilters, this.matchOptions);
-        const hash2 = createRequestHash(request6);
+        const request7 = formatRequestKey(requestOpts, this.#headerFilters, this.matchOptions);
+        const hash2 = createRequestHash(request7);
         const normalizedHeaders = normalizeHeaders(response.headers);
         const responseData = {
           statusCode: response.statusCode,
@@ -19824,7 +19824,7 @@ var require_snapshot_recorder = __commonJS({
           existingSnapshot.timestamp = (/* @__PURE__ */ new Date()).toISOString();
         } else {
           this.#snapshots.set(hash2, {
-            request: request6,
+            request: request7,
             responses: [responseData],
             // Always store as array for consistency
             callCount: 0,
@@ -19858,8 +19858,8 @@ var require_snapshot_recorder = __commonJS({
         if (this.isUrlExcluded(requestOpts)) {
           return void 0;
         }
-        const request6 = formatRequestKey(requestOpts, this.#headerFilters, this.matchOptions);
-        const hash2 = createRequestHash(request6);
+        const request7 = formatRequestKey(requestOpts, this.#headerFilters, this.matchOptions);
+        const hash2 = createRequestHash(request7);
         const snapshot = this.#snapshots.get(hash2);
         if (!snapshot) return void 0;
         const currentCallCount = snapshot.callCount || 0;
@@ -19954,8 +19954,8 @@ var require_snapshot_recorder = __commonJS({
        * @returns {boolean} - True if snapshot was deleted, false if not found
        */
       deleteSnapshot(requestOpts) {
-        const request6 = formatRequestKey(requestOpts, this.#headerFilters, this.matchOptions);
-        const hash2 = createRequestHash(request6);
+        const request7 = formatRequestKey(requestOpts, this.#headerFilters, this.matchOptions);
+        const hash2 = createRequestHash(request7);
         return this.#snapshots.delete(hash2);
       }
       /**
@@ -19964,8 +19964,8 @@ var require_snapshot_recorder = __commonJS({
        * @returns {SnapshotInfo|null} - Snapshot information or null if not found
        */
       getSnapshotInfo(requestOpts) {
-        const request6 = formatRequestKey(requestOpts, this.#headerFilters, this.matchOptions);
-        const hash2 = createRequestHash(request6);
+        const request7 = formatRequestKey(requestOpts, this.#headerFilters, this.matchOptions);
+        const hash2 = createRequestHash(request7);
         const snapshot = this.#snapshots.get(hash2);
         if (!snapshot) return null;
         return {
@@ -20256,16 +20256,16 @@ var require_snapshot_agent = __commonJS({
        */
       #setupMockInterceptors() {
         for (const snapshot of this[kSnapshotRecorder].getSnapshots()) {
-          const { request: request6, responses, response } = snapshot;
-          const url2 = new URL(request6.url);
+          const { request: request7, responses, response } = snapshot;
+          const url2 = new URL(request7.url);
           const mockPool = this.get(url2.origin);
           const responseData = responses ? responses[0] : response;
           if (!responseData) continue;
           mockPool.intercept({
             path: url2.pathname + url2.search,
-            method: request6.method,
-            headers: request6.headers,
-            body: request6.body
+            method: request7.method,
+            headers: request7.headers,
+            body: request7.body
           }).reply(responseData.statusCode, responseData.body, {
             headers: responseData.headers,
             trailers: responseData.trailers
@@ -25566,7 +25566,7 @@ var require_request2 = __commonJS({
         webidl.argumentLengthCheck(arguments, 1, prefix);
         input2 = webidl.converters.RequestInfo(input2);
         init = webidl.converters.RequestInit(init);
-        let request6 = null;
+        let request7 = null;
         let fallbackMode = null;
         const baseUrl = environmentSettingsObject.settingsObject.baseUrl;
         let signal = null;
@@ -25583,18 +25583,18 @@ var require_request2 = __commonJS({
               "Request cannot be constructed from a URL that includes credentials: " + input2
             );
           }
-          request6 = makeRequest({ urlList: [parsedURL] });
+          request7 = makeRequest({ urlList: [parsedURL] });
           fallbackMode = "cors";
         } else {
           assert2(webidl.is.Request(input2));
-          request6 = input2.#state;
+          request7 = input2.#state;
           signal = input2.#signal;
           this.#dispatcher = init.dispatcher || input2.#dispatcher;
         }
         const origin = environmentSettingsObject.settingsObject.origin;
         let window = "client";
-        if (request6.window?.constructor?.name === "EnvironmentSettingsObject" && sameOrigin(request6.window, origin)) {
-          window = request6.window;
+        if (request7.window?.constructor?.name === "EnvironmentSettingsObject" && sameOrigin(request7.window, origin)) {
+          window = request7.window;
         }
         if (init.window != null) {
           throw new TypeError(`'window' option '${window}' must be null`);
@@ -25602,66 +25602,66 @@ var require_request2 = __commonJS({
         if ("window" in init) {
           window = "no-window";
         }
-        request6 = makeRequest({
+        request7 = makeRequest({
           // URL request’s URL.
           // undici implementation note: this is set as the first item in request's urlList in makeRequest
           // method request’s method.
-          method: request6.method,
+          method: request7.method,
           // header list A copy of request’s header list.
           // undici implementation note: headersList is cloned in makeRequest
-          headersList: request6.headersList,
+          headersList: request7.headersList,
           // unsafe-request flag Set.
-          unsafeRequest: request6.unsafeRequest,
+          unsafeRequest: request7.unsafeRequest,
           // client This’s relevant settings object.
           client: environmentSettingsObject.settingsObject,
           // window window.
           window,
           // priority request’s priority.
-          priority: request6.priority,
+          priority: request7.priority,
           // origin request’s origin. The propagation of the origin is only significant for navigation requests
           // being handled by a service worker. In this scenario a request can have an origin that is different
           // from the current client.
-          origin: request6.origin,
+          origin: request7.origin,
           // referrer request’s referrer.
-          referrer: request6.referrer,
+          referrer: request7.referrer,
           // referrer policy request’s referrer policy.
-          referrerPolicy: request6.referrerPolicy,
+          referrerPolicy: request7.referrerPolicy,
           // mode request’s mode.
-          mode: request6.mode,
+          mode: request7.mode,
           // credentials mode request’s credentials mode.
-          credentials: request6.credentials,
+          credentials: request7.credentials,
           // cache mode request’s cache mode.
-          cache: request6.cache,
+          cache: request7.cache,
           // redirect mode request’s redirect mode.
-          redirect: request6.redirect,
+          redirect: request7.redirect,
           // integrity metadata request’s integrity metadata.
-          integrity: request6.integrity,
+          integrity: request7.integrity,
           // keepalive request’s keepalive.
-          keepalive: request6.keepalive,
+          keepalive: request7.keepalive,
           // reload-navigation flag request’s reload-navigation flag.
-          reloadNavigation: request6.reloadNavigation,
+          reloadNavigation: request7.reloadNavigation,
           // history-navigation flag request’s history-navigation flag.
-          historyNavigation: request6.historyNavigation,
+          historyNavigation: request7.historyNavigation,
           // URL list A clone of request’s URL list.
-          urlList: [...request6.urlList]
+          urlList: [...request7.urlList]
         });
         const initHasKey = Object.keys(init).length !== 0;
         if (initHasKey) {
-          if (request6.mode === "navigate") {
-            request6.mode = "same-origin";
+          if (request7.mode === "navigate") {
+            request7.mode = "same-origin";
           }
-          request6.reloadNavigation = false;
-          request6.historyNavigation = false;
-          request6.origin = "client";
-          request6.referrer = "client";
-          request6.referrerPolicy = "";
-          request6.url = request6.urlList[request6.urlList.length - 1];
-          request6.urlList = [request6.url];
+          request7.reloadNavigation = false;
+          request7.historyNavigation = false;
+          request7.origin = "client";
+          request7.referrer = "client";
+          request7.referrerPolicy = "";
+          request7.url = request7.urlList[request7.urlList.length - 1];
+          request7.urlList = [request7.url];
         }
         if (init.referrer !== void 0) {
           const referrer = init.referrer;
           if (referrer === "") {
-            request6.referrer = "no-referrer";
+            request7.referrer = "no-referrer";
           } else {
             let parsedReferrer;
             try {
@@ -25670,14 +25670,14 @@ var require_request2 = __commonJS({
               throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err });
             }
             if (parsedReferrer.protocol === "about:" && parsedReferrer.hostname === "client" || origin && !sameOrigin(parsedReferrer, environmentSettingsObject.settingsObject.baseUrl)) {
-              request6.referrer = "client";
+              request7.referrer = "client";
             } else {
-              request6.referrer = parsedReferrer;
+              request7.referrer = parsedReferrer;
             }
           }
         }
         if (init.referrerPolicy !== void 0) {
-          request6.referrerPolicy = init.referrerPolicy;
+          request7.referrerPolicy = init.referrerPolicy;
         }
         let mode;
         if (init.mode !== void 0) {
@@ -25692,33 +25692,33 @@ var require_request2 = __commonJS({
           });
         }
         if (mode != null) {
-          request6.mode = mode;
+          request7.mode = mode;
         }
         if (init.credentials !== void 0) {
-          request6.credentials = init.credentials;
+          request7.credentials = init.credentials;
         }
         if (init.cache !== void 0) {
-          request6.cache = init.cache;
+          request7.cache = init.cache;
         }
-        if (request6.cache === "only-if-cached" && request6.mode !== "same-origin") {
+        if (request7.cache === "only-if-cached" && request7.mode !== "same-origin") {
           throw new TypeError(
             "'only-if-cached' can be set only with 'same-origin' mode"
           );
         }
         if (init.redirect !== void 0) {
-          request6.redirect = init.redirect;
+          request7.redirect = init.redirect;
         }
         if (init.integrity != null) {
-          request6.integrity = String(init.integrity);
+          request7.integrity = String(init.integrity);
         }
         if (init.keepalive !== void 0) {
-          request6.keepalive = Boolean(init.keepalive);
+          request7.keepalive = Boolean(init.keepalive);
         }
         if (init.method !== void 0) {
           let method = init.method;
           const mayBeNormalized = normalizedMethodRecords[method];
           if (mayBeNormalized !== void 0) {
-            request6.method = mayBeNormalized;
+            request7.method = mayBeNormalized;
           } else {
             if (!isValidHTTPToken(method)) {
               throw new TypeError(`'${method}' is not a valid HTTP method.`);
@@ -25728,9 +25728,9 @@ var require_request2 = __commonJS({
               throw new TypeError(`'${method}' HTTP method is unsupported.`);
             }
             method = normalizedMethodRecordsBase[upperCase] ?? method;
-            request6.method = method;
+            request7.method = method;
           }
-          if (!patchMethodWarning && request6.method === "patch") {
+          if (!patchMethodWarning && request7.method === "patch") {
             process.emitWarning("Using `patch` is highly likely to result in a `405 Method Not Allowed`. `PATCH` is much more likely to succeed.", {
               code: "UNDICI-FETCH-patch"
             });
@@ -25740,7 +25740,7 @@ var require_request2 = __commonJS({
         if (init.signal !== void 0) {
           signal = init.signal;
         }
-        this.#state = request6;
+        this.#state = request7;
         const ac = new AbortController();
         this.#signal = ac.signal;
         if (signal != null) {
@@ -25758,12 +25758,12 @@ var require_request2 = __commonJS({
           }
         }
         this.#headers = new Headers(kConstruct);
-        setHeadersList(this.#headers, request6.headersList);
+        setHeadersList(this.#headers, request7.headersList);
         setHeadersGuard(this.#headers, "request");
         if (mode === "no-cors") {
-          if (!corsSafeListedMethodsSet.has(request6.method)) {
+          if (!corsSafeListedMethodsSet.has(request7.method)) {
             throw new TypeError(
-              `'${request6.method} is unsupported in no-cors mode.`
+              `'${request7.method} is unsupported in no-cors mode.`
             );
           }
           setHeadersGuard(this.#headers, "request-no-cors");
@@ -25782,14 +25782,14 @@ var require_request2 = __commonJS({
           }
         }
         const inputBody = webidl.is.Request(input2) ? input2.#state.body : null;
-        if ((init.body != null || inputBody != null) && (request6.method === "GET" || request6.method === "HEAD")) {
+        if ((init.body != null || inputBody != null) && (request7.method === "GET" || request7.method === "HEAD")) {
           throw new TypeError("Request with GET/HEAD method cannot have body.");
         }
         let initBody = null;
         if (init.body != null) {
           const [extractedBody, contentType] = extractBody(
             init.body,
-            request6.keepalive
+            request7.keepalive
           );
           initBody = extractedBody;
           if (contentType && !getHeadersList(this.#headers).contains("content-type", true)) {
@@ -25801,12 +25801,12 @@ var require_request2 = __commonJS({
           if (initBody != null && init.duplex == null) {
             throw new TypeError("RequestInit: duplex option is required when sending a body.");
           }
-          if (request6.mode !== "same-origin" && request6.mode !== "cors") {
+          if (request7.mode !== "same-origin" && request7.mode !== "cors") {
             throw new TypeError(
               'If request is made from ReadableStream, mode should be "same-origin" or "cors"'
             );
           }
-          request6.useCORSPreflightFlag = true;
+          request7.useCORSPreflightFlag = true;
         }
         let finalBody = inputOrInitBody;
         if (initBody == null && inputBody != null) {
@@ -25996,42 +25996,42 @@ var require_request2 = __commonJS({
        * @param {Request} request
        * @param {AbortSignal} newSignal
        */
-      static setRequestSignal(request6, newSignal) {
-        request6.#signal = newSignal;
-        return request6;
+      static setRequestSignal(request7, newSignal) {
+        request7.#signal = newSignal;
+        return request7;
       }
       /**
        * @param {Request} request
        */
-      static getRequestDispatcher(request6) {
-        return request6.#dispatcher;
+      static getRequestDispatcher(request7) {
+        return request7.#dispatcher;
       }
       /**
        * @param {Request} request
        * @param {import('../../dispatcher/dispatcher')} newDispatcher
        */
-      static setRequestDispatcher(request6, newDispatcher) {
-        request6.#dispatcher = newDispatcher;
+      static setRequestDispatcher(request7, newDispatcher) {
+        request7.#dispatcher = newDispatcher;
       }
       /**
        * @param {Request} request
        * @param {Headers} newHeaders
        */
-      static setRequestHeaders(request6, newHeaders) {
-        request6.#headers = newHeaders;
+      static setRequestHeaders(request7, newHeaders) {
+        request7.#headers = newHeaders;
       }
       /**
        * @param {Request} request
        */
-      static getRequestState(request6) {
-        return request6.#state;
+      static getRequestState(request7) {
+        return request7.#state;
       }
       /**
        * @param {Request} request
        * @param {any} newState
        */
-      static setRequestState(request6, newState) {
-        request6.#state = newState;
+      static setRequestState(request7, newState) {
+        request7.#state = newState;
       }
     };
     var { setRequestSignal, getRequestDispatcher, setRequestDispatcher, setRequestHeaders, getRequestState, setRequestState } = Request;
@@ -26086,23 +26086,23 @@ var require_request2 = __commonJS({
         headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList()
       };
     }
-    function cloneRequest(request6) {
-      const newRequest = makeRequest({ ...request6, body: null });
-      if (request6.body != null) {
-        newRequest.body = cloneBody(request6.body);
+    function cloneRequest(request7) {
+      const newRequest = makeRequest({ ...request7, body: null });
+      if (request7.body != null) {
+        newRequest.body = cloneBody(request7.body);
       }
       return newRequest;
     }
     function fromInnerRequest(innerRequest, dispatcher, signal, guard) {
-      const request6 = new Request(kConstruct);
-      setRequestState(request6, innerRequest);
-      setRequestDispatcher(request6, dispatcher);
-      setRequestSignal(request6, signal);
+      const request7 = new Request(kConstruct);
+      setRequestState(request7, innerRequest);
+      setRequestDispatcher(request7, dispatcher);
+      setRequestSignal(request7, signal);
       const headers = new Headers(kConstruct);
-      setRequestHeaders(request6, headers);
+      setRequestHeaders(request7, headers);
       setHeadersList(headers, innerRequest.headersList);
       setHeadersGuard(headers, guard);
-      return request6;
+      return request7;
     }
     Object.defineProperties(Request.prototype, {
       method: kEnumerableProperty,
@@ -26494,14 +26494,14 @@ var require_fetch = __commonJS({
         p.reject(e);
         return p.promise;
       }
-      const request6 = getRequestState(requestObject);
+      const request7 = getRequestState(requestObject);
       if (requestObject.signal.aborted) {
-        abortFetch(p, request6, null, requestObject.signal.reason, null);
+        abortFetch(p, request7, null, requestObject.signal.reason, null);
         return p.promise;
       }
-      const globalObject = request6.client.globalObject;
+      const globalObject = request7.client.globalObject;
       if (globalObject?.constructor?.name === "ServiceWorkerGlobalScope") {
-        request6.serviceWorkers = "none";
+        request7.serviceWorkers = "none";
       }
       let responseObject = null;
       let locallyAborted = false;
@@ -26513,7 +26513,7 @@ var require_fetch = __commonJS({
           assert2(controller != null);
           controller.abort(requestObject.signal.reason);
           const realResponse = responseObject?.deref();
-          abortFetch(p, request6, realResponse, requestObject.signal.reason, controller.controller);
+          abortFetch(p, request7, realResponse, requestObject.signal.reason, controller.controller);
         }
       );
       const processResponse = (response) => {
@@ -26521,7 +26521,7 @@ var require_fetch = __commonJS({
           return;
         }
         if (response.aborted) {
-          abortFetch(p, request6, responseObject, controller.serializedAbortReason, controller.controller);
+          abortFetch(p, request7, responseObject, controller.serializedAbortReason, controller.controller);
           return;
         }
         if (response.type === "error") {
@@ -26533,7 +26533,7 @@ var require_fetch = __commonJS({
         p = null;
       };
       controller = fetching({
-        request: request6,
+        request: request7,
         processResponseEndOfBody: handleFetchDone,
         processResponse,
         dispatcher: getRequestDispatcher(requestObject),
@@ -26580,12 +26580,12 @@ var require_fetch = __commonJS({
       );
     }
     var markResourceTiming = performance.markResourceTiming;
-    function abortFetch(p, request6, responseObject, error62, controller) {
+    function abortFetch(p, request7, responseObject, error62, controller) {
       if (p) {
         p.reject(error62);
       }
-      if (request6.body?.stream != null && isReadable(request6.body.stream)) {
-        request6.body.stream.cancel(error62).catch((err) => {
+      if (request7.body?.stream != null && isReadable(request7.body.stream)) {
+        request7.body.stream.cancel(error62).catch((err) => {
           if (err.code === "ERR_INVALID_STATE") {
             return;
           }
@@ -26601,7 +26601,7 @@ var require_fetch = __commonJS({
       }
     }
     function fetching({
-      request: request6,
+      request: request7,
       processRequestBodyChunkLength,
       processRequestEndOfBody,
       processResponse,
@@ -26616,9 +26616,9 @@ var require_fetch = __commonJS({
       assert2(dispatcher);
       let taskDestination = null;
       let crossOriginIsolatedCapability = false;
-      if (request6.client != null) {
-        taskDestination = request6.client.globalObject;
-        crossOriginIsolatedCapability = request6.client.crossOriginIsolatedCapability;
+      if (request7.client != null) {
+        taskDestination = request7.client.globalObject;
+        crossOriginIsolatedCapability = request7.client.crossOriginIsolatedCapability;
       }
       const currentTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability);
       const timingInfo = createOpaqueTimingInfo({
@@ -26626,7 +26626,7 @@ var require_fetch = __commonJS({
       });
       const fetchParams = {
         controller: new Fetch(dispatcher),
-        request: request6,
+        request: request7,
         timingInfo,
         processRequestBodyChunkLength,
         processRequestEndOfBody,
@@ -26638,79 +26638,79 @@ var require_fetch = __commonJS({
         // Keep requestObject alive to prevent its AbortController from being GC'd
         requestObject
       };
-      assert2(!request6.body || request6.body.stream);
-      if (request6.window === "client") {
-        request6.window = request6.client?.globalObject?.constructor?.name === "Window" ? request6.client : "no-window";
+      assert2(!request7.body || request7.body.stream);
+      if (request7.window === "client") {
+        request7.window = request7.client?.globalObject?.constructor?.name === "Window" ? request7.client : "no-window";
       }
-      if (request6.origin === "client") {
-        request6.origin = request6.client.origin;
+      if (request7.origin === "client") {
+        request7.origin = request7.client.origin;
       }
-      if (request6.policyContainer === "client") {
-        if (request6.client != null) {
-          request6.policyContainer = clonePolicyContainer(
-            request6.client.policyContainer
+      if (request7.policyContainer === "client") {
+        if (request7.client != null) {
+          request7.policyContainer = clonePolicyContainer(
+            request7.client.policyContainer
           );
         } else {
-          request6.policyContainer = makePolicyContainer();
+          request7.policyContainer = makePolicyContainer();
         }
       }
-      if (!request6.headersList.contains("accept", true)) {
+      if (!request7.headersList.contains("accept", true)) {
         const value = "*/*";
-        request6.headersList.append("accept", value, true);
+        request7.headersList.append("accept", value, true);
       }
-      if (!request6.headersList.contains("accept-language", true)) {
-        request6.headersList.append("accept-language", "*", true);
+      if (!request7.headersList.contains("accept-language", true)) {
+        request7.headersList.append("accept-language", "*", true);
       }
-      if (request6.priority === null) {
+      if (request7.priority === null) {
       }
-      if (subresourceSet.has(request6.destination)) {
+      if (subresourceSet.has(request7.destination)) {
       }
       mainFetch(fetchParams, false);
       return fetchParams.controller;
     }
     async function mainFetch(fetchParams, recursive2) {
       try {
-        const request6 = fetchParams.request;
+        const request7 = fetchParams.request;
         let response = null;
-        if (request6.localURLsOnly && !urlIsLocal(requestCurrentURL(request6))) {
+        if (request7.localURLsOnly && !urlIsLocal(requestCurrentURL(request7))) {
           response = makeNetworkError("local URLs only");
         }
-        tryUpgradeRequestToAPotentiallyTrustworthyURL(request6);
-        if (requestBadPort(request6) === "blocked") {
+        tryUpgradeRequestToAPotentiallyTrustworthyURL(request7);
+        if (requestBadPort(request7) === "blocked") {
           response = makeNetworkError("bad port");
         }
-        if (request6.referrerPolicy === "") {
-          request6.referrerPolicy = request6.policyContainer.referrerPolicy;
+        if (request7.referrerPolicy === "") {
+          request7.referrerPolicy = request7.policyContainer.referrerPolicy;
         }
-        if (request6.referrer !== "no-referrer") {
-          request6.referrer = determineRequestsReferrer(request6);
+        if (request7.referrer !== "no-referrer") {
+          request7.referrer = determineRequestsReferrer(request7);
         }
         if (response === null) {
-          const currentURL = requestCurrentURL(request6);
+          const currentURL = requestCurrentURL(request7);
           if (
             // - request’s current URL’s origin is same origin with request’s origin,
             //   and request’s response tainting is "basic"
-            sameOrigin(currentURL, request6.url) && request6.responseTainting === "basic" || // request’s current URL’s scheme is "data"
+            sameOrigin(currentURL, request7.url) && request7.responseTainting === "basic" || // request’s current URL’s scheme is "data"
             currentURL.protocol === "data:" || // - request’s mode is "navigate" or "websocket"
-            (request6.mode === "navigate" || request6.mode === "websocket")
+            (request7.mode === "navigate" || request7.mode === "websocket")
           ) {
-            request6.responseTainting = "basic";
+            request7.responseTainting = "basic";
             response = await schemeFetch(fetchParams);
-          } else if (request6.mode === "same-origin") {
+          } else if (request7.mode === "same-origin") {
             response = makeNetworkError('request mode cannot be "same-origin"');
-          } else if (request6.mode === "no-cors") {
-            if (request6.redirect !== "follow") {
+          } else if (request7.mode === "no-cors") {
+            if (request7.redirect !== "follow") {
               response = makeNetworkError(
                 'redirect mode cannot be "follow" for "no-cors" request'
               );
             } else {
-              request6.responseTainting = "opaque";
+              request7.responseTainting = "opaque";
               response = await schemeFetch(fetchParams);
             }
-          } else if (!urlIsHttpHttpsScheme(requestCurrentURL(request6))) {
+          } else if (!urlIsHttpHttpsScheme(requestCurrentURL(request7))) {
             response = makeNetworkError("URL scheme must be a HTTP(S) scheme");
           } else {
-            request6.responseTainting = "cors";
+            request7.responseTainting = "cors";
             response = await httpFetch(fetchParams);
           }
         }
@@ -26718,13 +26718,13 @@ var require_fetch = __commonJS({
           return response;
         }
         if (response.status !== 0 && !response.internalResponse) {
-          if (request6.responseTainting === "cors") {
+          if (request7.responseTainting === "cors") {
           }
-          if (request6.responseTainting === "basic") {
+          if (request7.responseTainting === "basic") {
             response = filterResponse(response, "basic");
-          } else if (request6.responseTainting === "cors") {
+          } else if (request7.responseTainting === "cors") {
             response = filterResponse(response, "cors");
-          } else if (request6.responseTainting === "opaque") {
+          } else if (request7.responseTainting === "opaque") {
             response = filterResponse(response, "opaque");
           } else {
             assert2(false);
@@ -26732,26 +26732,26 @@ var require_fetch = __commonJS({
         }
         let internalResponse = response.status === 0 ? response : response.internalResponse;
         if (internalResponse.urlList.length === 0) {
-          internalResponse.urlList.push(...request6.urlList);
+          internalResponse.urlList.push(...request7.urlList);
         }
-        if (!request6.timingAllowFailed) {
+        if (!request7.timingAllowFailed) {
           response.timingAllowPassed = true;
         }
-        if (response.type === "opaque" && internalResponse.status === 206 && internalResponse.rangeRequested && !request6.headers.contains("range", true)) {
+        if (response.type === "opaque" && internalResponse.status === 206 && internalResponse.rangeRequested && !request7.headers.contains("range", true)) {
           response = internalResponse = makeNetworkError();
         }
-        if (response.status !== 0 && (request6.method === "HEAD" || request6.method === "CONNECT" || nullBodyStatus.includes(internalResponse.status))) {
+        if (response.status !== 0 && (request7.method === "HEAD" || request7.method === "CONNECT" || nullBodyStatus.includes(internalResponse.status))) {
           internalResponse.body = null;
           fetchParams.controller.dump = true;
         }
-        if (request6.integrity) {
+        if (request7.integrity) {
           const processBodyError = (reason) => fetchFinale(fetchParams, makeNetworkError(reason));
-          if (request6.responseTainting === "opaque" || response.body == null) {
+          if (request7.responseTainting === "opaque" || response.body == null) {
             processBodyError(response.error);
             return;
           }
           const processBody = (bytes) => {
-            if (!bytesMatch(bytes, request6.integrity)) {
+            if (!bytesMatch(bytes, request7.integrity)) {
               processBodyError("integrity mismatch");
               return;
             }
@@ -26770,8 +26770,8 @@ var require_fetch = __commonJS({
       if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) {
         return Promise.resolve(makeAppropriateNetworkError(fetchParams));
       }
-      const { request: request6 } = fetchParams;
-      const { protocol: scheme } = requestCurrentURL(request6);
+      const { request: request7 } = fetchParams;
+      const { protocol: scheme } = requestCurrentURL(request7);
       switch (scheme) {
         case "about:": {
           return Promise.resolve(makeNetworkError("about scheme is not supported"));
@@ -26780,19 +26780,19 @@ var require_fetch = __commonJS({
           if (!resolveObjectURL) {
             resolveObjectURL = require("node:buffer").resolveObjectURL;
           }
-          const blobURLEntry = requestCurrentURL(request6);
+          const blobURLEntry = requestCurrentURL(request7);
           if (blobURLEntry.search.length !== 0) {
             return Promise.resolve(makeNetworkError("NetworkError when attempting to fetch resource."));
           }
           const blob = resolveObjectURL(blobURLEntry.toString());
-          if (request6.method !== "GET" || !webidl.is.Blob(blob)) {
+          if (request7.method !== "GET" || !webidl.is.Blob(blob)) {
             return Promise.resolve(makeNetworkError("invalid method"));
           }
           const response = makeResponse();
           const fullLength = blob.size;
           const serializedFullLength = isomorphicEncode(`${fullLength}`);
           const type = blob.type;
-          if (!request6.headersList.contains("range", true)) {
+          if (!request7.headersList.contains("range", true)) {
             const bodyWithType = extractBody(blob);
             response.statusText = "OK";
             response.body = bodyWithType[0];
@@ -26800,7 +26800,7 @@ var require_fetch = __commonJS({
             response.headersList.set("content-type", type, true);
           } else {
             response.rangeRequested = true;
-            const rangeHeader = request6.headersList.get("range", true);
+            const rangeHeader = request7.headersList.get("range", true);
             const rangeValue = simpleRangeHeaderValue(rangeHeader, true);
             if (rangeValue === "failure") {
               return Promise.resolve(makeNetworkError("failed to fetch the data URL"));
@@ -26831,7 +26831,7 @@ var require_fetch = __commonJS({
           return Promise.resolve(response);
         }
         case "data:": {
-          const currentURL = requestCurrentURL(request6);
+          const currentURL = requestCurrentURL(request7);
           const dataURLStruct = dataURLProcessor(currentURL);
           if (dataURLStruct === "failure") {
             return Promise.resolve(makeNetworkError("failed to fetch the data URL"));
@@ -26920,41 +26920,41 @@ var require_fetch = __commonJS({
       }
     }
     async function httpFetch(fetchParams) {
-      const request6 = fetchParams.request;
+      const request7 = fetchParams.request;
       let response = null;
       let actualResponse = null;
       const timingInfo = fetchParams.timingInfo;
-      if (request6.serviceWorkers === "all") {
+      if (request7.serviceWorkers === "all") {
       }
       if (response === null) {
-        if (request6.redirect === "follow") {
-          request6.serviceWorkers = "none";
+        if (request7.redirect === "follow") {
+          request7.serviceWorkers = "none";
         }
         actualResponse = response = await httpNetworkOrCacheFetch(fetchParams);
-        if (request6.responseTainting === "cors" && corsCheck(request6, response) === "failure") {
+        if (request7.responseTainting === "cors" && corsCheck(request7, response) === "failure") {
           return makeNetworkError("cors failure");
         }
-        if (TAOCheck(request6, response) === "failure") {
-          request6.timingAllowFailed = true;
+        if (TAOCheck(request7, response) === "failure") {
+          request7.timingAllowFailed = true;
         }
       }
-      if ((request6.responseTainting === "opaque" || response.type === "opaque") && crossOriginResourcePolicyCheck(
-        request6.origin,
-        request6.client,
-        request6.destination,
+      if ((request7.responseTainting === "opaque" || response.type === "opaque") && crossOriginResourcePolicyCheck(
+        request7.origin,
+        request7.client,
+        request7.destination,
         actualResponse
       ) === "blocked") {
         return makeNetworkError("blocked");
       }
       if (redirectStatusSet.has(actualResponse.status)) {
-        if (request6.redirect !== "manual") {
+        if (request7.redirect !== "manual") {
           fetchParams.controller.connection.destroy(void 0, false);
         }
-        if (request6.redirect === "error") {
+        if (request7.redirect === "error") {
           response = makeNetworkError("unexpected redirect");
-        } else if (request6.redirect === "manual") {
+        } else if (request7.redirect === "manual") {
           response = actualResponse;
-        } else if (request6.redirect === "follow") {
+        } else if (request7.redirect === "follow") {
           response = await httpRedirectFetch(fetchParams, response);
         } else {
           assert2(false);
@@ -26964,13 +26964,13 @@ var require_fetch = __commonJS({
       return response;
     }
     function httpRedirectFetch(fetchParams, response) {
-      const request6 = fetchParams.request;
+      const request7 = fetchParams.request;
       const actualResponse = response.internalResponse ? response.internalResponse : response;
       let locationURL;
       try {
         locationURL = responseLocationURL(
           actualResponse,
-          requestCurrentURL(request6).hash
+          requestCurrentURL(request7).hash
         );
         if (locationURL == null) {
           return response;
@@ -26981,63 +26981,63 @@ var require_fetch = __commonJS({
       if (!urlIsHttpHttpsScheme(locationURL)) {
         return Promise.resolve(makeNetworkError("URL scheme must be a HTTP(S) scheme"));
       }
-      if (request6.redirectCount === 20) {
+      if (request7.redirectCount === 20) {
         return Promise.resolve(makeNetworkError("redirect count exceeded"));
       }
-      request6.redirectCount += 1;
-      if (request6.mode === "cors" && (locationURL.username || locationURL.password) && !sameOrigin(request6, locationURL)) {
+      request7.redirectCount += 1;
+      if (request7.mode === "cors" && (locationURL.username || locationURL.password) && !sameOrigin(request7, locationURL)) {
         return Promise.resolve(makeNetworkError('cross origin not allowed for request mode "cors"'));
       }
-      if (request6.responseTainting === "cors" && (locationURL.username || locationURL.password)) {
+      if (request7.responseTainting === "cors" && (locationURL.username || locationURL.password)) {
         return Promise.resolve(makeNetworkError(
           'URL cannot contain credentials for request mode "cors"'
         ));
       }
-      if (actualResponse.status !== 303 && request6.body != null && request6.body.source == null) {
+      if (actualResponse.status !== 303 && request7.body != null && request7.body.source == null) {
         return Promise.resolve(makeNetworkError());
       }
-      if ([301, 302].includes(actualResponse.status) && request6.method === "POST" || actualResponse.status === 303 && !GET_OR_HEAD.includes(request6.method)) {
-        request6.method = "GET";
-        request6.body = null;
+      if ([301, 302].includes(actualResponse.status) && request7.method === "POST" || actualResponse.status === 303 && !GET_OR_HEAD.includes(request7.method)) {
+        request7.method = "GET";
+        request7.body = null;
         for (const headerName of requestBodyHeader) {
-          request6.headersList.delete(headerName);
+          request7.headersList.delete(headerName);
         }
       }
-      if (!sameOrigin(requestCurrentURL(request6), locationURL)) {
-        request6.headersList.delete("authorization", true);
-        request6.headersList.delete("proxy-authorization", true);
-        request6.headersList.delete("cookie", true);
-        request6.headersList.delete("host", true);
+      if (!sameOrigin(requestCurrentURL(request7), locationURL)) {
+        request7.headersList.delete("authorization", true);
+        request7.headersList.delete("proxy-authorization", true);
+        request7.headersList.delete("cookie", true);
+        request7.headersList.delete("host", true);
       }
-      if (request6.body != null) {
-        assert2(request6.body.source != null);
-        request6.body = safelyExtractBody(request6.body.source)[0];
+      if (request7.body != null) {
+        assert2(request7.body.source != null);
+        request7.body = safelyExtractBody(request7.body.source)[0];
       }
       const timingInfo = fetchParams.timingInfo;
       timingInfo.redirectEndTime = timingInfo.postRedirectStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability);
       if (timingInfo.redirectStartTime === 0) {
         timingInfo.redirectStartTime = timingInfo.startTime;
       }
-      request6.urlList.push(locationURL);
-      setRequestReferrerPolicyOnRedirect(request6, actualResponse);
+      request7.urlList.push(locationURL);
+      setRequestReferrerPolicyOnRedirect(request7, actualResponse);
       return mainFetch(fetchParams, true);
     }
     async function httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch = false, isNewConnectionFetch = false) {
-      const request6 = fetchParams.request;
+      const request7 = fetchParams.request;
       let httpFetchParams = null;
       let httpRequest = null;
       let response = null;
       const httpCache = null;
       const revalidatingFlag = false;
-      if (request6.window === "no-window" && request6.redirect === "error") {
+      if (request7.window === "no-window" && request7.redirect === "error") {
         httpFetchParams = fetchParams;
-        httpRequest = request6;
+        httpRequest = request7;
       } else {
-        httpRequest = cloneRequest(request6);
+        httpRequest = cloneRequest(request7);
         httpFetchParams = { ...fetchParams };
         httpFetchParams.request = httpRequest;
       }
-      const includeCredentials = request6.credentials === "include" || request6.credentials === "same-origin" && request6.responseTainting === "basic";
+      const includeCredentials = request7.credentials === "include" || request7.credentials === "same-origin" && request7.responseTainting === "basic";
       const contentLength = httpRequest.body ? httpRequest.body.length : null;
       let contentLengthHeaderValue = null;
       if (httpRequest.body == null && ["POST", "PUT"].includes(httpRequest.method)) {
@@ -27124,14 +27124,14 @@ var require_fetch = __commonJS({
         response.rangeRequested = true;
       }
       response.requestIncludesCredentials = includeCredentials;
-      if (response.status === 401 && httpRequest.responseTainting !== "cors" && includeCredentials && (request6.useURLCredentials !== void 0 || isTraversableNavigable(request6.traversableForUserPrompts))) {
-        if (request6.body != null) {
-          if (request6.body.source == null) {
+      if (response.status === 401 && httpRequest.responseTainting !== "cors" && includeCredentials && (request7.useURLCredentials !== void 0 || isTraversableNavigable(request7.traversableForUserPrompts))) {
+        if (request7.body != null) {
+          if (request7.body.source == null) {
             return response;
           }
-          request6.body = safelyExtractBody(request6.body.source)[0];
+          request7.body = safelyExtractBody(request7.body.source)[0];
         }
-        if (request6.useURLCredentials === void 0 || isAuthenticationFetch) {
+        if (request7.useURLCredentials === void 0 || isAuthenticationFetch) {
           if (isCancelled(fetchParams)) {
             return makeAppropriateNetworkError(fetchParams);
           }
@@ -27141,7 +27141,7 @@ var require_fetch = __commonJS({
         response = await httpNetworkOrCacheFetch(fetchParams, true);
       }
       if (response.status === 407) {
-        if (request6.window === "no-window") {
+        if (request7.window === "no-window") {
           return makeNetworkError();
         }
         if (isCancelled(fetchParams)) {
@@ -27153,7 +27153,7 @@ var require_fetch = __commonJS({
         // response’s status is 421
         response.status === 421 && // isNewConnectionFetch is false
         !isNewConnectionFetch && // request’s body is null, or request’s body is non-null and request’s body’s source is non-null
-        (request6.body == null || request6.body.source != null)
+        (request7.body == null || request7.body.source != null)
       ) {
         if (isCancelled(fetchParams)) {
           return makeAppropriateNetworkError(fetchParams);
@@ -27183,21 +27183,21 @@ var require_fetch = __commonJS({
           }
         }
       };
-      const request6 = fetchParams.request;
+      const request7 = fetchParams.request;
       let response = null;
       const timingInfo = fetchParams.timingInfo;
       const httpCache = null;
       if (httpCache == null) {
-        request6.cache = "no-store";
+        request7.cache = "no-store";
       }
       const newConnection = forceNewConnection ? "yes" : "no";
-      if (request6.mode === "websocket") {
+      if (request7.mode === "websocket") {
       } else {
       }
       let requestBody = null;
-      if (request6.body == null && fetchParams.processRequestEndOfBody) {
+      if (request7.body == null && fetchParams.processRequestEndOfBody) {
         queueMicrotask(() => fetchParams.processRequestEndOfBody());
-      } else if (request6.body != null) {
+      } else if (request7.body != null) {
         const processBodyChunk = async function* (bytes) {
           if (isCancelled(fetchParams)) {
             return;
@@ -27225,7 +27225,7 @@ var require_fetch = __commonJS({
         };
         requestBody = (async function* () {
           try {
-            for await (const bytes of request6.body.stream) {
+            for await (const bytes of request7.body.stream) {
               yield* processBodyChunk(bytes);
             }
             processEndOfBody();
@@ -27332,7 +27332,7 @@ var require_fetch = __commonJS({
       }
       return response;
       function dispatch({ body }) {
-        const url2 = requestCurrentURL(request6);
+        const url2 = requestCurrentURL(request7);
         const agent = fetchParams.controller.dispatcher;
         const path41 = url2.pathname + url2.search;
         const hasTrailingQuestionMark = url2.search.length === 0 && url2.href[url2.href.length - url2.hash.length - 1] === "?";
@@ -27340,11 +27340,11 @@ var require_fetch = __commonJS({
           {
             path: hasTrailingQuestionMark ? `${path41}?` : path41,
             origin: url2.origin,
-            method: request6.method,
-            body: agent.isMockActive ? request6.body && (request6.body.source || request6.body.stream) : body,
-            headers: request6.headersList.entries,
+            method: request7.method,
+            body: agent.isMockActive ? request7.body && (request7.body.source || request7.body.stream) : body,
+            headers: request7.headersList.entries,
             maxRedirections: 0,
-            upgrade: request6.mode === "websocket" ? "websocket" : void 0
+            upgrade: request7.mode === "websocket" ? "websocket" : void 0
           },
           {
             body: null,
@@ -27381,9 +27381,9 @@ var require_fetch = __commonJS({
               }
               const location = headersList.get("location", true);
               this.body = new Readable({ read: resume });
-              const willFollow = location && request6.redirect === "follow" && redirectStatusSet.has(status);
+              const willFollow = location && request7.redirect === "follow" && redirectStatusSet.has(status);
               const decoders = [];
-              if (request6.method !== "HEAD" && request6.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow) {
+              if (request7.method !== "HEAD" && request7.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow) {
                 const contentEncoding = headersList.get("content-encoding", true);
                 const codings = contentEncoding ? contentEncoding.toLowerCase().split(",") : [];
                 const maxContentEncodings = 5;
@@ -27579,31 +27579,31 @@ var require_cache3 = __commonJS({
         webidl.util.markAsUncloneable(this);
         this.#relevantRequestResponseList = arguments[1];
       }
-      async match(request6, options = {}) {
+      async match(request7, options = {}) {
         webidl.brandCheck(this, _Cache);
         const prefix = "Cache.match";
         webidl.argumentLengthCheck(arguments, 1, prefix);
-        request6 = webidl.converters.RequestInfo(request6);
+        request7 = webidl.converters.RequestInfo(request7);
         options = webidl.converters.CacheQueryOptions(options, prefix, "options");
-        const p = this.#internalMatchAll(request6, options, 1);
+        const p = this.#internalMatchAll(request7, options, 1);
         if (p.length === 0) {
           return;
         }
         return p[0];
       }
-      async matchAll(request6 = void 0, options = {}) {
+      async matchAll(request7 = void 0, options = {}) {
         webidl.brandCheck(this, _Cache);
         const prefix = "Cache.matchAll";
-        if (request6 !== void 0) request6 = webidl.converters.RequestInfo(request6);
+        if (request7 !== void 0) request7 = webidl.converters.RequestInfo(request7);
         options = webidl.converters.CacheQueryOptions(options, prefix, "options");
-        return this.#internalMatchAll(request6, options);
+        return this.#internalMatchAll(request7, options);
       }
-      async add(request6) {
+      async add(request7) {
         webidl.brandCheck(this, _Cache);
         const prefix = "Cache.add";
         webidl.argumentLengthCheck(arguments, 1, prefix);
-        request6 = webidl.converters.RequestInfo(request6);
-        const requests = [request6];
+        request7 = webidl.converters.RequestInfo(request7);
+        const requests = [request7];
         const responseArrayPromise = this.addAll(requests);
         return await responseArrayPromise;
       }
@@ -27613,19 +27613,19 @@ var require_cache3 = __commonJS({
         webidl.argumentLengthCheck(arguments, 1, prefix);
         const responsePromises = [];
         const requestList = [];
-        for (let request6 of requests) {
-          if (request6 === void 0) {
+        for (let request7 of requests) {
+          if (request7 === void 0) {
             throw webidl.errors.conversionFailed({
               prefix,
               argument: "Argument 1",
               types: ["undefined is not allowed"]
             });
           }
-          request6 = webidl.converters.RequestInfo(request6);
-          if (typeof request6 === "string") {
+          request7 = webidl.converters.RequestInfo(request7);
+          if (typeof request7 === "string") {
             continue;
           }
-          const r2 = getRequestState(request6);
+          const r2 = getRequestState(request7);
           if (!urlIsHttpHttpsScheme(r2.url) || r2.method !== "GET") {
             throw webidl.errors.exception({
               header: prefix,
@@ -27634,8 +27634,8 @@ var require_cache3 = __commonJS({
           }
         }
         const fetchControllers = [];
-        for (const request6 of requests) {
-          const r2 = getRequestState(new Request(request6));
+        for (const request7 of requests) {
+          const r2 = getRequestState(new Request(request7));
           if (!urlIsHttpHttpsScheme(r2.url)) {
             throw webidl.errors.exception({
               header: prefix,
@@ -27712,17 +27712,17 @@ var require_cache3 = __commonJS({
         });
         return cacheJobPromise.promise;
       }
-      async put(request6, response) {
+      async put(request7, response) {
         webidl.brandCheck(this, _Cache);
         const prefix = "Cache.put";
         webidl.argumentLengthCheck(arguments, 2, prefix);
-        request6 = webidl.converters.RequestInfo(request6);
+        request7 = webidl.converters.RequestInfo(request7);
         response = webidl.converters.Response(response, prefix, "response");
         let innerRequest = null;
-        if (webidl.is.Request(request6)) {
-          innerRequest = getRequestState(request6);
+        if (webidl.is.Request(request7)) {
+          innerRequest = getRequestState(request7);
         } else {
-          innerRequest = getRequestState(new Request(request6));
+          innerRequest = getRequestState(new Request(request7));
         }
         if (!urlIsHttpHttpsScheme(innerRequest.url) || innerRequest.method !== "GET") {
           throw webidl.errors.exception({
@@ -27793,21 +27793,21 @@ var require_cache3 = __commonJS({
         });
         return cacheJobPromise.promise;
       }
-      async delete(request6, options = {}) {
+      async delete(request7, options = {}) {
         webidl.brandCheck(this, _Cache);
         const prefix = "Cache.delete";
         webidl.argumentLengthCheck(arguments, 1, prefix);
-        request6 = webidl.converters.RequestInfo(request6);
+        request7 = webidl.converters.RequestInfo(request7);
         options = webidl.converters.CacheQueryOptions(options, prefix, "options");
         let r2 = null;
-        if (webidl.is.Request(request6)) {
-          r2 = getRequestState(request6);
+        if (webidl.is.Request(request7)) {
+          r2 = getRequestState(request7);
           if (r2.method !== "GET" && !options.ignoreMethod) {
             return false;
           }
         } else {
-          assert2(typeof request6 === "string");
-          r2 = getRequestState(new Request(request6));
+          assert2(typeof request7 === "string");
+          r2 = getRequestState(new Request(request7));
         }
         const operations = [];
         const operation = {
@@ -27839,25 +27839,25 @@ var require_cache3 = __commonJS({
        * @param {import('../../../types/cache').CacheQueryOptions} options
        * @returns {Promise<readonly Request[]>}
        */
-      async keys(request6 = void 0, options = {}) {
+      async keys(request7 = void 0, options = {}) {
         webidl.brandCheck(this, _Cache);
         const prefix = "Cache.keys";
-        if (request6 !== void 0) request6 = webidl.converters.RequestInfo(request6);
+        if (request7 !== void 0) request7 = webidl.converters.RequestInfo(request7);
         options = webidl.converters.CacheQueryOptions(options, prefix, "options");
         let r2 = null;
-        if (request6 !== void 0) {
-          if (webidl.is.Request(request6)) {
-            r2 = getRequestState(request6);
+        if (request7 !== void 0) {
+          if (webidl.is.Request(request7)) {
+            r2 = getRequestState(request7);
             if (r2.method !== "GET" && !options.ignoreMethod) {
               return [];
             }
-          } else if (typeof request6 === "string") {
-            r2 = getRequestState(new Request(request6));
+          } else if (typeof request7 === "string") {
+            r2 = getRequestState(new Request(request7));
           }
         }
         const promise2 = createDeferredPromise();
         const requests = [];
-        if (request6 === void 0) {
+        if (request7 === void 0) {
           for (const requestResponse of this.#relevantRequestResponseList) {
             requests.push(requestResponse[0]);
           }
@@ -27869,9 +27869,9 @@ var require_cache3 = __commonJS({
         }
         queueMicrotask(() => {
           const requestList = [];
-          for (const request7 of requests) {
+          for (const request8 of requests) {
             const requestObject = fromInnerRequest(
-              request7,
+              request8,
               void 0,
               new AbortController().signal,
               "immutable"
@@ -27990,9 +27990,9 @@ var require_cache3 = __commonJS({
        * @param {import('../../../types/cache').CacheQueryOptions | undefined} options
        * @returns {boolean}
        */
-      #requestMatchesCachedItem(requestQuery, request6, response = null, options) {
+      #requestMatchesCachedItem(requestQuery, request7, response = null, options) {
         const queryURL = new URL(requestQuery.url);
-        const cachedURL = new URL(request6.url);
+        const cachedURL = new URL(request7.url);
         if (options?.ignoreSearch) {
           cachedURL.search = "";
           queryURL.search = "";
@@ -28008,7 +28008,7 @@ var require_cache3 = __commonJS({
           if (fieldValue === "*") {
             return false;
           }
-          const requestValue = request6.headersList.get(fieldValue);
+          const requestValue = request7.headersList.get(fieldValue);
           const queryValue = requestQuery.headersList.get(fieldValue);
           if (requestValue !== queryValue) {
             return false;
@@ -28016,20 +28016,20 @@ var require_cache3 = __commonJS({
         }
         return true;
       }
-      #internalMatchAll(request6, options, maxResponses = Infinity) {
+      #internalMatchAll(request7, options, maxResponses = Infinity) {
         let r2 = null;
-        if (request6 !== void 0) {
-          if (webidl.is.Request(request6)) {
-            r2 = getRequestState(request6);
+        if (request7 !== void 0) {
+          if (webidl.is.Request(request7)) {
+            r2 = getRequestState(request7);
             if (r2.method !== "GET" && !options.ignoreMethod) {
               return [];
             }
-          } else if (typeof request6 === "string") {
-            r2 = getRequestState(new Request(request6));
+          } else if (typeof request7 === "string") {
+            r2 = getRequestState(new Request(request7));
           }
         }
         const responses = [];
-        if (request6 === void 0) {
+        if (request7 === void 0) {
           for (const requestResponse of this.#relevantRequestResponseList) {
             responses.push(requestResponse[1]);
           }
@@ -28121,21 +28121,21 @@ var require_cachestorage = __commonJS({
         }
         webidl.util.markAsUncloneable(this);
       }
-      async match(request6, options = {}) {
+      async match(request7, options = {}) {
         webidl.brandCheck(this, _CacheStorage);
         webidl.argumentLengthCheck(arguments, 1, "CacheStorage.match");
-        request6 = webidl.converters.RequestInfo(request6);
+        request7 = webidl.converters.RequestInfo(request7);
         options = webidl.converters.MultiCacheQueryOptions(options);
         if (options.cacheName != null) {
           if (this.#caches.has(options.cacheName)) {
             const cacheList = this.#caches.get(options.cacheName);
             const cache = new Cache(kConstruct, cacheList);
-            return await cache.match(request6, options);
+            return await cache.match(request7, options);
           }
         } else {
           for (const cacheList of this.#caches.values()) {
             const cache = new Cache(kConstruct, cacheList);
-            const response = await cache.match(request6, options);
+            const response = await cache.match(request7, options);
             if (response !== void 0) {
               return response;
             }
@@ -29327,7 +29327,7 @@ var require_connection = __commonJS({
     function establishWebSocketConnection(url2, protocols, client, handler, options) {
       const requestURL = url2;
       requestURL.protocol = url2.protocol === "ws:" ? "http:" : "https:";
-      const request6 = makeRequest({
+      const request7 = makeRequest({
         urlList: [requestURL],
         client,
         serviceWorkers: "none",
@@ -29340,18 +29340,18 @@ var require_connection = __commonJS({
       });
       if (options.headers) {
         const headersList = getHeadersList(new Headers(options.headers));
-        request6.headersList = headersList;
+        request7.headersList = headersList;
       }
       const keyValue = crypto.randomBytes(16).toString("base64");
-      request6.headersList.append("sec-websocket-key", keyValue, true);
-      request6.headersList.append("sec-websocket-version", "13", true);
+      request7.headersList.append("sec-websocket-key", keyValue, true);
+      request7.headersList.append("sec-websocket-version", "13", true);
       for (const protocol of protocols) {
-        request6.headersList.append("sec-websocket-protocol", protocol, true);
+        request7.headersList.append("sec-websocket-protocol", protocol, true);
       }
       const permessageDeflate = "permessage-deflate; client_max_window_bits";
-      request6.headersList.append("sec-websocket-extensions", permessageDeflate, true);
+      request7.headersList.append("sec-websocket-extensions", permessageDeflate, true);
       const controller = fetching({
-        request: request6,
+        request: request7,
         useParallelQueue: true,
         dispatcher: options.dispatcher,
         processResponse(response) {
@@ -29398,7 +29398,7 @@ var require_connection = __commonJS({
           }
           const secProtocol = response.headersList.get("Sec-WebSocket-Protocol");
           if (secProtocol !== null) {
-            const requestProtocols = getDecodeSplit("sec-websocket-protocol", request6.headersList);
+            const requestProtocols = getDecodeSplit("sec-websocket-protocol", request7.headersList);
             if (requestProtocols === null || !requestProtocols.includes(secProtocol)) {
               failWebsocketConnection(handler, 1002, "Protocol was not set in the opening handshake.");
               return;
@@ -59667,6 +59667,7 @@ function buildLayoutPaths(root) {
     frontdoorCaBundlesDir: import_node_path17.default.join(root, "frontdoor", "ca", "bundles"),
     frontdoorStateFile: import_node_path17.default.join(root, "frontdoor", "state.json"),
     frontdoorLockFile: import_node_path17.default.join(root, "frontdoor", "start.lock"),
+    frontdoorControlTokenFile: import_node_path17.default.join(root, "frontdoor", "control-token"),
     frontdoorSessionsDir: import_node_path17.default.join(root, "frontdoor", "sessions"),
     frontdoorLogPath: import_node_path17.default.join(root, "logs", "frontdoor.log"),
     usageDir: import_node_path17.default.join(root, "usage"),
@@ -61039,7 +61040,7 @@ function registerIdentityCommand(program2, deps) {
 // package.json
 var package_default = {
   name: "agent-shim",
-  version: "8.2.0",
+  version: "8.3.0",
   description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   license: "MIT",
   author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -63637,9 +63638,9 @@ function headersFor(credentials, sessionId) {
     session_id: sessionId
   };
 }
-async function callCodex(ports, request6, sessionId, signal) {
+async function callCodex(ports, request7, sessionId, signal) {
   const url2 = ports.url ?? CODEX_RESPONSES_URL;
-  const body = JSON.stringify(request6);
+  const body = JSON.stringify(request7);
   const send = async (credentials2) => await fetchUntilHeaders(ports.fetch, ports.timers, url2, {
     method: "POST",
     headers: headersFor(credentials2, sessionId),
@@ -63913,23 +63914,23 @@ function singleValue(value) {
   return typeof value === "string" ? value : void 0;
 }
 function admitLaunch(isLiveToken) {
-  return (request6) => {
-    const token = singleValue(request6.headers[AUTH_HEADER]);
-    return token !== void 0 && isLiveToken(token) ? { ok: true, headers: { ...request6.forwardable } } : { ok: false, message: "agent-shim front door: this request carries no capability from a live agent-shim launch" };
+  return (request7) => {
+    const token = singleValue(request7.headers[AUTH_HEADER]);
+    return token !== void 0 && isLiveToken(token) ? { ok: true, headers: { ...request7.forwardable } } : { ok: false, message: "agent-shim front door: this request carries no capability from a live agent-shim launch" };
   };
 }
 function admitHop(hopSecret, custody) {
-  return (request6) => {
-    if (singleValue(request6.headers[HOP_SECRET_HEADER]) !== hopSecret) {
+  return (request7) => {
+    if (singleValue(request7.headers[HOP_SECRET_HEADER]) !== hopSecret) {
       return { ok: false, message: "agent-shim front door: the direct listener serves only this door's own headroom hop" };
     }
-    const hopId = singleValue(request6.headers[HOP_ID_HEADER]);
-    const provider = parseProviderPath(new URL(request6.url, "http://127.0.0.1").pathname)?.provider;
+    const hopId = singleValue(request7.headers[HOP_ID_HEADER]);
+    const provider = parseProviderPath(new URL(request7.url, "http://127.0.0.1").pathname)?.provider;
     const credentials = hopId === void 0 || provider === void 0 ? void 0 : custody.redeem(hopId, provider);
     if (credentials === void 0) {
       return { ok: false, message: "agent-shim front door: this request names no live headroom hop for its provider" };
     }
-    return { ok: true, headers: restoreCredentials(request6.forwardable, credentials) };
+    return { ok: true, headers: restoreCredentials(request7.forwardable, credentials) };
   };
 }
 function createDoorPipelines(deps) {
@@ -64047,8 +64048,8 @@ function createFileCapture(file2, now = () => /* @__PURE__ */ new Date()) {
     connect: (target, intercepted) => {
       append({ kind: "connect", host: target.host, port: target.port, intercepted });
     },
-    upgrade: (request6) => {
-      append({ kind: "upgrade", method: request6.method ?? "?", url: request6.url ?? "?", headers: redactHeaders(request6.headers) });
+    upgrade: (request7) => {
+      append({ kind: "upgrade", method: request7.method ?? "?", url: request7.url ?? "?", headers: redactHeaders(request7.headers) });
     },
     tapStream: (host) => {
       nextId += 1;
@@ -64083,10 +64084,10 @@ function createFileCapture(file2, now = () => /* @__PURE__ */ new Date()) {
         }
       };
     },
-    observePassthrough: (request6) => {
+    observePassthrough: (request7) => {
       nextId += 1;
       const id = nextId;
-      append({ kind: "request", id, method: request6.method ?? "?", url: request6.url ?? "?", headers: redactHeaders(request6.headers) });
+      append({ kind: "request", id, method: request7.method ?? "?", url: request7.url ?? "?", headers: redactHeaders(request7.headers) });
       const logged = { request: 0, response: 0 };
       const sequences = { request: 0, response: 0 };
       const chunk = (direction, incoming) => {
@@ -64651,14 +64652,14 @@ function caParses(ca) {
 var TAP_ALPN_PROTOCOLS = ["h2", "http/1.1"];
 async function startConnectServer(config2, effects, preferredPort) {
   const tunnelTokens = /* @__PURE__ */ new WeakMap();
-  const onUpgrade = (host) => (request6, socket, head) => {
-    config2.capture?.upgrade(request6);
+  const onUpgrade = (host) => (request7, socket, head) => {
+    config2.capture?.upgrade(request7);
     if (head.length > 0) {
       socket.pause();
       socket.unshift(head);
     }
-    const headText = `${request6.method ?? "GET"} ${request6.url ?? "/"} HTTP/1.1\r
-${request6.rawHeaders.reduce((accumulated, value, index) => index % 2 === 0 ? `${accumulated}${value}: ` : `${accumulated}${value}\r
+    const headText = `${request7.method ?? "GET"} ${request7.url ?? "/"} HTTP/1.1\r
+${request7.rawHeaders.reduce((accumulated, value, index) => index % 2 === 0 ? `${accumulated}${value}: ` : `${accumulated}${value}\r
 `, "")}\r
 `;
     pumpTapSession(socket, async (clientAlpn) => await effects.connectTlsUpstream(host, HTTPS_PORT, clientAlpn), config2.capture?.tapStream?.(host), Buffer.from(headText, "utf8"));
@@ -64671,16 +64672,16 @@ ${request6.rawHeaders.reduce((accumulated, value, index) => index % 2 === 0 ? `$
       const tlsAcceptor2 = effects.createTlsAcceptor(config2.leafFor(host), serveSecure2, TAP_ALPN_PROTOCOLS);
       return { host, serveSecure: serveSecure2, tlsAcceptor: tlsAcceptor2 };
     }
-    const handler = (request6, response) => {
-      if (host === config2.routedHost && servedByPipeline(request6.url)) {
-        const tunnelToken = tunnelTokens.get(request6.socket);
-        if (tunnelToken !== void 0 && request6.headers[AUTH_HEADER] === void 0) {
-          request6.headers[AUTH_HEADER] = tunnelToken;
+    const handler = (request7, response) => {
+      if (host === config2.routedHost && servedByPipeline(request7.url)) {
+        const tunnelToken = tunnelTokens.get(request7.socket);
+        if (tunnelToken !== void 0 && request7.headers[AUTH_HEADER] === void 0) {
+          request7.headers[AUTH_HEADER] = tunnelToken;
         }
-        config2.serveRouted(request6, response);
+        config2.serveRouted(request7, response);
         return;
       }
-      effects.forwardHttp(config2.upstreamFor(host), request6, response, config2.capture?.observePassthrough(request6));
+      effects.forwardHttp(config2.upstreamFor(host), request7, response, config2.capture?.observePassthrough(request7));
     };
     const httpSession = effects.createHttpSession(handler, onUpgrade(host));
     const serveSecure = (secure, capability) => {
@@ -64977,6 +64978,40 @@ var ExemptTlsAgent = class extends https.Agent {
     return tls.connect(tlsOptions);
   }
 };
+function realRcEventDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_PORT }) {
+  const agent = new ExemptTlsAgent();
+  return {
+    writeEvents: async (sessionId, headers, body) => await new Promise((resolve, reject) => {
+      const options = {
+        host: target.host,
+        port: target.port,
+        method: "POST",
+        path: `/v1/code/sessions/${encodeURIComponent(sessionId)}/events`,
+        // The Host header names the host whose API this is, not the address dialled: a redirected test dials a loopback stand-in while still speaking to the API host by name, exactly as the forwarded paths present their SNI.
+        headers: { ...headers, host: target.servername ?? target.host, "content-length": String(Buffer.byteLength(body, "utf8")) },
+        agent
+      };
+      options.servername = target.servername ?? target.host;
+      if (target.ca !== void 0) {
+        options.ca = [...target.ca];
+      }
+      if (target.rejectUnauthorized !== void 0) {
+        options.rejectUnauthorized = target.rejectUnauthorized;
+      }
+      const request7 = https.request(options, (response) => {
+        const chunks = [];
+        response.on("data", (chunk) => {
+          chunks.push(chunk);
+        });
+        response.on("end", () => {
+          resolve({ status: response.statusCode ?? HTTP_BAD_GATEWAY, body: Buffer.concat(chunks).toString("utf8") });
+        });
+      });
+      request7.once("error", reject);
+      request7.end(body);
+    })
+  };
+}
 function realConnectEffects() {
   const plainAgent = new ExemptHttpAgent();
   const tlsAgent = new ExemptTlsAgent();
@@ -65082,8 +65117,8 @@ function realConnectEffects() {
         socket.destroy();
       });
       if (onUpgrade !== void 0) {
-        server.on("upgrade", (request6, socket, head) => {
-          onUpgrade(request6, socket, head);
+        server.on("upgrade", (request7, socket, head) => {
+          onUpgrade(request7, socket, head);
         });
       }
       return {
@@ -65122,14 +65157,14 @@ function realConnectEffects() {
       });
       socket.once("error", reject);
     }),
-    forwardHttp: (target, request6, response, observer) => {
-      const headers = forwardableHeaders(request6.headers);
+    forwardHttp: (target, request7, response, observer) => {
+      const headers = forwardableHeaders(request7.headers);
       const options = {
         host: target.host,
         port: target.port,
         lookup: realAddressLookup,
-        method: request6.method,
-        path: request6.url,
+        method: request7.method,
+        path: request7.url,
         headers,
         agent: target.tls ? tlsAgent : plainAgent
       };
@@ -65164,15 +65199,15 @@ function realConnectEffects() {
         response.end(body);
       });
       if (observer !== void 0) {
-        request6.on("data", (chunk) => {
+        request7.on("data", (chunk) => {
           observer.onRequestChunk(chunk);
         });
         response.on("close", () => {
           observer.onEnd();
         });
       }
-      request6.pipe(upstream);
-      request6.socket.setNoDelay(true);
+      request7.pipe(upstream);
+      request7.socket.setNoDelay(true);
       upstream.on("socket", (socket) => {
         socket.setNoDelay(true);
       });
@@ -65186,16 +65221,227 @@ var http3 = __toESM(require("node:http"), 1);
 // src/frontdoor/server.ts
 var import_node_http = __toESM(require("node:http"), 1);
 var import_node_https = __toESM(require("node:https"), 1);
+
+// src/frontdoor/rcControl.ts
+var https2 = __toESM(require("node:https"), 1);
+var CONTROL_PATH_PREFIX = "/__agent-shim/rc";
+var CONTROL_BODY_CAP_BYTES = 10485760;
+function answerJson(response, status, body) {
+  const text2 = JSON.stringify(body);
+  response.writeHead(status, { "content-type": "application/json", "content-length": String(Buffer.byteLength(text2, "utf8")) });
+  response.end(text2);
+}
+async function readBody(request7) {
+  return await new Promise((resolve, reject) => {
+    const chunks = [];
+    let total = 0;
+    request7.on("data", (chunk) => {
+      total += chunk.length;
+      if (total > CONTROL_BODY_CAP_BYTES) {
+        request7.destroy();
+        reject(new Error("too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    request7.on("end", () => {
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+    request7.on("error", () => {
+      reject(new Error("the request body ended early"));
+    });
+  });
+}
+function createRcControlHandler(deps) {
+  const sessionsPath = `${CONTROL_PATH_PREFIX}/sessions`;
+  const injectPath = `${CONTROL_PATH_PREFIX}/inject`;
+  return (request7, response) => {
+    const presented = request7.headers.authorization;
+    const bearerPrefix = "bearer ".length;
+    const token = typeof presented === "string" && presented.slice(0, bearerPrefix).toLowerCase() === "bearer " ? presented.slice(bearerPrefix) : void 0;
+    if (token === void 0 || !isLiveCapability(token, [deps.expectedToken])) {
+      answerJson(response, HTTP_STATUS.unauthorized, { error: "the front door's control routes demand this generation's control token as a Bearer credential" });
+      return;
+    }
+    const url2 = request7.url ?? "/";
+    const handle = async () => {
+      if (url2 === sessionsPath) {
+        if (request7.method !== "GET") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the session list is a GET" });
+          return;
+        }
+        answerJson(response, HTTP_STATUS.ok, { sessions: deps.list() });
+        return;
+      }
+      if (url2 === injectPath) {
+        if (request7.method !== "POST") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the inject operation is a POST" });
+          return;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(await readBody(request7));
+        } catch {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the inject body is not readable JSON within the control body cap" });
+          return;
+        }
+        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || !("text" in parsed) || typeof parsed.session !== "string" || typeof parsed.text !== "string" || parsed.session === "" || parsed.text === "") {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the inject body must be JSON naming a non-empty session id and text" });
+          return;
+        }
+        const result = await deps.inject(parsed.session, parsed.text);
+        if (result.ok) {
+          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, sequenceNums: result.sequenceNums });
+          return;
+        }
+        answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
+        return;
+      }
+      answerJson(response, HTTP_STATUS.notFound, { error: `no such control route: ${url2}` });
+    };
+    handle().catch((error62) => {
+      answerJson(response, HTTP_STATUS.internalServerError, { error: `the control route failed: ${error62 instanceof Error ? error62.message : String(error62)}` });
+    });
+  };
+}
+function realRcControlTransport(port, ca) {
+  return {
+    request: async (options) => await new Promise((resolve, reject) => {
+      const request7 = https2.request(
+        {
+          host: "127.0.0.1",
+          port,
+          method: options.method,
+          path: options.path,
+          headers: options.body === void 0 ? options.headers : { ...options.headers, "content-length": String(Buffer.byteLength(options.body, "utf8")) },
+          agent: false,
+          ca: [ca]
+        },
+        (response) => {
+          const chunks = [];
+          response.on("data", (chunk) => {
+            chunks.push(chunk);
+          });
+          response.on("end", () => {
+            resolve({ status: response.statusCode ?? 0, body: Buffer.concat(chunks).toString("utf8") });
+          });
+        }
+      );
+      request7.once("error", reject);
+      if (options.body === void 0) {
+        request7.end();
+      } else {
+        request7.end(options.body);
+      }
+    })
+  };
+}
+function controlErrorOf(body) {
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed === "object" && parsed !== null && "error" in parsed && typeof parsed.error === "string") {
+      return parsed.error;
+    }
+  } catch {
+    return body;
+  }
+  return void 0;
+}
+function isRcSessionSummary(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (!("id" in value) || !("createdAt" in value) || !("lastSeenAt" in value)) {
+    return false;
+  }
+  return typeof value.id === "string" && typeof value.createdAt === "number" && typeof value.lastSeenAt === "number";
+}
+function sequenceNumsOfBody(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null || !("sequenceNums" in parsed) || !Array.isArray(parsed.sequenceNums)) {
+    return void 0;
+  }
+  const sequenceNums = [];
+  const values = parsed.sequenceNums;
+  for (const value of values) {
+    if (typeof value !== "number") {
+      return void 0;
+    }
+    sequenceNums.push(value);
+  }
+  return sequenceNums;
+}
+function frontDoorRcControl(transport, token) {
+  const headers = { authorization: `Bearer ${token}` };
+  const sessionsOf = (answer, what) => {
+    if (answer.status !== HTTP_STATUS.ok) {
+      throw new Error(`${what} failed (HTTP ${String(answer.status)}): ${controlErrorOf(answer.body) ?? answer.body}`);
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(answer.body);
+    } catch {
+      throw new Error(`${what}: the door's answer was not JSON: ${answer.body}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || !("sessions" in parsed) || !Array.isArray(parsed.sessions)) {
+      throw new Error(`${what}: the door's answer named no sessions list: ${answer.body}`);
+    }
+    const candidates = parsed.sessions;
+    const sessions = [];
+    for (const value of candidates) {
+      if (!isRcSessionSummary(value)) {
+        throw new Error(`${what}: the door's answer named no sessions list: ${answer.body}`);
+      }
+      sessions.push(value);
+    }
+    return sessions;
+  };
+  return {
+    listSessions: async () => sessionsOf(await transport.request({ method: "GET", path: `${CONTROL_PATH_PREFIX}/sessions`, headers }), "listing the door's Remote Control sessions"),
+    sendPrompt: async (sessionId, text2) => {
+      let answer;
+      try {
+        answer = await transport.request({
+          method: "POST",
+          path: `${CONTROL_PATH_PREFIX}/inject`,
+          headers: { ...headers, "content-type": "application/json" },
+          body: JSON.stringify({ session: sessionId, text: text2 })
+        });
+      } catch (error62) {
+        return { ok: false, message: `could not reach the front door's control listener: ${error62 instanceof Error ? error62.message : String(error62)}` };
+      }
+      if (answer.status === HTTP_STATUS.ok) {
+        const sequenceNums = sequenceNumsOfBody(answer.body);
+        if (sequenceNums === void 0) {
+          return { ok: false, message: `the door accepted the event but its answer named no sequence numbers: ${answer.body}` };
+        }
+        return { ok: true, sequenceNums };
+      }
+      return { ok: false, message: `injecting into ${sessionId} failed (HTTP ${String(answer.status)}): ${controlErrorOf(answer.body) ?? answer.body}` };
+    }
+  };
+}
+
+// src/frontdoor/server.ts
 var HEALTH_TIMEOUT_MS = 2e3;
 var HEALTH_START_BUDGET_MS = 5e3;
 var HEALTH_RETRY_MS = 50;
-function createFrontDoorServer(pipeline, log, tls2) {
-  const handler = (request6, response) => {
-    if (request6.method === "GET" && request6.url === "/healthz") {
+function createFrontDoorServer(pipeline, log, tls2, control) {
+  const handler = (request7, response) => {
+    if (request7.method === "GET" && request7.url === "/healthz") {
       response.writeHead(HTTP_STATUS.ok, { "Content-Type": "text/plain" });
       response.end("ok");
       return;
     }
+    if (control !== void 0 && (request7.url ?? "/").startsWith(CONTROL_PATH_PREFIX)) {
+      control(request7, response);
+      return;
+    }
     const abort = new AbortController();
     response.on("close", () => {
       if (!response.writableFinished) {
@@ -65203,13 +65449,13 @@ function createFrontDoorServer(pipeline, log, tls2) {
       }
     });
     const handle = async () => {
-      await pipeline({ method: request6.method ?? "GET", url: request6.url ?? "/", headers: aliasLegacyWireHeaders(request6.headers), body: request6, signal: abort.signal, response });
-      if (!request6.readableEnded) {
-        request6.resume();
+      await pipeline({ method: request7.method ?? "GET", url: request7.url ?? "/", headers: aliasLegacyWireHeaders(request7.headers), body: request7, signal: abort.signal, response });
+      if (!request7.readableEnded) {
+        request7.resume();
       }
     };
     handle().catch((error62) => {
-      log(`request ${request6.method ?? "?"} ${request6.url ?? "?"} failed: ${error62 instanceof Error ? `${error62.name}: ${error62.message}` : String(error62)}`);
+      log(`request ${request7.method ?? "?"} ${request7.url ?? "?"} failed: ${error62 instanceof Error ? `${error62.name}: ${error62.message}` : String(error62)}`);
       if (!response.headersSent) {
         response.writeHead(HTTP_STATUS.internalServerError, { "Content-Type": "application/json" });
         response.end(JSON.stringify({ type: "error", error: { type: "api_error", message: "internal error in the agent-shim front door" } }));
@@ -65234,11 +65480,11 @@ async function frontDoorHealthy(port, ca) {
       resolve(response.statusCode === HTTP_STATUS.ok);
     };
     const options = { host: "127.0.0.1", port, path: "/healthz", agent: false, timeout: HEALTH_TIMEOUT_MS };
-    const request6 = ca === void 0 ? import_node_http.default.get(options, onResponse) : import_node_https.default.get({ ...options, ca: [ca] }, onResponse);
-    request6.on("timeout", () => {
-      request6.destroy();
+    const request7 = ca === void 0 ? import_node_http.default.get(options, onResponse) : import_node_https.default.get({ ...options, ca: [ca] }, onResponse);
+    request7.on("timeout", () => {
+      request7.destroy();
     });
-    request6.on("error", () => {
+    request7.on("error", () => {
       resolve(false);
     });
   });
@@ -65323,24 +65569,24 @@ function responseHeaders(headers) {
   }
   return result;
 }
-async function applyHeadroomHop(request6, response, upstream, deps) {
+async function applyHeadroomHop(request7, response, upstream, deps) {
   const target = deps.headroomSocket();
   if (target === void 0) {
     await answerBadGateway(response, "agent-shim front door: the headroom daemon is restarting");
     return;
   }
   if (target.refused !== void 0) {
-    deps.log(`front door: refusing the headroom hop (${request6.method} ${new URL(request6.url, "http://127.0.0.1").pathname}): ${target.refused}`);
+    deps.log(`front door: refusing the headroom hop (${request7.method} ${new URL(request7.url, "http://127.0.0.1").pathname}): ${target.refused}`);
     await answerBadGateway(response, `agent-shim front door: refusing to send this request to headroom: ${target.refused}`);
     return;
   }
   const { socketPath } = target;
-  let headers = forwardableHeaders(request6.headers);
+  let headers = forwardableHeaders(request7.headers);
   let hopId;
   if (upstream !== void 0) {
-    const provider = parseProviderPath(new URL(request6.url, "http://127.0.0.1").pathname)?.provider;
+    const provider = parseProviderPath(new URL(request7.url, "http://127.0.0.1").pathname)?.provider;
     if (provider === void 0) {
-      throw new Error(`headroom hop for ${request6.url} names an upstream but no provider`);
+      throw new Error(`headroom hop for ${request7.url} names an upstream but no provider`);
     }
     const sequestered = deps.custody.sequester(headers, provider);
     hopId = sequestered.hopId;
@@ -65348,12 +65594,12 @@ async function applyHeadroomHop(request6, response, upstream, deps) {
     headers[HOP_ID_HEADER] = hopId;
     headers[HEADROOM_BASE_URL_HEADER] = upstream;
   }
-  if (request6.session.projectId !== void 0) {
-    headers[PROJECT_ID_HEADER] = request6.session.projectId;
+  if (request7.session.projectId !== void 0) {
+    headers[PROJECT_ID_HEADER] = request7.session.projectId;
   }
   headers[HOP_SECRET_HEADER] = deps.hopSecret;
   try {
-    await forwardThroughHeadroom(request6, response, { socketPath, headers, log: deps.log });
+    await forwardThroughHeadroom(request7, response, { socketPath, headers, log: deps.log });
   } finally {
     if (hopId !== void 0) {
       deps.custody.release(hopId);
@@ -65366,7 +65612,7 @@ async function answerBadGateway(response, message) {
   response.end();
 }
 var HOP_AGENT = new http3.Agent({ keepAlive: false });
-async function forwardThroughHeadroom(request6, response, target) {
+async function forwardThroughHeadroom(request7, response, target) {
   const { socketPath, headers } = target;
   await new Promise((resolve) => {
     const onUpstreamResponse = (upstreamResponse) => {
@@ -65375,17 +65621,17 @@ async function forwardThroughHeadroom(request6, response, target) {
       const stream = async () => {
         try {
           for await (const chunk of upstreamChunks(upstreamResponse)) {
-            if (request6.signal.aborted) {
+            if (request7.signal.aborted) {
               break;
             }
             await response.write(chunk);
           }
-          if (!request6.signal.aborted) {
+          if (!request7.signal.aborted) {
             response.end();
           }
         } catch (error62) {
-          if (!request6.signal.aborted) {
-            target.log(`front door: headroom hop to ${socketPath} ended mid-stream (${request6.method} ${new URL(request6.url, "http://127.0.0.1").pathname}): ${error62 instanceof Error ? error62.message : String(error62)}`);
+          if (!request7.signal.aborted) {
+            target.log(`front door: headroom hop to ${socketPath} ended mid-stream (${request7.method} ${new URL(request7.url, "http://127.0.0.1").pathname}): ${error62 instanceof Error ? error62.message : String(error62)}`);
           }
           response.destroy();
         }
@@ -65393,11 +65639,11 @@ async function forwardThroughHeadroom(request6, response, target) {
       };
       void stream();
     };
-    const hop = http3.request({ socketPath, method: request6.method, path: request6.url, headers, agent: HOP_AGENT }, onUpstreamResponse);
+    const hop = http3.request({ socketPath, method: request7.method, path: request7.url, headers, agent: HOP_AGENT }, onUpstreamResponse);
     hop.on("error", (error62) => {
       const phase = response.headersSent ? "mid-stream" : "before the response started";
       const code = "code" in error62 && typeof error62.code === "string" ? ` ${error62.code}` : "";
-      target.log(`front door: headroom hop to ${socketPath} failed (${request6.method} ${new URL(request6.url, "http://127.0.0.1").pathname}, ${phase}): ${error62.message}${code}`);
+      target.log(`front door: headroom hop to ${socketPath} failed (${request7.method} ${new URL(request7.url, "http://127.0.0.1").pathname}, ${phase}): ${error62.message}${code}`);
       if (!response.headersSent) {
         response.start(HTTP_BAD_GATEWAY2, { "Content-Type": "application/json" });
         void response.write(JSON.stringify({ type: "error", error: { type: "api_error", message: `agent-shim front door: the headroom daemon is unreachable (${error62.message})` } })).then(() => {
@@ -65408,11 +65654,11 @@ async function forwardThroughHeadroom(request6, response, target) {
       }
       resolve(void 0);
     });
-    request6.signal.addEventListener("abort", () => {
+    request7.signal.addEventListener("abort", () => {
       hop.destroy();
     });
-    request6.body.pipe(hop);
-    request6.body.on("error", () => {
+    request7.body.pipe(hop);
+    request7.body.on("error", () => {
       hop.destroy();
     });
   });
@@ -65446,7 +65692,7 @@ function describeThrown(error62) {
   return error62 instanceof Error ? error62.message : String(error62);
 }
 function createRoutedResponse(response, context) {
-  const { deps, session, route, request: request6 } = context;
+  const { deps, session, route, request: request7 } = context;
   let headersSent = false;
   let bodyObservers = [];
   let finished = false;
@@ -65492,7 +65738,7 @@ function createRoutedResponse(response, context) {
     start: (status, headers) => {
       for (const observe of deps.responseObservers) {
         try {
-          const body = observe({ session, route, method: request6.method, path: request6.path, receivedAt: request6.receivedAt, status, headers });
+          const body = observe({ session, route, method: request7.method, path: request7.path, receivedAt: request7.receivedAt, status, headers });
           if (body !== void 0) {
             bodyObservers.push(body);
           }
@@ -65532,34 +65778,34 @@ function createRoutedResponse(response, context) {
     }
   };
 }
-async function serveRouted(request6, deps) {
-  const observed = { method: request6.method, path: pathOf(request6.url), receivedAt: deps.now() };
-  const identified = identifyRequest(request6.headers);
-  const admission = deps.admit({ url: request6.url, headers: request6.headers, forwardable: identified.forwardableHeaders });
+async function serveRouted(request7, deps) {
+  const observed = { method: request7.method, path: pathOf(request7.url), receivedAt: deps.now() };
+  const identified = identifyRequest(request7.headers);
+  const admission = deps.admit({ url: request7.url, headers: request7.headers, forwardable: identified.forwardableHeaders });
   if (!admission.ok) {
-    const response2 = createRoutedResponse(request6.response, { deps, session: identified.session, route: "(unauthorized)", request: observed });
+    const response2 = createRoutedResponse(request7.response, { deps, session: identified.session, route: "(unauthorized)", request: observed });
     response2.start(HTTP_STATUS.unauthorized, { "Content-Type": "application/json" });
     await response2.write(errorBody(HTTP_STATUS.unauthorized, admission.message));
     response2.end();
     return;
   }
   const routed = {
-    method: request6.method,
-    url: request6.url,
+    method: request7.method,
+    url: request7.url,
     headers: admission.headers,
-    body: request6.body,
-    signal: request6.signal,
+    body: request7.body,
+    signal: request7.signal,
     session: identified.session
   };
   const resolution = await deps.resolveRoute(routed);
   if (!resolution.ok) {
-    const response2 = createRoutedResponse(request6.response, { deps, session: identified.session, route: "(unrouted)", request: observed });
+    const response2 = createRoutedResponse(request7.response, { deps, session: identified.session, route: "(unrouted)", request: observed });
     response2.start(resolution.status, { "Content-Type": "application/json" });
     await response2.write(errorBody(resolution.status, resolution.message));
     response2.end();
     return;
   }
-  const response = createRoutedResponse(request6.response, { deps, session: identified.session, route: resolution.route.name, request: observed });
+  const response = createRoutedResponse(request7.response, { deps, session: identified.session, route: resolution.route.name, request: observed });
   try {
     if (identified.session.headroom && resolution.route.headroomEligible && deps.headroom !== void 0) {
       await applyHeadroomHop(routed, response, resolution.route.headroomUpstream, deps.headroom);
@@ -65567,7 +65813,7 @@ async function serveRouted(request6, deps) {
       await resolution.route.serve(routed, response);
     }
   } catch (error62) {
-    if (request6.signal.aborted) {
+    if (request7.signal.aborted) {
       return;
     }
     deps.log(`front door: route ${resolution.route.name} failed: ${error62 instanceof Error ? `${error62.name}: ${error62.message}` : String(error62)}`);
@@ -65676,8 +65922,8 @@ var REQUESTABLE_EFFORTS = ["low", "medium", "high"];
 function isRequestableEffort(value) {
   return REQUESTABLE_EFFORTS.includes(value);
 }
-function mapEffort(request6, config2) {
-  const requested = request6.output_config?.effort;
+function mapEffort(request7, config2) {
+  const requested = request7.output_config?.effort;
   return requested !== void 0 && isRequestableEffort(requested) ? requested : config2.effort;
 }
 var BILLING_HEADER_LINE = /^x-anthropic-billing-header:[^\n]*\n/;
@@ -65803,7 +66049,7 @@ function translateRequest(body, config2) {
   const tools = mapTools(body.tools, names);
   const toolChoice = mapToolChoice(body.tool_choice, names);
   const userId = body.metadata?.user_id;
-  const request6 = {
+  const request7 = {
     model: mapModel(body.model ?? "", config2),
     instructions: systemToInstructions(body.system),
     input: messagesToInput(body.messages, names),
@@ -65815,7 +66061,7 @@ function translateRequest(body, config2) {
     ...tools === void 0 ? {} : { tools },
     ...toolChoice === void 0 ? {} : { tool_choice: toolChoice }
   };
-  return { request: request6, toolNames: names };
+  return { request: request7, toolNames: names };
 }
 
 // src/codex/events.ts
@@ -66190,7 +66436,7 @@ function describeError(error62) {
   return error62 instanceof Error ? `${error62.name}: ${error62.message}` : String(error62);
 }
 function createCodexRoute(ports) {
-  const handleMessages = async (request6, config2, raw) => {
+  const handleMessages = async (request7, config2, raw) => {
     const parsed = MessagesRequestSchema.safeParse(raw);
     if (!parsed.success) {
       return errorResponse(HTTP_STATUS.badRequest, `not an Anthropic Messages request: ${parsed.error.issues.map((issue2) => `${issue2.path.join(".")}: ${issue2.message}`).join("; ")}`);
@@ -66202,9 +66448,9 @@ function createCodexRoute(ports) {
     const elapsed = () => `${String(ports.now() - started)}ms`;
     let upstream;
     try {
-      upstream = await callCodex(ports.upstream, upstreamRequest, sessionIdFor(body.metadata?.user_id, ports.upstream.randomId), request6.signal);
+      upstream = await callCodex(ports.upstream, upstreamRequest, sessionIdFor(body.metadata?.user_id, ports.upstream.randomId), request7.signal);
     } catch (error62) {
-      if (request6.signal.aborted) {
+      if (request7.signal.aborted) {
         return errorResponse(HTTP_STATUS.clientClosedRequest, "client disconnected");
       }
       ports.log(`${upstreamRequest.model} upstream fetch failed after ${elapsed()}: ${describeError(error62)}`);
@@ -66264,7 +66510,7 @@ function createCodexRoute(ports) {
           ports.log(`${upstreamRequest.model} stream ended without completing after ${elapsed()}`);
           yield errorFrame(HTTP_STATUS.badGateway, "codex backend stream ended without completing");
         } catch (error62) {
-          if (request6.signal.aborted) {
+          if (request7.signal.aborted) {
             return;
           }
           ports.log(`${upstreamRequest.model} stream relay failed: ${describeError(error62)}`);
@@ -66290,7 +66536,7 @@ function createCodexRoute(ports) {
         }
       }
     } catch (error62) {
-      if (request6.signal.aborted) {
+      if (request7.signal.aborted) {
         return errorResponse(HTTP_STATUS.clientClosedRequest, "client disconnected");
       }
       ports.log(`${upstreamRequest.model} stream relay failed: ${describeError(error62)}`);
@@ -66307,26 +66553,26 @@ function createCodexRoute(ports) {
     const text2 = JSON.stringify({ system: parsed.data.system, messages: parsed.data.messages, tools: parsed.data.tools });
     return { status: HTTP_STATUS.ok, headers: { "Content-Type": "application/json" }, body: JSON.stringify({ input_tokens: Math.ceil(text2.length / CHARS_PER_TOKEN) }) };
   };
-  return async (request6) => {
-    if (request6.method === "GET" && request6.path === "/healthz") {
+  return async (request7) => {
+    if (request7.method === "GET" && request7.path === "/healthz") {
       return { status: HTTP_STATUS.ok, headers: { "Content-Type": "text/plain" }, body: "ok" };
     }
-    if (request6.method !== "POST") {
-      return errorResponse(HTTP_STATUS.methodNotAllowed, `unsupported ${request6.method} ${request6.path}`);
+    if (request7.method !== "POST") {
+      return errorResponse(HTTP_STATUS.methodNotAllowed, `unsupported ${request7.method} ${request7.path}`);
     }
-    const scoped = parseProviderPath(request6.path);
+    const scoped = parseProviderPath(request7.path);
     if (scoped === void 0 || scoped.rest !== "/v1/messages" && scoped.rest !== "/v1/messages/count_tokens") {
-      return errorResponse(HTTP_STATUS.notFound, `no such endpoint: ${request6.path}`);
+      return errorResponse(HTTP_STATUS.notFound, `no such endpoint: ${request7.path}`);
     }
     const provider = ports.loadProvider(scoped.provider);
     if (!provider.ok) {
       return errorResponse(provider.status, provider.message);
     }
-    const json2 = parseJson3(request6.body);
+    const json2 = parseJson3(request7.body);
     if (!json2.ok) {
       return errorResponse(HTTP_STATUS.badRequest, json2.message);
     }
-    return scoped.rest === "/v1/messages" ? await handleMessages(request6, provider.config, json2.value) : handleCountTokens(json2.value);
+    return scoped.rest === "/v1/messages" ? await handleMessages(request7, provider.config, json2.value) : handleCountTokens(json2.value);
   };
 }
 
@@ -66338,10 +66584,10 @@ var BodyTooLargeError = class extends Error {
     this.name = "BodyTooLargeError";
   }
 };
-async function readBody(request6) {
+async function readBody2(request7) {
   const chunks = [];
   let size = 0;
-  for await (const chunk of request6.body) {
+  for await (const chunk of request7.body) {
     if (!Buffer.isBuffer(chunk)) {
       throw new TypeError("request body chunk was not a Buffer");
     }
@@ -66374,10 +66620,10 @@ function createCodexRouteMount(ports, upstreamBase, provider) {
     name: `codex:${provider}`,
     headroomEligible: true,
     headroomUpstream: upstreamBase,
-    serve: async (request6, response) => {
+    serve: async (request7, response) => {
       let body;
       try {
-        body = await readBody(request6);
+        body = await readBody2(request7);
       } catch (error62) {
         const tooLarge = error62 instanceof BodyTooLargeError;
         response.start(tooLarge ? HTTP_STATUS.payloadTooLarge : HTTP_STATUS.badRequest, { "Content-Type": "application/json" });
@@ -66385,23 +66631,23 @@ function createCodexRouteMount(ports, upstreamBase, provider) {
           JSON.stringify({ type: "error", error: { type: "invalid_request_error", message: error62 instanceof Error ? error62.message : String(error62) } })
         );
         response.end();
-        request6.body.resume();
+        request7.body.resume();
         return;
       }
-      const path41 = new URL(request6.url, "http://127.0.0.1").pathname;
-      const translated = { method: request6.method, path: path41, body, signal: request6.signal };
+      const path41 = new URL(request7.url, "http://127.0.0.1").pathname;
+      const translated = { method: request7.method, path: path41, body, signal: request7.signal };
       const routed = await route(translated);
-      if (request6.signal.aborted) {
+      if (request7.signal.aborted) {
         return;
       }
-      await writeRouteResponse(routed, response, request6.signal);
+      await writeRouteResponse(routed, response, request7.signal);
     }
   };
 }
 
 // src/frontdoor/passthrough.ts
 var http4 = __toESM(require("node:http"), 1);
-var https3 = __toESM(require("node:https"), 1);
+var https4 = __toESM(require("node:https"), 1);
 function responseHeaders2(headers) {
   const result = {};
   for (const [name, value] of Object.entries(forwardableHeaders(headers))) {
@@ -66421,16 +66667,16 @@ function createPassthroughRoute(name, target) {
     name,
     headroomEligible: true,
     headroomUpstream: target.headroomUpstream,
-    serve: async (request6, response) => {
-      const incoming = new URL(request6.url, "http://127.0.0.1");
+    serve: async (request7, response) => {
+      const incoming = new URL(request7.url, "http://127.0.0.1");
       const path41 = target.stripPrefix !== void 0 && incoming.pathname.startsWith(target.stripPrefix) ? incoming.pathname.slice(target.stripPrefix.length) : incoming.pathname;
-      const headers = forwardableHeaders(request6.headers);
+      const headers = forwardableHeaders(request7.headers);
       delete headers.host;
       await new Promise((resolve) => {
         const options = {
           host: base.hostname,
           port: base.port === "" ? void 0 : Number(base.port),
-          method: request6.method,
+          method: request7.method,
           path: `${basePath}${path41}${incoming.search}`,
           headers,
           agent
@@ -66441,7 +66687,7 @@ function createPassthroughRoute(name, target) {
           const stream = async () => {
             try {
               for await (const chunk of upstreamChunks(upstreamResponse)) {
-                if (request6.signal.aborted) {
+                if (request7.signal.aborted) {
                   return;
                 }
                 await response.write(chunk);
@@ -66454,7 +66700,7 @@ function createPassthroughRoute(name, target) {
           };
           void stream();
         };
-        const forward = tls2 ? https3.request(options, onUpstreamResponse) : http4.request(options, onUpstreamResponse);
+        const forward = tls2 ? https4.request(options, onUpstreamResponse) : http4.request(options, onUpstreamResponse);
         forward.on("error", (error62) => {
           if (!response.headersSent) {
             response.start(HTTP_STATUS.badGateway, { "Content-Type": "application/json" });
@@ -66466,11 +66712,11 @@ function createPassthroughRoute(name, target) {
           }
           resolve(void 0);
         });
-        request6.signal.addEventListener("abort", () => {
+        request7.signal.addEventListener("abort", () => {
           forward.destroy();
         });
-        request6.body.pipe(forward);
-        request6.body.on("error", () => {
+        request7.body.pipe(forward);
+        request7.body.on("error", () => {
           forward.destroy();
         });
       });
@@ -66492,8 +66738,8 @@ function createProviderRouteResolver(deps) {
     passthroughByTarget.set(key, route);
     return route;
   };
-  const resolve = (request6) => {
-    const path41 = new URL(request6.url, "http://127.0.0.1").pathname;
+  const resolve = (request7) => {
+    const path41 = new URL(request7.url, "http://127.0.0.1").pathname;
     const scoped = parseProviderPath(path41);
     if (scoped === void 0) {
       return path41.startsWith("/v1/") ? { ok: true, route: oauthRoute } : { ok: false, status: HTTP_STATUS.notFound, message: `no such endpoint: ${path41}` };
@@ -66532,7 +66778,246 @@ function createProviderRouteResolver(deps) {
       })
     };
   };
-  return async (request6) => await Promise.resolve(resolve(request6));
+  return async (request7) => await Promise.resolve(resolve(request7));
+}
+
+// src/frontdoor/rcSessions.ts
+var RC_SESSIONS_PATH_PREFIX = "/v1/code/sessions";
+var RC_SESSION_ID_PREFIX = "cse_";
+var RC_IDLE_EXPIRY_MS = 45e3;
+var RC_CREATE_RESPONSE_CAP_BYTES = 8192;
+var CONFLICT_REASON_HEADER = "x-ccr-conflict-reason";
+var SUCCESS_STATUS_MAX_EXCLUSIVE = 300;
+function isSuccessful(status) {
+  return status >= HTTP_STATUS.ok && status < SUCCESS_STATUS_MAX_EXCLUSIVE;
+}
+function singleHeader(headers, name) {
+  const value = headers[name];
+  return typeof value === "string" ? value : void 0;
+}
+function sessionCreateId(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null || !("session" in parsed)) {
+    return void 0;
+  }
+  const session = parsed.session;
+  if (typeof session !== "object" || session === null || !("id" in session)) {
+    return void 0;
+  }
+  const id = session.id;
+  return typeof id === "string" && id.startsWith(RC_SESSION_ID_PREFIX) ? id : void 0;
+}
+function createRcSessionTracker(deps) {
+  const entries = /* @__PURE__ */ new Map();
+  const expire = (id) => {
+    entries.delete(id);
+  };
+  const sweep = () => {
+    for (const [id, entry] of entries) {
+      if (deps.now() - entry.lastSeenAt >= deps.idleMs) {
+        expire(id);
+      }
+    }
+  };
+  const timer = setInterval(sweep, deps.idleMs);
+  timer.unref();
+  const observeExchange = (request7) => {
+    const method = (request7.method ?? "").toUpperCase();
+    const path41 = new URL(request7.url ?? "/", "http://127.0.0.1").pathname;
+    if (!path41.startsWith(RC_SESSIONS_PATH_PREFIX)) {
+      return void 0;
+    }
+    const tail = path41.slice(RC_SESSIONS_PATH_PREFIX.length);
+    const facts = {
+      authorization: singleHeader(request7.headers, "authorization"),
+      anthropicVersion: singleHeader(request7.headers, "anthropic-version"),
+      anthropicClientPlatform: singleHeader(request7.headers, "anthropic-client-platform")
+    };
+    if (tail === "") {
+      if (method !== "POST") {
+        return void 0;
+      }
+      let accepted = false;
+      let buffered = 0;
+      let body = "";
+      return {
+        onResponse: (status) => {
+          accepted = isSuccessful(status);
+        },
+        onBodyChunk: (chunk) => {
+          if (!accepted || buffered >= RC_CREATE_RESPONSE_CAP_BYTES) {
+            return;
+          }
+          const text2 = Buffer.from(chunk).toString("utf8");
+          body = body + text2.slice(0, RC_CREATE_RESPONSE_CAP_BYTES - buffered);
+          buffered = body.length;
+        },
+        onEnd: () => {
+          if (!accepted) {
+            return;
+          }
+          const id2 = sessionCreateId(body);
+          if (id2 === void 0) {
+            return;
+          }
+          entries.set(id2, { id: id2, createdAt: deps.now(), lastSeenAt: deps.now(), ...facts });
+        }
+      };
+    }
+    const rest = tail.slice(1);
+    const [id] = rest.split("/");
+    if (id?.startsWith(RC_SESSION_ID_PREFIX) !== true) {
+      return void 0;
+    }
+    const entry = entries.get(id);
+    if (entry === void 0) {
+      entries.set(id, { id, createdAt: deps.now(), lastSeenAt: deps.now(), ...facts });
+    } else {
+      entry.lastSeenAt = deps.now();
+      entry.authorization = facts.authorization ?? entry.authorization;
+      entry.anthropicVersion = facts.anthropicVersion ?? entry.anthropicVersion;
+      entry.anthropicClientPlatform = facts.anthropicClientPlatform ?? entry.anthropicClientPlatform;
+    }
+    const archiving = method === "POST" && rest === `${id}/archive`;
+    return {
+      onResponse: (status, headers) => {
+        if (singleHeader(headers, CONFLICT_REASON_HEADER) !== void 0 || archiving && isSuccessful(status)) {
+          expire(id);
+        }
+      },
+      onBodyChunk: () => {
+      },
+      onEnd: () => {
+      }
+    };
+  };
+  return {
+    observeExchange,
+    list: () => {
+      sweep();
+      return [...entries.values()].sort((left, right) => left.createdAt - right.createdAt || (left.id < right.id ? -1 : 1)).map(({ id, createdAt, lastSeenAt }) => ({ id, createdAt, lastSeenAt }));
+    },
+    credentialOf: (sessionId) => {
+      const entry = entries.get(sessionId);
+      return entry === void 0 ? void 0 : { authorization: entry.authorization, anthropicVersion: entry.anthropicVersion, anthropicClientPlatform: entry.anthropicClientPlatform };
+    },
+    close: () => {
+      clearInterval(timer);
+    }
+  };
+}
+function observingRoutedRoute(route, tracker) {
+  return {
+    ...route,
+    serve: async (request7, response) => {
+      const observed = tracker.observeExchange({ method: request7.method, url: request7.url, headers: request7.headers });
+      await route.serve(request7, observed === void 0 ? response : teeRoutedResponse(response, observed));
+    }
+  };
+}
+function teeRoutedResponse(response, observer) {
+  return {
+    get headersSent() {
+      return response.headersSent;
+    },
+    start: (status, headers) => {
+      observer.onResponse(status, headers);
+      response.start(status, headers);
+    },
+    flush: () => {
+      response.flush();
+    },
+    write: async (chunk) => {
+      observer.onBodyChunk(typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk);
+      await response.write(chunk);
+    },
+    end: () => {
+      response.end();
+      observer.onEnd();
+    },
+    destroy: () => {
+      response.destroy();
+      observer.onEnd();
+    }
+  };
+}
+function buildRcUserMessagePayload(uuid3, sessionId, text2) {
+  return {
+    type: "user",
+    uuid: uuid3,
+    session_id: sessionId,
+    parent_tool_use_id: null,
+    message: { role: "user", content: text2 }
+  };
+}
+function buildRcEventWriteBody(payload) {
+  return { events: [{ payload }] };
+}
+function sequenceNumsOf(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null || !("results" in parsed) || !Array.isArray(parsed.results)) {
+    return void 0;
+  }
+  const sequenceNums = [];
+  const results = parsed.results;
+  for (const result of results) {
+    if (typeof result !== "object" || result === null || !("sequence_num" in result)) {
+      return void 0;
+    }
+    const sequenceNum = result.sequence_num;
+    if (typeof sequenceNum !== "number") {
+      return void 0;
+    }
+    sequenceNums.push(sequenceNum);
+  }
+  return sequenceNums.length === 0 ? void 0 : sequenceNums;
+}
+function rcInjectResultFromAnswer(answer) {
+  if (!isSuccessful(answer.status)) {
+    if (answer.status === HTTP_STATUS.unauthorized) {
+      return { ok: false, message: `the API refused the observed Authorization bearer for this session (HTTP 401): the bearer went stale after the door last saw the session's traffic. The session's own client refreshes it on its next call, which the door will observe, so retry once Remote Control has been active again. API answer: ${answer.body}` };
+    }
+    return { ok: false, message: `the API answered HTTP ${String(answer.status)} to the injected event: ${answer.body}` };
+  }
+  const sequenceNums = sequenceNumsOf(answer.body);
+  if (sequenceNums === void 0) {
+    return { ok: false, message: `the API accepted the injected event but its answer named no results[].sequence_num, so delivery cannot be confirmed: ${answer.body}` };
+  }
+  return { ok: true, sequenceNums };
+}
+async function injectRcUserMessage(deps, sessionId, text2) {
+  const credential = deps.credentialOf(sessionId);
+  if (credential === void 0) {
+    return { ok: false, message: `the front door has not observed Remote Control session ${sessionId}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` };
+  }
+  const headers = { "content-type": "application/json" };
+  if (credential.authorization !== void 0) {
+    headers.authorization = credential.authorization;
+  }
+  if (credential.anthropicVersion !== void 0) {
+    headers["anthropic-version"] = credential.anthropicVersion;
+  }
+  if (credential.anthropicClientPlatform !== void 0) {
+    headers["anthropic-client-platform"] = credential.anthropicClientPlatform;
+  }
+  const body = JSON.stringify(buildRcEventWriteBody(buildRcUserMessagePayload(deps.newUuid(), sessionId, text2)));
+  let answer;
+  try {
+    answer = await deps.dial.writeEvents(sessionId, headers, body);
+  } catch (error62) {
+    return { ok: false, message: `the door could not reach the API host to inject into session ${sessionId}: ${error62 instanceof Error ? error62.message : String(error62)}` };
+  }
+  return rcInjectResultFromAnswer(answer);
 }
 
 // src/usage/providerQuota.ts
@@ -66826,13 +67311,21 @@ function headroomSocketTarget(fsPort, trust, paths) {
   const socketPath = readHeadroomState(fsPort, paths.headroomStateFile)?.socketPath;
   return socketPath === void 0 ? void 0 : verifyHeadroomSocket(socketPath, trust);
 }
+function rcObservingResolver(resolve, tracker) {
+  return async (request7) => {
+    const resolution = await resolve(request7);
+    return resolution.ok ? { ok: true, route: observingRoutedRoute(resolution.route, tracker) } : resolution;
+  };
+}
 function realFrontDoorSupervisorPorts(paths) {
   const log = (line) => {
     appendLog(paths, `frontdoor ${String(process.pid)}: ${line}`);
   };
   let directPort = 0;
   const codexPorts = createCodexRoutePorts(log);
-  const resolveRoute = createProviderRouteResolver({ fs: realFsPort, providersDir: paths.providersDir, codexPorts, directPort: () => directPort });
+  const rcTracker = createRcSessionTracker({ now: () => Date.now(), idleMs: RC_IDLE_EXPIRY_MS });
+  const rcControlToken = (0, import_node_crypto11.randomUUID)();
+  const resolveRoute = rcObservingResolver(createProviderRouteResolver({ fs: realFsPort, providersDir: paths.providersDir, codexPorts, directPort: () => directPort }), rcTracker);
   const isLiveToken = (token) => isLiveCapability(token, liveSessionTokens(realFarmFs, paths.frontdoorSessionsDir));
   const usageStore = createUsageStore({
     fs: realFarmFs,
@@ -66884,15 +67377,26 @@ function realFrontDoorSupervisorPorts(paths) {
     isRunning: realIsProcessRunning,
     startProviderListener: async (preferredPort) => {
       const authority = loadCa();
+      const rcInject = async (sessionId, text2) => await injectRcUserMessage({ credentialOf: rcTracker.credentialOf, dial: realRcEventDial(), newUuid: import_node_crypto11.randomUUID }, sessionId, text2);
+      realFarmFs.mkdirp(paths.frontdoorDir);
+      realFarmFs.writeFilePrivate(paths.frontdoorControlTokenFile, `${rcControlToken}
+`);
       const server = createFrontDoorServer(
-        async (request6) => {
-          await serveRouted(request6, pipelines.clientFacing);
+        async (request7) => {
+          await serveRouted(request7, pipelines.clientFacing);
         },
         log,
-        mintLeaf(authority, LOOPBACK_LEAF_NAMES, /* @__PURE__ */ new Date())
+        mintLeaf(authority, LOOPBACK_LEAF_NAMES, /* @__PURE__ */ new Date()),
+        createRcControlHandler({ expectedToken: rcControlToken, list: rcTracker.list, inject: rcInject })
       );
       const handle = await listenFrontDoor(server, { ...preferredPort === void 0 ? {} : { preferredPort }, ca: authority.certPem, onError: onListenerError("provider") });
-      return { port: handle.port, close: handle.close };
+      return {
+        port: handle.port,
+        close: async () => {
+          realFarmFs.removeRecursive(paths.frontdoorControlTokenFile);
+          await handle.close();
+        }
+      };
     },
     startConnectListener: async (preferredPort) => {
       const transparentPort = process.env.AGENT_SHIM_TRANSPARENT_SURFACE === void 0 ? void 0 : Number(process.env.AGENT_SHIM_TRANSPARENT_SURFACE);
@@ -66910,16 +67414,16 @@ function realFrontDoorSupervisorPorts(paths) {
           interceptHosts: CONNECT_INTERCEPT_HOSTS,
           tapHosts: CONNECT_TAP_HOSTS,
           routedHost: CONNECT_INTERCEPT_HOST,
-          serveRouted: (request6, response) => {
+          serveRouted: (request7, response) => {
             const abort = new AbortController();
             response.on("close", () => {
               if (!response.writableFinished) {
                 abort.abort();
               }
             });
-            void serveRouted({ method: request6.method ?? "GET", url: request6.url ?? "/", headers: request6.headers, body: request6, signal: abort.signal, response }, pipelines.clientFacing).catch(
+            void serveRouted({ method: request7.method ?? "GET", url: request7.url ?? "/", headers: request7.headers, body: request7, signal: abort.signal, response }, pipelines.clientFacing).catch(
               (error62) => {
-                log(`connect request ${request6.method ?? "?"} ${request6.url ?? "?"} failed: ${error62 instanceof Error ? `${error62.name}: ${error62.message}` : String(error62)}`);
+                log(`connect request ${request7.method ?? "?"} ${request7.url ?? "?"} failed: ${error62 instanceof Error ? `${error62.name}: ${error62.message}` : String(error62)}`);
                 if (!response.headersSent) {
                   response.writeHead(HTTP_STATUS.badGateway, { "Content-Type": "application/json" });
                   response.end(JSON.stringify({ type: "error", error: { type: "api_error", message: "internal error in the agent-shim front door" } }));
@@ -66942,8 +67446,8 @@ function realFrontDoorSupervisorPorts(paths) {
       return { port: server.port, close: server.close };
     },
     startDirectListener: async (preferredPort) => {
-      const server = createFrontDoorServer(async (request6) => {
-        await serveRouted(request6, pipelines.direct);
+      const server = createFrontDoorServer(async (request7) => {
+        await serveRouted(request7, pipelines.direct);
       }, log);
       const handle = await listenFrontDoor(server, {
         ...preferredPort === void 0 ? {} : { preferredPort },
@@ -67006,6 +67510,27 @@ function formatFrontDoorStatus(status, caCertPath) {
   lines.push(`daemon log: ${status.logPath}${status.logExists ? "" : " (not created yet)"}`);
   return lines;
 }
+function formatRcSessionList(sessions) {
+  if (sessions.length === 0) {
+    return ["no Remote Control sessions observed"];
+  }
+  return sessions.map((session) => `${session.id}  created ${new Date(session.createdAt).toISOString()}  last seen ${new Date(session.lastSeenAt).toISOString()}`);
+}
+function frontDoorRcControlFromState(fsPort, paths) {
+  const state = readFrontDoorState(fsPort, paths.frontdoorStateFile);
+  if (state?.port === void 0) {
+    throw new Error("the front door is not serving: Remote Control sessions are observed only while it runs, so start a session through the door first");
+  }
+  const ca = fsPort.readFileUtf8(paths.frontdoorCaCertFile);
+  if (ca === void 0) {
+    throw new Error(`the front door's CA certificate is missing at ${paths.frontdoorCaCertFile}, so its control listener cannot be authenticated`);
+  }
+  const token = fsPort.readFileUtf8(paths.frontdoorControlTokenFile)?.trim();
+  if (token === void 0 || token === "") {
+    throw new Error(`the serving front door's control token is missing at ${paths.frontdoorControlTokenFile}`);
+  }
+  return frontDoorRcControl(realRcControlTransport(state.port, ca), token);
+}
 function registerFrontDoorCommand(program2, deps) {
   const { paths } = deps;
   const frontdoor = withExamples(program2.command("frontdoor").description("Inspect the front-door daemon that routes every agent-shim session."), [
@@ -67024,6 +67549,36 @@ function registerFrontDoorCommand(program2, deps) {
     }),
     ["agent-shim frontdoor status", "agent-shim frontdoor status --json"]
   );
+  const rc = withExamples(frontdoor.command("rc").description("Observe the Remote Control sessions passing through the front door, and send a prompt into one."), [
+    "agent-shim frontdoor rc list"
+  ]);
+  withExamples(
+    rc.command("list").description("List the Remote Control sessions the front door has observed, with when each was created and last seen. Read-only.").option("--json", "Print the sessions as JSON.").action(async (options) => {
+      const sessions = await frontDoorRcControlFromState(realFarmFs, paths).listSessions();
+      if (options.json === true) {
+        printJson({ sessions });
+        return;
+      }
+      for (const line of formatRcSessionList(sessions)) {
+        console.log(line);
+      }
+    }),
+    ["agent-shim frontdoor rc list", "agent-shim frontdoor rc list --json"]
+  );
+  withExamples(
+    rc.command("send").description("Send a text prompt into one observed Remote Control session, arriving as a message from an attached client would.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").requiredOption("--text <text>", "The prompt text to deliver.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
+      const result = await frontDoorRcControlFromState(realFarmFs, paths).sendPrompt(options.session, options.text);
+      if (!result.ok) {
+        throw new Error(result.message);
+      }
+      if (options.json === true) {
+        printJson({ session: options.session, sequenceNums: result.sequenceNums });
+        return;
+      }
+      console.log(`sent to ${options.session}: sequence_num ${result.sequenceNums.join(", ")}`);
+    }),
+    ['agent-shim frontdoor rc send --session cse_00000000-0000-4000-8000-000000000000 --text "run the tests"']
+  );
   program2.command("__frontdoor-supervisor", { hidden: true }).description("Internal: serve the front-door routing listeners. Started by the launcher; never run by hand.").allowUnknownOption().action(async () => {
     const idleShutdownMinutes = readGlobalConfig(paths)?.frontdoor?.idleShutdownMinutes ?? FRONTDOOR_DEFAULT_IDLE_SHUTDOWN_MINUTES;
     process.on("SIGTERM", () => {