npm - modelstat - Versions diffs - 0.13.0 → 0.14.0 - Mend

modelstat 0.13.0 → 0.14.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/cli.mjs CHANGED Viewed

@@ -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"
       );