modelstat 0.13.0 → 0.14.0

package/dist/cli.mjs

@@ -10742,10 +10742,10 @@ var require_util = __commonJS({
       }
       return obj;
     }
-    function errorRequest(client, request3, err) {
+    function errorRequest(client, request4, err) {
       try {
-        request3.onError(err);
-        assert(request3.aborted);
+        request4.onError(err);
+        assert(request4.aborted);
       } catch (err2) {
         client.emit("error", err2);
       }
@@ -11407,7 +11407,7 @@ var require_request = __commonJS({
         return this;
       }
     };
-    function processHeader(request3, key, val) {
+    function processHeader(request4, key, val) {
       if (val && (typeof val === "object" && !Array.isArray(val))) {
         throw new InvalidArgumentError(`invalid ${key} header`);
       } else if (val === void 0) {
@@ -11447,24 +11447,24 @@ var require_request = __commonJS({
         val = `${val}`;
       }
       if (headerName === "host") {
-        if (request3.host !== null) {
+        if (request4.host !== null) {
           throw new InvalidArgumentError("duplicate host header");
         }
         if (typeof val !== "string") {
           throw new InvalidArgumentError("invalid host header");
         }
-        request3.host = val;
+        request4.host = val;
       } else if (headerName === "content-length") {
-        if (request3.contentLength !== null) {
+        if (request4.contentLength !== null) {
           throw new InvalidArgumentError("duplicate content-length header");
         }
-        request3.contentLength = parseInt(val, 10);
-        if (!Number.isFinite(request3.contentLength)) {
+        request4.contentLength = parseInt(val, 10);
+        if (!Number.isFinite(request4.contentLength)) {
           throw new InvalidArgumentError("invalid content-length header");
         }
-      } else if (request3.contentType === null && headerName === "content-type") {
-        request3.contentType = val;
-        request3.headers.push(key, val);
+      } else if (request4.contentType === null && headerName === "content-type") {
+        request4.contentType = val;
+        request4.headers.push(key, val);
       } else if (headerName === "transfer-encoding" || headerName === "keep-alive" || headerName === "upgrade") {
         throw new InvalidArgumentError(`invalid ${headerName} header`);
       } else if (headerName === "connection") {
@@ -11478,13 +11478,13 @@ var require_request = __commonJS({
             throw new InvalidArgumentError("invalid connection header");
           }
           if (trimmed === "close") {
-            request3.reset = true;
+            request4.reset = true;
           }
         }
       } else if (headerName === "expect") {
         throw new NotSupportedError("expect header not supported");
       } else {
-        request3.headers.push(key, val);
+        request4.headers.push(key, val);
       }
     }
     module.exports = Request;
@@ -11732,9 +11732,9 @@ var require_dispatcher_base = __commonJS({
       }
       close(callback) {
         if (callback === void 0) {
-          return new Promise((resolve6, reject) => {
+          return new Promise((resolve7, reject) => {
             this.close((err, data) => {
-              return err ? reject(err) : resolve6(data);
+              return err ? reject(err) : resolve7(data);
             });
           });
         }
@@ -11772,9 +11772,9 @@ var require_dispatcher_base = __commonJS({
           err = null;
         }
         if (callback === void 0) {
-          return new Promise((resolve6, reject) => {
+          return new Promise((resolve7, reject) => {
             this.destroy(err, (err2, data) => {
-              return err2 ? reject(err2) : resolve6(data);
+              return err2 ? reject(err2) : resolve7(data);
             });
           });
         }
@@ -14040,11 +14040,11 @@ var require_util2 = __commonJS({
     function normalizeBinaryStringToUtf8(value) {
       return Buffer.from(value, "binary").toString("utf8");
     }
-    function requestCurrentURL(request3) {
-      return request3.urlList[request3.urlList.length - 1];
+    function requestCurrentURL(request4) {
+      return request4.urlList[request4.urlList.length - 1];
     }
-    function requestBadPort(request3) {
-      const url = requestCurrentURL(request3);
+    function requestBadPort(request4) {
+      const url = requestCurrentURL(request4);
       if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) {
         return "blocked";
       }
@@ -14082,10 +14082,10 @@ var require_util2 = __commonJS({
       }
       return policy;
     }
-    function setRequestReferrerPolicyOnRedirect(request3, actualResponse) {
+    function setRequestReferrerPolicyOnRedirect(request4, actualResponse) {
       const policy = parseReferrerPolicy(actualResponse);
       if (policy !== "") {
-        request3.referrerPolicy = policy;
+        request4.referrerPolicy = policy;
       }
     }
     function crossOriginResourcePolicyCheck() {
@@ -14102,33 +14102,33 @@ var require_util2 = __commonJS({
       header = httpRequest.mode;
       httpRequest.headersList.set("sec-fetch-mode", header, true);
     }
-    function appendRequestOriginHeader(request3) {
-      let serializedOrigin = request3.origin;
+    function appendRequestOriginHeader(request4) {
+      let serializedOrigin = request4.origin;
       if (serializedOrigin === "client" || serializedOrigin === void 0) {
         return;
       }
-      if (request3.responseTainting === "cors" || request3.mode === "websocket") {
-        request3.headersList.append("origin", serializedOrigin, true);
-      } else if (request3.method !== "GET" && request3.method !== "HEAD") {
-        switch (request3.referrerPolicy) {
+      if (request4.responseTainting === "cors" || request4.mode === "websocket") {
+        request4.headersList.append("origin", serializedOrigin, true);
+      } else if (request4.method !== "GET" && request4.method !== "HEAD") {
+        switch (request4.referrerPolicy) {
           case "no-referrer":
             serializedOrigin = null;
             break;
           case "no-referrer-when-downgrade":
           case "strict-origin":
           case "strict-origin-when-cross-origin":
-            if (request3.origin && urlHasHttpsScheme(request3.origin) && !urlHasHttpsScheme(requestCurrentURL(request3))) {
+            if (request4.origin && urlHasHttpsScheme(request4.origin) && !urlHasHttpsScheme(requestCurrentURL(request4))) {
               serializedOrigin = null;
             }
             break;
           case "same-origin":
-            if (!sameOrigin(request3, requestCurrentURL(request3))) {
+            if (!sameOrigin(request4, requestCurrentURL(request4))) {
               serializedOrigin = null;
             }
             break;
           default:
         }
-        request3.headersList.append("origin", serializedOrigin, true);
+        request4.headersList.append("origin", serializedOrigin, true);
       }
     }
     function coarsenTime(timestamp, crossOriginIsolatedCapability) {
@@ -14182,18 +14182,18 @@ var require_util2 = __commonJS({
         referrerPolicy: policyContainer.referrerPolicy
       };
     }
-    function determineRequestsReferrer(request3) {
-      const policy = request3.referrerPolicy;
+    function determineRequestsReferrer(request4) {
+      const policy = request4.referrerPolicy;
       assert(policy);
       let referrerSource = null;
-      if (request3.referrer === "client") {
+      if (request4.referrer === "client") {
         const globalOrigin = getGlobalOrigin();
         if (!globalOrigin || globalOrigin.origin === "null") {
           return "no-referrer";
         }
         referrerSource = new URL(globalOrigin);
-      } else if (webidl.is.URL(request3.referrer)) {
-        referrerSource = request3.referrer;
+      } else if (webidl.is.URL(request4.referrer)) {
+        referrerSource = request4.referrer;
       }
       let referrerURL = stripURLForReferrer(referrerSource);
       const referrerOrigin = stripURLForReferrer(referrerSource, true);
@@ -14211,14 +14211,14 @@ var require_util2 = __commonJS({
         case "unsafe-url":
           return referrerURL;
         case "strict-origin": {
-          const currentURL = requestCurrentURL(request3);
+          const currentURL = requestCurrentURL(request4);
           if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
             return "no-referrer";
           }
           return referrerOrigin;
         }
         case "strict-origin-when-cross-origin": {
-          const currentURL = requestCurrentURL(request3);
+          const currentURL = requestCurrentURL(request4);
           if (sameOrigin(referrerURL, currentURL)) {
             return referrerURL;
           }
@@ -14228,17 +14228,17 @@ var require_util2 = __commonJS({
           return referrerOrigin;
         }
         case "same-origin":
-          if (sameOrigin(request3, referrerURL)) {
+          if (sameOrigin(request4, referrerURL)) {
             return referrerURL;
           }
           return "no-referrer";
         case "origin-when-cross-origin":
-          if (sameOrigin(request3, referrerURL)) {
+          if (sameOrigin(request4, referrerURL)) {
             return referrerURL;
           }
           return referrerOrigin;
         case "no-referrer-when-downgrade": {
-          const currentURL = requestCurrentURL(request3);
+          const currentURL = requestCurrentURL(request4);
           if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
             return "no-referrer";
           }
@@ -14305,7 +14305,7 @@ var require_util2 = __commonJS({
       if (url.protocol === "blob:") return true;
       return isOriginPotentiallyTrustworthy(url.origin);
     }
-    function tryUpgradeRequestToAPotentiallyTrustworthyURL(request3) {
+    function tryUpgradeRequestToAPotentiallyTrustworthyURL(request4) {
     }
     function sameOrigin(A, B) {
       if (A.origin === B.origin && A.origin === "null") {
@@ -14684,7 +14684,7 @@ var require_util2 = __commonJS({
       }
       return gettingDecodingSplitting(value);
     }
-    function hasAuthenticationEntry(request3) {
+    function hasAuthenticationEntry(request4) {
       return false;
     }
     function includesCredentials(url) {
@@ -15251,8 +15251,8 @@ var require_promise = __commonJS({
     function createDeferredPromise() {
       let res;
       let rej;
-      const promise = new Promise((resolve6, reject) => {
-        res = resolve6;
+      const promise = new Promise((resolve7, reject) => {
+        res = resolve7;
         rej = reject;
       });
       return { promise, resolve: res, reject: rej };
@@ -15869,11 +15869,11 @@ var require_client_h1 = __commonJS({
         if (socket.destroyed) {
           return -1;
         }
-        const request3 = client[kQueue][client[kRunningIdx]];
-        if (!request3) {
+        const request4 = client[kQueue][client[kRunningIdx]];
+        if (!request4) {
           return -1;
         }
-        request3.onResponseStarted();
+        request4.onResponseStarted();
         return 0;
       }
       /**
@@ -15935,9 +15935,9 @@ var require_client_h1 = __commonJS({
         assert(!socket.destroyed);
         assert(!this.paused);
         assert((headers.length & 1) === 0);
-        const request3 = client[kQueue][client[kRunningIdx]];
-        assert(request3);
-        assert(request3.upgrade || request3.method === "CONNECT");
+        const request4 = client[kQueue][client[kRunningIdx]];
+        assert(request4);
+        assert(request4.upgrade || request4.method === "CONNECT");
         this.statusCode = 0;
         this.statusText = "";
         this.shouldKeepAlive = false;
@@ -15954,7 +15954,7 @@ var require_client_h1 = __commonJS({
         client[kQueue][client[kRunningIdx]++] = null;
         client.emit("disconnect", client[kUrl], [client], new InformationalError("upgrade"));
         try {
-          request3.onUpgrade(statusCode, headers, socket);
+          request4.onUpgrade(statusCode, headers, socket);
         } catch (err) {
           util2.destroy(socket, err);
         }
@@ -15971,8 +15971,8 @@ var require_client_h1 = __commonJS({
         if (socket.destroyed) {
           return -1;
         }
-        const request3 = client[kQueue][client[kRunningIdx]];
-        if (!request3) {
+        const request4 = client[kQueue][client[kRunningIdx]];
+        if (!request4) {
           return -1;
         }
         assert(!this.upgrade);
@@ -15981,23 +15981,23 @@ var require_client_h1 = __commonJS({
           util2.destroy(socket, new SocketError("bad response", util2.getSocketInfo(socket)));
           return -1;
         }
-        if (upgrade && !request3.upgrade) {
+        if (upgrade && !request4.upgrade) {
           util2.destroy(socket, new SocketError("bad upgrade", util2.getSocketInfo(socket)));
           return -1;
         }
         assert(this.timeoutType === TIMEOUT_HEADERS);
         this.statusCode = statusCode;
         this.shouldKeepAlive = shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD.
-        request3.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive";
+        request4.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive";
         if (this.statusCode >= 200) {
-          const bodyTimeout = request3.bodyTimeout != null ? request3.bodyTimeout : client[kBodyTimeout];
+          const bodyTimeout = request4.bodyTimeout != null ? request4.bodyTimeout : client[kBodyTimeout];
           this.setTimeout(bodyTimeout, TIMEOUT_BODY);
         } else if (this.timeout) {
           if (this.timeout.refresh) {
             this.timeout.refresh();
           }
         }
-        if (request3.method === "CONNECT") {
+        if (request4.method === "CONNECT") {
           assert(client[kRunning] === 1);
           this.upgrade = true;
           return 2;
@@ -16028,11 +16028,11 @@ var require_client_h1 = __commonJS({
         } else {
           socket[kReset] = true;
         }
-        const pause = request3.onHeaders(statusCode, headers, this.resume, statusText) === false;
-        if (request3.aborted) {
+        const pause = request4.onHeaders(statusCode, headers, this.resume, statusText) === false;
+        if (request4.aborted) {
           return -1;
         }
-        if (request3.method === "HEAD") {
+        if (request4.method === "HEAD") {
           return 1;
         }
         if (statusCode < 200) {
@@ -16053,8 +16053,8 @@ var require_client_h1 = __commonJS({
         if (socket.destroyed) {
           return -1;
         }
-        const request3 = client[kQueue][client[kRunningIdx]];
-        assert(request3);
+        const request4 = client[kQueue][client[kRunningIdx]];
+        assert(request4);
         assert(this.timeoutType === TIMEOUT_BODY);
         if (this.timeout) {
           if (this.timeout.refresh) {
@@ -16067,7 +16067,7 @@ var require_client_h1 = __commonJS({
           return -1;
         }
         this.bytesRead += buf.length;
-        if (request3.onData(buf) === false) {
+        if (request4.onData(buf) === false) {
           return constants.ERROR.PAUSED;
         }
         return 0;
@@ -16085,8 +16085,8 @@ var require_client_h1 = __commonJS({
         }
         assert(statusCode >= 100);
         assert((this.headers.length & 1) === 0);
-        const request3 = client[kQueue][client[kRunningIdx]];
-        assert(request3);
+        const request4 = client[kQueue][client[kRunningIdx]];
+        assert(request4);
         this.statusCode = 0;
         this.statusText = "";
         this.bytesRead = 0;
@@ -16098,11 +16098,11 @@ var require_client_h1 = __commonJS({
         if (statusCode < 200) {
           return 0;
         }
-        if (request3.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) {
+        if (request4.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) {
           util2.destroy(socket, new ResponseContentLengthMismatchError());
           return -1;
         }
-        request3.onComplete(headers);
+        request4.onComplete(headers);
         client[kQueue][client[kRunningIdx]++] = null;
         if (socket[kWriting]) {
           assert(client[kRunning] === 0);
@@ -16167,8 +16167,8 @@ var require_client_h1 = __commonJS({
       return {
         version: "h1",
         defaultPipelining: 1,
-        write(request3) {
-          return writeH1(client, request3);
+        write(request4) {
+          return writeH1(client, request4);
         },
         resume() {
           resumeH1(client);
@@ -16195,18 +16195,18 @@ var require_client_h1 = __commonJS({
          * @param {import('../core/request.js')} request
          * @returns {boolean}
          */
-        busy(request3) {
+        busy(request4) {
           if (socket[kWriting] || socket[kReset] || socket[kBlocking]) {
             return true;
           }
-          if (request3) {
-            if (client[kRunning] > 0 && !request3.idempotent) {
+          if (request4) {
+            if (client[kRunning] > 0 && !request4.idempotent) {
               return true;
             }
-            if (client[kRunning] > 0 && (request3.upgrade || request3.method === "CONNECT")) {
+            if (client[kRunning] > 0 && (request4.upgrade || request4.method === "CONNECT")) {
               return true;
             }
-            if (client[kRunning] > 0 && util2.bodyLength(request3.body) !== 0 && (util2.isStream(request3.body) || util2.isAsyncIterable(request3.body) || util2.isFormDataLike(request3.body))) {
+            if (client[kRunning] > 0 && util2.bodyLength(request4.body) !== 0 && (util2.isStream(request4.body) || util2.isAsyncIterable(request4.body) || util2.isFormDataLike(request4.body))) {
               return true;
             }
           }
@@ -16252,13 +16252,13 @@ var require_client_h1 = __commonJS({
         assert(client[kPending] === 0);
         const requests = client[kQueue].splice(client[kRunningIdx]);
         for (let i = 0; i < requests.length; i++) {
-          const request3 = requests[i];
-          util2.errorRequest(client, request3, err);
+          const request4 = requests[i];
+          util2.errorRequest(client, request4, err);
         }
       } else if (client[kRunning] > 0 && err.code !== "UND_ERR_INFO") {
-        const request3 = client[kQueue][client[kRunningIdx]];
+        const request4 = client[kQueue][client[kRunningIdx]];
         client[kQueue][client[kRunningIdx]++] = null;
-        util2.errorRequest(client, request3, err);
+        util2.errorRequest(client, request4, err);
       }
       client[kPendingIdx] = client[kRunningIdx];
       assert(client[kRunning] === 0);
@@ -16286,8 +16286,8 @@ var require_client_h1 = __commonJS({
           }
         } else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) {
           if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) {
-            const request3 = client[kQueue][client[kRunningIdx]];
-            const headersTimeout = request3.headersTimeout != null ? request3.headersTimeout : client[kHeadersTimeout];
+            const request4 = client[kQueue][client[kRunningIdx]];
+            const headersTimeout = request4.headersTimeout != null ? request4.headersTimeout : client[kHeadersTimeout];
             socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS);
           }
         }
@@ -16296,21 +16296,21 @@ var require_client_h1 = __commonJS({
     function shouldSendContentLength(method) {
       return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
     }
-    function writeH1(client, request3) {
-      const { method, path, host, upgrade, blocking, reset } = request3;
-      let { body, headers, contentLength } = request3;
+    function writeH1(client, request4) {
+      const { method, path, host, upgrade, blocking, reset } = request4;
+      let { body, headers, contentLength } = request4;
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
       if (util2.isFormDataLike(body)) {
         if (!extractBody) {
           extractBody = require_body().extractBody;
         }
         const [bodyStream, contentType] = extractBody(body);
-        if (request3.contentType == null) {
+        if (request4.contentType == null) {
           headers.push("content-type", contentType);
         }
         body = bodyStream.stream;
         contentLength = bodyStream.length;
-      } else if (util2.isBlobLike(body) && request3.contentType == null && body.type) {
+      } else if (util2.isBlobLike(body) && request4.contentType == null && body.type) {
         headers.push("content-type", body.type);
       }
       if (body && typeof body.read === "function") {
@@ -16319,33 +16319,33 @@ var require_client_h1 = __commonJS({
       const bodyLength = util2.bodyLength(body);
       contentLength = bodyLength ?? contentLength;
       if (contentLength === null) {
-        contentLength = request3.contentLength;
+        contentLength = request4.contentLength;
       }
       if (contentLength === 0 && !expectsPayload) {
         contentLength = null;
       }
-      if (shouldSendContentLength(method) && contentLength > 0 && request3.contentLength !== null && request3.contentLength !== contentLength) {
+      if (shouldSendContentLength(method) && contentLength > 0 && request4.contentLength !== null && request4.contentLength !== contentLength) {
         if (client[kStrictContentLength]) {
-          util2.errorRequest(client, request3, new RequestContentLengthMismatchError());
+          util2.errorRequest(client, request4, new RequestContentLengthMismatchError());
           return false;
         }
         process.emitWarning(new RequestContentLengthMismatchError());
       }
       const socket = client[kSocket];
       const abort = (err) => {
-        if (request3.aborted || request3.completed) {
+        if (request4.aborted || request4.completed) {
           return;
         }
-        util2.errorRequest(client, request3, err || new RequestAbortedError());
+        util2.errorRequest(client, request4, err || new RequestAbortedError());
         util2.destroy(body);
         util2.destroy(socket, new InformationalError("aborted"));
       };
       try {
-        request3.onConnect(abort);
+        request4.onConnect(abort);
       } catch (err) {
-        util2.errorRequest(client, request3, err);
+        util2.errorRequest(client, request4, err);
       }
-      if (request3.aborted) {
+      if (request4.aborted) {
         return false;
       }
       if (method === "HEAD") {
@@ -16364,7 +16364,7 @@ var require_client_h1 = __commonJS({
         socket[kBlocking] = true;
       }
       if (socket.setTypeOfService) {
-        socket.setTypeOfService(request3.typeOfService);
+        socket.setTypeOfService(request4.typeOfService);
       }
       let header = `${method} ${path} HTTP/1.1\r
 `;
@@ -16399,31 +16399,31 @@ upgrade: ${upgrade}\r
         }
       }
       if (channels.sendHeaders.hasSubscribers) {
-        channels.sendHeaders.publish({ request: request3, headers: header, socket });
+        channels.sendHeaders.publish({ request: request4, headers: header, socket });
       }
       if (!body || bodyLength === 0) {
-        writeBuffer(abort, null, client, request3, socket, contentLength, header, expectsPayload);
+        writeBuffer(abort, null, client, request4, socket, contentLength, header, expectsPayload);
       } else if (util2.isBuffer(body)) {
-        writeBuffer(abort, body, client, request3, socket, contentLength, header, expectsPayload);
+        writeBuffer(abort, body, client, request4, socket, contentLength, header, expectsPayload);
       } else if (util2.isBlobLike(body)) {
         if (typeof body.stream === "function") {
-          writeIterable(abort, body.stream(), client, request3, socket, contentLength, header, expectsPayload);
+          writeIterable(abort, body.stream(), client, request4, socket, contentLength, header, expectsPayload);
         } else {
-          writeBlob(abort, body, client, request3, socket, contentLength, header, expectsPayload);
+          writeBlob(abort, body, client, request4, socket, contentLength, header, expectsPayload);
         }
       } else if (util2.isStream(body)) {
-        writeStream(abort, body, client, request3, socket, contentLength, header, expectsPayload);
+        writeStream(abort, body, client, request4, socket, contentLength, header, expectsPayload);
       } else if (util2.isIterable(body)) {
-        writeIterable(abort, body, client, request3, socket, contentLength, header, expectsPayload);
+        writeIterable(abort, body, client, request4, socket, contentLength, header, expectsPayload);
       } else {
         assert(false);
       }
       return true;
     }
-    function writeStream(abort, body, client, request3, socket, contentLength, header, expectsPayload) {
+    function writeStream(abort, body, client, request4, socket, contentLength, header, expectsPayload) {
       assert(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
       let finished = false;
-      const writer = new AsyncWriter({ abort, socket, request: request3, contentLength, client, expectsPayload, header });
+      const writer = new AsyncWriter({ abort, socket, request: request4, contentLength, client, expectsPayload, header });
       const onData = function(chunk) {
         if (finished) {
           return;
@@ -16489,7 +16489,7 @@ upgrade: ${upgrade}\r
         setImmediate(onClose);
       }
     }
-    function writeBuffer(abort, body, client, request3, socket, contentLength, header, expectsPayload) {
+    function writeBuffer(abort, body, client, request4, socket, contentLength, header, expectsPayload) {
       try {
         if (!body) {
           if (contentLength === 0) {
@@ -16509,18 +16509,18 @@ upgrade: ${upgrade}\r
 `, "latin1");
           socket.write(body);
           socket.uncork();
-          request3.onBodySent(body);
-          if (!expectsPayload && request3.reset !== false) {
+          request4.onBodySent(body);
+          if (!expectsPayload && request4.reset !== false) {
             socket[kReset] = true;
           }
         }
-        request3.onRequestSent();
+        request4.onRequestSent();
         client[kResume]();
       } catch (err) {
         abort(err);
       }
     }
-    async function writeBlob(abort, body, client, request3, socket, contentLength, header, expectsPayload) {
+    async function writeBlob(abort, body, client, request4, socket, contentLength, header, expectsPayload) {
       assert(contentLength === body.size, "blob body must have content length");
       try {
         if (contentLength != null && contentLength !== body.size) {
@@ -16533,9 +16533,9 @@ upgrade: ${upgrade}\r
 `, "latin1");
         socket.write(buffer);
         socket.uncork();
-        request3.onBodySent(buffer);
-        request3.onRequestSent();
-        if (!expectsPayload && request3.reset !== false) {
+        request4.onBodySent(buffer);
+        request4.onRequestSent();
+        if (!expectsPayload && request4.reset !== false) {
           socket[kReset] = true;
         }
         client[kResume]();
@@ -16543,7 +16543,7 @@ upgrade: ${upgrade}\r
         abort(err);
       }
     }
-    async function writeIterable(abort, body, client, request3, socket, contentLength, header, expectsPayload) {
+    async function writeIterable(abort, body, client, request4, socket, contentLength, header, expectsPayload) {
       assert(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined");
       let callback = null;
       function onDrain() {
@@ -16553,16 +16553,16 @@ upgrade: ${upgrade}\r
           cb();
         }
       }
-      const waitForDrain = () => new Promise((resolve6, reject) => {
+      const waitForDrain = () => new Promise((resolve7, reject) => {
         assert(callback === null);
         if (socket[kError]) {
           reject(socket[kError]);
         } else {
-          callback = resolve6;
+          callback = resolve7;
         }
       });
       socket.on("close", onDrain).on("drain", onDrain);
-      const writer = new AsyncWriter({ abort, socket, request: request3, contentLength, client, expectsPayload, header });
+      const writer = new AsyncWriter({ abort, socket, request: request4, contentLength, client, expectsPayload, header });
       try {
         for await (const chunk of body) {
           if (socket[kError]) {
@@ -16591,9 +16591,9 @@ upgrade: ${upgrade}\r
        * @param {boolean} arg.expectsPayload
        * @param {string} arg.header
        */
-      constructor({ abort, socket, request: request3, contentLength, client, expectsPayload, header }) {
+      constructor({ abort, socket, request: request4, contentLength, client, expectsPayload, header }) {
         this.socket = socket;
-        this.request = request3;
+        this.request = request4;
         this.contentLength = contentLength;
         this.client = client;
         this.bytesWritten = 0;
@@ -16607,7 +16607,7 @@ upgrade: ${upgrade}\r
        * @returns
        */
       write(chunk) {
-        const { socket, request: request3, contentLength, client, bytesWritten, expectsPayload, header } = this;
+        const { socket, request: request4, contentLength, client, bytesWritten, expectsPayload, header } = this;
         if (socket[kError]) {
           throw socket[kError];
         }
@@ -16626,7 +16626,7 @@ upgrade: ${upgrade}\r
         }
         socket.cork();
         if (bytesWritten === 0) {
-          if (!expectsPayload && request3.reset !== false) {
+          if (!expectsPayload && request4.reset !== false) {
             socket[kReset] = true;
           }
           if (contentLength === null) {
@@ -16646,7 +16646,7 @@ ${len.toString(16)}\r
         this.bytesWritten += len;
         const ret = socket.write(chunk);
         socket.uncork();
-        request3.onBodySent(chunk);
+        request4.onBodySent(chunk);
         if (!ret) {
           if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
             if (socket[kParser].timeout.refresh) {
@@ -16660,8 +16660,8 @@ ${len.toString(16)}\r
        * @returns {void}
        */
       end() {
-        const { socket, contentLength, client, bytesWritten, expectsPayload, header, request: request3 } = this;
-        request3.onRequestSent();
+        const { socket, contentLength, client, bytesWritten, expectsPayload, header, request: request4 } = this;
+        request4.onRequestSent();
         socket[kWriting] = false;
         if (socket[kError]) {
           throw socket[kError];
@@ -16838,8 +16838,8 @@ var require_client_h2 = __commonJS({
          * @param {import('../core/request.js')} request
          * @returns {boolean}
         */
-        write(request3) {
-          return writeH2(client, request3);
+        write(request4) {
+          return writeH2(client, request4);
         },
         /**
          * @returns {void}
@@ -16868,14 +16868,14 @@ var require_client_h2 = __commonJS({
          * @param {import('../core/request.js')} request
          * @returns {boolean}
         */
-        busy(request3) {
-          if (request3 != null) {
+        busy(request4) {
+          if (request4 != null) {
             if (client[kRunning] > 0) {
-              if (request3.idempotent === false) return true;
-              if ((request3.upgrade === "websocket" || request3.method === "CONNECT") && session[kRemoteSettings] === false) return true;
-              if (util2.bodyLength(request3.body) !== 0 && (util2.isStream(request3.body) || util2.isAsyncIterable(request3.body) || util2.isFormDataLike(request3.body))) return true;
+              if (request4.idempotent === false) return true;
+              if ((request4.upgrade === "websocket" || request4.method === "CONNECT") && session[kRemoteSettings] === false) return true;
+              if (util2.bodyLength(request4.body) !== 0 && (util2.isStream(request4.body) || util2.isAsyncIterable(request4.body) || util2.isFormDataLike(request4.body))) return true;
             } else {
-              return (request3.upgrade === "websocket" || request3.method === "CONNECT") && session[kRemoteSettings] === false;
+              return (request4.upgrade === "websocket" || request4.method === "CONNECT") && session[kRemoteSettings] === false;
             }
           }
           return false;
@@ -16960,9 +16960,9 @@ var require_client_h2 = __commonJS({
       this[kHTTP2Session] = null;
       util2.destroy(this[kSocket], err);
       if (client[kRunningIdx] < client[kQueue].length) {
-        const request3 = client[kQueue][client[kRunningIdx]];
+        const request4 = client[kQueue][client[kRunningIdx]];
         client[kQueue][client[kRunningIdx]++] = null;
-        util2.errorRequest(client, request3, err);
+        util2.errorRequest(client, request4, err);
         client[kPendingIdx] = client[kRunningIdx];
       }
       assert(client[kRunning] === 0);
@@ -16984,8 +16984,8 @@ var require_client_h2 = __commonJS({
         assert(client[kPending] === 0);
         const requests = client[kQueue].splice(client[kRunningIdx]);
         for (let i = 0; i < requests.length; i++) {
-          const request3 = requests[i];
-          util2.errorRequest(client, request3, err);
+          const request4 = requests[i];
+          util2.errorRequest(client, request4, err);
         }
       }
     }
@@ -17016,13 +17016,13 @@ var require_client_h2 = __commonJS({
     function shouldSendContentLength(method) {
       return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
     }
-    function writeH2(client, request3) {
-      const requestTimeout = request3.bodyTimeout ?? client[kBodyTimeout];
+    function writeH2(client, request4) {
+      const requestTimeout = request4.bodyTimeout ?? client[kBodyTimeout];
       const session = client[kHTTP2Session];
-      const { method, path, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request3;
-      let { body } = request3;
+      const { method, path, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request4;
+      let { body } = request4;
       if (upgrade != null && upgrade !== "websocket") {
-        util2.errorRequest(client, request3, new InvalidArgumentError(`Custom upgrade "${upgrade}" not supported over HTTP/2`));
+        util2.errorRequest(client, request4, new InvalidArgumentError(`Custom upgrade "${upgrade}" not supported over HTTP/2`));
         return false;
       }
       const headers = {};
@@ -17056,11 +17056,11 @@ var require_client_h2 = __commonJS({
       headers[HTTP2_HEADER_AUTHORITY] = host || `${hostname3}${port ? `:${port}` : ""}`;
       headers[HTTP2_HEADER_METHOD] = method;
       const abort = (err) => {
-        if (request3.aborted || request3.completed) {
+        if (request4.aborted || request4.completed) {
           return;
         }
         err = err || new RequestAbortedError();
-        util2.errorRequest(client, request3, err);
+        util2.errorRequest(client, request4, err);
         if (stream != null) {
           stream.removeAllListeners("data");
           stream.close();
@@ -17070,18 +17070,18 @@ var require_client_h2 = __commonJS({
         util2.destroy(body, err);
       };
       try {
-        request3.onConnect(abort);
+        request4.onConnect(abort);
       } catch (err) {
-        util2.errorRequest(client, request3, err);
+        util2.errorRequest(client, request4, err);
       }
-      if (request3.aborted) {
+      if (request4.aborted) {
         return false;
       }
       if (upgrade || method === "CONNECT") {
         session.ref();
         if (upgrade === "websocket") {
           if (session[kEnableConnectProtocol] === false) {
-            util2.errorRequest(client, request3, new InformationalError("HTTP/2: Extended CONNECT protocol not supported by server"));
+            util2.errorRequest(client, request4, new InformationalError("HTTP/2: Extended CONNECT protocol not supported by server"));
             session.unref();
             return false;
           }
@@ -17097,7 +17097,7 @@ var require_client_h2 = __commonJS({
           stream[kHTTP2Stream] = true;
           stream.once("response", (headers2, _flags) => {
             const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2;
-            request3.onUpgrade(statusCode, parseH2Headers(realHeaders), stream);
+            request4.onUpgrade(statusCode, parseH2Headers(realHeaders), stream);
             ++session[kOpenStreams];
             client[kQueue][client[kRunningIdx]++] = null;
           });
@@ -17117,7 +17117,7 @@ var require_client_h2 = __commonJS({
         stream[kHTTP2Stream] = true;
         stream.on("response", (headers2) => {
           const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2;
-          request3.onUpgrade(statusCode, parseH2Headers(realHeaders), stream);
+          request4.onUpgrade(statusCode, parseH2Headers(realHeaders), stream);
           ++session[kOpenStreams];
           client[kQueue][client[kRunningIdx]++] = null;
         });
@@ -17143,14 +17143,14 @@ var require_client_h2 = __commonJS({
         contentLength = bodyStream.length;
       }
       if (contentLength == null) {
-        contentLength = request3.contentLength;
+        contentLength = request4.contentLength;
       }
       if (!expectsPayload) {
         contentLength = null;
       }
-      if (shouldSendContentLength(method) && contentLength > 0 && request3.contentLength != null && request3.contentLength !== contentLength) {
+      if (shouldSendContentLength(method) && contentLength > 0 && request4.contentLength != null && request4.contentLength !== contentLength) {
         if (client[kStrictContentLength]) {
-          util2.errorRequest(client, request3, new RequestContentLengthMismatchError());
+          util2.errorRequest(client, request4, new RequestContentLengthMismatchError());
           return false;
         }
         process.emitWarning(new RequestContentLengthMismatchError());
@@ -17166,7 +17166,7 @@ var require_client_h2 = __commonJS({
           header += `${key}: ${headers[key]}\r
 `;
         }
-        channels.sendHeaders.publish({ request: request3, headers: header, socket: session[kSocket] });
+        channels.sendHeaders.publish({ request: request4, headers: header, socket: session[kSocket] });
       }
       const shouldEndStream = method === "GET" || method === "HEAD" || body === null;
       if (expectContinue) {
@@ -17187,20 +17187,20 @@ var require_client_h2 = __commonJS({
       let responseReceived = false;
       stream.once("response", (headers2) => {
         const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2;
-        request3.onResponseStarted();
+        request4.onResponseStarted();
         responseReceived = true;
-        if (request3.aborted) {
+        if (request4.aborted) {
           stream.removeAllListeners("data");
           return;
         }
-        if (request3.onHeaders(Number(statusCode), parseH2Headers(realHeaders), stream.resume.bind(stream), "") === false) {
+        if (request4.onHeaders(Number(statusCode), parseH2Headers(realHeaders), stream.resume.bind(stream), "") === false) {
           stream.pause();
         }
         stream.on("data", (chunk) => {
-          if (request3.aborted || request3.completed) {
+          if (request4.aborted || request4.completed) {
             return;
           }
-          if (request3.onData(chunk) === false) {
+          if (request4.onData(chunk) === false) {
             stream.pause();
           }
         });
@@ -17208,8 +17208,8 @@ var require_client_h2 = __commonJS({
       stream.once("end", () => {
         stream.removeAllListeners("data");
         if (responseReceived) {
-          if (!request3.aborted && !request3.completed) {
-            request3.onComplete({});
+          if (!request4.aborted && !request4.completed) {
+            request4.onComplete({});
           }
           client[kQueue][client[kRunningIdx]++] = null;
           client[kResume]();
@@ -17248,11 +17248,11 @@ var require_client_h2 = __commonJS({
         abort(err);
       });
       stream.once("trailers", (trailers) => {
-        if (request3.aborted || request3.completed) {
+        if (request4.aborted || request4.completed) {
           return;
         }
         stream.removeAllListeners("data");
-        request3.onComplete(trailers);
+        request4.onComplete(trailers);
       });
       return true;
       function writeBodyH2() {
@@ -17262,7 +17262,7 @@ var require_client_h2 = __commonJS({
             stream,
             null,
             client,
-            request3,
+            request4,
             client[kSocket],
             contentLength,
             expectsPayload
@@ -17273,7 +17273,7 @@ var require_client_h2 = __commonJS({
             stream,
             body,
             client,
-            request3,
+            request4,
             client[kSocket],
             contentLength,
             expectsPayload
@@ -17285,7 +17285,7 @@ var require_client_h2 = __commonJS({
               stream,
               body.stream(),
               client,
-              request3,
+              request4,
               client[kSocket],
               contentLength,
               expectsPayload
@@ -17296,7 +17296,7 @@ var require_client_h2 = __commonJS({
               stream,
               body,
               client,
-              request3,
+              request4,
               client[kSocket],
               contentLength,
               expectsPayload
@@ -17310,7 +17310,7 @@ var require_client_h2 = __commonJS({
             stream,
             body,
             client,
-            request3,
+            request4,
             contentLength
           );
         } else if (util2.isIterable(body)) {
@@ -17319,7 +17319,7 @@ var require_client_h2 = __commonJS({
             stream,
             body,
             client,
-            request3,
+            request4,
             client[kSocket],
             contentLength,
             expectsPayload
@@ -17329,7 +17329,7 @@ var require_client_h2 = __commonJS({
         }
       }
     }
-    function writeBuffer(abort, h2stream, body, client, request3, socket, contentLength, expectsPayload) {
+    function writeBuffer(abort, h2stream, body, client, request4, socket, contentLength, expectsPayload) {
       try {
         if (body != null && util2.isBuffer(body)) {
           assert(contentLength === body.byteLength, "buffer body must have content length");
@@ -17337,18 +17337,18 @@ var require_client_h2 = __commonJS({
           h2stream.write(body);
           h2stream.uncork();
           h2stream.end();
-          request3.onBodySent(body);
+          request4.onBodySent(body);
         }
         if (!expectsPayload) {
           socket[kReset] = true;
         }
-        request3.onRequestSent();
+        request4.onRequestSent();
         client[kResume]();
       } catch (error) {
         abort(error);
       }
     }
-    function writeStream(abort, socket, expectsPayload, h2stream, body, client, request3, contentLength) {
+    function writeStream(abort, socket, expectsPayload, h2stream, body, client, request4, contentLength) {
       assert(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
       const pipe = pipeline2(
         body,
@@ -17359,7 +17359,7 @@ var require_client_h2 = __commonJS({
             abort(err);
           } else {
             util2.removeAllListeners(pipe);
-            request3.onRequestSent();
+            request4.onRequestSent();
             if (!expectsPayload) {
               socket[kReset] = true;
             }
@@ -17369,10 +17369,10 @@ var require_client_h2 = __commonJS({
       );
       util2.addListener(pipe, "data", onPipeData);
       function onPipeData(chunk) {
-        request3.onBodySent(chunk);
+        request4.onBodySent(chunk);
       }
     }
-    async function writeBlob(abort, h2stream, body, client, request3, socket, contentLength, expectsPayload) {
+    async function writeBlob(abort, h2stream, body, client, request4, socket, contentLength, expectsPayload) {
       assert(contentLength === body.size, "blob body must have content length");
       try {
         if (contentLength != null && contentLength !== body.size) {
@@ -17383,8 +17383,8 @@ var require_client_h2 = __commonJS({
         h2stream.write(buffer);
         h2stream.uncork();
         h2stream.end();
-        request3.onBodySent(buffer);
-        request3.onRequestSent();
+        request4.onBodySent(buffer);
+        request4.onRequestSent();
         if (!expectsPayload) {
           socket[kReset] = true;
         }
@@ -17393,7 +17393,7 @@ var require_client_h2 = __commonJS({
         abort(err);
       }
     }
-    async function writeIterable(abort, h2stream, body, client, request3, socket, contentLength, expectsPayload) {
+    async function writeIterable(abort, h2stream, body, client, request4, socket, contentLength, expectsPayload) {
       assert(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined");
       let callback = null;
       function onDrain() {
@@ -17403,12 +17403,12 @@ var require_client_h2 = __commonJS({
           cb();
         }
       }
-      const waitForDrain = () => new Promise((resolve6, reject) => {
+      const waitForDrain = () => new Promise((resolve7, reject) => {
         assert(callback === null);
         if (socket[kError]) {
           reject(socket[kError]);
         } else {
-          callback = resolve6;
+          callback = resolve7;
         }
       });
       h2stream.on("close", onDrain).on("drain", onDrain);
@@ -17418,13 +17418,13 @@ var require_client_h2 = __commonJS({
             throw socket[kError];
           }
           const res = h2stream.write(chunk);
-          request3.onBodySent(chunk);
+          request4.onBodySent(chunk);
           if (!res) {
             await waitForDrain();
           }
         }
         h2stream.end();
-        request3.onRequestSent();
+        request4.onRequestSent();
         if (!expectsPayload) {
           socket[kReset] = true;
         }
@@ -17704,10 +17704,10 @@ var require_client = __commonJS({
         this.once("connect", cb);
       }
       [kDispatch](opts, handler) {
-        const request3 = new Request(this[kUrl].origin, opts, handler);
-        this[kQueue].push(request3);
+        const request4 = new Request(this[kUrl].origin, opts, handler);
+        this[kQueue].push(request4);
         if (this[kResuming]) {
-        } else if (util2.bodyLength(request3.body) == null && util2.isIterable(request3.body)) {
+        } else if (util2.bodyLength(request4.body) == null && util2.isIterable(request4.body)) {
           this[kResuming] = 1;
           queueMicrotask(() => resume(this));
         } else {
@@ -17719,27 +17719,27 @@ var require_client = __commonJS({
         return this[kNeedDrain] < 2;
       }
       [kClose]() {
-        return new Promise((resolve6) => {
+        return new Promise((resolve7) => {
           if (this[kSize]) {
-            this[kClosedResolve] = resolve6;
+            this[kClosedResolve] = resolve7;
           } else {
-            resolve6(null);
+            resolve7(null);
           }
         });
       }
       [kDestroy](err) {
-        return new Promise((resolve6) => {
+        return new Promise((resolve7) => {
           const requests = this[kQueue].splice(this[kPendingIdx]);
           for (let i = 0; i < requests.length; i++) {
-            const request3 = requests[i];
-            util2.errorRequest(this, request3, err);
+            const request4 = requests[i];
+            util2.errorRequest(this, request4, err);
           }
           const callback = () => {
             if (this[kClosedResolve]) {
               this[kClosedResolve]();
               this[kClosedResolve] = null;
             }
-            resolve6(null);
+            resolve7(null);
           };
           if (this[kHTTPContext]) {
             this[kHTTPContext].destroy(err, callback);
@@ -17756,8 +17756,8 @@ var require_client = __commonJS({
         assert(client[kPendingIdx] === client[kRunningIdx]);
         const requests = client[kQueue].splice(client[kRunningIdx]);
         for (let i = 0; i < requests.length; i++) {
-          const request3 = requests[i];
-          util2.errorRequest(client, request3, err);
+          const request4 = requests[i];
+          util2.errorRequest(client, request4, err);
         }
         assert(client[kSize] === 0);
       }
@@ -17867,8 +17867,8 @@ var require_client = __commonJS({
       if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") {
         assert(client[kRunning] === 0);
         while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
-          const request3 = client[kQueue][client[kPendingIdx]++];
-          util2.errorRequest(client, request3, err);
+          const request4 = client[kQueue][client[kPendingIdx]++];
+          util2.errorRequest(client, request4, err);
         }
       } else {
         onError(client, err);
@@ -17923,15 +17923,15 @@ var require_client = __commonJS({
         if (client[kRunning] >= (getPipelining(client) || 1)) {
           return;
         }
-        const request3 = client[kQueue][client[kPendingIdx]];
-        if (request3 === null) {
+        const request4 = client[kQueue][client[kPendingIdx]];
+        if (request4 === null) {
           return;
         }
-        if (client[kUrl].protocol === "https:" && client[kServerName] !== request3.servername) {
+        if (client[kUrl].protocol === "https:" && client[kServerName] !== request4.servername) {
           if (client[kRunning] > 0) {
             return;
           }
-          client[kServerName] = request3.servername;
+          client[kServerName] = request4.servername;
           client[kHTTPContext]?.destroy(new InformationalError("servername changed"), () => {
             client[kHTTPContext] = null;
             resume(client);
@@ -17947,10 +17947,10 @@ var require_client = __commonJS({
         if (client[kHTTPContext].destroyed) {
           return;
         }
-        if (client[kHTTPContext].busy(request3)) {
+        if (client[kHTTPContext].busy(request4)) {
           return;
         }
-        if (!request3.aborted && client[kHTTPContext].write(request3)) {
+        if (!request4.aborted && client[kHTTPContext].write(request4)) {
           client[kPendingIdx]++;
         } else {
           client[kQueue].splice(client[kPendingIdx], 1);
@@ -18144,8 +18144,8 @@ var require_pool_base = __commonJS({
           }
           return Promise.all(closeAll);
         } else {
-          return new Promise((resolve6) => {
-            this[kClosedResolve] = resolve6;
+          return new Promise((resolve7) => {
+            this[kClosedResolve] = resolve7;
           });
         }
       }
@@ -18982,13 +18982,13 @@ var require_socks5_client = __commonJS({
         }
         debug("starting handshake with", this.authMethods.length, "auth methods");
         this.state = STATES.HANDSHAKING;
-        const request3 = Buffer2.alloc(2 + this.authMethods.length);
-        request3[0] = SOCKS_VERSION;
-        request3[1] = this.authMethods.length;
+        const request4 = Buffer2.alloc(2 + this.authMethods.length);
+        request4[0] = SOCKS_VERSION;
+        request4[1] = this.authMethods.length;
         this.authMethods.forEach((method, i) => {
-          request3[2 + i] = method;
+          request4[2 + i] = method;
         });
-        this.socket.write(request3);
+        this.socket.write(request4);
       }
       /**
        * Handle handshake response from server
@@ -19030,13 +19030,13 @@ var require_socks5_client = __commonJS({
         if (usernameBuffer.length > 255 || passwordBuffer.length > 255) {
           throw new InvalidArgumentError("Username or password too long");
         }
-        const request3 = Buffer2.alloc(3 + usernameBuffer.length + passwordBuffer.length);
-        request3[0] = 1;
-        request3[1] = usernameBuffer.length;
-        usernameBuffer.copy(request3, 2);
-        request3[2 + usernameBuffer.length] = passwordBuffer.length;
-        passwordBuffer.copy(request3, 3 + usernameBuffer.length);
-        this.socket.write(request3);
+        const request4 = Buffer2.alloc(3 + usernameBuffer.length + passwordBuffer.length);
+        request4[0] = 1;
+        request4[1] = usernameBuffer.length;
+        usernameBuffer.copy(request4, 2);
+        request4[2 + usernameBuffer.length] = passwordBuffer.length;
+        passwordBuffer.copy(request4, 3 + usernameBuffer.length);
+        this.socket.write(request4);
       }
       /**
        * Handle authentication response
@@ -19068,22 +19068,22 @@ var require_socks5_client = __commonJS({
         }
         debug("connecting to", address, port);
         this.state = STATES.CONNECTING;
-        const request3 = this.buildConnectRequest(COMMANDS.CONNECT, address, port);
-        this.socket.write(request3);
+        const request4 = this.buildConnectRequest(COMMANDS.CONNECT, address, port);
+        this.socket.write(request4);
       }
       /**
        * Build a SOCKS5 request
        */
       buildConnectRequest(command, address, port) {
         const { type: addressType, buffer: addressBuffer } = parseAddress(address);
-        const request3 = Buffer2.alloc(4 + addressBuffer.length + 2);
-        request3[0] = SOCKS_VERSION;
-        request3[1] = command;
-        request3[2] = 0;
-        request3[3] = addressType;
-        addressBuffer.copy(request3, 4);
-        request3.writeUInt16BE(port, 4 + addressBuffer.length);
-        return request3;
+        const request4 = Buffer2.alloc(4 + addressBuffer.length + 2);
+        request4[0] = SOCKS_VERSION;
+        request4[1] = command;
+        request4[2] = 0;
+        request4[3] = addressType;
+        addressBuffer.copy(request4, 4);
+        request4.writeUInt16BE(port, 4 + addressBuffer.length);
+        return request4;
       }
       /**
        * Handle CONNECT response
@@ -19237,10 +19237,10 @@ var require_socks5_proxy_agent = __commonJS({
         const proxyHost = this[kProxyUrl].hostname;
         const proxyPort = parseInt(this[kProxyUrl].port) || 1080;
         debug("creating SOCKS5 connection to", proxyHost, proxyPort);
-        const socket = await new Promise((resolve6, reject) => {
+        const socket = await new Promise((resolve7, reject) => {
           const onConnect = () => {
             socket2.removeListener("error", onError);
-            resolve6(socket2);
+            resolve7(socket2);
           };
           const onError = (err) => {
             socket2.removeListener("connect", onConnect);
@@ -19259,14 +19259,14 @@ var require_socks5_proxy_agent = __commonJS({
           socket.destroy();
         });
         await socks5Client.handshake();
-        await new Promise((resolve6, reject) => {
+        await new Promise((resolve7, reject) => {
           const timeout = setTimeout(() => {
             reject(new Error("SOCKS5 authentication timeout"));
           }, 5e3);
           const onAuthenticated = () => {
             clearTimeout(timeout);
             socks5Client.removeListener("error", onError);
-            resolve6();
+            resolve7();
           };
           const onError = (err) => {
             clearTimeout(timeout);
@@ -19275,14 +19275,14 @@ var require_socks5_proxy_agent = __commonJS({
           };
           if (socks5Client.state === "authenticated") {
             clearTimeout(timeout);
-            resolve6();
+            resolve7();
           } else {
             socks5Client.once("authenticated", onAuthenticated);
             socks5Client.once("error", onError);
           }
         });
         await socks5Client.connect(targetHost, targetPort);
-        await new Promise((resolve6, reject) => {
+        await new Promise((resolve7, reject) => {
           const timeout = setTimeout(() => {
             reject(new Error("SOCKS5 connection timeout"));
           }, 5e3);
@@ -19290,7 +19290,7 @@ var require_socks5_proxy_agent = __commonJS({
             debug("SOCKS5 tunnel established to", targetHost, targetPort, "via", info);
             clearTimeout(timeout);
             socks5Client.removeListener("error", onError);
-            resolve6();
+            resolve7();
           };
           const onError = (err) => {
             clearTimeout(timeout);
@@ -19331,8 +19331,8 @@ var require_socks5_proxy_agent = __commonJS({
                       servername: targetHost,
                       ...connectOpts.tls || {}
                     });
-                    await new Promise((resolve6, reject) => {
-                      finalSocket.once("secureConnect", resolve6);
+                    await new Promise((resolve7, reject) => {
+                      finalSocket.once("secureConnect", resolve7);
                       finalSocket.once("error", reject);
                     });
                   }
@@ -20357,7 +20357,7 @@ var require_readable = __commonJS({
         if (this._readableState.closeEmitted) {
           return Promise.resolve(null);
         }
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           if (this[kContentLength] && this[kContentLength] > limit || this[kBytesRead] > limit) {
             this.destroy(new AbortError());
           }
@@ -20371,11 +20371,11 @@ var require_readable = __commonJS({
               if (signal.aborted) {
                 reject(signal.reason ?? new AbortError());
               } else {
-                resolve6(null);
+                resolve7(null);
               }
             });
           } else {
-            this.on("close", resolve6);
+            this.on("close", resolve7);
           }
           this.on("error", noop).on("data", () => {
             if (this[kBytesRead] > limit) {
@@ -20403,7 +20403,7 @@ var require_readable = __commonJS({
     }
     function consume(stream, type) {
       assert(!stream[kConsume]);
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         if (isUnusable(stream)) {
           const rState = stream._readableState;
           if (rState.destroyed && rState.closeEmitted === false) {
@@ -20418,7 +20418,7 @@ var require_readable = __commonJS({
             stream[kConsume] = {
               type,
               stream,
-              resolve: resolve6,
+              resolve: resolve7,
               reject,
               length: 0,
               body: []
@@ -20492,18 +20492,18 @@ var require_readable = __commonJS({
       return buffer;
     }
     function consumeEnd(consume2, encoding) {
-      const { type, body, resolve: resolve6, stream, length } = consume2;
+      const { type, body, resolve: resolve7, stream, length } = consume2;
       try {
         if (type === "text") {
-          resolve6(chunksDecode(body, length, encoding));
+          resolve7(chunksDecode(body, length, encoding));
         } else if (type === "json") {
-          resolve6(JSON.parse(chunksDecode(body, length, encoding)));
+          resolve7(JSON.parse(chunksDecode(body, length, encoding)));
         } else if (type === "arrayBuffer") {
-          resolve6(chunksConcat(body, length).buffer);
+          resolve7(chunksConcat(body, length).buffer);
         } else if (type === "blob") {
-          resolve6(new Blob(body, { type: stream[kContentType] }));
+          resolve7(new Blob(body, { type: stream[kContentType] }));
         } else if (type === "bytes") {
-          resolve6(chunksConcat(body, length));
+          resolve7(chunksConcat(body, length));
         }
         consumeFinish(consume2);
       } catch (err) {
@@ -20691,11 +20691,11 @@ var require_api_request = __commonJS({
         }
       }
     };
-    function request3(opts, callback) {
+    function request4(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve6, reject) => {
-          request3.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve6(data);
+        return new Promise((resolve7, reject) => {
+          request4.call(this, opts, (err, data) => {
+            return err ? reject(err) : resolve7(data);
           });
         });
       }
@@ -20710,7 +20710,7 @@ var require_api_request = __commonJS({
         queueMicrotask(() => callback(err, { opaque }));
       }
     }
-    module.exports = request3;
+    module.exports = request4;
     module.exports.RequestHandler = RequestHandler;
   }
 });
@@ -20907,9 +20907,9 @@ var require_api_stream = __commonJS({
     };
     function stream(opts, factory, callback) {
       if (callback === void 0) {
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           stream.call(this, opts, factory, (err, data) => {
-            return err ? reject(err) : resolve6(data);
+            return err ? reject(err) : resolve7(data);
           });
         });
       }
@@ -21197,9 +21197,9 @@ var require_api_upgrade = __commonJS({
     };
     function upgrade(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           upgrade.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve6(data);
+            return err ? reject(err) : resolve7(data);
           });
         });
       }
@@ -21292,9 +21292,9 @@ var require_api_connect = __commonJS({
     };
     function connect(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           connect.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve6(data);
+            return err ? reject(err) : resolve7(data);
           });
         });
       }
@@ -22567,8 +22567,8 @@ var require_snapshot_utils = __commonJS({
 var require_snapshot_recorder = __commonJS({
   "../../node_modules/.pnpm/undici@7.25.0/node_modules/undici/lib/mock/snapshot-recorder.js"(exports, module) {
     "use strict";
-    var { writeFile: writeFile2, readFile: readFile2, mkdir: mkdir3 } = __require("fs/promises");
-    var { dirname: dirname9, resolve: resolve6 } = __require("path");
+    var { writeFile: writeFile3, readFile: readFile2, mkdir: mkdir4 } = __require("fs/promises");
+    var { dirname: dirname9, resolve: resolve7 } = __require("path");
     var { setTimeout: setTimeout2, clearTimeout: clearTimeout2 } = __require("timers");
     var { InvalidArgumentError, UndiciError } = require_errors();
     var { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } = require_snapshot_utils();
@@ -22693,8 +22693,8 @@ var require_snapshot_recorder = __commonJS({
         if (this.isUrlExcluded(requestOpts)) {
           return;
         }
-        const request3 = formatRequestKey(requestOpts, this.#headerFilters, this.matchOptions);
-        const hash = createRequestHash(request3);
+        const request4 = formatRequestKey(requestOpts, this.#headerFilters, this.matchOptions);
+        const hash = createRequestHash(request4);
         const normalizedHeaders = normalizeHeaders(response.headers);
         const responseData = {
           statusCode: response.statusCode,
@@ -22712,7 +22712,7 @@ var require_snapshot_recorder = __commonJS({
           existingSnapshot.timestamp = (/* @__PURE__ */ new Date()).toISOString();
         } else {
           this.#snapshots.set(hash, {
-            request: request3,
+            request: request4,
             responses: [responseData],
             // Always store as array for consistency
             callCount: 0,
@@ -22746,8 +22746,8 @@ var require_snapshot_recorder = __commonJS({
         if (this.isUrlExcluded(requestOpts)) {
           return void 0;
         }
-        const request3 = formatRequestKey(requestOpts, this.#headerFilters, this.matchOptions);
-        const hash = createRequestHash(request3);
+        const request4 = formatRequestKey(requestOpts, this.#headerFilters, this.matchOptions);
+        const hash = createRequestHash(request4);
         const snapshot = this.#snapshots.get(hash);
         if (!snapshot) return void 0;
         const currentCallCount = snapshot.callCount || 0;
@@ -22769,7 +22769,7 @@ var require_snapshot_recorder = __commonJS({
           throw new InvalidArgumentError("Snapshot path is required");
         }
         try {
-          const data = await readFile2(resolve6(path), "utf8");
+          const data = await readFile2(resolve7(path), "utf8");
           const parsed = JSON.parse(data);
           if (Array.isArray(parsed)) {
             this.#snapshots.clear();
@@ -22798,13 +22798,13 @@ var require_snapshot_recorder = __commonJS({
         if (!path) {
           throw new InvalidArgumentError("Snapshot path is required");
         }
-        const resolvedPath = resolve6(path);
-        await mkdir3(dirname9(resolvedPath), { recursive: true });
+        const resolvedPath = resolve7(path);
+        await mkdir4(dirname9(resolvedPath), { recursive: true });
         const data = Array.from(this.#snapshots.entries()).map(([hash, snapshot]) => ({
           hash,
           snapshot
         }));
-        await writeFile2(resolvedPath, JSON.stringify(data, null, 2), { flush: true });
+        await writeFile3(resolvedPath, JSON.stringify(data, null, 2), { flush: true });
       }
       /**
        * Clears all recorded snapshots
@@ -22842,8 +22842,8 @@ var require_snapshot_recorder = __commonJS({
        * @returns {boolean} - True if snapshot was deleted, false if not found
        */
       deleteSnapshot(requestOpts) {
-        const request3 = formatRequestKey(requestOpts, this.#headerFilters, this.matchOptions);
-        const hash = createRequestHash(request3);
+        const request4 = formatRequestKey(requestOpts, this.#headerFilters, this.matchOptions);
+        const hash = createRequestHash(request4);
         return this.#snapshots.delete(hash);
       }
       /**
@@ -22852,8 +22852,8 @@ var require_snapshot_recorder = __commonJS({
        * @returns {SnapshotInfo|null} - Snapshot information or null if not found
        */
       getSnapshotInfo(requestOpts) {
-        const request3 = formatRequestKey(requestOpts, this.#headerFilters, this.matchOptions);
-        const hash = createRequestHash(request3);
+        const request4 = formatRequestKey(requestOpts, this.#headerFilters, this.matchOptions);
+        const hash = createRequestHash(request4);
         const snapshot = this.#snapshots.get(hash);
         if (!snapshot) return null;
         return {
@@ -23144,16 +23144,16 @@ var require_snapshot_agent = __commonJS({
        */
       #setupMockInterceptors() {
         for (const snapshot of this[kSnapshotRecorder].getSnapshots()) {
-          const { request: request3, responses, response } = snapshot;
-          const url = new URL(request3.url);
+          const { request: request4, responses, response } = snapshot;
+          const url = new URL(request4.url);
           const mockPool = this.get(url.origin);
           const responseData = responses ? responses[0] : response;
           if (!responseData) continue;
           mockPool.intercept({
             path: url.pathname + url.search,
-            method: request3.method,
-            headers: request3.headers,
-            body: request3.body
+            method: request4.method,
+            headers: request4.headers,
+            body: request4.body
           }).reply(responseData.statusCode, responseData.body, {
             headers: responseData.headers,
             trailers: responseData.trailers
@@ -27870,7 +27870,7 @@ var require_request2 = __commonJS({
         webidl.argumentLengthCheck(arguments, 1, prefix);
         input = webidl.converters.RequestInfo(input);
         init = webidl.converters.RequestInit(init);
-        let request3 = null;
+        let request4 = null;
         let fallbackMode = null;
         const baseUrl = environmentSettingsObject.settingsObject.baseUrl;
         let signal = null;
@@ -27887,18 +27887,18 @@ var require_request2 = __commonJS({
               "Request cannot be constructed from a URL that includes credentials: " + input
             );
           }
-          request3 = makeRequest({ urlList: [parsedURL] });
+          request4 = makeRequest({ urlList: [parsedURL] });
           fallbackMode = "cors";
         } else {
           assert(webidl.is.Request(input));
-          request3 = input.#state;
+          request4 = input.#state;
           signal = input.#signal;
           this.#dispatcher = init.dispatcher || input.#dispatcher;
         }
         const origin = environmentSettingsObject.settingsObject.origin;
         let window2 = "client";
-        if (request3.window?.constructor?.name === "EnvironmentSettingsObject" && sameOrigin(request3.window, origin)) {
-          window2 = request3.window;
+        if (request4.window?.constructor?.name === "EnvironmentSettingsObject" && sameOrigin(request4.window, origin)) {
+          window2 = request4.window;
         }
         if (init.window != null) {
           throw new TypeError(`'window' option '${window2}' must be null`);
@@ -27906,66 +27906,66 @@ var require_request2 = __commonJS({
         if ("window" in init) {
           window2 = "no-window";
         }
-        request3 = makeRequest({
+        request4 = 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: request3.method,
+          method: request4.method,
           // header list A copy of request’s header list.
           // undici implementation note: headersList is cloned in makeRequest
-          headersList: request3.headersList,
+          headersList: request4.headersList,
           // unsafe-request flag Set.
-          unsafeRequest: request3.unsafeRequest,
+          unsafeRequest: request4.unsafeRequest,
           // client This’s relevant settings object.
           client: environmentSettingsObject.settingsObject,
           // window window.
           window: window2,
           // priority request’s priority.
-          priority: request3.priority,
+          priority: request4.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: request3.origin,
+          origin: request4.origin,
           // referrer request’s referrer.
-          referrer: request3.referrer,
+          referrer: request4.referrer,
           // referrer policy request’s referrer policy.
-          referrerPolicy: request3.referrerPolicy,
+          referrerPolicy: request4.referrerPolicy,
           // mode request’s mode.
-          mode: request3.mode,
+          mode: request4.mode,
           // credentials mode request’s credentials mode.
-          credentials: request3.credentials,
+          credentials: request4.credentials,
           // cache mode request’s cache mode.
-          cache: request3.cache,
+          cache: request4.cache,
           // redirect mode request’s redirect mode.
-          redirect: request3.redirect,
+          redirect: request4.redirect,
           // integrity metadata request’s integrity metadata.
-          integrity: request3.integrity,
+          integrity: request4.integrity,
           // keepalive request’s keepalive.
-          keepalive: request3.keepalive,
+          keepalive: request4.keepalive,
           // reload-navigation flag request’s reload-navigation flag.
-          reloadNavigation: request3.reloadNavigation,
+          reloadNavigation: request4.reloadNavigation,
           // history-navigation flag request’s history-navigation flag.
-          historyNavigation: request3.historyNavigation,
+          historyNavigation: request4.historyNavigation,
           // URL list A clone of request’s URL list.
-          urlList: [...request3.urlList]
+          urlList: [...request4.urlList]
         });
         const initHasKey = Object.keys(init).length !== 0;
         if (initHasKey) {
-          if (request3.mode === "navigate") {
-            request3.mode = "same-origin";
+          if (request4.mode === "navigate") {
+            request4.mode = "same-origin";
           }
-          request3.reloadNavigation = false;
-          request3.historyNavigation = false;
-          request3.origin = "client";
-          request3.referrer = "client";
-          request3.referrerPolicy = "";
-          request3.url = request3.urlList[request3.urlList.length - 1];
-          request3.urlList = [request3.url];
+          request4.reloadNavigation = false;
+          request4.historyNavigation = false;
+          request4.origin = "client";
+          request4.referrer = "client";
+          request4.referrerPolicy = "";
+          request4.url = request4.urlList[request4.urlList.length - 1];
+          request4.urlList = [request4.url];
         }
         if (init.referrer !== void 0) {
           const referrer = init.referrer;
           if (referrer === "") {
-            request3.referrer = "no-referrer";
+            request4.referrer = "no-referrer";
           } else {
             let parsedReferrer;
             try {
@@ -27974,14 +27974,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)) {
-              request3.referrer = "client";
+              request4.referrer = "client";
             } else {
-              request3.referrer = parsedReferrer;
+              request4.referrer = parsedReferrer;
             }
           }
         }
         if (init.referrerPolicy !== void 0) {
-          request3.referrerPolicy = init.referrerPolicy;
+          request4.referrerPolicy = init.referrerPolicy;
         }
         let mode;
         if (init.mode !== void 0) {
@@ -27996,33 +27996,33 @@ var require_request2 = __commonJS({
           });
         }
         if (mode != null) {
-          request3.mode = mode;
+          request4.mode = mode;
         }
         if (init.credentials !== void 0) {
-          request3.credentials = init.credentials;
+          request4.credentials = init.credentials;
         }
         if (init.cache !== void 0) {
-          request3.cache = init.cache;
+          request4.cache = init.cache;
         }
-        if (request3.cache === "only-if-cached" && request3.mode !== "same-origin") {
+        if (request4.cache === "only-if-cached" && request4.mode !== "same-origin") {
           throw new TypeError(
             "'only-if-cached' can be set only with 'same-origin' mode"
           );
         }
         if (init.redirect !== void 0) {
-          request3.redirect = init.redirect;
+          request4.redirect = init.redirect;
         }
         if (init.integrity != null) {
-          request3.integrity = String(init.integrity);
+          request4.integrity = String(init.integrity);
         }
         if (init.keepalive !== void 0) {
-          request3.keepalive = Boolean(init.keepalive);
+          request4.keepalive = Boolean(init.keepalive);
         }
         if (init.method !== void 0) {
           let method = init.method;
           const mayBeNormalized = normalizedMethodRecords[method];
           if (mayBeNormalized !== void 0) {
-            request3.method = mayBeNormalized;
+            request4.method = mayBeNormalized;
           } else {
             if (!isValidHTTPToken(method)) {
               throw new TypeError(`'${method}' is not a valid HTTP method.`);
@@ -28032,9 +28032,9 @@ var require_request2 = __commonJS({
               throw new TypeError(`'${method}' HTTP method is unsupported.`);
             }
             method = normalizedMethodRecordsBase[upperCase] ?? method;
-            request3.method = method;
+            request4.method = method;
           }
-          if (!patchMethodWarning && request3.method === "patch") {
+          if (!patchMethodWarning && request4.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"
             });
@@ -28044,7 +28044,7 @@ var require_request2 = __commonJS({
         if (init.signal !== void 0) {
           signal = init.signal;
         }
-        this.#state = request3;
+        this.#state = request4;
         const ac = new AbortController();
         this.#signal = ac.signal;
         if (signal != null) {
@@ -28062,12 +28062,12 @@ var require_request2 = __commonJS({
           }
         }
         this.#headers = new Headers(kConstruct);
-        setHeadersList(this.#headers, request3.headersList);
+        setHeadersList(this.#headers, request4.headersList);
         setHeadersGuard(this.#headers, "request");
         if (mode === "no-cors") {
-          if (!corsSafeListedMethodsSet.has(request3.method)) {
+          if (!corsSafeListedMethodsSet.has(request4.method)) {
             throw new TypeError(
-              `'${request3.method} is unsupported in no-cors mode.`
+              `'${request4.method} is unsupported in no-cors mode.`
             );
           }
           setHeadersGuard(this.#headers, "request-no-cors");
@@ -28086,14 +28086,14 @@ var require_request2 = __commonJS({
           }
         }
         const inputBody = webidl.is.Request(input) ? input.#state.body : null;
-        if ((init.body != null || inputBody != null) && (request3.method === "GET" || request3.method === "HEAD")) {
+        if ((init.body != null || inputBody != null) && (request4.method === "GET" || request4.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,
-            request3.keepalive
+            request4.keepalive
           );
           initBody = extractedBody;
           if (contentType && !getHeadersList(this.#headers).contains("content-type", true)) {
@@ -28105,12 +28105,12 @@ var require_request2 = __commonJS({
           if (initBody != null && init.duplex == null) {
             throw new TypeError("RequestInit: duplex option is required when sending a body.");
           }
-          if (request3.mode !== "same-origin" && request3.mode !== "cors") {
+          if (request4.mode !== "same-origin" && request4.mode !== "cors") {
             throw new TypeError(
               'If request is made from ReadableStream, mode should be "same-origin" or "cors"'
             );
           }
-          request3.useCORSPreflightFlag = true;
+          request4.useCORSPreflightFlag = true;
         }
         let finalBody = inputOrInitBody;
         if (initBody == null && inputBody != null) {
@@ -28300,42 +28300,42 @@ var require_request2 = __commonJS({
        * @param {Request} request
        * @param {AbortSignal} newSignal
        */
-      static setRequestSignal(request3, newSignal) {
-        request3.#signal = newSignal;
-        return request3;
+      static setRequestSignal(request4, newSignal) {
+        request4.#signal = newSignal;
+        return request4;
       }
       /**
        * @param {Request} request
        */
-      static getRequestDispatcher(request3) {
-        return request3.#dispatcher;
+      static getRequestDispatcher(request4) {
+        return request4.#dispatcher;
       }
       /**
        * @param {Request} request
        * @param {import('../../dispatcher/dispatcher')} newDispatcher
        */
-      static setRequestDispatcher(request3, newDispatcher) {
-        request3.#dispatcher = newDispatcher;
+      static setRequestDispatcher(request4, newDispatcher) {
+        request4.#dispatcher = newDispatcher;
       }
       /**
        * @param {Request} request
        * @param {Headers} newHeaders
        */
-      static setRequestHeaders(request3, newHeaders) {
-        request3.#headers = newHeaders;
+      static setRequestHeaders(request4, newHeaders) {
+        request4.#headers = newHeaders;
       }
       /**
        * @param {Request} request
        */
-      static getRequestState(request3) {
-        return request3.#state;
+      static getRequestState(request4) {
+        return request4.#state;
       }
       /**
        * @param {Request} request
        * @param {any} newState
        */
-      static setRequestState(request3, newState) {
-        request3.#state = newState;
+      static setRequestState(request4, newState) {
+        request4.#state = newState;
       }
     };
     var { setRequestSignal, getRequestDispatcher, setRequestDispatcher, setRequestHeaders, getRequestState, setRequestState } = Request;
@@ -28390,23 +28390,23 @@ var require_request2 = __commonJS({
         headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList()
       };
     }
-    function cloneRequest(request3) {
-      const newRequest = makeRequest({ ...request3, body: null });
-      if (request3.body != null) {
-        newRequest.body = cloneBody(request3.body);
+    function cloneRequest(request4) {
+      const newRequest = makeRequest({ ...request4, body: null });
+      if (request4.body != null) {
+        newRequest.body = cloneBody(request4.body);
       }
       return newRequest;
     }
     function fromInnerRequest(innerRequest, dispatcher, signal, guard) {
-      const request3 = new Request(kConstruct);
-      setRequestState(request3, innerRequest);
-      setRequestDispatcher(request3, dispatcher);
-      setRequestSignal(request3, signal);
+      const request4 = new Request(kConstruct);
+      setRequestState(request4, innerRequest);
+      setRequestDispatcher(request4, dispatcher);
+      setRequestSignal(request4, signal);
       const headers = new Headers(kConstruct);
-      setRequestHeaders(request3, headers);
+      setRequestHeaders(request4, headers);
       setHeadersList(headers, innerRequest.headersList);
       setHeadersGuard(headers, guard);
-      return request3;
+      return request4;
     }
     Object.defineProperties(Request.prototype, {
       method: kEnumerableProperty,
@@ -28798,14 +28798,14 @@ var require_fetch = __commonJS({
         p.reject(e);
         return p.promise;
       }
-      const request3 = getRequestState(requestObject);
+      const request4 = getRequestState(requestObject);
       if (requestObject.signal.aborted) {
-        abortFetch(p, request3, null, requestObject.signal.reason, null);
+        abortFetch(p, request4, null, requestObject.signal.reason, null);
         return p.promise;
       }
-      const globalObject = request3.client.globalObject;
+      const globalObject = request4.client.globalObject;
       if (globalObject?.constructor?.name === "ServiceWorkerGlobalScope") {
-        request3.serviceWorkers = "none";
+        request4.serviceWorkers = "none";
       }
       let responseObject = null;
       let locallyAborted = false;
@@ -28817,7 +28817,7 @@ var require_fetch = __commonJS({
           assert(controller != null);
           controller.abort(requestObject.signal.reason);
           const realResponse = responseObject?.deref();
-          abortFetch(p, request3, realResponse, requestObject.signal.reason, controller.controller);
+          abortFetch(p, request4, realResponse, requestObject.signal.reason, controller.controller);
         }
       );
       const processResponse = (response) => {
@@ -28825,7 +28825,7 @@ var require_fetch = __commonJS({
           return;
         }
         if (response.aborted) {
-          abortFetch(p, request3, responseObject, controller.serializedAbortReason, controller.controller);
+          abortFetch(p, request4, responseObject, controller.serializedAbortReason, controller.controller);
           return;
         }
         if (response.type === "error") {
@@ -28837,7 +28837,7 @@ var require_fetch = __commonJS({
         p = null;
       };
       controller = fetching({
-        request: request3,
+        request: request4,
         processResponseEndOfBody: handleFetchDone,
         processResponse,
         dispatcher: getRequestDispatcher(requestObject),
@@ -28884,12 +28884,12 @@ var require_fetch = __commonJS({
       );
     }
     var markResourceTiming = performance.markResourceTiming;
-    function abortFetch(p, request3, responseObject, error, controller) {
+    function abortFetch(p, request4, responseObject, error, controller) {
       if (p) {
         p.reject(error);
       }
-      if (request3.body?.stream != null && isReadable(request3.body.stream)) {
-        request3.body.stream.cancel(error).catch((err) => {
+      if (request4.body?.stream != null && isReadable(request4.body.stream)) {
+        request4.body.stream.cancel(error).catch((err) => {
           if (err.code === "ERR_INVALID_STATE") {
             return;
           }
@@ -28905,7 +28905,7 @@ var require_fetch = __commonJS({
       }
     }
     function fetching({
-      request: request3,
+      request: request4,
       processRequestBodyChunkLength,
       processRequestEndOfBody,
       processResponse,
@@ -28920,9 +28920,9 @@ var require_fetch = __commonJS({
       assert(dispatcher);
       let taskDestination = null;
       let crossOriginIsolatedCapability = false;
-      if (request3.client != null) {
-        taskDestination = request3.client.globalObject;
-        crossOriginIsolatedCapability = request3.client.crossOriginIsolatedCapability;
+      if (request4.client != null) {
+        taskDestination = request4.client.globalObject;
+        crossOriginIsolatedCapability = request4.client.crossOriginIsolatedCapability;
       }
       const currentTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability);
       const timingInfo = createOpaqueTimingInfo({
@@ -28930,7 +28930,7 @@ var require_fetch = __commonJS({
       });
       const fetchParams = {
         controller: new Fetch(dispatcher),
-        request: request3,
+        request: request4,
         timingInfo,
         processRequestBodyChunkLength,
         processRequestEndOfBody,
@@ -28942,79 +28942,79 @@ var require_fetch = __commonJS({
         // Keep requestObject alive to prevent its AbortController from being GC'd
         requestObject
       };
-      assert(!request3.body || request3.body.stream);
-      if (request3.window === "client") {
-        request3.window = request3.client?.globalObject?.constructor?.name === "Window" ? request3.client : "no-window";
+      assert(!request4.body || request4.body.stream);
+      if (request4.window === "client") {
+        request4.window = request4.client?.globalObject?.constructor?.name === "Window" ? request4.client : "no-window";
       }
-      if (request3.origin === "client") {
-        request3.origin = request3.client.origin;
+      if (request4.origin === "client") {
+        request4.origin = request4.client.origin;
       }
-      if (request3.policyContainer === "client") {
-        if (request3.client != null) {
-          request3.policyContainer = clonePolicyContainer(
-            request3.client.policyContainer
+      if (request4.policyContainer === "client") {
+        if (request4.client != null) {
+          request4.policyContainer = clonePolicyContainer(
+            request4.client.policyContainer
           );
         } else {
-          request3.policyContainer = makePolicyContainer();
+          request4.policyContainer = makePolicyContainer();
         }
       }
-      if (!request3.headersList.contains("accept", true)) {
+      if (!request4.headersList.contains("accept", true)) {
         const value = "*/*";
-        request3.headersList.append("accept", value, true);
+        request4.headersList.append("accept", value, true);
       }
-      if (!request3.headersList.contains("accept-language", true)) {
-        request3.headersList.append("accept-language", "*", true);
+      if (!request4.headersList.contains("accept-language", true)) {
+        request4.headersList.append("accept-language", "*", true);
       }
-      if (request3.priority === null) {
+      if (request4.priority === null) {
       }
-      if (subresourceSet.has(request3.destination)) {
+      if (subresourceSet.has(request4.destination)) {
       }
       mainFetch(fetchParams, false);
       return fetchParams.controller;
     }
     async function mainFetch(fetchParams, recursive) {
       try {
-        const request3 = fetchParams.request;
+        const request4 = fetchParams.request;
         let response = null;
-        if (request3.localURLsOnly && !urlIsLocal(requestCurrentURL(request3))) {
+        if (request4.localURLsOnly && !urlIsLocal(requestCurrentURL(request4))) {
           response = makeNetworkError("local URLs only");
         }
-        tryUpgradeRequestToAPotentiallyTrustworthyURL(request3);
-        if (requestBadPort(request3) === "blocked") {
+        tryUpgradeRequestToAPotentiallyTrustworthyURL(request4);
+        if (requestBadPort(request4) === "blocked") {
           response = makeNetworkError("bad port");
         }
-        if (request3.referrerPolicy === "") {
-          request3.referrerPolicy = request3.policyContainer.referrerPolicy;
+        if (request4.referrerPolicy === "") {
+          request4.referrerPolicy = request4.policyContainer.referrerPolicy;
         }
-        if (request3.referrer !== "no-referrer") {
-          request3.referrer = determineRequestsReferrer(request3);
+        if (request4.referrer !== "no-referrer") {
+          request4.referrer = determineRequestsReferrer(request4);
         }
         if (response === null) {
-          const currentURL = requestCurrentURL(request3);
+          const currentURL = requestCurrentURL(request4);
           if (
             // - request’s current URL’s origin is same origin with request’s origin,
             //   and request’s response tainting is "basic"
-            sameOrigin(currentURL, request3.url) && request3.responseTainting === "basic" || // request’s current URL’s scheme is "data"
+            sameOrigin(currentURL, request4.url) && request4.responseTainting === "basic" || // request’s current URL’s scheme is "data"
             currentURL.protocol === "data:" || // - request’s mode is "navigate" or "websocket"
-            (request3.mode === "navigate" || request3.mode === "websocket")
+            (request4.mode === "navigate" || request4.mode === "websocket")
           ) {
-            request3.responseTainting = "basic";
+            request4.responseTainting = "basic";
             response = await schemeFetch(fetchParams);
-          } else if (request3.mode === "same-origin") {
+          } else if (request4.mode === "same-origin") {
             response = makeNetworkError('request mode cannot be "same-origin"');
-          } else if (request3.mode === "no-cors") {
-            if (request3.redirect !== "follow") {
+          } else if (request4.mode === "no-cors") {
+            if (request4.redirect !== "follow") {
               response = makeNetworkError(
                 'redirect mode cannot be "follow" for "no-cors" request'
               );
             } else {
-              request3.responseTainting = "opaque";
+              request4.responseTainting = "opaque";
               response = await schemeFetch(fetchParams);
             }
-          } else if (!urlIsHttpHttpsScheme(requestCurrentURL(request3))) {
+          } else if (!urlIsHttpHttpsScheme(requestCurrentURL(request4))) {
             response = makeNetworkError("URL scheme must be a HTTP(S) scheme");
           } else {
-            request3.responseTainting = "cors";
+            request4.responseTainting = "cors";
             response = await httpFetch(fetchParams);
           }
         }
@@ -29022,13 +29022,13 @@ var require_fetch = __commonJS({
           return response;
         }
         if (response.status !== 0 && !response.internalResponse) {
-          if (request3.responseTainting === "cors") {
+          if (request4.responseTainting === "cors") {
           }
-          if (request3.responseTainting === "basic") {
+          if (request4.responseTainting === "basic") {
             response = filterResponse(response, "basic");
-          } else if (request3.responseTainting === "cors") {
+          } else if (request4.responseTainting === "cors") {
             response = filterResponse(response, "cors");
-          } else if (request3.responseTainting === "opaque") {
+          } else if (request4.responseTainting === "opaque") {
             response = filterResponse(response, "opaque");
           } else {
             assert(false);
@@ -29036,26 +29036,26 @@ var require_fetch = __commonJS({
         }
         let internalResponse = response.status === 0 ? response : response.internalResponse;
         if (internalResponse.urlList.length === 0) {
-          internalResponse.urlList.push(...request3.urlList);
+          internalResponse.urlList.push(...request4.urlList);
         }
-        if (!request3.timingAllowFailed) {
+        if (!request4.timingAllowFailed) {
           response.timingAllowPassed = true;
         }
-        if (response.type === "opaque" && internalResponse.status === 206 && internalResponse.rangeRequested && !request3.headers.contains("range", true)) {
+        if (response.type === "opaque" && internalResponse.status === 206 && internalResponse.rangeRequested && !request4.headers.contains("range", true)) {
           response = internalResponse = makeNetworkError();
         }
-        if (response.status !== 0 && (request3.method === "HEAD" || request3.method === "CONNECT" || nullBodyStatus.includes(internalResponse.status))) {
+        if (response.status !== 0 && (request4.method === "HEAD" || request4.method === "CONNECT" || nullBodyStatus.includes(internalResponse.status))) {
           internalResponse.body = null;
           fetchParams.controller.dump = true;
         }
-        if (request3.integrity) {
+        if (request4.integrity) {
           const processBodyError = (reason) => fetchFinale(fetchParams, makeNetworkError(reason));
-          if (request3.responseTainting === "opaque" || response.body == null) {
+          if (request4.responseTainting === "opaque" || response.body == null) {
             processBodyError(response.error);
             return;
           }
           const processBody = (bytes) => {
-            if (!bytesMatch(bytes, request3.integrity)) {
+            if (!bytesMatch(bytes, request4.integrity)) {
               processBodyError("integrity mismatch");
               return;
             }
@@ -29074,8 +29074,8 @@ var require_fetch = __commonJS({
       if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) {
         return Promise.resolve(makeAppropriateNetworkError(fetchParams));
       }
-      const { request: request3 } = fetchParams;
-      const { protocol: scheme } = requestCurrentURL(request3);
+      const { request: request4 } = fetchParams;
+      const { protocol: scheme } = requestCurrentURL(request4);
       switch (scheme) {
         case "about:": {
           return Promise.resolve(makeNetworkError("about scheme is not supported"));
@@ -29084,19 +29084,19 @@ var require_fetch = __commonJS({
           if (!resolveObjectURL) {
             resolveObjectURL = __require("buffer").resolveObjectURL;
           }
-          const blobURLEntry = requestCurrentURL(request3);
+          const blobURLEntry = requestCurrentURL(request4);
           if (blobURLEntry.search.length !== 0) {
             return Promise.resolve(makeNetworkError("NetworkError when attempting to fetch resource."));
           }
           const blob = resolveObjectURL(blobURLEntry.toString());
-          if (request3.method !== "GET" || !webidl.is.Blob(blob)) {
+          if (request4.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 (!request3.headersList.contains("range", true)) {
+          if (!request4.headersList.contains("range", true)) {
             const bodyWithType = extractBody(blob);
             response.statusText = "OK";
             response.body = bodyWithType[0];
@@ -29104,7 +29104,7 @@ var require_fetch = __commonJS({
             response.headersList.set("content-type", type, true);
           } else {
             response.rangeRequested = true;
-            const rangeHeader = request3.headersList.get("range", true);
+            const rangeHeader = request4.headersList.get("range", true);
             const rangeValue = simpleRangeHeaderValue(rangeHeader, true);
             if (rangeValue === "failure") {
               return Promise.resolve(makeNetworkError("failed to fetch the data URL"));
@@ -29135,7 +29135,7 @@ var require_fetch = __commonJS({
           return Promise.resolve(response);
         }
         case "data:": {
-          const currentURL = requestCurrentURL(request3);
+          const currentURL = requestCurrentURL(request4);
           const dataURLStruct = dataURLProcessor(currentURL);
           if (dataURLStruct === "failure") {
             return Promise.resolve(makeNetworkError("failed to fetch the data URL"));
@@ -29224,41 +29224,41 @@ var require_fetch = __commonJS({
       }
     }
     async function httpFetch(fetchParams) {
-      const request3 = fetchParams.request;
+      const request4 = fetchParams.request;
       let response = null;
       let actualResponse = null;
       const timingInfo = fetchParams.timingInfo;
-      if (request3.serviceWorkers === "all") {
+      if (request4.serviceWorkers === "all") {
       }
       if (response === null) {
-        if (request3.redirect === "follow") {
-          request3.serviceWorkers = "none";
+        if (request4.redirect === "follow") {
+          request4.serviceWorkers = "none";
         }
         actualResponse = response = await httpNetworkOrCacheFetch(fetchParams);
-        if (request3.responseTainting === "cors" && corsCheck(request3, response) === "failure") {
+        if (request4.responseTainting === "cors" && corsCheck(request4, response) === "failure") {
           return makeNetworkError("cors failure");
         }
-        if (TAOCheck(request3, response) === "failure") {
-          request3.timingAllowFailed = true;
+        if (TAOCheck(request4, response) === "failure") {
+          request4.timingAllowFailed = true;
         }
       }
-      if ((request3.responseTainting === "opaque" || response.type === "opaque") && crossOriginResourcePolicyCheck(
-        request3.origin,
-        request3.client,
-        request3.destination,
+      if ((request4.responseTainting === "opaque" || response.type === "opaque") && crossOriginResourcePolicyCheck(
+        request4.origin,
+        request4.client,
+        request4.destination,
         actualResponse
       ) === "blocked") {
         return makeNetworkError("blocked");
       }
       if (redirectStatusSet.has(actualResponse.status)) {
-        if (request3.redirect !== "manual") {
+        if (request4.redirect !== "manual") {
           fetchParams.controller.connection.destroy(void 0, false);
         }
-        if (request3.redirect === "error") {
+        if (request4.redirect === "error") {
           response = makeNetworkError("unexpected redirect");
-        } else if (request3.redirect === "manual") {
+        } else if (request4.redirect === "manual") {
           response = actualResponse;
-        } else if (request3.redirect === "follow") {
+        } else if (request4.redirect === "follow") {
           response = await httpRedirectFetch(fetchParams, response);
         } else {
           assert(false);
@@ -29268,13 +29268,13 @@ var require_fetch = __commonJS({
       return response;
     }
     function httpRedirectFetch(fetchParams, response) {
-      const request3 = fetchParams.request;
+      const request4 = fetchParams.request;
       const actualResponse = response.internalResponse ? response.internalResponse : response;
       let locationURL;
       try {
         locationURL = responseLocationURL(
           actualResponse,
-          requestCurrentURL(request3).hash
+          requestCurrentURL(request4).hash
         );
         if (locationURL == null) {
           return response;
@@ -29285,63 +29285,63 @@ var require_fetch = __commonJS({
       if (!urlIsHttpHttpsScheme(locationURL)) {
         return Promise.resolve(makeNetworkError("URL scheme must be a HTTP(S) scheme"));
       }
-      if (request3.redirectCount === 20) {
+      if (request4.redirectCount === 20) {
         return Promise.resolve(makeNetworkError("redirect count exceeded"));
       }
-      request3.redirectCount += 1;
-      if (request3.mode === "cors" && (locationURL.username || locationURL.password) && !sameOrigin(request3, locationURL)) {
+      request4.redirectCount += 1;
+      if (request4.mode === "cors" && (locationURL.username || locationURL.password) && !sameOrigin(request4, locationURL)) {
         return Promise.resolve(makeNetworkError('cross origin not allowed for request mode "cors"'));
       }
-      if (request3.responseTainting === "cors" && (locationURL.username || locationURL.password)) {
+      if (request4.responseTainting === "cors" && (locationURL.username || locationURL.password)) {
         return Promise.resolve(makeNetworkError(
           'URL cannot contain credentials for request mode "cors"'
         ));
       }
-      if (actualResponse.status !== 303 && request3.body != null && request3.body.source == null) {
+      if (actualResponse.status !== 303 && request4.body != null && request4.body.source == null) {
         return Promise.resolve(makeNetworkError());
       }
-      if ([301, 302].includes(actualResponse.status) && request3.method === "POST" || actualResponse.status === 303 && !GET_OR_HEAD.includes(request3.method)) {
-        request3.method = "GET";
-        request3.body = null;
+      if ([301, 302].includes(actualResponse.status) && request4.method === "POST" || actualResponse.status === 303 && !GET_OR_HEAD.includes(request4.method)) {
+        request4.method = "GET";
+        request4.body = null;
         for (const headerName of requestBodyHeader) {
-          request3.headersList.delete(headerName);
+          request4.headersList.delete(headerName);
         }
       }
-      if (!sameOrigin(requestCurrentURL(request3), locationURL)) {
-        request3.headersList.delete("authorization", true);
-        request3.headersList.delete("proxy-authorization", true);
-        request3.headersList.delete("cookie", true);
-        request3.headersList.delete("host", true);
+      if (!sameOrigin(requestCurrentURL(request4), locationURL)) {
+        request4.headersList.delete("authorization", true);
+        request4.headersList.delete("proxy-authorization", true);
+        request4.headersList.delete("cookie", true);
+        request4.headersList.delete("host", true);
       }
-      if (request3.body != null) {
-        assert(request3.body.source != null);
-        request3.body = safelyExtractBody(request3.body.source)[0];
+      if (request4.body != null) {
+        assert(request4.body.source != null);
+        request4.body = safelyExtractBody(request4.body.source)[0];
       }
       const timingInfo = fetchParams.timingInfo;
       timingInfo.redirectEndTime = timingInfo.postRedirectStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability);
       if (timingInfo.redirectStartTime === 0) {
         timingInfo.redirectStartTime = timingInfo.startTime;
       }
-      request3.urlList.push(locationURL);
-      setRequestReferrerPolicyOnRedirect(request3, actualResponse);
+      request4.urlList.push(locationURL);
+      setRequestReferrerPolicyOnRedirect(request4, actualResponse);
       return mainFetch(fetchParams, true);
     }
     async function httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch = false, isNewConnectionFetch = false) {
-      const request3 = fetchParams.request;
+      const request4 = fetchParams.request;
       let httpFetchParams = null;
       let httpRequest = null;
       let response = null;
       const httpCache = null;
       const revalidatingFlag = false;
-      if (request3.window === "no-window" && request3.redirect === "error") {
+      if (request4.window === "no-window" && request4.redirect === "error") {
         httpFetchParams = fetchParams;
-        httpRequest = request3;
+        httpRequest = request4;
       } else {
-        httpRequest = cloneRequest(request3);
+        httpRequest = cloneRequest(request4);
         httpFetchParams = { ...fetchParams };
         httpFetchParams.request = httpRequest;
       }
-      const includeCredentials = request3.credentials === "include" || request3.credentials === "same-origin" && request3.responseTainting === "basic";
+      const includeCredentials = request4.credentials === "include" || request4.credentials === "same-origin" && request4.responseTainting === "basic";
       const contentLength = httpRequest.body ? httpRequest.body.length : null;
       let contentLengthHeaderValue = null;
       if (httpRequest.body == null && ["POST", "PUT"].includes(httpRequest.method)) {
@@ -29428,14 +29428,14 @@ var require_fetch = __commonJS({
         response.rangeRequested = true;
       }
       response.requestIncludesCredentials = includeCredentials;
-      if (response.status === 401 && httpRequest.responseTainting !== "cors" && includeCredentials && (request3.useURLCredentials !== void 0 || isTraversableNavigable(request3.traversableForUserPrompts))) {
-        if (request3.body != null) {
-          if (request3.body.source == null) {
+      if (response.status === 401 && httpRequest.responseTainting !== "cors" && includeCredentials && (request4.useURLCredentials !== void 0 || isTraversableNavigable(request4.traversableForUserPrompts))) {
+        if (request4.body != null) {
+          if (request4.body.source == null) {
             return response;
           }
-          request3.body = safelyExtractBody(request3.body.source)[0];
+          request4.body = safelyExtractBody(request4.body.source)[0];
         }
-        if (request3.useURLCredentials === void 0 || isAuthenticationFetch) {
+        if (request4.useURLCredentials === void 0 || isAuthenticationFetch) {
           if (isCancelled(fetchParams)) {
             return makeAppropriateNetworkError(fetchParams);
           }
@@ -29445,7 +29445,7 @@ var require_fetch = __commonJS({
         response = await httpNetworkOrCacheFetch(fetchParams, true);
       }
       if (response.status === 407) {
-        if (request3.window === "no-window") {
+        if (request4.window === "no-window") {
           return makeNetworkError();
         }
         if (isCancelled(fetchParams)) {
@@ -29457,7 +29457,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
-        (request3.body == null || request3.body.source != null)
+        (request4.body == null || request4.body.source != null)
       ) {
         if (isCancelled(fetchParams)) {
           return makeAppropriateNetworkError(fetchParams);
@@ -29487,21 +29487,21 @@ var require_fetch = __commonJS({
           }
         }
       };
-      const request3 = fetchParams.request;
+      const request4 = fetchParams.request;
       let response = null;
       const timingInfo = fetchParams.timingInfo;
       const httpCache = null;
       if (httpCache == null) {
-        request3.cache = "no-store";
+        request4.cache = "no-store";
       }
       const newConnection = forceNewConnection ? "yes" : "no";
-      if (request3.mode === "websocket") {
+      if (request4.mode === "websocket") {
       } else {
       }
       let requestBody = null;
-      if (request3.body == null && fetchParams.processRequestEndOfBody) {
+      if (request4.body == null && fetchParams.processRequestEndOfBody) {
         queueMicrotask(() => fetchParams.processRequestEndOfBody());
-      } else if (request3.body != null) {
+      } else if (request4.body != null) {
         const processBodyChunk = async function* (bytes) {
           if (isCancelled(fetchParams)) {
             return;
@@ -29529,7 +29529,7 @@ var require_fetch = __commonJS({
         };
         requestBody = (async function* () {
           try {
-            for await (const bytes of request3.body.stream) {
+            for await (const bytes of request4.body.stream) {
               yield* processBodyChunk(bytes);
             }
             processEndOfBody();
@@ -29636,19 +29636,19 @@ var require_fetch = __commonJS({
       }
       return response;
       function dispatch({ body }) {
-        const url = requestCurrentURL(request3);
+        const url = requestCurrentURL(request4);
         const agent = fetchParams.controller.dispatcher;
         const path = url.pathname + url.search;
         const hasTrailingQuestionMark = url.search.length === 0 && url.href[url.href.length - url.hash.length - 1] === "?";
-        return new Promise((resolve6, reject) => agent.dispatch(
+        return new Promise((resolve7, reject) => agent.dispatch(
           {
             path: hasTrailingQuestionMark ? `${path}?` : path,
             origin: url.origin,
-            method: request3.method,
-            body: agent.isMockActive ? request3.body && (request3.body.source || request3.body.stream) : body,
-            headers: request3.headersList.entries,
+            method: request4.method,
+            body: agent.isMockActive ? request4.body && (request4.body.source || request4.body.stream) : body,
+            headers: request4.headersList.entries,
             maxRedirections: 0,
-            upgrade: request3.mode === "websocket" ? "websocket" : void 0
+            upgrade: request4.mode === "websocket" ? "websocket" : void 0
           },
           {
             body: null,
@@ -29685,9 +29685,9 @@ var require_fetch = __commonJS({
               }
               const location = headersList.get("location", true);
               this.body = new Readable2({ read: resume });
-              const willFollow = location && request3.redirect === "follow" && redirectStatusSet.has(status2);
+              const willFollow = location && request4.redirect === "follow" && redirectStatusSet.has(status2);
               const decoders = [];
-              if (request3.method !== "HEAD" && request3.method !== "CONNECT" && !nullBodyStatus.includes(status2) && !willFollow) {
+              if (request4.method !== "HEAD" && request4.method !== "CONNECT" && !nullBodyStatus.includes(status2) && !willFollow) {
                 const contentEncoding = headersList.get("content-encoding", true);
                 const codings = contentEncoding ? contentEncoding.toLowerCase().split(",") : [];
                 const maxContentEncodings = 5;
@@ -29728,7 +29728,7 @@ var require_fetch = __commonJS({
                 }
               }
               const onError = this.onError.bind(this);
-              resolve6({
+              resolve7({
                 status: status2,
                 statusText,
                 headersList,
@@ -29781,7 +29781,7 @@ var require_fetch = __commonJS({
                   headersList.append(headerName, String(value), true);
                 }
               }
-              resolve6({
+              resolve7({
                 status: status2,
                 statusText: STATUS_CODES[status2],
                 headersList,
@@ -29805,7 +29805,7 @@ var require_fetch = __commonJS({
                   headersList.append(nameStr, value.toString("latin1"), true);
                 }
               }
-              resolve6({
+              resolve7({
                 status: status2,
                 statusText: STATUS_CODES[status2],
                 headersList,
@@ -29883,31 +29883,31 @@ var require_cache3 = __commonJS({
         webidl.util.markAsUncloneable(this);
         this.#relevantRequestResponseList = arguments[1];
       }
-      async match(request3, options = {}) {
+      async match(request4, options = {}) {
         webidl.brandCheck(this, _Cache);
         const prefix = "Cache.match";
         webidl.argumentLengthCheck(arguments, 1, prefix);
-        request3 = webidl.converters.RequestInfo(request3);
+        request4 = webidl.converters.RequestInfo(request4);
         options = webidl.converters.CacheQueryOptions(options, prefix, "options");
-        const p = this.#internalMatchAll(request3, options, 1);
+        const p = this.#internalMatchAll(request4, options, 1);
         if (p.length === 0) {
           return;
         }
         return p[0];
       }
-      async matchAll(request3 = void 0, options = {}) {
+      async matchAll(request4 = void 0, options = {}) {
         webidl.brandCheck(this, _Cache);
         const prefix = "Cache.matchAll";
-        if (request3 !== void 0) request3 = webidl.converters.RequestInfo(request3);
+        if (request4 !== void 0) request4 = webidl.converters.RequestInfo(request4);
         options = webidl.converters.CacheQueryOptions(options, prefix, "options");
-        return this.#internalMatchAll(request3, options);
+        return this.#internalMatchAll(request4, options);
       }
-      async add(request3) {
+      async add(request4) {
         webidl.brandCheck(this, _Cache);
         const prefix = "Cache.add";
         webidl.argumentLengthCheck(arguments, 1, prefix);
-        request3 = webidl.converters.RequestInfo(request3);
-        const requests = [request3];
+        request4 = webidl.converters.RequestInfo(request4);
+        const requests = [request4];
         const responseArrayPromise = this.addAll(requests);
         return await responseArrayPromise;
       }
@@ -29917,19 +29917,19 @@ var require_cache3 = __commonJS({
         webidl.argumentLengthCheck(arguments, 1, prefix);
         const responsePromises = [];
         const requestList = [];
-        for (let request3 of requests) {
-          if (request3 === void 0) {
+        for (let request4 of requests) {
+          if (request4 === void 0) {
             throw webidl.errors.conversionFailed({
               prefix,
               argument: "Argument 1",
               types: ["undefined is not allowed"]
             });
           }
-          request3 = webidl.converters.RequestInfo(request3);
-          if (typeof request3 === "string") {
+          request4 = webidl.converters.RequestInfo(request4);
+          if (typeof request4 === "string") {
             continue;
           }
-          const r = getRequestState(request3);
+          const r = getRequestState(request4);
           if (!urlIsHttpHttpsScheme(r.url) || r.method !== "GET") {
             throw webidl.errors.exception({
               header: prefix,
@@ -29938,8 +29938,8 @@ var require_cache3 = __commonJS({
           }
         }
         const fetchControllers = [];
-        for (const request3 of requests) {
-          const r = getRequestState(new Request(request3));
+        for (const request4 of requests) {
+          const r = getRequestState(new Request(request4));
           if (!urlIsHttpHttpsScheme(r.url)) {
             throw webidl.errors.exception({
               header: prefix,
@@ -30016,17 +30016,17 @@ var require_cache3 = __commonJS({
         });
         return cacheJobPromise.promise;
       }
-      async put(request3, response) {
+      async put(request4, response) {
         webidl.brandCheck(this, _Cache);
         const prefix = "Cache.put";
         webidl.argumentLengthCheck(arguments, 2, prefix);
-        request3 = webidl.converters.RequestInfo(request3);
+        request4 = webidl.converters.RequestInfo(request4);
         response = webidl.converters.Response(response, prefix, "response");
         let innerRequest = null;
-        if (webidl.is.Request(request3)) {
-          innerRequest = getRequestState(request3);
+        if (webidl.is.Request(request4)) {
+          innerRequest = getRequestState(request4);
         } else {
-          innerRequest = getRequestState(new Request(request3));
+          innerRequest = getRequestState(new Request(request4));
         }
         if (!urlIsHttpHttpsScheme(innerRequest.url) || innerRequest.method !== "GET") {
           throw webidl.errors.exception({
@@ -30097,21 +30097,21 @@ var require_cache3 = __commonJS({
         });
         return cacheJobPromise.promise;
       }
-      async delete(request3, options = {}) {
+      async delete(request4, options = {}) {
         webidl.brandCheck(this, _Cache);
         const prefix = "Cache.delete";
         webidl.argumentLengthCheck(arguments, 1, prefix);
-        request3 = webidl.converters.RequestInfo(request3);
+        request4 = webidl.converters.RequestInfo(request4);
         options = webidl.converters.CacheQueryOptions(options, prefix, "options");
         let r = null;
-        if (webidl.is.Request(request3)) {
-          r = getRequestState(request3);
+        if (webidl.is.Request(request4)) {
+          r = getRequestState(request4);
           if (r.method !== "GET" && !options.ignoreMethod) {
             return false;
           }
         } else {
-          assert(typeof request3 === "string");
-          r = getRequestState(new Request(request3));
+          assert(typeof request4 === "string");
+          r = getRequestState(new Request(request4));
         }
         const operations = [];
         const operation = {
@@ -30143,25 +30143,25 @@ var require_cache3 = __commonJS({
        * @param {import('../../../types/cache').CacheQueryOptions} options
        * @returns {Promise<readonly Request[]>}
        */
-      async keys(request3 = void 0, options = {}) {
+      async keys(request4 = void 0, options = {}) {
         webidl.brandCheck(this, _Cache);
         const prefix = "Cache.keys";
-        if (request3 !== void 0) request3 = webidl.converters.RequestInfo(request3);
+        if (request4 !== void 0) request4 = webidl.converters.RequestInfo(request4);
         options = webidl.converters.CacheQueryOptions(options, prefix, "options");
         let r = null;
-        if (request3 !== void 0) {
-          if (webidl.is.Request(request3)) {
-            r = getRequestState(request3);
+        if (request4 !== void 0) {
+          if (webidl.is.Request(request4)) {
+            r = getRequestState(request4);
             if (r.method !== "GET" && !options.ignoreMethod) {
               return [];
             }
-          } else if (typeof request3 === "string") {
-            r = getRequestState(new Request(request3));
+          } else if (typeof request4 === "string") {
+            r = getRequestState(new Request(request4));
           }
         }
         const promise = createDeferredPromise();
         const requests = [];
-        if (request3 === void 0) {
+        if (request4 === void 0) {
           for (const requestResponse of this.#relevantRequestResponseList) {
             requests.push(requestResponse[0]);
           }
@@ -30173,9 +30173,9 @@ var require_cache3 = __commonJS({
         }
         queueMicrotask(() => {
           const requestList = [];
-          for (const request4 of requests) {
+          for (const request5 of requests) {
             const requestObject = fromInnerRequest(
-              request4,
+              request5,
               void 0,
               new AbortController().signal,
               "immutable"
@@ -30294,9 +30294,9 @@ var require_cache3 = __commonJS({
        * @param {import('../../../types/cache').CacheQueryOptions | undefined} options
        * @returns {boolean}
        */
-      #requestMatchesCachedItem(requestQuery, request3, response = null, options) {
+      #requestMatchesCachedItem(requestQuery, request4, response = null, options) {
         const queryURL = new URL(requestQuery.url);
-        const cachedURL = new URL(request3.url);
+        const cachedURL = new URL(request4.url);
         if (options?.ignoreSearch) {
           cachedURL.search = "";
           queryURL.search = "";
@@ -30312,7 +30312,7 @@ var require_cache3 = __commonJS({
           if (fieldValue === "*") {
             return false;
           }
-          const requestValue = request3.headersList.get(fieldValue);
+          const requestValue = request4.headersList.get(fieldValue);
           const queryValue = requestQuery.headersList.get(fieldValue);
           if (requestValue !== queryValue) {
             return false;
@@ -30320,20 +30320,20 @@ var require_cache3 = __commonJS({
         }
         return true;
       }
-      #internalMatchAll(request3, options, maxResponses = Infinity) {
+      #internalMatchAll(request4, options, maxResponses = Infinity) {
         let r = null;
-        if (request3 !== void 0) {
-          if (webidl.is.Request(request3)) {
-            r = getRequestState(request3);
+        if (request4 !== void 0) {
+          if (webidl.is.Request(request4)) {
+            r = getRequestState(request4);
             if (r.method !== "GET" && !options.ignoreMethod) {
               return [];
             }
-          } else if (typeof request3 === "string") {
-            r = getRequestState(new Request(request3));
+          } else if (typeof request4 === "string") {
+            r = getRequestState(new Request(request4));
           }
         }
         const responses = [];
-        if (request3 === void 0) {
+        if (request4 === void 0) {
           for (const requestResponse of this.#relevantRequestResponseList) {
             responses.push(requestResponse[1]);
           }
@@ -30425,21 +30425,21 @@ var require_cachestorage = __commonJS({
         }
         webidl.util.markAsUncloneable(this);
       }
-      async match(request3, options = {}) {
+      async match(request4, options = {}) {
         webidl.brandCheck(this, _CacheStorage);
         webidl.argumentLengthCheck(arguments, 1, "CacheStorage.match");
-        request3 = webidl.converters.RequestInfo(request3);
+        request4 = webidl.converters.RequestInfo(request4);
         options = webidl.converters.MultiCacheQueryOptions(options);
         if (options.cacheName != null) {
           if (this.#caches.has(options.cacheName)) {
             const cacheList = this.#caches.get(options.cacheName);
             const cache3 = new Cache(kConstruct, cacheList);
-            return await cache3.match(request3, options);
+            return await cache3.match(request4, options);
           }
         } else {
           for (const cacheList of this.#caches.values()) {
             const cache3 = new Cache(kConstruct, cacheList);
-            const response = await cache3.match(request3, options);
+            const response = await cache3.match(request4, options);
             if (response !== void 0) {
               return response;
             }
@@ -31598,7 +31598,7 @@ var require_connection = __commonJS({
     function establishWebSocketConnection(url, protocols, client, handler, options) {
       const requestURL = url;
       requestURL.protocol = url.protocol === "ws:" ? "http:" : "https:";
-      const request3 = makeRequest({
+      const request4 = makeRequest({
         urlList: [requestURL],
         client,
         serviceWorkers: "none",
@@ -31611,18 +31611,18 @@ var require_connection = __commonJS({
       });
       if (options.headers) {
         const headersList = getHeadersList(new Headers(options.headers));
-        request3.headersList = headersList;
+        request4.headersList = headersList;
       }
       const keyValue = crypto2.randomBytes(16).toString("base64");
-      request3.headersList.append("sec-websocket-key", keyValue, true);
-      request3.headersList.append("sec-websocket-version", "13", true);
+      request4.headersList.append("sec-websocket-key", keyValue, true);
+      request4.headersList.append("sec-websocket-version", "13", true);
       for (const protocol of protocols) {
-        request3.headersList.append("sec-websocket-protocol", protocol, true);
+        request4.headersList.append("sec-websocket-protocol", protocol, true);
       }
       const permessageDeflate = "permessage-deflate; client_max_window_bits";
-      request3.headersList.append("sec-websocket-extensions", permessageDeflate, true);
+      request4.headersList.append("sec-websocket-extensions", permessageDeflate, true);
       const controller = fetching({
-        request: request3,
+        request: request4,
         useParallelQueue: true,
         dispatcher: options.dispatcher,
         processResponse(response) {
@@ -31669,7 +31669,7 @@ var require_connection = __commonJS({
           }
           const secProtocol = response.headersList.get("Sec-WebSocket-Protocol");
           if (secProtocol !== null) {
-            const requestProtocols = getDecodeSplit("sec-websocket-protocol", request3.headersList);
+            const requestProtocols = getDecodeSplit("sec-websocket-protocol", request4.headersList);
             if (!requestProtocols.includes(secProtocol)) {
               failWebsocketConnection(handler, 1002, "Protocol was not set in the opening handshake.");
               return;
@@ -34816,6 +34816,21 @@ var init_config2 = __esm({
 });
 
 // src/api.ts
+var api_exports = {};
+__export(api_exports, {
+  DeviceMeUnauthorized: () => DeviceMeUnauthorized,
+  fetchBackfillDaySessions: () => fetchBackfillDaySessions,
+  fetchBackfillDays: () => fetchBackfillDays,
+  fetchDeviceMe: () => fetchDeviceMe,
+  fetchDeviceViewByClaim: () => fetchDeviceViewByClaim,
+  fetchDeviceViewJobsByClaim: () => fetchDeviceViewJobsByClaim,
+  fetchDeviceViewLedgerByClaim: () => fetchDeviceViewLedgerByClaim,
+  postControlScan: () => postControlScan,
+  reportDiscovery: () => reportDiscovery,
+  rotateDeviceSecret: () => rotateDeviceSecret,
+  selfRegister: () => selfRegister,
+  uploadBatch: () => uploadBatch
+});
 async function selfRegister(input) {
   const res = await (0, import_undici.request)(`${state.apiUrl}/v1/devices/self-register`, {
     method: "POST",
@@ -34898,7 +34913,7 @@ async function fetchDeviceViewLedgerByClaim(claimCode) {
 }
 function ingestClient() {
   if (_ingest) return _ingest;
-  const logger2 = createLogger("daemon.ingest");
+  const logger3 = createLogger("daemon.ingest");
   _ingest = new IngestClient({
     apiUrl: state.apiUrl,
     auth: {
@@ -34914,7 +34929,7 @@ function ingestClient() {
         }
       }
     },
-    logger: logger2
+    logger: logger3
   });
   return _ingest;
 }
@@ -34949,6 +34964,34 @@ function fetchBackfillDays() {
 function fetchBackfillDaySessions(day) {
   return backfillGet(`?day=${encodeURIComponent(day)}`);
 }
+function controlPort() {
+  return Number(process.env.MODELSTAT_LOCAL_INGEST_PORT) || 4319;
+}
+async function postControlScan(body, opts = {}) {
+  const port = opts.port ?? controlPort();
+  try {
+    const res = await (0, import_undici.request)(`http://127.0.0.1:${port}/v1/control/scan`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+      // A `wait:true` scan can take a while (cold-ish summariser, big session);
+      // give it room but don't hang forever. undici's headersTimeout/bodyTimeout
+      // default to 30s — lift them for the waiting case.
+      headersTimeout: body.wait ? 6e5 : 5e3,
+      bodyTimeout: body.wait ? 6e5 : 5e3
+    });
+    if (res.statusCode >= 300) {
+      const message = await res.body.text().catch(() => "");
+      return { kind: "error", status: res.statusCode, message };
+    }
+    const data = await res.body.json().catch(() => ({}));
+    return { kind: "ok", started: data.started === true, scanned: data.scanned === true };
+  } catch (e) {
+    const code = e.code;
+    if (code === "ECONNREFUSED" || code === "ECONNRESET") return { kind: "no_daemon" };
+    return { kind: "error", status: 0, message: e.message };
+  }
+}
 var import_undici, DeviceMeUnauthorized, _ingest;
 var init_api = __esm({
   "src/api.ts"() {
@@ -36248,7 +36291,7 @@ async function ensureLlamaModel(cfg = defaultLlamaConfig()) {
   const tmp = `${cfg.modelPath}.partial`;
   const { createWriteStream } = await import("fs");
   const { Readable: Readable2 } = await import("stream");
-  const { rename: rename2 } = await import("fs/promises");
+  const { rename: rename3 } = await import("fs/promises");
   const out = createWriteStream(tmp);
   const isTty = Boolean(process.stdout.isTTY);
   let received = 0;
@@ -36286,15 +36329,15 @@ async function ensureLlamaModel(cfg = defaultLlamaConfig()) {
       lastLog = now;
     }
   });
-  await new Promise((resolve6, reject) => {
+  await new Promise((resolve7, reject) => {
     nodeStream.pipe(out);
-    out.on("finish", () => resolve6());
+    out.on("finish", () => resolve7());
     out.on("error", reject);
     nodeStream.on("error", reject);
   });
   renderProgress(true);
   if (isTty) process.stdout.write("\n");
-  await rename2(tmp, cfg.modelPath);
+  await rename3(tmp, cfg.modelPath);
   console.log(`[modelstat] summariser model ready (${cfg.modelPath})`);
   return cfg.modelPath;
 }
@@ -37155,6 +37198,12 @@ var init_pipeline2 = __esm({
 });
 
 // src/scan.ts
+var scan_exports = {};
+__export(scan_exports, {
+  discoverJobs: () => discoverJobs,
+  scanAll: () => scanAll,
+  scanSession: () => scanSession
+});
 import { readdir, stat as stat2 } from "fs/promises";
 import { homedir as homedir5 } from "os";
 import { join as join7 } from "path";
@@ -37218,13 +37267,66 @@ async function scanAll(cb = {}) {
   const deviceId = state.deviceId;
   if (!deviceId) throw new Error("daemon not enrolled \u2014 run `register` first");
   const jobs = await discoverJobs(deviceId);
-  const ordered = (await Promise.all(
+  const ordered = await orderJobsNewestFirst(jobs);
+  return runScanOverJobs(
+    ordered,
+    deviceId,
+    { maxFiles: MAX_FILES_PER_SCAN, forceReadAll: false },
+    cb
+  );
+}
+async function scanSession(target = {}, cb = {}) {
+  const deviceId = state.deviceId;
+  if (!deviceId) throw new Error("daemon not enrolled \u2014 run `register` first");
+  const all = await discoverJobs(deviceId);
+  let selected;
+  if (target.file) {
+    const existing = all.find((j) => j.path === target.file);
+    selected = existing ? [existing] : [jobForFile(deviceId, target.file)];
+  } else if (target.sessionIds && target.sessionIds.length > 0) {
+    const wanted = new Set(target.sessionIds);
+    selected = all.filter((j) => {
+      const sid = sessionIdForPath(j.path);
+      return sid != null && wanted.has(sid);
+    });
+  } else {
+    const ordered = await orderJobsNewestFirst(all);
+    selected = ordered.slice(0, 1);
+  }
+  if (selected.length === 0) {
+    return {
+      filesScanned: 0,
+      filesUnchanged: 0,
+      batchesUploaded: 0,
+      eventsUploaded: 0,
+      segmentsUploaded: 0,
+      morePending: false
+    };
+  }
+  return runScanOverJobs(selected, deviceId, { maxFiles: null, forceReadAll: true }, cb);
+}
+function sessionIdForPath(path) {
+  return deriveSessionIdFromFilename(path) ?? deriveSessionIdFromRolloutPath(path);
+}
+function jobForFile(deviceId, full) {
+  const isCodex = full.includes("/.codex/sessions/") && /rollout-.*\.jsonl$/.test(full);
+  return {
+    path: full,
+    parse: async (sink) => {
+      const r = isCodex ? await parseCodexRollout({ deviceId, sourceFile: full, onEvents: sink }) : await parseClaudeCodeJsonl({ deviceId, sourceFile: full, onEvents: sink });
+      return { toolCalls: r.toolCalls ?? [], scriptContexts: r.scriptContexts ?? [] };
+    }
+  };
+}
+async function orderJobsNewestFirst(jobs) {
+  return (await Promise.all(
     jobs.map(async (j) => ({
       job: j,
       mtimeMs: (await stat2(j.path).catch(() => null))?.mtimeMs ?? 0
     }))
   )).sort((a, b) => b.mtimeMs - a.mtimeMs).map((x) => x.job);
-  const MAX_FILES_PER_SCAN = 12;
+}
+async function runScanOverJobs(ordered, deviceId, opts, cb) {
   let morePending = false;
   let filesScanned = 0;
   let filesUnchanged = 0;
@@ -37312,7 +37414,7 @@ async function scanAll(cb = {}) {
     cb.onFile?.(job.path, i, ordered.length);
     const cur = state.getCursor(job.path);
     const cs = await quickChecksum(job.path).catch(() => null);
-    if (cs && cur && cur.size === cs.size && cur.tailHash === cs.tailHash) {
+    if (!opts.forceReadAll && cs && cur && cur.size === cs.size && cur.tailHash === cs.tailHash) {
       filesUnchanged += 1;
       continue;
     }
@@ -37332,7 +37434,7 @@ async function scanAll(cb = {}) {
     } catch (e) {
       console.warn(`  ! parse failed for ${job.path}:`, e.message);
     }
-    if (filesScanned >= MAX_FILES_PER_SCAN) {
+    if (opts.maxFiles !== null && filesScanned >= opts.maxFiles) {
       morePending = true;
       break;
     }
@@ -37347,7 +37449,7 @@ async function scanAll(cb = {}) {
     morePending
   };
 }
-var DAEMON_VERSION, BATCH_MAX_EVENTS, BATCH_MAX_TOOL_CALLS, BATCH_BUFFER_HARD_CAP, ZERO_TOKENS;
+var DAEMON_VERSION, BATCH_MAX_EVENTS, BATCH_MAX_TOOL_CALLS, BATCH_BUFFER_HARD_CAP, ZERO_TOKENS, MAX_FILES_PER_SCAN;
 var init_scan = __esm({
   "src/scan.ts"() {
     "use strict";
@@ -37358,7 +37460,7 @@ var init_scan = __esm({
     init_api();
     init_config2();
     init_pipeline2();
-    DAEMON_VERSION = true ? "daemon-0.13.0" : "daemon-dev";
+    DAEMON_VERSION = true ? "daemon-0.14.0" : "daemon-dev";
     BATCH_MAX_EVENTS = INGEST_BATCH_MAX_EVENTS;
     BATCH_MAX_TOOL_CALLS = 2e4;
     BATCH_BUFFER_HARD_CAP = BATCH_MAX_EVENTS * 2;
@@ -37369,6 +37471,7 @@ var init_scan = __esm({
       cache_read: 0,
       reasoning: 0
     };
+    MAX_FILES_PER_SCAN = 12;
   }
 });
 
@@ -37595,8 +37698,105 @@ var init_update = __esm({
   }
 });
 
+// src/insights.ts
+var insights_exports = {};
+__export(insights_exports, {
+  cacheSessionInsights: () => cacheSessionInsights,
+  fetchSessionInsights: () => fetchSessionInsights,
+  refreshSessionInsights: () => refreshSessionInsights,
+  sessionInsightsPath: () => sessionInsightsPath
+});
+import { mkdir as mkdir2, rename, writeFile } from "fs/promises";
+function sessionsDir() {
+  return homePath("sessions");
+}
+function sessionInsightsPath(sessionId) {
+  return homePath("sessions", `${encodeURIComponent(sessionId)}.json`);
+}
+async function fetchSessionInsights(sessionIds, opts = {}) {
+  const bearer = state.bearer;
+  if (!bearer) return null;
+  if (sessionIds.length === 0) return null;
+  try {
+    const res = await (0, import_undici2.request)(`${state.apiUrl}/v1/mcp/call`, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${bearer}` },
+      body: JSON.stringify({
+        name: "session_insights",
+        arguments: { session_ids: sessionIds, eager: opts.eager === true }
+      })
+    });
+    if (res.statusCode >= 300) {
+      await res.body.dump();
+      return null;
+    }
+    const body = await res.body.json();
+    if (body.isError) return null;
+    const text = body.content?.find((c) => c.type === "text")?.text ?? body.content?.[0]?.text;
+    if (!text) return null;
+    return JSON.parse(text);
+  } catch (e) {
+    logger.warn(`session_insights fetch failed: ${e.message}`);
+    return null;
+  }
+}
+async function cacheSessionInsights(sessionId, insights) {
+  const path = sessionInsightsPath(sessionId);
+  const payload = { ...insights, cached_at: (/* @__PURE__ */ new Date()).toISOString() };
+  try {
+    await mkdir2(sessionsDir(), { recursive: true });
+    const tmp = `${path}.tmp`;
+    await writeFile(tmp, JSON.stringify(payload));
+    await rename(tmp, path);
+  } catch (e) {
+    logger.warn(`session insights cache write failed for ${sessionId}: ${e.message}`);
+  }
+}
+async function refreshSessionInsights(sessionIds) {
+  if (sessionIds.length === 0) return;
+  const cacheKey = sessionIds[0];
+  let insights = await fetchSessionInsights(sessionIds, { eager: true });
+  if (insights) await cacheSessionInsights(cacheKey, insights);
+  for (const delay of POLL_DELAYS_MS) {
+    if (!insights || insights.status !== "analyzing") break;
+    await sleep2(delay);
+    const next = await fetchSessionInsights(sessionIds, { eager: false });
+    if (next) {
+      insights = next;
+      await cacheSessionInsights(cacheKey, next);
+    }
+  }
+}
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var import_undici2, logger, POLL_DELAYS_MS;
+var init_insights = __esm({
+  "src/insights.ts"() {
+    "use strict";
+    import_undici2 = __toESM(require_undici(), 1);
+    init_logger();
+    init_config2();
+    init_paths();
+    logger = createLogger("daemon.insights");
+    POLL_DELAYS_MS = [1200, 2e3, 3e3, 4e3];
+  }
+});
+
 // src/receiver.ts
 import { createServer } from "http";
+import { homedir as homedir7 } from "os";
+import { resolve as resolve4, sep } from "path";
+function transcriptRoots() {
+  const home2 = homedir7();
+  return [resolve4(home2, ".claude/projects"), resolve4(home2, ".codex/sessions")];
+}
+function isAllowedTranscriptFile(file) {
+  const target = resolve4(file);
+  return transcriptRoots().some(
+    (root) => target === root || target.startsWith(root + sep)
+  );
+}
 function queue() {
   if (!store) store = new FileQueueStore(homePath("sdk-ingest-queue.json"));
   return store;
@@ -37671,36 +37871,51 @@ function localQueueDepth() {
 }
 function startLocalIngestReceiver(opts = {}) {
   const port = opts.port ?? (Number(process.env.MODELSTAT_LOCAL_INGEST_PORT) || DEFAULT_LOCAL_INGEST_PORT);
-  return new Promise((resolve6) => {
-    const server = createServer((req, res) => void handle(req, res));
+  const controlRunner = opts.onControlScan ? createControlRunner(opts.onControlScan) : null;
+  return new Promise((resolve7) => {
+    const server = createServer((req, res) => void handle(req, res, controlRunner));
     let settled = false;
     server.on("error", (err) => {
       if (settled) return;
       settled = true;
-      logger.warn(
+      logger2.warn(
         `local ingest receiver disabled \u2014 SDK local_daemon mode unavailable: ${err.code ?? err.message} on 127.0.0.1:${port}`
       );
-      resolve6(null);
+      resolve7(null);
     });
     server.listen(port, "127.0.0.1", () => {
       settled = true;
       const addr = server.address();
       const boundPort = typeof addr === "object" && addr ? addr.port : port;
-      logger.info(`local ingest receiver on http://127.0.0.1:${boundPort}/v1/ingest`);
-      resolve6({
+      logger2.info(`local ingest receiver on http://127.0.0.1:${boundPort}/v1/ingest`);
+      resolve7({
         port: boundPort,
         close: () => new Promise((r) => server.close(() => r()))
       });
     });
   });
 }
-async function handle(req, res) {
+function createControlRunner(handler) {
+  let active = null;
+  return {
+    run(target) {
+      const prev = active ?? Promise.resolve();
+      const next = prev.catch(() => void 0).then(() => handler(target));
+      active = next.catch(() => void 0);
+      return next;
+    }
+  };
+}
+async function handle(req, res, controlRunner) {
   const send = (code, body) => {
     res.writeHead(code, { "content-type": "application/json" });
     res.end(JSON.stringify(body));
   };
   const path = (req.url ?? "").split("?")[0];
   if (req.method === "GET" && path === "/healthz") return send(200, { ok: true });
+  if (req.method === "POST" && path === "/v1/control/scan") {
+    return handleControlScan(req, send, controlRunner);
+  }
   if (req.method !== "POST" || path !== "/v1/ingest" && path !== "/v1/ingest/raw") {
     return send(404, { error: "not found" });
   }
@@ -37731,11 +37946,56 @@ async function handle(req, res) {
     const accepted = await enqueue(parsed);
     return send(200, { accepted, queued: true });
   } catch (e) {
-    logger.warn(`local ingest enqueue failed: ${e.message}`);
+    logger2.warn(`local ingest enqueue failed: ${e.message}`);
     return send(500, { error: "enqueue failed" });
   }
 }
-var logger, DEFAULT_LOCAL_INGEST_PORT, MAX_BODY_BYTES, store, pipeline, draining;
+async function handleControlScan(req, send, controlRunner) {
+  if (!controlRunner) return send(503, { error: "control scan unavailable" });
+  const chunks = [];
+  let size = 0;
+  try {
+    for await (const chunk of req) {
+      size += chunk.length;
+      if (size > 64 * 1024) {
+        send(413, { error: "control body too large" });
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    }
+  } catch {
+    return send(400, { error: "read error" });
+  }
+  let body;
+  try {
+    const raw = chunks.length ? Buffer.concat(chunks).toString("utf8") : "{}";
+    body = JSON.parse(raw);
+  } catch {
+    return send(400, { error: "invalid json" });
+  }
+  const sessionIds = Array.isArray(body.session_ids) ? body.session_ids.filter((s) => typeof s === "string" && s.length > 0) : void 0;
+  let file;
+  if (body.file !== void 0) {
+    if (typeof body.file !== "string" || !isAllowedTranscriptFile(body.file)) {
+      return send(400, { error: "file must be under ~/.claude/projects or ~/.codex/sessions" });
+    }
+    file = body.file;
+  }
+  const target = { sessionIds, file };
+  const run = controlRunner.run(target);
+  if (body.wait === true) {
+    try {
+      await run;
+      return send(200, { ok: true, scanned: true });
+    } catch (e) {
+      return send(500, { error: `scan failed: ${e.message}` });
+    }
+  }
+  void run.catch((e) => logger2.warn(`control scan failed: ${e.message}`));
+  return send(200, { ok: true, started: true });
+}
+var logger2, DEFAULT_LOCAL_INGEST_PORT, MAX_BODY_BYTES, store, pipeline, draining;
 var init_receiver = __esm({
   "src/receiver.ts"() {
     "use strict";
@@ -37745,7 +38005,7 @@ var init_receiver = __esm({
     init_api();
     init_paths();
     init_pipeline2();
-    logger = createLogger("daemon.local-ingest");
+    logger2 = createLogger("daemon.local-ingest");
     DEFAULT_LOCAL_INGEST_PORT = 4319;
     MAX_BODY_BYTES = 16 * 1024 * 1024;
     store = null;
@@ -38074,11 +38334,11 @@ var init_src4 = __esm({
 });
 
 // ../../packages/remote-config/src/node.ts
-import { chmod, mkdir as mkdir2, readFile, rename, writeFile } from "fs/promises";
-import { homedir as homedir7 } from "os";
+import { chmod, mkdir as mkdir3, readFile, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir8 } from "os";
 import { join as join10 } from "path";
 function defaultRoot() {
-  return join10(homedir7(), ".modelstat", "config");
+  return join10(homedir8(), ".modelstat", "config");
 }
 function safeKind(kind) {
   if (!/^[a-z0-9_-]{1,64}$/.test(kind)) throw new Error(`unsafe config kind: ${kind}`);
@@ -38088,8 +38348,8 @@ function createNodeDiskCache(opts = {}) {
   const dir = opts.dir ?? defaultRoot();
   async function writeAtomic2(path, data) {
     const tmp = `${path}.${process.pid}.tmp`;
-    await writeFile(tmp, data, { mode: 384 });
-    await rename(tmp, path);
+    await writeFile2(tmp, data, { mode: 384 });
+    await rename2(tmp, path);
     try {
       await chmod(path, 384);
     } catch {
@@ -38107,7 +38367,7 @@ function createNodeDiskCache(opts = {}) {
     },
     async write(kind, payload) {
       const k = safeKind(kind);
-      await mkdir2(dir, { recursive: true, mode: 448 });
+      await mkdir3(dir, { recursive: true, mode: 448 });
       await writeAtomic2(join10(dir, `${k}.json`), `${JSON.stringify(payload)}
 `);
     }
@@ -39031,7 +39291,7 @@ var init_handler = __esm({
             this._addToNodeFs(path, initialAdd, wh, depth + 1);
           }
         }).on(EV.ERROR, this._boundHandleError);
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           if (!stream)
             return reject();
           stream.once(STR_END, () => {
@@ -39040,7 +39300,7 @@ var init_handler = __esm({
               return;
             }
             const wasThrottled = throttler ? throttler.clear() : false;
-            resolve6(void 0);
+            resolve7(void 0);
             previous.getChildren().filter((item) => {
               return item !== directory && !current.has(item);
             }).forEach((item) => {
@@ -39994,7 +40254,7 @@ async function sendHeartbeat() {
   if (!bearer || !deviceId) return;
   const body = { ...snapshotBody(), device_id: deviceId };
   try {
-    const res = await (0, import_undici2.request)(`${state.apiUrl}/v1/daemon/heartbeat`, {
+    const res = await (0, import_undici3.request)(`${state.apiUrl}/v1/daemon/heartbeat`, {
       method: "POST",
       headers: { "content-type": "application/json", authorization: `Bearer ${bearer}` },
       body: JSON.stringify(body)
@@ -40013,10 +40273,10 @@ async function sendHeartbeat() {
   writeLocalStatus(body).catch(() => void 0);
 }
 async function rotateRunawayLogs() {
-  const { homedir: homedir9 } = await import("os");
+  const { homedir: homedir10 } = await import("os");
   const { join: join14 } = await import("path");
-  const { open: open2, stat: stat7, truncate, writeFile: writeFile2 } = await import("fs/promises");
-  const dir = join14(homedir9(), ".modelstat", "logs");
+  const { open: open2, stat: stat7, truncate, writeFile: writeFile3 } = await import("fs/promises");
+  const dir = join14(homedir10(), ".modelstat", "logs");
   for (const name of ["out.log", "err.log"]) {
     const p = join14(dir, name);
     try {
@@ -40027,7 +40287,7 @@ async function rotateRunawayLogs() {
       try {
         const buf = Buffer.alloc(keep);
         await fh.read(buf, 0, keep, st.size - keep);
-        await writeFile2(p.replace(/\.log$/, ".old.log"), buf);
+        await writeFile3(p.replace(/\.log$/, ".old.log"), buf);
       } finally {
         await fh.close();
       }
@@ -40041,20 +40301,20 @@ async function rotateRunawayLogs() {
 }
 async function writeLocalStatus(snapshot) {
   const { join: join14 } = await import("path");
-  const { writeFile: writeFile2, mkdir: mkdir3, rename: rename2 } = await import("fs/promises");
+  const { writeFile: writeFile3, mkdir: mkdir4, rename: rename3 } = await import("fs/promises");
   const { modelstatHome: modelstatHome2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
   if (!lastStatusPath) {
     const dir = modelstatHome2();
     try {
-      await mkdir3(dir, { recursive: true });
+      await mkdir4(dir, { recursive: true });
     } catch {
     }
     lastStatusPath = join14(dir, "last-status.json");
   }
   const tmp = `${lastStatusPath}.tmp`;
   try {
-    await writeFile2(tmp, JSON.stringify({ ...snapshot, written_at: (/* @__PURE__ */ new Date()).toISOString() }));
-    await rename2(tmp, lastStatusPath);
+    await writeFile3(tmp, JSON.stringify({ ...snapshot, written_at: (/* @__PURE__ */ new Date()).toISOString() }));
+    await rename3(tmp, lastStatusPath);
   } catch {
   }
 }
@@ -40123,6 +40383,38 @@ async function runScanCycle(reason) {
 function requestScan(reason) {
   return scanRunner.trigger(reason);
 }
+async function runEagerSessionScan(target) {
+  setPhase("scanning", "Eager scan (current session)");
+  try {
+    const r = await scanSession(target, {
+      onProgress(p) {
+        if (p.segment === 0) setPhase("processing", "Analyzing current session");
+        else setPhase("processing", `Summarising segment ${p.segment}/${p.segmentTotal}`);
+      },
+      onUpload({ segments }) {
+        setPhase("uploading", `Uploading ${segments} segments`);
+        setStat("segments_sending", segments);
+      },
+      onUploaded({ events, segments }) {
+        bumpStat("events_uploaded", events);
+        setStat("segments_sent", state.bumpSegmentsSent(segments));
+        setStat("segments_sending", 0);
+        status.lastEventAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+    });
+    if (target.sessionIds && target.sessionIds.length > 0) {
+      await refreshSessionInsights(target.sessionIds);
+    }
+    setPhase("watching", "Waiting for new events");
+    setMessage(
+      r.segmentsUploaded > 0 ? `Eager scan: ${r.segmentsUploaded} segments uploaded` : "Eager scan: nothing new"
+    );
+  } catch (e) {
+    setStat("segments_sending", 0);
+    setPhase("watching", `Eager scan failed: ${describeErrorWithCause(e)}`);
+    throw e;
+  }
+}
 function basename4(p) {
   return p.split("/").pop() ?? p;
 }
@@ -40189,7 +40481,13 @@ async function runDaemon(opts = {}) {
     console.warn(`[modelstat] summariser preflight error (continuing): ${err.message}`);
     setMessage(`summariser preflight error (continuing): ${err.message}`);
   }
-  const localIngest = await startLocalIngestReceiver();
+  const localIngest = await startLocalIngestReceiver({
+    // Serve the loopback control endpoint so `modelstat scan --session` can
+    // warm this running daemon (summariser already loaded) instead of
+    // cold-spawning its own — and so the eager scan refreshes the local
+    // insights cache the statusline reads.
+    onControlScan: runEagerSessionScan
+  });
   const LOCAL_DRAIN_INTERVAL_MS = 5e3;
   let localDrainTimer = null;
   if (localIngest) {
@@ -40224,9 +40522,9 @@ async function runDaemon(opts = {}) {
     setMessage(`policy refresh unavailable: ${err.message}`);
   }
   const chokidar = (await Promise.resolve().then(() => (init_esm2(), esm_exports))).default;
-  const { homedir: homedir9, platform: platform7 } = await import("os");
+  const { homedir: homedir10, platform: platform7 } = await import("os");
   const { join: join14 } = await import("path");
-  const home2 = homedir9();
+  const home2 = homedir10();
   const dirs = [
     join14(home2, ".claude/projects"),
     join14(home2, ".codex/sessions"),
@@ -40288,24 +40586,25 @@ async function runDaemon(opts = {}) {
   await new Promise(() => {
   });
 }
-var import_undici2, DAEMON_VERSION2, HEARTBEAT_INTERVAL_MS, SCAN_INTERVAL_MS, DISCOVERY_INTERVAL_MS, SUMMARISER_RECOVERY_MIN_INTERVAL_MS, status, LOCAL_FLUSH_THROTTLE_MS, localFlushTimer, localFlushPending, lastVerdict, LOG_MAX_BYTES, LOG_TAIL_KEEP_BYTES, lastStatusPath, scanRunner;
+var import_undici3, DAEMON_VERSION2, HEARTBEAT_INTERVAL_MS, SCAN_INTERVAL_MS, DISCOVERY_INTERVAL_MS, SUMMARISER_RECOVERY_MIN_INTERVAL_MS, status, LOCAL_FLUSH_THROTTLE_MS, localFlushTimer, localFlushPending, lastVerdict, LOG_MAX_BYTES, LOG_TAIL_KEEP_BYTES, lastStatusPath, scanRunner;
 var init_daemon = __esm({
   "src/daemon.ts"() {
     "use strict";
     init_logger();
     init_src2();
-    import_undici2 = __toESM(require_undici(), 1);
+    import_undici3 = __toESM(require_undici(), 1);
     init_api();
     init_config2();
     init_lock();
     init_machine_key();
+    init_insights();
     init_receiver();
     init_reconcile();
     init_runtime_state();
     init_scan();
     init_single_flight();
     init_update();
-    DAEMON_VERSION2 = true ? "daemon-0.13.0" : "daemon-dev";
+    DAEMON_VERSION2 = true ? "daemon-0.14.0" : "daemon-dev";
     HEARTBEAT_INTERVAL_MS = 1e4;
     SCAN_INTERVAL_MS = 5 * 60 * 1e3;
     DISCOVERY_INTERVAL_MS = 6e4;
@@ -40337,10 +40636,10 @@ __export(watch_exports, {
   watchForever: () => watchForever
 });
 import { existsSync as existsSync12 } from "fs";
-import { homedir as homedir8, platform as platform5 } from "os";
+import { homedir as homedir9, platform as platform5 } from "os";
 import { join as join13 } from "path";
 function resolveWatchDirs() {
-  const home2 = homedir8();
+  const home2 = homedir9();
   const xdgConfig = process.env.XDG_CONFIG_HOME ?? join13(home2, ".config");
   const xdgData = process.env.XDG_DATA_HOME ?? join13(home2, ".local/share");
   const candidates = [
@@ -40831,16 +41130,16 @@ function createLineSplitter(onLine) {
   };
 }
 function runTrayBuild(cwd, buildScript, progress) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const child = spawn("bash", [buildScript], { cwd });
     const splitter = createLineSplitter((line) => progress?.onLine?.(line));
     const pump = (chunk) => splitter.push(chunk.toString("utf8"));
     child.stdout?.on("data", pump);
     child.stderr?.on("data", pump);
-    child.on("error", () => resolve6(null));
+    child.on("error", () => resolve7(null));
     child.on("close", (code) => {
       splitter.flush();
-      resolve6(code);
+      resolve7(code);
     });
   });
 }
@@ -40912,7 +41211,7 @@ async function confirmPrompt(question, defaultYes) {
   if (process.stdin.isTTY !== true) return defaultYes;
   const rl = createInterface3({ input: process.stdin, output: process.stdout });
   try {
-    const raw = await new Promise((resolve6) => rl.question(question, resolve6));
+    const raw = await new Promise((resolve7) => rl.question(question, resolve7));
     const ans = raw.trim().toLowerCase();
     if (ans === "") return defaultYes;
     if (ans === "y" || ans === "yes") return true;
@@ -40937,7 +41236,7 @@ function tryOpenBrowser(url) {
     return false;
   }
 }
-var DAEMON_VERSION3 = true ? "daemon-0.13.0" : "daemon-dev";
+var DAEMON_VERSION3 = true ? "daemon-0.14.0" : "daemon-dev";
 function osFamily() {
   const p = platform6();
   if (p === "darwin") return "macos";
@@ -40950,6 +41249,33 @@ function osArch() {
   if (a === "arm64") return "arm64";
   return "other";
 }
+function flagValue(args, flag) {
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === flag) return args[i + 1];
+    if (a.startsWith(`${flag}=`)) return a.slice(flag.length + 1);
+  }
+  return void 0;
+}
+function flagValues(args, flag) {
+  const out = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === flag) {
+      const v = args[i + 1];
+      if (v !== void 0 && !v.startsWith("--")) out.push(v);
+    } else if (a.startsWith(`${flag}=`)) {
+      out.push(a.slice(flag.length + 1));
+    }
+  }
+  return out;
+}
+function numericFlag(args, flag) {
+  const raw = flagValue(args, flag);
+  if (raw === void 0) return void 0;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : void 0;
+}
 function intendedDeviceUuid() {
   const salt = process.env.MODELSTAT_DEVICE_SALT?.trim();
   const key = salt ? `${machineKey()}:${salt}` : machineKey();
@@ -41308,7 +41634,17 @@ async function cmdDiscover() {
   });
   console.log("\u2713 reported to backend");
 }
-async function cmdScan() {
+async function cmdScan(rest) {
+  const sessionIds = flagValues(rest, "--session");
+  const file = flagValue(rest, "--file");
+  if (sessionIds.length > 0 || file) {
+    return cmdScanSession({
+      sessionIds,
+      file,
+      wait: rest.includes("--wait"),
+      port: numericFlag(rest, "--port")
+    });
+  }
   const { preflightSummariser: preflightSummariser2 } = await Promise.resolve().then(() => (init_pipeline2(), pipeline_exports));
   const { label, degraded } = await preflightSummariser2();
   console.log(
@@ -41332,6 +41668,47 @@ async function cmdScan() {
   } catch {
   }
 }
+async function cmdScanSession(opts) {
+  const { postControlScan: postControlScan2 } = await Promise.resolve().then(() => (init_api(), api_exports));
+  const target = {
+    ...opts.sessionIds.length ? { session_ids: opts.sessionIds } : {},
+    ...opts.file ? { file: opts.file } : {}
+  };
+  const outcome = await postControlScan2({ ...target, wait: opts.wait }, { port: opts.port });
+  if (outcome.kind === "ok") {
+    console.log(
+      opts.wait ? "\u2713 daemon force-scanned the session" : "\u2713 asked the running daemon to force-scan the session"
+    );
+    return;
+  }
+  if (outcome.kind === "error") {
+    console.error(`\u2717 daemon control scan failed (${outcome.status}): ${outcome.message}`);
+    process.exit(1);
+  }
+  console.log("no running daemon on the control port \u2014 scanning in-process\u2026");
+  const { preflightSummariser: preflightSummariser2 } = await Promise.resolve().then(() => (init_pipeline2(), pipeline_exports));
+  const { label, degraded } = await preflightSummariser2();
+  console.log(
+    degraded ? `[modelstat] \u26A0 summariser DEGRADED \u2014 ${label}; extractive fallback, ingest continues` : `[modelstat] summariser preflight ok: ${label}`
+  );
+  const { scanSession: scanSession2 } = await Promise.resolve().then(() => (init_scan(), scan_exports));
+  const r = await scanSession2({
+    ...opts.sessionIds.length ? { sessionIds: opts.sessionIds } : {},
+    ...opts.file ? { file: opts.file } : {}
+  });
+  console.log(
+    `Done: ${r.filesScanned} files scanned, ${r.batchesUploaded} batches, ${r.segmentsUploaded} segments, ${r.eventsUploaded} events uploaded`
+  );
+  if (opts.sessionIds.length > 0) {
+    const { refreshSessionInsights: refreshSessionInsights2 } = await Promise.resolve().then(() => (init_insights(), insights_exports));
+    await refreshSessionInsights2(opts.sessionIds);
+  }
+  try {
+    const { disposeLlama: disposeLlama2 } = await Promise.resolve().then(() => (init_node(), node_exports));
+    await disposeLlama2();
+  } catch {
+  }
+}
 async function cmdRescan() {
   const { PROCESSING_VERSION: PROCESSING_VERSION2 } = await Promise.resolve().then(() => (init_processing_version(), processing_version_exports));
   state.wipeCursors();
@@ -41651,7 +42028,7 @@ async function main() {
     case "discover":
       return cmdDiscover();
     case "scan":
-      return cmdScan();
+      return cmdScan(rest);
     case "rescan":
       return cmdRescan();
     case "watch":
@@ -41702,6 +42079,9 @@ async function main() {
       console.log();
       console.log("Dev / one-shots:");
       console.log("  npx modelstat@latest scan           \u2014 one-shot parse + upload of local JSONL");
+      console.log(
+        "  npx modelstat@latest scan --session <id>  \u2014 eager force-scan ONE session now (--file <path>, --wait)"
+      );
       console.log(
         "  npx modelstat@latest rescan         \u2014 wipe file cursors so the next scan re-reads & re-summarises everything"
       );