-function parseMultipart(buffer: Buffer, boundary: string): MultipartResult {
-  const bufferStr = buffer.toString();
-
-  // check if the second part contains a Location header (CDN redirect)
-  // pattern: after first boundary and JSON part, look for Location header
-  const parts = bufferStr.split(`--${boundary}`);
-  if (parts.length >= 3) {
-    const secondPart = parts[2];
-    const locationMatch = secondPart.match(/\r?\nLocation:\s*(.+)\r?\n/i);
-
-    if (locationMatch) {
-      return {
-        content: Buffer.from(''),
-        redirect: locationMatch[1].trim(),
-      };
-    }
-  }
-
-  // find where the last part's content starts (after the last \r\n\r\n)
-  const lastHeaderEnd = buffer.lastIndexOf('\r\n\r\n');
-  if (lastHeaderEnd === -1) return { content: buffer };
-
-  const binaryStart = lastHeaderEnd + 4;
-  const closingBoundary = buffer.lastIndexOf(`\r\n--${boundary}`);
-
-  const content =
-    closingBoundary > binaryStart
-      ? buffer.subarray(binaryStart, closingBoundary)
-      : buffer.subarray(binaryStart);
-
-  return { content };
-}
+function parseMultipart(buffer: Buffer, boundary: string): MultipartResult {
+  const delim = Buffer.from(`--${boundary}`);
+  const nextDelimPrefix = Buffer.from(`\r\n--${boundary}`);
+  const parts: { headers: Buffer; body: Buffer }[] = [];
+
+  let idx = buffer.indexOf(delim);
+  while (idx !== -1) {
+    let start = idx + delim.length;
+    if (buffer[start] === 13 && buffer[start + 1] === 10) start += 2; // \r\n
+    const headerEnd = buffer.indexOf('\r\n\r\n', start, 'ascii');
+    if (headerEnd === -1) break;
+    const headersBuf = buffer.subarray(start, headerEnd);
+    const nextIdx = buffer.indexOf(nextDelimPrefix, headerEnd + 4, 'ascii');
+    const bodyEnd = nextIdx === -1 ? buffer.length : nextIdx;
+    parts.push({ headers: headersBuf, body: buffer.subarray(headerEnd + 4, bodyEnd) });
+    idx = nextIdx === -1 ? -1 : nextIdx + 2; // skip \r\n
+  }
+
+  // CDN redirect convention: Location header in second part
+  if (parts[1]) {
+    const h = parts[1].headers.toString('ascii');
+    const m = h.match(/\bLocation:\s*(.+)\r?$/mi);
+    if (m) return { content: Buffer.alloc(0), redirect: m[1].trim() };
+  }
+
+  return parts.length ? { content: parts[parts.length - 1].body } : { content: buffer };
+}

-        res.on('data', (chunk) => {
+        res.on('data', (chunk) => {
           total += chunk.length;
           if (total > MAX_RESPONSE_BYTES) {
-            request.destroy(new Error('Response exceeds size limit'));
+            const err = new Error('Response exceeds size limit');
+            res.destroy(err);
+            request.destroy(err);
             return;
           }
           chunks.push(chunk);
         });

-      request.end(options.body);
+      const payload =
+        typeof options.body === 'string' || Buffer.isBuffer(options.body)
+          ? (options.body as string | Buffer)
+          : undefined;
+      if (options.body && !payload) {
+        request.destroy(new Error('Unsupported request body type'));
+        return;
+      }
+      request.end(payload);