claude-use 11.20.1 → 11.21.0

package/dist/cli.cjs

@@ -27955,8 +27955,8 @@ function redactJsonValue(value2) {
   }
   return value2;
 }
-function redactBody(chunk) {
-  const text2 = chunk.toString("utf8");
+function redactBody(chunk2) {
+  const text2 = chunk2.toString("utf8");
   try {
     const parsed = JSON.parse(text2);
     return JSON.stringify(redactJsonValue(parsed));
@@ -27988,13 +27988,13 @@ function createFileCapture(file2, now = () => /* @__PURE__ */ new Date()) {
       const stored = { "client-to-server": 0, "server-to-client": 0 };
       const sequences = { "client-to-server": 0, "server-to-client": 0 };
       return {
-        onChunk: (direction, chunk) => {
+        onChunk: (direction, chunk2) => {
           sequences[direction] += 1;
           const budget = STREAM_LOG_CAP_BYTES - stored[direction];
           if (budget <= 0) {
             return;
           }
-          const excerpt2 = chunk.subarray(0, Math.min(CHUNK_LOG_CAP_BYTES, budget));
+          const excerpt2 = chunk2.subarray(0, Math.min(CHUNK_LOG_CAP_BYTES, budget));
           stored[direction] += excerpt2.length;
           const text2 = excerpt2.toString("utf8");
           const faithful = Buffer.from(text2, "utf8").equals(excerpt2);
@@ -28003,9 +28003,9 @@ function createFileCapture(file2, now = () => /* @__PURE__ */ new Date()) {
             id: id2,
             dir: direction,
             seq: sequences[direction],
-            bytes: chunk.length,
+            bytes: chunk2.length,
             stored: excerpt2.length,
-            truncated: excerpt2.length < chunk.length,
+            truncated: excerpt2.length < chunk2.length,
             ...faithful ? { body: redactText(text2) } : { b64: excerpt2.toString("base64") }
           });
         },
@@ -28020,7 +28020,7 @@ function createFileCapture(file2, now = () => /* @__PURE__ */ new Date()) {
       append({ kind: "request", id: id2, method: request7.method ?? "?", url: request7.url ?? "?", headers: redactHeaders(request7.headers) });
       const logged = { request: 0, response: 0 };
       const sequences = { request: 0, response: 0 };
-      const chunk = (direction, incoming) => {
+      const chunk2 = (direction, incoming) => {
         sequences[direction] += 1;
         const budget = STREAM_LOG_CAP_BYTES - logged[direction];
         if (budget <= 0) {
@@ -28040,13 +28040,13 @@ function createFileCapture(file2, now = () => /* @__PURE__ */ new Date()) {
       };
       return {
         onRequestChunk: (incoming) => {
-          chunk("request", incoming);
+          chunk2("request", incoming);
         },
         onResponse: (status, headers) => {
           append({ kind: "response", id: id2, status, headers: redactHeaders(headers) });
         },
         onResponseChunk: (incoming) => {
-          chunk("response", incoming);
+          chunk2("response", incoming);
         },
         onEnd: () => {
           append({ kind: "end", id: id2, requestBytesCapped: logged.request >= STREAM_LOG_CAP_BYTES, responseBytesCapped: logged.response >= STREAM_LOG_CAP_BYTES });
@@ -34181,7 +34181,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.20.1",
+      version: "11.21.0",
       description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
       license: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -38431,13 +38431,13 @@ var require_request = __commonJS({
           channels.create.publish({ request: this });
         }
       }
-      onBodySent(chunk) {
+      onBodySent(chunk2) {
         if (channels.bodyChunkSent.hasSubscribers) {
-          channels.bodyChunkSent.publish({ request: this, chunk });
+          channels.bodyChunkSent.publish({ request: this, chunk: chunk2 });
         }
         if (this[kHandler].onBodySent) {
           try {
-            return this[kHandler].onBodySent(chunk);
+            return this[kHandler].onBodySent(chunk2);
           } catch (err) {
             this.abort(err);
           }
@@ -38480,14 +38480,14 @@ var require_request = __commonJS({
           this.abort(err);
         }
       }
-      onData(chunk) {
+      onData(chunk2) {
         assert2(!this.aborted);
         assert2(!this.completed);
         if (channels.bodyChunkReceived.hasSubscribers) {
-          channels.bodyChunkReceived.publish({ request: this, chunk });
+          channels.bodyChunkReceived.publish({ request: this, chunk: chunk2 });
         }
         try {
-          return this[kHandler].onData(chunk);
+          return this[kHandler].onData(chunk2);
         } catch (err) {
           this.abort(err);
           return false;
@@ -41652,17 +41652,17 @@ var require_util3 = __commonJS({
         const bytes = [];
         let byteLength = 0;
         do {
-          const { done, value: chunk } = await reader.read();
+          const { done, value: chunk2 } = await reader.read();
           if (done) {
             successSteps(Buffer.concat(bytes, byteLength));
             return;
           }
-          if (!isUint8Array(chunk)) {
+          if (!isUint8Array(chunk2)) {
             failureSteps(new TypeError("Received non-Uint8Array chunk"));
             return;
           }
-          bytes.push(chunk);
-          byteLength += chunk.length;
+          bytes.push(chunk2);
+          byteLength += chunk2.length;
         } while (true);
       } catch (e14) {
         failureSteps(e14);
@@ -41768,18 +41768,18 @@ var require_util3 = __commonJS({
         super();
         this.#zlibOptions = zlibOptions;
       }
-      _transform(chunk, encoding, callback) {
+      _transform(chunk2, encoding, callback) {
         if (!this._inflateStream) {
-          if (chunk.length === 0) {
+          if (chunk2.length === 0) {
             callback();
             return;
           }
-          this._inflateStream = (chunk[0] & 15) === 8 ? zlib2.createInflate(this.#zlibOptions) : zlib2.createInflateRaw(this.#zlibOptions);
+          this._inflateStream = (chunk2[0] & 15) === 8 ? zlib2.createInflate(this.#zlibOptions) : zlib2.createInflateRaw(this.#zlibOptions);
           this._inflateStream.on("data", this.push.bind(this));
           this._inflateStream.on("end", () => this.push(null));
           this._inflateStream.on("error", (err) => this.destroy(err));
         }
-        this._inflateStream.write(chunk, encoding, callback);
+        this._inflateStream.write(chunk2, encoding, callback);
       }
       _final(callback) {
         if (this._inflateStream) {
@@ -42520,29 +42520,29 @@ Content-Disposition: form-data`;
         let hasUnknownSizeValue = false;
         for (const [name, value2] of object3) {
           if (typeof value2 === "string") {
-            const chunk2 = textEncoder.encode(prefix + `; name="${formdataEscape(normalizeLinefeeds(name))}"\r
+            const chunk3 = textEncoder.encode(prefix + `; name="${formdataEscape(normalizeLinefeeds(name))}"\r
 \r
 ${normalizeLinefeeds(value2)}\r
 `);
-            blobParts.push(chunk2);
-            length += chunk2.byteLength;
+            blobParts.push(chunk3);
+            length += chunk3.byteLength;
           } else {
-            const chunk2 = textEncoder.encode(`${prefix}; name="${formdataEscape(normalizeLinefeeds(name))}"` + (value2.name ? `; filename="${formdataEscape(value2.name)}"` : "") + `\r
+            const chunk3 = textEncoder.encode(`${prefix}; name="${formdataEscape(normalizeLinefeeds(name))}"` + (value2.name ? `; filename="${formdataEscape(value2.name)}"` : "") + `\r
 Content-Type: ${value2.type || "application/octet-stream"}\r
 \r
 `);
-            blobParts.push(chunk2, value2, rn2);
+            blobParts.push(chunk3, value2, rn2);
             if (typeof value2.size === "number") {
-              length += chunk2.byteLength + value2.size + rn2.byteLength;
+              length += chunk3.byteLength + value2.size + rn2.byteLength;
             } else {
               hasUnknownSizeValue = true;
             }
           }
         }
-        const chunk = textEncoder.encode(`--${boundary}--\r
+        const chunk2 = textEncoder.encode(`--${boundary}--\r
 `);
-        blobParts.push(chunk);
-        length += chunk.byteLength;
+        blobParts.push(chunk2);
+        length += chunk2.byteLength;
         if (hasUnknownSizeValue) {
           length = null;
         }
@@ -42974,41 +42974,41 @@ var require_client_h1 = __commonJS({
       }
       readMore() {
         while (!this.paused && this.ptr) {
-          const chunk = this.socket.read();
-          if (chunk === null) {
+          const chunk2 = this.socket.read();
+          if (chunk2 === null) {
             break;
           }
-          this.execute(chunk);
+          this.execute(chunk2);
         }
       }
       /**
        * @param {Buffer} chunk
        */
-      execute(chunk) {
+      execute(chunk2) {
         assert2(currentParser === null);
         assert2(this.ptr != null);
         assert2(!this.paused);
         const { socket, llhttp } = this;
-        if (chunk.length > currentBufferSize) {
+        if (chunk2.length > currentBufferSize) {
           if (currentBufferPtr) {
             llhttp.free(currentBufferPtr);
           }
-          currentBufferSize = Math.ceil(chunk.length / 4096) * 4096;
+          currentBufferSize = Math.ceil(chunk2.length / 4096) * 4096;
           currentBufferPtr = llhttp.malloc(currentBufferSize);
         }
-        new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(chunk);
+        new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(chunk2);
         try {
           let ret;
           try {
-            currentBufferRef = chunk;
+            currentBufferRef = chunk2;
             currentParser = this;
-            ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, chunk.length);
+            ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, chunk2.length);
           } finally {
             currentParser = null;
             currentBufferRef = null;
           }
           if (ret !== constants2.ERROR.OK) {
-            const data = chunk.subarray(llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr);
+            const data = chunk2.subarray(llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr);
             if (ret === constants2.ERROR.PAUSED_UPGRADE) {
               this.onUpgrade(data);
             } else if (ret === constants2.ERROR.PAUSED) {
@@ -43707,12 +43707,12 @@ upgrade: ${upgrade}\r
       assert2(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
       let finished = false;
       const writer = new AsyncWriter({ abort, socket, request: request7, contentLength, client, expectsPayload, header });
-      const onData = function(chunk) {
+      const onData = function(chunk2) {
         if (finished) {
           return;
         }
         try {
-          if (!writer.write(chunk) && this.pause) {
+          if (!writer.write(chunk2) && this.pause) {
             this.pause();
           }
         } catch (err) {
@@ -43847,11 +43847,11 @@ upgrade: ${upgrade}\r
       socket.on("close", onDrain).on("drain", onDrain);
       const writer = new AsyncWriter({ abort, socket, request: request7, contentLength, client, expectsPayload, header });
       try {
-        for await (const chunk of body) {
+        for await (const chunk2 of body) {
           if (socket[kError]) {
             throw socket[kError];
           }
-          if (!writer.write(chunk)) {
+          if (!writer.write(chunk2)) {
             await waitForDrain();
           }
         }
@@ -43889,7 +43889,7 @@ upgrade: ${upgrade}\r
        * @param {Buffer} chunk
        * @returns
        */
-      write(chunk) {
+      write(chunk2) {
         const { socket, request: request7, contentLength, client, bytesWritten, expectsPayload, header } = this;
         if (socket[kError]) {
           throw socket[kError];
@@ -43897,7 +43897,7 @@ upgrade: ${upgrade}\r
         if (socket.destroyed) {
           return false;
         }
-        const len = Buffer.byteLength(chunk);
+        const len = Buffer.byteLength(chunk2);
         if (!len) {
           return true;
         }
@@ -43927,9 +43927,9 @@ ${len.toString(16)}\r
 `, "latin1");
         }
         this.bytesWritten += len;
-        const ret = socket.write(chunk);
+        const ret = socket.write(chunk2);
         socket.uncork();
-        request7.onBodySent(chunk);
+        request7.onBodySent(chunk2);
         if (!ret) {
           if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
             if (socket[kParser].timeout.refresh) {
@@ -44508,11 +44508,11 @@ var require_client_h2 = __commonJS({
         if (request7.onHeaders(Number(statusCode), parseH2Headers(realHeaders), stream.resume.bind(stream), "") === false) {
           stream.pause();
         }
-        stream.on("data", (chunk) => {
+        stream.on("data", (chunk2) => {
           if (request7.aborted || request7.completed) {
             return;
           }
-          if (request7.onData(chunk) === false) {
+          if (request7.onData(chunk2) === false) {
             stream.pause();
           }
         });
@@ -44682,8 +44682,8 @@ var require_client_h2 = __commonJS({
         }
       );
       util2.addListener(pipe2, "data", onPipeData);
-      function onPipeData(chunk) {
-        request7.onBodySent(chunk);
+      function onPipeData(chunk2) {
+        request7.onBodySent(chunk2);
       }
     }
     async function writeBlob(abort, h2stream, body, client, request7, socket, contentLength, expectsPayload) {
@@ -44727,12 +44727,12 @@ var require_client_h2 = __commonJS({
       });
       h2stream.on("close", onDrain).on("drain", onDrain);
       try {
-        for await (const chunk of body) {
+        for await (const chunk2 of body) {
           if (socket[kError]) {
             throw socket[kError];
           }
-          const res = h2stream.write(chunk);
-          request7.onBodySent(chunk);
+          const res = h2stream.write(chunk2);
+          request7.onBodySent(chunk2);
           if (!res) {
             await waitForDrain();
           }
@@ -47395,12 +47395,12 @@ var require_retry_handler = __commonJS({
           });
         }
       }
-      onResponseData(controller, chunk) {
+      onResponseData(controller, chunk2) {
         if (this.error) {
           return;
         }
-        this.start += chunk.length;
-        this.handler.onResponseData?.(controller, chunk);
+        this.start += chunk2.length;
+        this.handler.onResponseData?.(controller, chunk2);
       }
       onResponseEnd(controller, trailers) {
         if (this.error && this.retryOpts.throwOnError) {
@@ -47655,15 +47655,15 @@ var require_readable = __commonJS({
        * @param {Buffer|null} chunk
        * @returns {boolean}
        */
-      push(chunk) {
-        if (chunk) {
-          this[kBytesRead] += chunk.length;
+      push(chunk2) {
+        if (chunk2) {
+          this[kBytesRead] += chunk2.length;
           if (this[kConsume]) {
-            consumePush(this[kConsume], chunk);
-            return this[kReading] ? super.push(chunk) : true;
+            consumePush(this[kConsume], chunk2);
+            return this[kReading] ? super.push(chunk2) : true;
           }
         }
-        return super.push(chunk);
+        return super.push(chunk2);
       }
       /**
        * Consumes and returns the body as a string.
@@ -47854,8 +47854,8 @@ var require_readable = __commonJS({
           consumePush(consume2, state.buffer[n10]);
         }
       } else {
-        for (const chunk of state.buffer) {
-          consumePush(consume2, chunk);
+        for (const chunk2 of state.buffer) {
+          consumePush(consume2, chunk2);
         }
       }
       if (state.endEmitted) {
@@ -47892,9 +47892,9 @@ var require_readable = __commonJS({
       const buffer2 = new Uint8Array(Buffer.allocUnsafeSlow(length).buffer);
       let offset = 0;
       for (let i10 = 0; i10 < chunks.length; ++i10) {
-        const chunk = chunks[i10];
-        buffer2.set(chunk, offset);
-        offset += chunk.length;
+        const chunk2 = chunks[i10];
+        buffer2.set(chunk2, offset);
+        offset += chunk2.length;
       }
       return buffer2;
     }
@@ -47917,9 +47917,9 @@ var require_readable = __commonJS({
         stream.destroy(err);
       }
     }
-    function consumePush(consume2, chunk) {
-      consume2.length += chunk.length;
-      consume2.body.push(chunk);
+    function consumePush(consume2, chunk2) {
+      consume2.length += chunk2.length;
+      consume2.body.push(chunk2);
     }
     function consumeFinish(consume2, err) {
       if (consume2.body === null) {
@@ -48064,8 +48064,8 @@ var require_api_request = __commonJS({
           }
         }
       }
-      onData(chunk) {
-        return this.res.push(chunk);
+      onData(chunk2) {
+        return this.res.push(chunk2);
       }
       onComplete(trailers) {
         util2.parseHeaders(trailers, this.trailers);
@@ -48280,9 +48280,9 @@ var require_api_stream = __commonJS({
         const needDrain = res.writableNeedDrain !== void 0 ? res.writableNeedDrain : res._writableState?.needDrain;
         return needDrain !== true;
       }
-      onData(chunk) {
+      onData(chunk2) {
         const { res } = this;
-        return res ? res.write(chunk) : true;
+        return res ? res.write(chunk2) : true;
       }
       onComplete(trailers) {
         const { res } = this;
@@ -48423,9 +48423,9 @@ var require_api_pipeline = __commonJS({
               body.resume();
             }
           },
-          write: (chunk, encoding, callback) => {
+          write: (chunk2, encoding, callback) => {
             const { req } = this;
-            if (req.push(chunk, encoding) || req._readableState.destroyed) {
+            if (req.push(chunk2, encoding) || req._readableState.destroyed) {
               callback();
             } else {
               req[kResume] = callback;
@@ -48490,9 +48490,9 @@ var require_api_pipeline = __commonJS({
         if (!body || typeof body.on !== "function") {
           throw new InvalidReturnValueError("expected Readable");
         }
-        body.on("data", (chunk) => {
+        body.on("data", (chunk2) => {
           const { ret, body: body2 } = this;
-          if (!ret.push(chunk) && body2.pause) {
+          if (!ret.push(chunk2) && body2.pause) {
             body2.pause();
           }
         }).on("error", (err) => {
@@ -48509,9 +48509,9 @@ var require_api_pipeline = __commonJS({
         });
         this.body = body;
       }
-      onData(chunk) {
+      onData(chunk2) {
         const { res } = this;
-        return res.push(chunk);
+        return res.push(chunk2);
       }
       onComplete(trailers) {
         const { res } = this;
@@ -49670,8 +49670,8 @@ var require_pending_interceptors_formatter = __commonJS({
     module2.exports = class PendingInterceptorsFormatter {
       constructor({ disableColors } = {}) {
         this.transform = new Transform({
-          transform(chunk, _enc, cb2) {
-            cb2(null, chunk);
+          transform(chunk2, _enc, cb2) {
+            cb2(null, chunk2);
           }
         });
         this.logger = new Console({
@@ -50465,9 +50465,9 @@ var require_snapshot_agent = __commonJS({
             responseData.headers = headers;
             return handler.onResponseStart(controller, statusCode, headers, statusMessage);
           },
-          onResponseData(controller, chunk) {
-            responseData.body.push(chunk);
-            return handler.onResponseData(controller, chunk);
+          onResponseData(controller, chunk2) {
+            responseData.body.push(chunk2);
+            return handler.onResponseData(controller, chunk2);
           },
           onResponseEnd(controller, trailers) {
             responseData.trailers = trailers;
@@ -50849,10 +50849,10 @@ var require_redirect_handler = __commonJS({
         this.opts.origin = origin;
         this.opts.query = null;
       }
-      onResponseData(controller, chunk) {
+      onResponseData(controller, chunk2) {
         if (this.location) {
         } else {
-          this.handler.onResponseData?.(controller, chunk);
+          this.handler.onResponseData?.(controller, chunk2);
         }
       }
       onResponseEnd(controller, trailers) {
@@ -50962,11 +50962,11 @@ var require_response_error = __commonJS({
           this.#decoder = new TextDecoder("utf-8");
         }
       }
-      onResponseData(controller, chunk) {
+      onResponseData(controller, chunk2) {
         if (this.#statusCode < 400) {
-          return super.onResponseData(controller, chunk);
+          return super.onResponseData(controller, chunk2);
         }
-        this.#body += this.#decoder?.decode(chunk, { stream: true }) ?? "";
+        this.#body += this.#decoder?.decode(chunk2, { stream: true }) ?? "";
       }
       onResponseEnd(controller, trailers) {
         if (this.#statusCode >= 400) {
@@ -51073,8 +51073,8 @@ var require_dump = __commonJS({
       onResponseError(controller, err) {
         super.onResponseError(controller, this.aborted === true ? this.reason : err);
       }
-      onResponseData(controller, chunk) {
-        this.#size = this.#size + chunk.length;
+      onResponseData(controller, chunk2) {
+        this.#size = this.#size + chunk2.length;
         if (this.#size > this.#maxSize) {
           throw new RequestAbortedError(
             `Response size (${this.#size}) larger than maxSize (${this.#maxSize})`
@@ -52784,9 +52784,9 @@ var require_cache_handler = __commonJS({
             if (typeof cachedValue.body.values === "function") {
               const bodyIterator = cachedValue.body.values();
               const streamCachedBody = () => {
-                for (const chunk of bodyIterator) {
-                  const full = this.#writeStream.write(chunk) === false;
-                  this.#handler.onResponseData?.(controller, chunk);
+                for (const chunk2 of bodyIterator) {
+                  const full = this.#writeStream.write(chunk2) === false;
+                  this.#handler.onResponseData?.(controller, chunk2);
                   if (full) {
                     break;
                   }
@@ -52804,9 +52804,9 @@ var require_cache_handler = __commonJS({
               });
               streamCachedBody();
             } else if (typeof cachedValue.body.on === "function") {
-              cachedValue.body.on("data", (chunk) => {
-                this.#writeStream.write(chunk);
-                this.#handler.onResponseData?.(controller, chunk);
+              cachedValue.body.on("data", (chunk2) => {
+                this.#writeStream.write(chunk2);
+                this.#handler.onResponseData?.(controller, chunk2);
               }).on("end", () => {
                 this.#writeStream.end();
               }).on("error", () => {
@@ -52849,11 +52849,11 @@ var require_cache_handler = __commonJS({
           downstreamOnHeaders();
         }
       }
-      onResponseData(controller, chunk) {
-        if (this.#writeStream?.write(chunk) === false) {
+      onResponseData(controller, chunk2) {
+        if (this.#writeStream?.write(chunk2) === false) {
           controller.pause();
         }
-        this.#handler.onResponseData?.(controller, chunk);
+        this.#handler.onResponseData?.(controller, chunk2);
       }
       onResponseEnd(controller, trailers) {
         this.#writeStream?.end();
@@ -53150,15 +53150,15 @@ var require_memory_cache_store = __commonJS({
         const store = this;
         const entry = { ...key, ...val, body: [], size: 0 };
         return new Writable({
-          write(chunk, encoding, callback) {
-            if (typeof chunk === "string") {
-              chunk = Buffer.from(chunk, encoding);
+          write(chunk2, encoding, callback) {
+            if (typeof chunk2 === "string") {
+              chunk2 = Buffer.from(chunk2, encoding);
             }
-            entry.size += chunk.byteLength;
+            entry.size += chunk2.byteLength;
             if (entry.size >= store.#maxEntrySize) {
               this.destroy();
             } else {
-              entry.body.push(chunk);
+              entry.body.push(chunk2);
             }
             callback(null);
           },
@@ -53319,11 +53319,11 @@ var require_cache_revalidation_handler = __commonJS({
           statusMessage
         );
       }
-      onResponseData(controller, chunk) {
+      onResponseData(controller, chunk2) {
         if (this.#successful) {
           return;
         }
-        return this.#handler.onResponseData?.(controller, chunk);
+        return this.#handler.onResponseData?.(controller, chunk2);
       }
       onResponseEnd(controller, trailers) {
         if (this.#successful) {
@@ -53572,8 +53572,8 @@ var require_cache2 = __commonJS({
       if (opts.method === "HEAD") {
         stream.destroy();
       } else {
-        stream.on("data", function(chunk) {
-          handler.onResponseData?.(controller, chunk);
+        stream.on("data", function(chunk2) {
+          handler.onResponseData?.(controller, chunk2);
         });
       }
     }
@@ -53794,8 +53794,8 @@ var require_decompress = __commonJS({
     function createMaxSizeLimiter(maxSize) {
       let size = 0;
       return new TransformStream2({
-        transform(chunk, _encoding, callback) {
-          const decompressedSize = size + chunk.length;
+        transform(chunk2, _encoding, callback) {
+          const decompressedSize = size + chunk2.length;
           if (decompressedSize > maxSize) {
             callback(new ResponseExceededMaxSizeError(
               `Decompressed response size (${decompressedSize}) exceeded maxSize (${maxSize})`
@@ -53803,7 +53803,7 @@ var require_decompress = __commonJS({
             return;
           }
           size = decompressedSize;
-          callback(null, chunk);
+          callback(null, chunk2);
         }
       });
     }
@@ -53911,9 +53911,9 @@ var require_decompress = __commonJS({
           if (this.#terminated) {
             return;
           }
-          let chunk;
-          while ((chunk = decompressor.read()) !== null) {
-            const decompressedSize = this.#decompressedSize + chunk.length;
+          let chunk2;
+          while ((chunk2 = decompressor.read()) !== null) {
+            const decompressedSize = this.#decompressedSize + chunk2.length;
             if (decompressedSize > this.#maxSize) {
               this.#fail(controller, new ResponseExceededMaxSizeError(
                 `Decompressed response size (${decompressedSize}) exceeded maxSize (${this.#maxSize})`
@@ -53921,7 +53921,7 @@ var require_decompress = __commonJS({
               return;
             }
             this.#decompressedSize = decompressedSize;
-            const result = super.onResponseData(controller, chunk);
+            const result = super.onResponseData(controller, chunk2);
             if (result === false) {
               break;
             }
@@ -54030,12 +54030,12 @@ var require_decompress = __commonJS({
        * @param {Buffer} chunk
        * @returns {void}
        */
-      onResponseData(controller, chunk) {
+      onResponseData(controller, chunk2) {
         if (this.#decompressors.length > 0) {
-          this.#decompressors[0].write(chunk);
+          this.#decompressors[0].write(chunk2);
           return;
         }
-        super.onResponseData(controller, chunk);
+        super.onResponseData(controller, chunk2);
       }
       /**
        * @param {Controller} controller
@@ -54242,12 +54242,12 @@ var require_deduplication_handler = __commonJS({
        * @param {import('../../types/dispatcher.d.ts').default.DispatchController} controller
        * @param {Buffer} chunk
        */
-      onResponseData(controller, chunk) {
+      onResponseData(controller, chunk2) {
         if (this.#aborted || this.#completed) {
           return;
         }
         this.#responseDataStarted = true;
-        this.#primaryHandler.onResponseData?.(controller, chunk);
+        this.#primaryHandler.onResponseData?.(controller, chunk2);
         for (const waitingHandler of this.#waitingHandlers) {
           const { handler, controller: waitingController } = waitingHandler;
           if (waitingHandler.done || waitingController.aborted) {
@@ -54255,11 +54255,11 @@ var require_deduplication_handler = __commonJS({
             continue;
           }
           if (waitingController.paused) {
-            this.#bufferWaitingChunk(waitingHandler, chunk);
+            this.#bufferWaitingChunk(waitingHandler, chunk2);
             continue;
           }
           try {
-            handler.onResponseData?.(waitingController, chunk);
+            handler.onResponseData?.(waitingController, chunk2);
           } catch {
           }
           if (waitingController.aborted) {
@@ -54384,14 +54384,14 @@ var require_deduplication_handler = __commonJS({
        * @param {WaitingHandler} waitingHandler
        * @param {Buffer} chunk
        */
-      #bufferWaitingChunk(waitingHandler, chunk) {
+      #bufferWaitingChunk(waitingHandler, chunk2) {
         if (waitingHandler.done || waitingHandler.controller.aborted) {
           waitingHandler.done = true;
           waitingHandler.bufferedChunks = [];
           waitingHandler.bufferedBytes = 0;
           return;
         }
-        const bufferedChunk = Buffer.from(chunk);
+        const bufferedChunk = Buffer.from(chunk2);
         waitingHandler.bufferedChunks.push(bufferedChunk);
         waitingHandler.bufferedBytes += bufferedChunk.length;
         if (waitingHandler.bufferedBytes > this.#maxBufferSize) {
@@ -54781,10 +54781,10 @@ var require_sqlite_cache_store = __commonJS({
         const store = this;
         return new Writable({
           decodeStrings: true,
-          write(chunk, encoding, callback) {
-            size += chunk.byteLength;
+          write(chunk2, encoding, callback) {
+            size += chunk2.byteLength;
             if (size < store.#maxEntrySize) {
-              body.push(chunk);
+              body.push(chunk2);
             } else {
               this.destroy();
             }
@@ -57731,11 +57731,11 @@ var require_fetch = __commonJS({
               });
               return true;
             },
-            onData(chunk) {
+            onData(chunk2) {
               if (fetchParams.controller.dump) {
                 return;
               }
-              const bytes = chunk;
+              const bytes = chunk2;
               timingInfo.encodedBodySize += bytes.byteLength;
               return this.body.push(bytes);
             },
@@ -59789,7 +59789,7 @@ var require_permessage_deflate = __commonJS({
        * @param {boolean} fin Final fragment flag
        * @param {Function} callback Callback function
        */
-      decompress(chunk, fin, callback) {
+      decompress(chunk2, fin, callback) {
         if (!this.#inflate) {
           let windowBits = Z_DEFAULT_WINDOWBITS;
           if (this.#options.serverMaxWindowBits) {
@@ -59823,7 +59823,7 @@ var require_permessage_deflate = __commonJS({
             callback(err);
           });
         }
-        this.#inflate.write(chunk);
+        this.#inflate.write(chunk2);
         if (fin) {
           this.#inflate.write(tail);
         }
@@ -59897,9 +59897,9 @@ var require_receiver = __commonJS({
        * @param {Buffer} chunk
        * @param {() => void} callback
        */
-      _write(chunk, _, callback) {
-        this.#buffers.push(chunk);
-        this.#byteOffset += chunk.length;
+      _write(chunk2, _, callback) {
+        this.#buffers.push(chunk2);
+        this.#byteOffset += chunk2.length;
         this.#loop = true;
         this.run(callback);
       }
@@ -60343,8 +60343,8 @@ var require_websocket = __commonJS({
         onMessage: (opcode, data) => this.#onMessage(opcode, data),
         onParserError: (err) => failWebsocketConnection(this.#handler, null, err.message),
         onParserDrain: () => this.#onParserDrain(),
-        onSocketData: (chunk) => {
-          if (!this.#parser.write(chunk)) {
+        onSocketData: (chunk2) => {
+          if (!this.#parser.write(chunk2)) {
             this.#handler.socket.pause();
           }
         },
@@ -60902,8 +60902,8 @@ var require_websocketstream = __commonJS({
         onMessage: (opcode, data) => this.#onMessage(opcode, data),
         onParserError: (err) => failWebsocketConnection(this.#handler, null, err.message),
         onParserDrain: () => this.#handler.socket.resume(),
-        onSocketData: (chunk) => {
-          if (!this.#parser.write(chunk)) {
+        onSocketData: (chunk2) => {
+          if (!this.#parser.write(chunk2)) {
             this.#handler.socket.pause();
           }
         },
@@ -60998,18 +60998,18 @@ var require_websocketstream = __commonJS({
         const reason = closeInfo.reason;
         closeWebSocketConnection(this.#handler, code, reason, true);
       }
-      #write(chunk) {
-        chunk = webidl.converters.WebSocketStreamWrite(chunk);
+      #write(chunk2) {
+        chunk2 = webidl.converters.WebSocketStreamWrite(chunk2);
         const promise2 = createDeferredPromise();
         let data = null;
         let opcode = null;
-        if (webidl.is.BufferSource(chunk)) {
-          data = new Uint8Array(ArrayBuffer.isView(chunk) ? new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength) : chunk.slice());
+        if (webidl.is.BufferSource(chunk2)) {
+          data = new Uint8Array(ArrayBuffer.isView(chunk2) ? new Uint8Array(chunk2.buffer, chunk2.byteOffset, chunk2.byteLength) : chunk2.slice());
           opcode = opcodes.BINARY;
         } else {
           let string4;
           try {
-            string4 = webidl.converters.DOMString(chunk);
+            string4 = webidl.converters.DOMString(chunk2);
           } catch (e14) {
             promise2.reject(e14);
             return promise2.promise;
@@ -61050,7 +61050,7 @@ var require_websocketstream = __commonJS({
           start: (controller) => {
             this.#writableStreamController = controller;
           },
-          write: (chunk) => this.#write(chunk),
+          write: (chunk2) => this.#write(chunk2),
           close: () => closeWebSocketConnection(this.#handler, null, null),
           abort: (reason) => this.#closeUsingReason(reason)
         });
@@ -61067,18 +61067,18 @@ var require_websocketstream = __commonJS({
         if (this.#handler.readyState !== states.OPEN) {
           return;
         }
-        let chunk;
+        let chunk2;
         if (type2 === opcodes.TEXT) {
           try {
-            chunk = utf8Decode(data);
+            chunk2 = utf8Decode(data);
           } catch {
             failWebsocketConnection(this.#handler, 1007, "Received invalid UTF-8 in text frame.");
             return;
           }
         } else if (type2 === opcodes.BINARY) {
-          chunk = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+          chunk2 = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
         }
-        this.#readableStreamController.enqueue(chunk);
+        this.#readableStreamController.enqueue(chunk2);
       }
       /** @type {import('../websocket').Handler['onSocketClose']} */
       #onSocketClose() {
@@ -61287,12 +61287,12 @@ var require_eventsource_stream = __commonJS({
        * @param {Function} callback
        * @returns {void}
        */
-      _transform(chunk, _encoding, callback) {
-        if (chunk.length === 0) {
+      _transform(chunk2, _encoding, callback) {
+        if (chunk2.length === 0) {
           callback();
           return;
         }
-        this.chunks.push(chunk);
+        this.chunks.push(chunk2);
         if (this.checkBOM) {
           if (this.handleBOM()) {
             callback();
@@ -61460,10 +61460,10 @@ ${value2}`;
         const chunks = [];
         let length = 0;
         for (let i10 = this.lineChunkIndex; i10 <= this.chunkIndex; i10++) {
-          const chunk = this.chunks[i10];
+          const chunk2 = this.chunks[i10];
           const start = i10 === this.lineChunkIndex ? this.linePos : 0;
-          const end = i10 === this.chunkIndex ? this.pos : chunk.length;
-          const slice = chunk.subarray(start, end);
+          const end = i10 === this.chunkIndex ? this.pos : chunk2.length;
+          const slice = chunk2.subarray(start, end);
           length += slice.length;
           chunks.push(slice);
         }
@@ -61473,10 +61473,10 @@ ${value2}`;
         let chunkIndex = this.lineChunkIndex;
         let pos = this.linePos;
         while (chunkIndex < this.chunks.length) {
-          const chunk = this.chunks[chunkIndex];
-          const remaining = chunk.length - pos;
+          const chunk2 = this.chunks[chunkIndex];
+          const remaining = chunk2.length - pos;
           if (offset < remaining) {
-            return chunk[pos + offset];
+            return chunk2[pos + offset];
           }
           offset -= remaining;
           chunkIndex++;
@@ -61485,8 +61485,8 @@ ${value2}`;
       }
       discardLeadingBytes(count) {
         while (count > 0 && this.lineChunkIndex < this.chunks.length) {
-          const chunk = this.chunks[this.lineChunkIndex];
-          const remaining = chunk.length - this.linePos;
+          const chunk2 = this.chunks[this.lineChunkIndex];
+          const remaining = chunk2.length - this.linePos;
           if (count < remaining) {
             this.linePos += count;
             count = 0;
@@ -64247,8 +64247,8 @@ async function* callCloudAntigravity(params, fetchFn = fetch) {
   let buffer2 = "";
   const sseDataPrefix = "data:";
   for await (const rawChunk of response.body) {
-    const chunk = rawChunk instanceof Uint8Array ? rawChunk : Buffer.from(String(rawChunk));
-    buffer2 += decoder.decode(chunk, { stream: true });
+    const chunk2 = rawChunk instanceof Uint8Array ? rawChunk : Buffer.from(String(rawChunk));
+    buffer2 += decoder.decode(chunk2, { stream: true });
     const lines = buffer2.split("\n");
     buffer2 = lines.pop() ?? "";
     for (const line of lines) {
@@ -106082,15 +106082,15 @@ ${itemIndentStr}`);
       }
       let sumChunks = [chunks.shift()];
       let sumWidth = this.displayWidth(sumChunks[0]);
-      chunks.forEach((chunk) => {
-        const visibleWidth = this.displayWidth(chunk);
+      chunks.forEach((chunk2) => {
+        const visibleWidth = this.displayWidth(chunk2);
         if (sumWidth + visibleWidth <= width) {
-          sumChunks.push(chunk);
+          sumChunks.push(chunk2);
           sumWidth += visibleWidth;
           return;
         }
         wrappedLines.push(sumChunks.join(""));
-        const nextChunk = chunk.trimStart();
+        const nextChunk = chunk2.trimStart();
         sumChunks = [nextChunk];
         sumWidth = this.displayWidth(nextChunk);
       });
@@ -113873,8 +113873,8 @@ async function runChild(options) {
   await new Promise((resolve2, reject) => {
     const child = (0, import_node_child_process5.spawn)(invocation.command, [...invocation.args], { stdio: ["ignore", "ignore", "pipe"], env: { ...process.env, AGENT_SHIM_HOME: options.paths.root } });
     let stderr = "";
-    child.stderr.on("data", (chunk) => {
-      stderr = `${stderr}${chunk.toString()}`.slice(-STDERR_TAIL_CHARS);
+    child.stderr.on("data", (chunk2) => {
+      stderr = `${stderr}${chunk2.toString()}`.slice(-STDERR_TAIL_CHARS);
     });
     const killer = setTimeout(() => {
       child.kill("SIGKILL");
@@ -114697,11 +114697,11 @@ function pumpTapSession(secure, openUpstream, tap, prefix = Buffer.alloc(0)) {
       upstream.write(prefix);
     }
     if (tap !== void 0) {
-      secure.on("data", (chunk) => {
-        tap.onChunk("client-to-server", chunk);
+      secure.on("data", (chunk2) => {
+        tap.onChunk("client-to-server", chunk2);
       });
-      upstream.on("data", (chunk) => {
-        tap.onChunk("server-to-client", chunk);
+      upstream.on("data", (chunk2) => {
+        tap.onChunk("server-to-client", chunk2);
       });
     }
     secure.pipe(upstream);
@@ -115167,8 +115167,8 @@ function handleConnect(socket, context) {
   });
   context.ledger.accept(socket);
   let buffer2 = Buffer.alloc(0);
-  const onData = (chunk) => {
-    buffer2 = Buffer.concat([buffer2, chunk]);
+  const onData = (chunk2) => {
+    buffer2 = Buffer.concat([buffer2, chunk2]);
     const headEnd = buffer2.indexOf(HEAD_TERMINATOR);
     if (headEnd === -1 ? buffer2.length > MAX_CONNECT_HEAD_BYTES : headEnd > MAX_CONNECT_HEAD_BYTES) {
       context.ledger.headReceived(socket);
@@ -115639,11 +115639,11 @@ function createRcSessionTracker(deps) {
         onResponse: (status) => {
           accepted2 = isSuccessful(status);
         },
-        onBodyChunk: (chunk) => {
+        onBodyChunk: (chunk2) => {
           if (!accepted2 || buffered2 >= RC_CREATE_RESPONSE_CAP_BYTES) {
             return;
           }
-          const text2 = Buffer.from(chunk).toString("utf8");
+          const text2 = Buffer.from(chunk2).toString("utf8");
           body = body + text2.slice(0, RC_CREATE_RESPONSE_CAP_BYTES - buffered2);
           buffered2 = body.length;
         },
@@ -115708,12 +115708,12 @@ function createRcSessionTracker(deps) {
     const archiving = method === "POST" && rest === `${id2}/archive`;
     return {
       ...bodyKind === void 0 ? {} : {
-        onRequestChunk: (chunk) => {
+        onRequestChunk: (chunk2) => {
           if (oversized) {
             return;
           }
-          chunks.push(Buffer.from(chunk));
-          buffered += chunk.length;
+          chunks.push(Buffer.from(chunk2));
+          buffered += chunk2.length;
           if (buffered > RC_REQUEST_PARSE_CAP_BYTES) {
             oversized = true;
             chunks = [];
@@ -115821,8 +115821,8 @@ function observingRoutedRoute(route, tracker, hooks) {
     serve: async (request7, response) => {
       const observed = tracker.observeExchange({ method: request7.method, url: request7.url, headers: request7.headers });
       if (observed?.onRequestChunk !== void 0) {
-        request7.body.on("data", (chunk) => {
-          observed.onRequestChunk?.(chunk);
+        request7.body.on("data", (chunk2) => {
+          observed.onRequestChunk?.(chunk2);
         });
         request7.body.on("end", () => {
           observed.onRequestEnd?.();
@@ -115844,9 +115844,9 @@ function teeRoutedResponse(response, observer, onSettled) {
     flush: () => {
       response.flush();
     },
-    write: async (chunk) => {
-      observer.onBodyChunk(typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk);
-      await response.write(chunk);
+    write: async (chunk2) => {
+      observer.onBodyChunk(typeof chunk2 === "string" ? Buffer.from(chunk2, "utf8") : chunk2);
+      await response.write(chunk2);
     },
     end: () => {
       response.end();
@@ -116191,14 +116191,14 @@ async function readBody(request7) {
   return await new Promise((resolve2, reject) => {
     const chunks = [];
     let total = 0;
-    request7.on("data", (chunk) => {
-      total += chunk.length;
+    request7.on("data", (chunk2) => {
+      total += chunk2.length;
       if (total > CONTROL_BODY_CAP_BYTES) {
         request7.destroy();
         reject(new Error("too large"));
         return;
       }
-      chunks.push(chunk);
+      chunks.push(chunk2);
     });
     request7.on("end", () => {
       resolve2(Buffer.concat(chunks).toString("utf8"));
@@ -116482,8 +116482,8 @@ function realRcControlTransport(port, ca2) {
         },
         (response) => {
           const chunks = [];
-          response.on("data", (chunk) => {
-            chunks.push(chunk);
+          response.on("data", (chunk2) => {
+            chunks.push(chunk2);
           });
           response.on("end", () => {
             resolve2({ status: response.statusCode ?? 0, body: Buffer.concat(chunks).toString("utf8") });
@@ -116847,13 +116847,13 @@ async function listenFrontDoor(server, options = {}) {
   }
 }
 async function* upstreamChunks(stream) {
-  for await (const chunk of stream) {
-    if (typeof chunk === "string") {
-      yield Buffer.from(chunk, "utf8");
+  for await (const chunk2 of stream) {
+    if (typeof chunk2 === "string") {
+      yield Buffer.from(chunk2, "utf8");
       continue;
     }
-    if (chunk instanceof Uint8Array) {
-      yield chunk;
+    if (chunk2 instanceof Uint8Array) {
+      yield chunk2;
     }
   }
 }
@@ -117011,8 +117011,8 @@ function realRcEventDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_PO
     }
     const request7 = https3.request(options, (response) => {
       const chunks = [];
-      response.on("data", (chunk) => {
-        chunks.push(chunk);
+      response.on("data", (chunk2) => {
+        chunks.push(chunk2);
       });
       response.on("end", () => {
         resolve2({ status: response.statusCode ?? HTTP_BAD_GATEWAY, body: Buffer.concat(chunks).toString("utf8") });
@@ -117092,8 +117092,8 @@ function realRcStreamDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_P
   });
   const readAll = async (response) => {
     const chunks = [];
-    for await (const chunk of upstreamChunks(response)) {
-      chunks.push(Buffer.from(chunk));
+    for await (const chunk2 of upstreamChunks(response)) {
+      chunks.push(Buffer.from(chunk2));
     }
     return Buffer.concat(chunks).toString("utf8");
   };
@@ -117284,8 +117284,8 @@ function realConnectEffects(ports = DOOR_SOURCE_PORTS) {
         response.writeHead(upstreamResponse.statusCode ?? HTTP_BAD_GATEWAY, forwardableHeaders(upstreamResponse.headers));
         response.flushHeaders();
         if (observer !== void 0) {
-          upstreamResponse.on("data", (chunk) => {
-            observer.onResponseChunk(chunk);
+          upstreamResponse.on("data", (chunk2) => {
+            observer.onResponseChunk(chunk2);
           });
         }
         upstreamResponse.pipe(response);
@@ -117301,8 +117301,8 @@ function realConnectEffects(ports = DOOR_SOURCE_PORTS) {
         response.end(body);
       });
       if (observer !== void 0) {
-        request7.on("data", (chunk) => {
-          observer.onRequestChunk(chunk);
+        request7.on("data", (chunk2) => {
+          observer.onRequestChunk(chunk2);
         });
         if (observer.onRequestEnd !== void 0) {
           request7.on("end", () => {
@@ -118987,25 +118987,25 @@ var EventStreamDecoder = class {
   // Last MAX_DELIMITER_OVERLAP characters of the pending text, prefixed to the
   // next chunk so a delimiter straddling the boundary is still found.
   tail = "";
-  feed(chunk) {
+  feed(chunk2) {
     if (this.pending.length === 0) {
-      const first = chunk.charCodeAt(0);
+      const first = chunk2.charCodeAt(0);
       if (first === LF2 || first === CR2) {
-        chunk = chunk.replace(LEADING_LINE_ENDINGS_REGEX, "");
+        chunk2 = chunk2.replace(LEADING_LINE_ENDINGS_REGEX, "");
       }
     }
-    if (chunk === "") {
+    if (chunk2 === "") {
       return;
     }
-    const scan = this.tail + chunk;
-    this.pending.push(chunk);
+    const scan = this.tail + chunk2;
+    this.pending.push(chunk2);
     MESSAGE_DELIMITER_REGEX.lastIndex = 0;
     let match = MESSAGE_DELIMITER_REGEX.exec(scan);
     if (match === null) {
       this.tail = scan.slice(-2);
       return;
     }
-    const buffered = this.pending.length === 1 ? chunk : this.pending.join("");
+    const buffered = this.pending.length === 1 ? chunk2 : this.pending.join("");
     const offset = buffered.length - scan.length;
     const parts = [];
     let start = 0;
@@ -119038,8 +119038,8 @@ var EventStreamDecoderStream = class {
           controller.enqueue(event);
         });
       },
-      transform(chunk) {
-        decoder.feed(chunk);
+      transform(chunk2) {
+        decoder.feed(chunk2);
       },
       flush() {
         decoder.end();
@@ -124449,13 +124449,13 @@ var RequestLimitHandlerPlugin = class {
             let currentBodySize = 0;
             const limitedStream = stream.pipeThrough(
               new TransformStream({
-                transform(chunk, controller) {
-                  currentBodySize += chunk.byteLength;
+                transform(chunk2, controller) {
+                  currentBodySize += chunk2.byteLength;
                   if (currentBodySize > maxBodySize) {
                     controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
                     return;
                   }
-                  controller.enqueue(chunk);
+                  controller.enqueue(chunk2);
                 }
               })
             );
@@ -124511,8 +124511,8 @@ function toWebReadableStream(stream) {
     }
   });
 }
-function readableChunkToBytes(stream, chunk) {
-  return typeof chunk === "string" ? import_node_buffer.Buffer.from(chunk, stream.readableEncoding ?? "utf8") : chunk;
+function readableChunkToBytes(stream, chunk2) {
+  return typeof chunk2 === "string" ? import_node_buffer.Buffer.from(chunk2, stream.readableEncoding ?? "utf8") : chunk2;
 }
 async function _drainIterator(iterator) {
   while (!(await iterator.next()).done) {
@@ -124628,16 +124628,16 @@ function _streamToFormData(stream, contentType) {
 async function _streamToString(stream) {
   const decoder = new TextDecoder();
   let string4 = "";
-  for await (const chunk of stream) {
-    string4 += decoder.decode(readableChunkToBytes(stream, chunk), { stream: true });
+  for await (const chunk2 of stream) {
+    string4 += decoder.decode(readableChunkToBytes(stream, chunk2), { stream: true });
   }
   string4 += decoder.decode();
   return string4;
 }
 async function _streamToFile(stream, fileName, contentType) {
   const chunks = [];
-  for await (const chunk of stream) {
-    chunks.push(readableChunkToBytes(stream, chunk));
+  for await (const chunk2 of stream) {
+    chunks.push(readableChunkToBytes(stream, chunk2));
   }
   return new File(chunks, fileName, { type: contentType });
 }
@@ -127485,11 +127485,11 @@ async function collectBody(body) {
         resolve2(result);
       }
     };
-    body.on("data", (chunk) => {
+    body.on("data", (chunk2) => {
       if (settled) {
         return;
       }
-      const piece = typeof chunk === "string" ? Buffer.from(chunk) : chunk instanceof Uint8Array ? Buffer.from(chunk) : void 0;
+      const piece = typeof chunk2 === "string" ? Buffer.from(chunk2) : chunk2 instanceof Uint8Array ? Buffer.from(chunk2) : void 0;
       if (piece === void 0) {
         settle2({ kind: "failed" });
         return;
@@ -127539,11 +127539,11 @@ async function hopOnce(request7, response, target, body, mayRetry) {
       response.flush();
       const stream = async () => {
         try {
-          for await (const chunk of upstreamChunks(upstreamResponse)) {
+          for await (const chunk2 of upstreamChunks(upstreamResponse)) {
             if (request7.signal.aborted) {
               break;
             }
-            await response.write(chunk);
+            await response.write(chunk2);
           }
           if (!request7.signal.aborted) {
             response.end();
@@ -127677,13 +127677,13 @@ function createRoutedResponse(response, context) {
     flush: () => {
       response.flushHeaders();
     },
-    write: async (chunk) => {
+    write: async (chunk2) => {
       if (response.destroyed || response.writableEnded) {
         return;
       }
-      const accepted = response.write(chunk);
+      const accepted = response.write(chunk2);
       if (bodyObservers.length > 0) {
-        const bytes = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
+        const bytes = typeof chunk2 === "string" ? Buffer.from(chunk2, "utf8") : chunk2;
         observeBody((observer) => {
           observer.chunk(bytes);
         });
@@ -128653,8 +128653,8 @@ async function* parseSse(body) {
     } catch {
     }
   };
-  for await (const chunk of body) {
-    buffer2 += decoder.decode(chunk, { stream: true });
+  for await (const chunk2 of body) {
+    buffer2 += decoder.decode(chunk2, { stream: true });
     let newline = buffer2.indexOf("\n");
     while (newline !== -1) {
       const line = buffer2.slice(0, newline).replace(/\r$/, "");
@@ -129109,15 +129109,15 @@ var BodyTooLargeError = class extends Error {
 async function readBody2(request7) {
   const chunks = [];
   let size = 0;
-  for await (const chunk of request7.body) {
-    if (!Buffer.isBuffer(chunk)) {
+  for await (const chunk2 of request7.body) {
+    if (!Buffer.isBuffer(chunk2)) {
       throw new TypeError("request body chunk was not a Buffer");
     }
-    size += chunk.length;
+    size += chunk2.length;
     if (size > CODEX_MAX_BODY_BYTES) {
       throw new BodyTooLargeError();
     }
-    chunks.push(chunk);
+    chunks.push(chunk2);
   }
   return Buffer.concat(chunks).toString("utf8");
 }
@@ -129128,11 +129128,11 @@ async function writeRouteResponse(routed, response, signal) {
     response.end();
     return;
   }
-  for await (const chunk of routed.body) {
+  for await (const chunk2 of routed.body) {
     if (signal.aborted) {
       return;
     }
-    await response.write(chunk);
+    await response.write(chunk2);
   }
   response.end();
 }
@@ -129225,20 +129225,20 @@ function createAntigravityRelay(params) {
       activeBlockType = void 0;
     }
   };
-  const pushChunk = (chunk) => {
+  const pushChunk = (chunk2) => {
     frames.length = 0;
     ensureStarted();
-    if (chunk.usageMetadata !== void 0) {
-      const cached2 = chunk.usageMetadata.cachedContentTokenCount ?? 0;
-      const promptTotal = chunk.usageMetadata.promptTokenCount ?? usage.input_tokens + cached2;
+    if (chunk2.usageMetadata !== void 0) {
+      const cached2 = chunk2.usageMetadata.cachedContentTokenCount ?? 0;
+      const promptTotal = chunk2.usageMetadata.promptTokenCount ?? usage.input_tokens + cached2;
       usage = {
         input_tokens: Math.max(0, promptTotal - cached2),
         cache_creation_input_tokens: 0,
         cache_read_input_tokens: cached2,
-        output_tokens: chunk.usageMetadata.candidatesTokenCount ?? usage.output_tokens
+        output_tokens: chunk2.usageMetadata.candidatesTokenCount ?? usage.output_tokens
       };
     }
-    const candidate = chunk.candidates?.[0];
+    const candidate = chunk2.candidates?.[0];
     if (candidate?.content?.parts !== void 0) {
       for (const part of candidate.content.parts) {
         if ("text" in part && typeof part.text === "string" && (part.thoughtSignature === void 0 || part.text.length > 0)) {
@@ -129724,15 +129724,15 @@ var BodyTooLargeError2 = class extends Error {
 async function readBody3(request7) {
   const chunks = [];
   let size = 0;
-  for await (const chunk of request7.body) {
-    if (!Buffer.isBuffer(chunk)) {
+  for await (const chunk2 of request7.body) {
+    if (!Buffer.isBuffer(chunk2)) {
       throw new TypeError("request body chunk was not a Buffer");
     }
-    size += chunk.length;
+    size += chunk2.length;
     if (size > ANTIGRAVITY_MAX_BODY_BYTES) {
       throw new BodyTooLargeError2();
     }
-    chunks.push(chunk);
+    chunks.push(chunk2);
   }
   return Buffer.concat(chunks).toString("utf8");
 }
@@ -129743,11 +129743,11 @@ async function writeRouteResponse2(routed, response, signal) {
     response.end();
     return;
   }
-  for await (const chunk of routed.body) {
+  for await (const chunk2 of routed.body) {
     if (signal.aborted) {
       return;
     }
-    await response.write(chunk);
+    await response.write(chunk2);
   }
   response.end();
 }
@@ -129823,11 +129823,11 @@ function createPassthroughRoute(name, target) {
           response.flush();
           const stream = async () => {
             try {
-              for await (const chunk of upstreamChunks(upstreamResponse)) {
+              for await (const chunk2 of upstreamChunks(upstreamResponse)) {
                 if (request7.signal.aborted) {
                   return;
                 }
-                await response.write(chunk);
+                await response.write(chunk2);
               }
               response.end();
             } catch {
@@ -129886,8 +129886,8 @@ async function scanRequestHead(request7, wholeBody = false) {
     const settle2 = () => {
       const model = modelIn();
       const hasImage = /"type"\s*:\s*"image"/.test(text2);
-      for (const chunk of head) {
-        replay.write(chunk);
+      for (const chunk2 of head) {
+        replay.write(chunk2);
       }
       const maxTokens = /"max_tokens"\s*:\s*([0-9]+)/.exec(text2)?.[1];
       resolve2({
@@ -129901,9 +129901,9 @@ async function scanRequestHead(request7, wholeBody = false) {
         replayed: { ...request7, body: replay }
       });
     };
-    body.on("data", (chunk) => {
+    body.on("data", (chunk2) => {
       if (decided) {
-        if (!replay.write(chunk)) {
+        if (!replay.write(chunk2)) {
           body.pause();
           replay.once("drain", () => {
             body.resume();
@@ -129911,9 +129911,9 @@ async function scanRequestHead(request7, wholeBody = false) {
         }
         return;
       }
-      head.push(chunk);
-      seen += chunk.length;
-      text2 += chunk.toString("utf8");
+      head.push(chunk2);
+      seen += chunk2.length;
+      text2 += chunk2.toString("utf8");
       if (!wholeBody && (modelIn() !== void 0 || seen >= REQUEST_SCAN_CAP_BYTES)) {
         decided = true;
         body.pause();
@@ -131796,12 +131796,12 @@ function readableContentType(contentType) {
 async function readCapped(chunks) {
   const collected = [];
   let total = 0;
-  for await (const chunk of chunks) {
-    total += chunk.byteLength;
+  for await (const chunk2 of chunks) {
+    total += chunk2.byteLength;
     if (total > RC_WEB_FETCH_MAX_BYTES) {
       return { tooLarge: true, text: "" };
     }
-    collected.push(Buffer.from(chunk));
+    collected.push(Buffer.from(chunk2));
   }
   return { tooLarge: false, text: Buffer.concat(collected).toString("utf8") };
 }
@@ -132011,14 +132011,14 @@ async function readBody4(request7, capBytes) {
   return await new Promise((resolve2, reject) => {
     const chunks = [];
     let total = 0;
-    request7.on("data", (chunk) => {
-      total += chunk.length;
+    request7.on("data", (chunk2) => {
+      total += chunk2.length;
       if (total > capBytes) {
         request7.destroy();
         reject(new Error("body too large"));
         return;
       }
-      chunks.push(chunk);
+      chunks.push(chunk2);
     });
     request7.on("end", () => {
       resolve2(Buffer.concat(chunks).toString("utf8"));
@@ -132786,10 +132786,10 @@ function createRcStreamHub(deps) {
     }
     deps.log?.(`rc stream ${attachment.sessionId}: attached as client ${attachment.clientId}${resume === void 0 ? ", reading from the stream's own head" : `, resuming after sequence number ${String(resume.fromSequenceNum)}`}`);
     const parser = createSseParser();
-    for await (const chunk of answer.chunks) {
+    for await (const chunk2 of answer.chunks) {
       attachment.controller.signal.throwIfAborted();
       let lastEventId;
-      for (const parsed of parser.write(Buffer.from(chunk).toString("utf8"))) {
+      for (const parsed of parser.write(Buffer.from(chunk2).toString("utf8"))) {
         const envelope = parseRcStreamEnvelope(parsed);
         if (envelope === void 0) {
           continue;
@@ -133688,8 +133688,8 @@ var realHeadroomGet = async (target, requestPath, timeoutMs) => {
   return await new Promise((resolve2, reject) => {
     const request7 = import_node_http4.default.request({ socketPath: target.socketPath, path: requestPath, method: "GET", headers: { accept: "application/json", host: "localhost" }, timeout: timeoutMs }, (response) => {
       const chunks = [];
-      response.on("data", (chunk) => {
-        chunks.push(chunk);
+      response.on("data", (chunk2) => {
+        chunks.push(chunk2);
       });
       response.on("end", () => {
         resolve2({ status: response.statusCode ?? 0, text: Buffer.concat(chunks).toString("utf8") });
@@ -133907,6 +133907,84 @@ function providerScopedState(snapshot, providerName, providerDisplayName) {
   return void 0;
 }
 
+// src/statusline/ansi.ts
+var ESCAPE_CHAR_CODE = 27;
+var ESCAPE = String.fromCharCode(ESCAPE_CHAR_CODE);
+var ANSI_REGEX = new RegExp(`${ESCAPE}\\[[0-9;]*[a-zA-Z]`, "g");
+function visibleLength(text2) {
+  return text2.replace(ANSI_REGEX, "").length;
+}
+
+// src/statusline/barGrid.ts
+var BRACKET_COLUMNS = 2;
+function chunk(items, size) {
+  const chunks = [];
+  for (let start = 0; start < items.length; start += size) {
+    chunks.push(items.slice(start, start + size));
+  }
+  return chunks;
+}
+function lastColumnOf(index, rowLength, columns) {
+  return index === rowLength - 1 ? columns - 1 : index;
+}
+function measureGrid(rows, separatorLength, baseBarCells) {
+  const columns = Math.max(...rows.map((row) => row.length));
+  const prefixWidths = Array.from({ length: columns }, () => 0);
+  const suffixWidths = Array.from({ length: columns }, () => 0);
+  for (const row of rows) {
+    row.forEach((cell, index) => {
+      const last = lastColumnOf(index, row.length, columns);
+      prefixWidths[index] = Math.max(prefixWidths[index] ?? 0, visibleLength(cell.prefix));
+      suffixWidths[last] = Math.max(suffixWidths[last] ?? 0, visibleLength(cell.suffix));
+    });
+  }
+  const fixed = [...prefixWidths, ...suffixWidths].reduce((total, width) => total + width, 0) + columns * (baseBarCells + BRACKET_COLUMNS);
+  return { rows, columns, prefixWidths, suffixWidths, baseWidth: fixed + separatorLength * (columns - 1) };
+}
+function padTo(text2, width) {
+  return text2 + " ".repeat(Math.max(0, width - visibleLength(text2)));
+}
+function renderGrid(grid, maxWidth, separator, baseBarCells) {
+  const separatorLength = visibleLength(separator);
+  const spare = Math.max(0, maxWidth - grid.baseWidth);
+  const barCells = Array.from({ length: grid.columns }, (_, column) => baseBarCells + Math.floor(spare / grid.columns) + (column < spare % grid.columns ? 1 : 0));
+  const blockWidths = barCells.map((cells) => cells + BRACKET_COLUMNS);
+  return grid.rows.map(
+    (row) => row.map((cell, index) => {
+      const last = lastColumnOf(index, row.length, grid.columns);
+      let blockWidth = blockWidths[index] ?? 0;
+      for (let column = index + 1; column <= last; column += 1) {
+        blockWidth += separatorLength + (grid.suffixWidths[column - 1] ?? 0) + (grid.prefixWidths[column] ?? 0) + (blockWidths[column] ?? 0);
+      }
+      const prefix = padTo(cell.prefix, grid.prefixWidths[index] ?? 0);
+      const bar = cell.draw(blockWidth - BRACKET_COLUMNS);
+      const suffix = index === row.length - 1 ? cell.suffix : padTo(cell.suffix, grid.suffixWidths[last] ?? 0);
+      return `${prefix}${bar}${suffix}`;
+    }).join(separator)
+  );
+}
+function layoutBarGrid(groups, maxWidth, separator, baseBarCells) {
+  const nonEmpty = groups.filter((group) => group.length > 0);
+  if (nonEmpty.length === 0) {
+    return [];
+  }
+  const separatorLength = visibleLength(separator);
+  const widest = Math.max(...nonEmpty.map((group) => group.length));
+  const layoutFor = (perRow) => measureGrid(nonEmpty.flatMap((group) => chunk(group, perRow)), separatorLength, baseBarCells);
+  const candidates = [measureGrid([nonEmpty.flat()], separatorLength, baseBarCells)];
+  for (let perRow = widest; perRow > 1; perRow -= 1) {
+    candidates.push(layoutFor(perRow));
+  }
+  const fitting = candidates.find((grid) => grid.baseWidth <= maxWidth);
+  if (fitting !== void 0) {
+    return renderGrid(fitting, maxWidth, separator, baseBarCells);
+  }
+  if (nonEmpty.length > 1) {
+    return nonEmpty.flatMap((group) => layoutBarGrid([group], maxWidth, separator, baseBarCells));
+  }
+  return renderGrid(layoutFor(1), maxWidth, separator, baseBarCells);
+}
+
 // src/statusline/render.ts
 var BAR_WIDTH = 10;
 var SECONDS_PER_MINUTE2 = 60;
@@ -133922,17 +134000,11 @@ var FULL_PERCENT2 = 100;
 var ONE_PERCENT = 1;
 var USED_RED_AT = 0.9;
 var USED_YELLOW_AT = 0.7;
-var ESCAPE_CHAR_CODE = 27;
-var ESCAPE = String.fromCharCode(ESCAPE_CHAR_CODE);
 var RESET = `${ESCAPE}[0m`;
 var DIM = `${ESCAPE}[90m`;
 var GREEN = `${ESCAPE}[32m`;
 var YELLOW = `${ESCAPE}[33m`;
 var RED = `${ESCAPE}[31m`;
-var ANSI_REGEX = new RegExp(`${ESCAPE}\\[[0-9;]*[a-zA-Z]`, "g");
-function visibleLength(text2) {
-  return text2.replace(ANSI_REGEX, "").length;
-}
 function colorize() {
   return process.env.NO_COLOR === void 0;
 }
@@ -134059,69 +134131,30 @@ function secondsUntil(resetAt, nowMs) {
   const resetMs = Date.parse(resetAt);
   return Number.isNaN(resetMs) ? void 0 : Math.max(0, Math.round((resetMs - nowMs) / THOUSAND));
 }
-var Segment = class {
-  constructor(kind, text2 = "", prefix = "", suffix = "", fraction = 0, isUsed = true) {
-    this.kind = kind;
-    this.text = text2;
-    this.prefix = prefix;
-    this.suffix = suffix;
-    this.fraction = fraction;
-    this.isUsed = isUsed;
-  }
-  kind;
-  text;
-  prefix;
-  suffix;
-  fraction;
-  isUsed;
-  baseLength(baseBarWidth) {
-    if (this.kind === "static") {
-      return visibleLength(this.text);
-    }
-    return visibleLength(this.prefix) + baseBarWidth + 2 + visibleLength(this.suffix);
-  }
-  render(barWidth) {
-    if (this.kind === "static") {
-      return this.text;
-    }
-    const clamped = Math.max(0, Math.min(1, this.fraction));
-    const filled = Math.round(clamped * barWidth);
-    const color = statusColor(clamped, this.isUsed);
-    const bar = color === "" ? `[${"\u2588".repeat(filled)}${"\u2591".repeat(barWidth - filled)}]` : `[${color}${"\u2588".repeat(filled)}${DIM}${"\u2591".repeat(barWidth - filled)}${RESET}]`;
-    return `${this.prefix}${bar}${this.suffix}`;
-  }
-};
-function renderLineWithExtra(segments, maxWidth, separator, baseBarWidth) {
-  const separatorLength = visibleLength(separator);
-  const bars = segments.filter((segment) => segment.kind === "bar");
-  const lineBase = segments.reduce((total, segment) => total + segment.baseLength(baseBarWidth), 0) + separatorLength * (segments.length - 1);
-  const extra = Math.max(0, maxWidth - lineBase);
-  const extraById = /* @__PURE__ */ new Map();
-  if (bars.length > 0 && extra > 0) {
-    const perBar = Math.floor(extra / bars.length);
-    const remainder = extra % bars.length;
-    bars.forEach((bar, index) => {
-      extraById.set(bar, perBar + (index < remainder ? 1 : 0));
-    });
-  }
-  return segments.map((segment) => segment.render(baseBarWidth + (extraById.get(segment) ?? 0))).join(separator);
+function drawBar(fraction, cells) {
+  const clamped = Math.max(0, Math.min(1, fraction));
+  const filled = Math.round(clamped * cells);
+  const color = statusColor(clamped, true);
+  return color === "" ? `[${"\u2588".repeat(filled)}${"\u2591".repeat(cells - filled)}]` : `[${color}${"\u2588".repeat(filled)}${DIM}${"\u2591".repeat(cells - filled)}${RESET}]`;
 }
-function justifySegments(segments, maxWidth, separator, baseBarWidth) {
-  const rendered = segments.map((segment) => segment.render(baseBarWidth));
-  if (segments.length < 2) {
-    return rendered.join(separator);
+function barCell(prefix, suffix, fraction) {
+  return { prefix, suffix, draw: (cells) => drawBar(fraction, cells) };
+}
+function justify(texts, maxWidth, separator) {
+  if (texts.length < 2) {
+    return texts.join(separator);
   }
   const separatorLength = visibleLength(separator);
-  const total = segments.reduce((sum, segment) => sum + segment.baseLength(baseBarWidth), 0) + separatorLength * (segments.length - 1);
+  const total = texts.reduce((sum, text2) => sum + visibleLength(text2), 0) + separatorLength * (texts.length - 1);
   const spare = maxWidth - total;
   if (spare <= 0) {
-    return rendered.join(separator);
+    return texts.join(separator);
   }
-  const gaps = segments.length - 1;
+  const gaps = texts.length - 1;
   const extraPerGap = Math.floor(spare / gaps);
   let remainder = spare % gaps;
   const parts = [];
-  segments.forEach((_, index) => {
+  texts.forEach((text2, index) => {
     if (index > 0) {
       const extra = extraPerGap + (remainder > 0 ? 1 : 0);
       if (remainder > 0) {
@@ -134130,82 +134163,55 @@ function justifySegments(segments, maxWidth, separator, baseBarWidth) {
       const left = Math.floor(extra / 2);
       parts.push(`${" ".repeat(left + 1)}|${" ".repeat(extra - left + 1)}`);
     }
-    parts.push(rendered[index] ?? "");
+    parts.push(text2);
   });
   return parts.join("");
 }
-function packSegments(segments, maxWidth, separator, baseBarWidth, fillWrapped) {
+function layoutHeader(texts, maxWidth, separator) {
   const separatorLength = visibleLength(separator);
   const lines = [];
   let current = [];
   let currentWidth = 0;
-  for (const segment of segments) {
-    const width = segment.baseLength(baseBarWidth);
+  for (const text2 of texts) {
+    const width = visibleLength(text2);
     const added = current.length === 0 ? width : width + separatorLength;
     if (current.length > 0 && currentWidth + added > maxWidth) {
       lines.push(current);
-      current = [segment];
+      current = [text2];
       currentWidth = width;
     } else {
-      current.push(segment);
+      current.push(text2);
       currentWidth += added;
     }
   }
   if (current.length > 0) {
     lines.push(current);
   }
-  return lines.map((line) => fillWrapped ? renderLineWithExtra(line, maxWidth, separator, baseBarWidth) : justifySegments(line, maxWidth, separator, baseBarWidth));
-}
-function layoutGrouped(group1, group2, maxWidth, fillMode, separator, baseBarWidth) {
-  const separatorLength = visibleLength(separator);
-  const allSegments = [...group1, ...group2];
-  if (allSegments.length === 0) {
-    return "";
-  }
-  const fillUnwrapped = fillMode === "always";
-  const fillWrapped = fillMode === "always" || fillMode === "wrapped";
-  const totalBase = allSegments.reduce((total, segment) => total + segment.baseLength(baseBarWidth), 0) + separatorLength * (allSegments.length - 1);
-  if (totalBase <= maxWidth) {
-    if (fillUnwrapped) {
-      return renderLineWithExtra(allSegments, maxWidth, separator, baseBarWidth);
-    }
-    return justifySegments(allSegments, maxWidth, separator, baseBarWidth);
-  }
-  const lines = [group1, group2].map((group) => {
-    if (group.length === 0) {
-      return "";
-    }
-    const groupBase = group.reduce((total, segment) => total + segment.baseLength(baseBarWidth), 0) + separatorLength * (group.length - 1);
-    if (groupBase <= maxWidth) {
-      return fillWrapped ? renderLineWithExtra(group, maxWidth, separator, baseBarWidth) : group.map((segment) => segment.render(baseBarWidth)).join(separator);
-    }
-    return packSegments(group, maxWidth, separator, baseBarWidth, fillWrapped).join("\n");
-  });
-  return lines.filter((line) => line !== "").join("\n");
+  return lines.map((line) => justify(line, maxWidth, separator)).join("\n");
 }
 function renderStatuslineBlock(summary, view, terminalWidth, nowMs) {
   const header = [];
   if (view.modelDisplayName !== void 0 && view.modelDisplayName !== "") {
-    header.push(new Segment("static", view.modelDisplayName));
+    header.push(view.modelDisplayName);
   }
   if (summary.provider !== void 0) {
     const account = [summary.providerAccountEmail, summary.providerPlan].filter((part) => part !== void 0);
-    header.push(new Segment("static", account.length > 0 ? `${summary.provider} \xB7 ${account.join(" \xB7 ")}` : summary.provider));
+    header.push(account.length > 0 ? `${summary.provider} \xB7 ${account.join(" \xB7 ")}` : summary.provider);
   }
   const loginPlan = summary.provider === void 0 ? summary.loginPlan ?? accountPlanLabel(summary) : void 0;
   const loginOrgName = summary.loginOrganizationType === "claude_team" || summary.loginOrganizationType === "claude_enterprise" ? summary.loginOrganizationName : void 0;
   const loginParts = [summary.loginAccountEmail, loginOrgName, loginPlan].filter((part) => part !== void 0);
   if (summary.loginAccountEmail !== void 0 && summary.loginAccountEmail !== summary.providerAccountEmail) {
-    header.push(new Segment("static", loginParts.join(" \xB7 ")));
+    header.push(loginParts.join(" \xB7 "));
   } else if (summary.provider === void 0 && loginParts.length > 0) {
-    header.push(new Segment("static", loginParts.join(" \xB7 ")));
+    header.push(loginParts.join(" \xB7 "));
   }
   if (summary.identity !== void 0 && summary.provider !== void 0 && summary.identity !== summary.providerAccountEmail && summary.identity !== summary.loginAccountEmail) {
-    header.push(new Segment("static", summary.identity));
+    header.push(summary.identity);
   }
   const savings = headroomText(summary.headroom);
   if (savings !== void 0) {
-    header.push(new Segment("static", savings));
+    header.push(savings);
   }
   const contextGroup = [];
   if (view.contextUsedPercentage !== void 0) {
@@ -134214,13 +134220,13 @@ function renderStatuslineBlock(summary, view, terminalWidth, nowMs) {
     const percent2 = `${color}${view.contextUsedPercentage.toFixed(1)}%${RESET}`;
     const tokens = view.contextTotalTokens !== void 0 && view.contextWindowTokens !== void 0 ? `${formatTokens(view.contextTotalTokens)}/${formatTokens(view.contextWindowTokens)} ` : "";
     const cache = cacheShareText(view);
-    contextGroup.push(new Segment("bar", "", `Ctx ${tokens}`, ` ${percent2}${cache}`, fraction, true));
+    contextGroup.push(barCell(`Ctx ${tokens}`, ` ${percent2}${cache}`, fraction));
   }
   const quotaGroup = [];
   const drawWindow = (label, fraction, resetsAt) => {
     const clamped = Math.max(0, Math.min(1, fraction));
     const color = statusColor(clamped, true);
-    quotaGroup.push(new Segment("bar", "", `${label} `, ` ${color}${(fraction * FULL_PERCENT2).toFixed(1)}%${RESET} (${formatDuration(secondsUntil(resetsAt, nowMs))})`, clamped, true));
+    quotaGroup.push(barCell(`${label} `, ` ${color}${(fraction * FULL_PERCENT2).toFixed(1)}%${RESET} (${formatDuration(secondsUntil(resetsAt, nowMs))})`, clamped));
   };
   if (summary.quotaFamilies.length > 0) {
     for (const window of summary.quotaFamilies) {
@@ -134242,12 +134248,9 @@ function renderStatuslineBlock(summary, view, terminalWidth, nowMs) {
   const width = Math.max(TWENTY, terminalWidth - RESERVED_COLUMNS);
   const lines = [];
   if (header.length > 0) {
-    lines.push(layoutGrouped(header, [], width, "never", SEPARATOR2, BAR_WIDTH));
-  }
-  const body = layoutGrouped(contextGroup, quotaGroup, width, "always", SEPARATOR2, BAR_WIDTH);
-  if (body !== "") {
-    lines.push(body);
+    lines.push(layoutHeader(header, width, SEPARATOR2));
   }
+  lines.push(...layoutBarGrid([contextGroup, quotaGroup], width, SEPARATOR2, BAR_WIDTH));
   return lines.join("\n");
 }
 
@@ -134289,8 +134292,8 @@ function payloadViewOf(payload) {
 async function readAllStdin() {
   return await new Promise((resolve2) => {
     const chunks = [];
-    process.stdin.on("data", (chunk) => {
-      chunks.push(chunk);
+    process.stdin.on("data", (chunk2) => {
+      chunks.push(chunk2);
     });
     process.stdin.on("end", () => {
       resolve2(Buffer.concat(chunks).toString("utf8"));
@@ -135910,13 +135913,13 @@ var ReadBuffer = class {
   constructor(options) {
     this._maxBufferSize = options?.maxBufferSize ?? STDIO_DEFAULT_MAX_BUFFER_SIZE;
   }
-  append(chunk) {
-    const newSize = (this._buffer?.length ?? 0) + chunk.length;
+  append(chunk2) {
+    const newSize = (this._buffer?.length ?? 0) + chunk2.length;
     if (newSize > this._maxBufferSize) {
       this.clear();
       throw new Error(`ReadBuffer exceeded maximum size of ${this._maxBufferSize} bytes`);
     }
-    this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
+    this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk2]) : chunk2;
   }
   readMessage() {
     if (!this._buffer) {
@@ -135947,9 +135950,9 @@ var StdioServerTransport = class {
     this._stdin = _stdin;
     this._stdout = _stdout;
     this._started = false;
-    this._ondata = (chunk) => {
+    this._ondata = (chunk2) => {
       try {
-        this._readBuffer.append(chunk);
+        this._readBuffer.append(chunk2);
         this.processReadBuffer();
       } catch (error63) {
         this.onerror?.(error63);
@@ -144489,8 +144492,8 @@ init_realPorts();
 init_realCredentialCache();
 async function readStandardInput() {
   const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  for await (const chunk2 of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk2) ? chunk2 : Buffer.from(String(chunk2)));
   }
   return Buffer.concat(chunks).toString("utf8");
 }