hbsig 0.2.1 → 0.2.3

package/cjs/httpsig.js

@@ -348,18 +348,48 @@ function encodeBodyPart(partName, bodyPart, inlineKey) {
   return "";
 }
 
-// Helper to detect if a Buffer contains binary data
-function isBinaryData(buf) {
-  // Check first 100 bytes for binary indicators
-  for (var i = 0; i < Math.min(buf.length, 100); i++) {
+// Improved helper to detect if data is likely binary
+function isBinaryData(data) {
+  var buf;
+  if (typeof data === "string") {
+    // Convert string to buffer using binary encoding to check byte values
+    buf = Buffer.from(data, "binary");
+  } else if (Buffer.isBuffer(data)) {
+    buf = data;
+  } else {
+    return false;
+  }
+
+  // Check a larger sample for better detection
+  var sampleSize = Math.min(buf.length, 512);
+  var nullCount = 0;
+  var controlCount = 0;
+  var highByteCount = 0;
+  for (var i = 0; i < sampleSize; i++) {
     var _byte = buf[i];
-    // Non-printable chars (except CR/LF/TAB)
-    if (_byte < 32 && _byte !== 9 && _byte !== 10 && _byte !== 13) return true;
-    // High byte range that's not valid text
-    if (_byte > 126 && _byte < 160) return true;
-    // Null byte is definitely binary
-    if (_byte === 0) return true;
+
+    // Null bytes are a strong indicator of binary
+    if (_byte === 0) {
+      nullCount++;
+      if (nullCount > 0) return true; // Even one null byte indicates binary
+    }
+
+    // Control characters (except common text ones: TAB, LF, CR)
+    if (_byte < 32 && _byte !== 9 && _byte !== 10 && _byte !== 13) {
+      controlCount++;
+    }
+
+    // High byte values that aren't valid UTF-8 continuation bytes
+    if (_byte > 127) {
+      highByteCount++;
+    }
   }
+
+  // If more than 10% of bytes are control chars, likely binary
+  if (controlCount / sampleSize > 0.1) return true;
+
+  // If more than 30% are high bytes without valid UTF-8 sequences, likely binary
+  if (highByteCount / sampleSize > 0.3) return true;
   return false;
 }
 
@@ -404,73 +434,83 @@ function parseMultipart(contentType, body) {
       // Parse headers more carefully to handle binary data
       var currentPos = 0;
       while (currentPos < headerBlock.length) {
-        // Find next line ending (but be careful with binary data)
-        var lineEnd = headerBlock.indexOf("\r\n", currentPos);
-        if (lineEnd === -1) lineEnd = headerBlock.indexOf("\n", currentPos);
-        if (lineEnd === -1) lineEnd = headerBlock.length;
-        var line = headerBlock.substring(currentPos, lineEnd);
-        var colonIndex = line.indexOf(": ");
-        if (colonIndex > 0) {
-          var name = line.substring(0, colonIndex).toLowerCase();
-          var value = line.substring(colonIndex + 2);
-
-          // Special handling for known binary fields or detected binary data
-          if (name === "owner" || name === "signature") {
-            // These fields contain binary data that may have embedded newlines
-            // We need to read until we find the next header or end of headers
-            var valueStart = currentPos + colonIndex + 2;
-
-            // Look ahead to find where this field really ends
-            // The next header will start with a valid header name followed by ": "
-            var searchPos = valueStart;
-            var valueEnd = headerBlock.length;
-
-            // Look for the next valid header pattern
-            while (searchPos < headerBlock.length) {
-              var nextNewline = headerBlock.indexOf("\n", searchPos);
-              if (nextNewline === -1) break;
-
-              // Check if what follows looks like a header
-              var nextLineStart = nextNewline + 1;
-              var nextColon = headerBlock.indexOf(":", nextLineStart);
-
-              // Valid header should have colon relatively close to line start
-              if (nextColon > nextLineStart && nextColon < nextLineStart + 50) {
-                // Check if the text before colon looks like a header name (ASCII text)
-                var possibleHeaderName = headerBlock.substring(nextLineStart, nextColon);
-                var looksLikeHeader = /^[a-zA-Z0-9-]+$/.test(possibleHeaderName);
-                if (looksLikeHeader) {
-                  // Found the next header, value ends at the newline before it
-                  valueEnd = nextNewline;
-                  break;
-                }
-              }
-              searchPos = nextNewline + 1;
-            }
+        // Find the next colon to identify a potential header
+        var colonPos = headerBlock.indexOf(": ", currentPos);
+        if (colonPos === -1) {
+          // No more headers
+          break;
+        }
 
-            // Extract the full value as binary string
-            value = headerBlock.substring(valueStart, valueEnd);
+        // Look backwards from colon to find the start of this line
+        var lineStart = currentPos;
+        var searchBack = colonPos - 1;
+        while (searchBack >= currentPos) {
+          if (headerBlock[searchBack] === "\n") {
+            lineStart = searchBack + 1;
+            break;
+          }
+          searchBack--;
+        }
 
-            // Remove trailing CR if present (since we found the LF)
-            if (value.endsWith("\r")) {
-              value = value.substring(0, value.length - 1);
-            }
+        // Extract the header name
+        var name = headerBlock.substring(lineStart, colonPos).trim().toLowerCase();
 
-            // Convert to Buffer to preserve binary
-            headers[name] = Buffer.from(value, "binary");
-            currentPos = valueEnd + 1;
-          } else if (isBinaryData(Buffer.from(value, "binary"))) {
-            // Regular field but contains binary data
-            headers[name] = Buffer.from(value, "binary");
-            currentPos = lineEnd + (headerBlock[lineEnd] === "\r" ? 2 : 1);
-          } else {
-            // Regular text field
-            headers[name] = value;
-            currentPos = lineEnd + (headerBlock[lineEnd] === "\r" ? 2 : 1);
+        // Check if this looks like a valid header name
+        if (!/^[a-zA-Z0-9-]+$/.test(name) || name.length > 50) {
+          // Not a valid header, skip past this colon
+          currentPos = colonPos + 2;
+          continue;
+        }
+
+        // Start of value is after ": "
+        var valueStart = colonPos + 2;
+
+        // Find the end of this header's value by looking for the next valid header
+        var valueEnd = headerBlock.length;
+        var searchPos = valueStart;
+        while (searchPos < headerBlock.length) {
+          var nextNewline = headerBlock.indexOf("\n", searchPos);
+          if (nextNewline === -1) break;
+          var nextLineStart = nextNewline + 1;
+          if (nextLineStart >= headerBlock.length) break;
+
+          // Check if next line starts with a header pattern
+          var nextColon = headerBlock.indexOf(": ", nextLineStart);
+          if (nextColon > nextLineStart && nextColon < nextLineStart + 50) {
+            var possibleHeaderName = headerBlock.substring(nextLineStart, nextColon).trim();
+
+            // Must be valid header name format
+            if (/^[a-zA-Z0-9-]+$/.test(possibleHeaderName)) {
+              valueEnd = nextNewline;
+              break;
+            }
           }
+          searchPos = nextNewline + 1;
+        }
+
+        // Extract the value
+        var value = headerBlock.substring(valueStart, valueEnd);
+
+        // Trim trailing CRLF or LF
+        if (value.endsWith("\r\n")) {
+          value = value.substring(0, value.length - 2);
+        } else if (value.endsWith("\n")) {
+          value = value.substring(0, value.length - 1);
+        } else if (value.endsWith("\r")) {
+          value = value.substring(0, value.length - 1);
+        }
+
+        // Determine if this is binary data
+        if (value.length > 0 && isBinaryData(value)) {
+          headers[name] = Buffer.from(value, "binary");
         } else {
-          // No colon found, skip this line
-          currentPos = lineEnd + (headerBlock[lineEnd] === "\r" ? 2 : 1);
+          headers[name] = value;
+        }
+
+        // Move to the end of this header's value
+        currentPos = valueEnd + 1;
+        if (headerBlock[valueEnd] === "\r") {
+          currentPos++;
         }
       }
       var disposition = headers["content-disposition"];
@@ -495,8 +535,8 @@ function parseMultipart(contentType, body) {
 
         // If there's body content in the inline part, add it as 'body'
         if (partBody) {
-          // Convert back to Buffer to preserve binary data
-          result[partName] = Buffer.from(partBody, "binary");
+          // Keep as Buffer if it's binary data
+          result[partName] = isBinaryData(partBody) ? Buffer.from(partBody, "binary") : partBody;
         }
       } else {
         // Handle named form-data parts
@@ -510,14 +550,15 @@ function parseMultipart(contentType, body) {
         var _restHeaders = _objectSpread({}, headers);
         delete _restHeaders["content-disposition"];
         if (Object.keys(_restHeaders).length === 0) {
-          // Convert body back to Buffer
-          result[partName] = Buffer.from(partBody, "binary");
+          // Keep as Buffer if it's binary data
+          result[partName] = isBinaryData(partBody) ? Buffer.from(partBody, "binary") : partBody;
         } else if (!partBody) {
+          // ao-types should stay with this part, not be extracted
           result[partName] = _restHeaders;
         } else {
-          // Convert body back to Buffer
+          // Keep as Buffer if it's binary data
           result[partName] = _objectSpread(_objectSpread({}, _restHeaders), {}, {
-            body: Buffer.from(partBody, "binary")
+            body: isBinaryData(partBody) ? Buffer.from(partBody, "binary") : partBody
           });
         }
       }
@@ -593,27 +634,27 @@ function httpsig_from(http) {
 
     // Convert flat structure to nested using flat.js
     var flat = {};
+    var nonFlat = {};
     for (var _i9 = 0, _Object$entries9 = Object.entries(withBodyKeys); _i9 < _Object$entries9.length; _i9++) {
       var _Object$entries9$_i = _slicedToArray(_Object$entries9[_i9], 2),
         key = _Object$entries9$_i[0],
         value = _Object$entries9$_i[1];
       if (key.includes("/")) {
         flat[key] = value;
+      } else {
+        nonFlat[key] = value;
       }
     }
     if (Object.keys(flat).length > 0) {
+      // Merge non-flat keys into flat for processing
+      // This ensures flat_from can see existing objects like results: { "ao-types": "..." }
+      var combined = _objectSpread(_objectSpread({}, nonFlat), flat);
+
       // Use flat_from to convert flat structure to nested
-      var nested = (0, _flat.flat_from)(flat);
-      for (var _i0 = 0, _Object$entries0 = Object.entries(nested); _i0 < _Object$entries0.length; _i0++) {
-        var _Object$entries0$_i = _slicedToArray(_Object$entries0[_i0], 2),
-          _key2 = _Object$entries0$_i[0],
-          _value3 = _Object$entries0$_i[1];
-        withBodyKeys[_key2] = _value3;
-      }
-      for (var _i1 = 0, _Object$keys = Object.keys(flat); _i1 < _Object$keys.length; _i1++) {
-        var _key3 = _Object$keys[_i1];
-        delete withBodyKeys[_key3];
-      }
+      var nested = (0, _flat.flat_from)(combined);
+
+      // The nested result already has everything merged
+      withBodyKeys = nested;
     }
   } else if (body) {
     withBodyKeys[inlinedKey] = body;
@@ -630,10 +671,10 @@ function httpsig_from(http) {
   delete result["content-digest"];
 
   // Extract hashpaths if any
-  for (var _i10 = 0, _Object$keys2 = Object.keys(result); _i10 < _Object$keys2.length; _i10++) {
-    var _key4 = _Object$keys2[_i10];
-    if (_key4.startsWith("hashpath")) {
-      delete result[_key4];
+  for (var _i0 = 0, _Object$keys = Object.keys(result); _i0 < _Object$keys.length; _i0++) {
+    var _key2 = _Object$keys[_i0];
+    if (_key2.startsWith("hashpath")) {
+      delete result[_key2];
     }
   }
   return result;
@@ -671,10 +712,10 @@ function httpsig_to(tabm) {
     // For flat structures, just return with normalized keys
     // This matches Erlang which returns the map unchanged
     var result = _objectSpread({}, inlineFieldHdrs);
-    for (var _i11 = 0, _Object$entries1 = Object.entries(stripped); _i11 < _Object$entries1.length; _i11++) {
-      var _Object$entries1$_i = _slicedToArray(_Object$entries1[_i11], 2),
-        key = _Object$entries1$_i[0],
-        value = _Object$entries1$_i[1];
+    for (var _i1 = 0, _Object$entries0 = Object.entries(stripped); _i1 < _Object$entries0.length; _i1++) {
+      var _Object$entries0$_i = _slicedToArray(_Object$entries0[_i1], 2),
+        key = _Object$entries0$_i[0],
+        value = _Object$entries0$_i[1];
       // Keep Buffers as Buffers - don't convert to strings
       result[key] = value;
     }
@@ -697,26 +738,26 @@ function httpsig_to(tabm) {
   var headers = _objectSpread({}, inlineFieldHdrs);
 
   // Process each field - ao-types at top level should go to headers
-  for (var _i12 = 0, _Object$entries10 = Object.entries(stripped); _i12 < _Object$entries10.length; _i12++) {
-    var _Object$entries10$_i = _slicedToArray(_Object$entries10[_i12], 2),
-      _key5 = _Object$entries10$_i[0],
-      _value4 = _Object$entries10$_i[1];
-    if (_key5 === "ao-types") {
+  for (var _i10 = 0, _Object$entries1 = Object.entries(stripped); _i10 < _Object$entries1.length; _i10++) {
+    var _Object$entries1$_i = _slicedToArray(_Object$entries1[_i10], 2),
+      _key3 = _Object$entries1$_i[0],
+      _value3 = _Object$entries1$_i[1];
+    if (_key3 === "ao-types") {
       // Top-level ao-types goes to headers only
       // Keep as Buffer if it's a Buffer, otherwise use as-is
-      headers[_key5] = _value4;
-    } else if (_key5 === "body" || _key5 === inlineKeyVal) {
-      bodyMap[_key5 === inlineKeyVal ? inlineKeyVal : "body"] = _value4;
-    } else if (_typeof(_value4) === "object" && _value4 !== null && !Array.isArray(_value4) && !Buffer.isBuffer(_value4)) {
-      bodyMap[_key5] = _value4;
-    } else if (typeof _value4 === "string" && _value4.length <= MAX_HEADER_LENGTH && _key5 !== "ao-types") {
-      headers[normalizeKey(_key5)] = _value4;
-    } else if (Buffer.isBuffer(_value4) && _value4.length <= MAX_HEADER_LENGTH && _key5 !== "ao-types") {
+      headers[_key3] = _value3;
+    } else if (_key3 === "body" || _key3 === inlineKeyVal) {
+      bodyMap[_key3 === inlineKeyVal ? inlineKeyVal : "body"] = _value3;
+    } else if (_typeof(_value3) === "object" && _value3 !== null && !Array.isArray(_value3) && !Buffer.isBuffer(_value3)) {
+      bodyMap[_key3] = _value3;
+    } else if (typeof _value3 === "string" && _value3.length <= MAX_HEADER_LENGTH && _key3 !== "ao-types") {
+      headers[normalizeKey(_key3)] = _value3;
+    } else if (Buffer.isBuffer(_value3) && _value3.length <= MAX_HEADER_LENGTH && _key3 !== "ao-types") {
       // Keep buffers as buffers for headers
-      headers[normalizeKey(_key5)] = _value4;
-    } else if (_key5 !== "ao-types") {
+      headers[normalizeKey(_key3)] = _value3;
+    } else if (_key3 !== "ao-types") {
       // Only add to bodyMap if it's not ao-types
-      bodyMap[_key5] = _value4;
+      bodyMap[_key3] = _value3;
     }
   }
 
@@ -745,22 +786,22 @@ function httpsig_to(tabm) {
     try {
       for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
         var _step4$value = _slicedToArray(_step4.value, 2),
-          _key6 = _step4$value[0],
-          _value5 = _step4$value[1];
-        if (_typeof(_value5) === "object" && _value5 !== null && Object.keys(_value5).length === 1 && "body" in _value5) {
-          var encoded = encodeBodyPart("".concat(_key6, "/body"), _value5, "body");
+          _key4 = _step4$value[0],
+          _value4 = _step4$value[1];
+        if (_typeof(_value4) === "object" && _value4 !== null && Object.keys(_value4).length === 1 && "body" in _value4) {
+          var encoded = encodeBodyPart("".concat(_key4, "/body"), _value4, "body");
           parts.push({
-            name: "".concat(_key6, "/body"),
+            name: "".concat(_key4, "/body"),
             body: encoded
           });
-          bodyKeysList.push(_key6);
+          bodyKeysList.push(_key4);
         } else {
-          var _encoded = encodeBodyPart(_key6, _value5, inlineKeyVal);
+          var _encoded = encodeBodyPart(_key4, _value4, inlineKeyVal);
           parts.push({
-            name: _key6,
+            name: _key4,
             body: _encoded
           });
-          bodyKeysList.push(_key6);
+          bodyKeysList.push(_key4);
         }
       }
     } catch (err) {

package/cjs/send-utils.js

@@ -951,7 +951,7 @@ var toMsg = /*#__PURE__*/function () {
 var result = exports.result = /*#__PURE__*/function () {
   var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(response) {
     var _from$signer, _from$hashpath;
-    var headers, msg, out, body, http, _from;
+    var headers, msg, tabm, out, body, http, _from;
     return _regenerator().w(function (_context2) {
       while (1) switch (_context2.n) {
         case 0:
@@ -963,7 +963,8 @@ var result = exports.result = /*#__PURE__*/function () {
           return toMsg(response);
         case 1:
           msg = _context2.v;
-          out = (0, _structured.structured_to)((0, _httpsig.httpsig_from)(msg));
+          tabm = (0, _httpsig.httpsig_from)(msg); //console.log("TABM:", JSON.stringify(tabm))
+          out = (0, _structured.structured_to)(tabm);
           body = Buffer.from(msg.body).toString();
           http = {
             headers: headers,

package/esm/httpsig.js

@@ -291,18 +291,51 @@ function encodeBodyPart(partName, bodyPart, inlineKey) {
   return ""
 }
 
-// Helper to detect if a Buffer contains binary data
-function isBinaryData(buf) {
-  // Check first 100 bytes for binary indicators
-  for (let i = 0; i < Math.min(buf.length, 100); i++) {
+// Improved helper to detect if data is likely binary
+function isBinaryData(data) {
+  let buf
+
+  if (typeof data === "string") {
+    // Convert string to buffer using binary encoding to check byte values
+    buf = Buffer.from(data, "binary")
+  } else if (Buffer.isBuffer(data)) {
+    buf = data
+  } else {
+    return false
+  }
+
+  // Check a larger sample for better detection
+  const sampleSize = Math.min(buf.length, 512)
+  let nullCount = 0
+  let controlCount = 0
+  let highByteCount = 0
+
+  for (let i = 0; i < sampleSize; i++) {
     const byte = buf[i]
-    // Non-printable chars (except CR/LF/TAB)
-    if (byte < 32 && byte !== 9 && byte !== 10 && byte !== 13) return true
-    // High byte range that's not valid text
-    if (byte > 126 && byte < 160) return true
-    // Null byte is definitely binary
-    if (byte === 0) return true
+
+    // Null bytes are a strong indicator of binary
+    if (byte === 0) {
+      nullCount++
+      if (nullCount > 0) return true // Even one null byte indicates binary
+    }
+
+    // Control characters (except common text ones: TAB, LF, CR)
+    if (byte < 32 && byte !== 9 && byte !== 10 && byte !== 13) {
+      controlCount++
+    }
+
+    // High byte values that aren't valid UTF-8 continuation bytes
+    if (byte > 127) {
+      highByteCount++
+    }
   }
+
+  // If more than 10% of bytes are control chars, likely binary
+  if (controlCount / sampleSize > 0.1) return true
+
+  // If more than 30% are high bytes without valid UTF-8 sequences, likely binary
+  if (highByteCount / sampleSize > 0.3) return true
+
   return false
 }
 
@@ -348,79 +381,93 @@ function parseMultipart(contentType, body) {
     // Parse headers more carefully to handle binary data
     let currentPos = 0
     while (currentPos < headerBlock.length) {
-      // Find next line ending (but be careful with binary data)
-      let lineEnd = headerBlock.indexOf("\r\n", currentPos)
-      if (lineEnd === -1) lineEnd = headerBlock.indexOf("\n", currentPos)
-      if (lineEnd === -1) lineEnd = headerBlock.length
-
-      const line = headerBlock.substring(currentPos, lineEnd)
-      const colonIndex = line.indexOf(": ")
-
-      if (colonIndex > 0) {
-        const name = line.substring(0, colonIndex).toLowerCase()
-        let value = line.substring(colonIndex + 2)
-
-        // Special handling for known binary fields or detected binary data
-        if (name === "owner" || name === "signature") {
-          // These fields contain binary data that may have embedded newlines
-          // We need to read until we find the next header or end of headers
-          let valueStart = currentPos + colonIndex + 2
-
-          // Look ahead to find where this field really ends
-          // The next header will start with a valid header name followed by ": "
-          let searchPos = valueStart
-          let valueEnd = headerBlock.length
-
-          // Look for the next valid header pattern
-          while (searchPos < headerBlock.length) {
-            let nextNewline = headerBlock.indexOf("\n", searchPos)
-            if (nextNewline === -1) break
-
-            // Check if what follows looks like a header
-            let nextLineStart = nextNewline + 1
-            let nextColon = headerBlock.indexOf(":", nextLineStart)
-
-            // Valid header should have colon relatively close to line start
-            if (nextColon > nextLineStart && nextColon < nextLineStart + 50) {
-              // Check if the text before colon looks like a header name (ASCII text)
-              let possibleHeaderName = headerBlock.substring(
-                nextLineStart,
-                nextColon
-              )
-              let looksLikeHeader = /^[a-zA-Z0-9-]+$/.test(possibleHeaderName)
-
-              if (looksLikeHeader) {
-                // Found the next header, value ends at the newline before it
-                valueEnd = nextNewline
-                break
-              }
-            }
-            searchPos = nextNewline + 1
-          }
+      // Find the next colon to identify a potential header
+      let colonPos = headerBlock.indexOf(": ", currentPos)
 
-          // Extract the full value as binary string
-          value = headerBlock.substring(valueStart, valueEnd)
+      if (colonPos === -1) {
+        // No more headers
+        break
+      }
 
-          // Remove trailing CR if present (since we found the LF)
-          if (value.endsWith("\r")) {
-            value = value.substring(0, value.length - 1)
-          }
+      // Look backwards from colon to find the start of this line
+      let lineStart = currentPos
+      let searchBack = colonPos - 1
+      while (searchBack >= currentPos) {
+        if (headerBlock[searchBack] === "\n") {
+          lineStart = searchBack + 1
+          break
+        }
+        searchBack--
+      }
 
-          // Convert to Buffer to preserve binary
-          headers[name] = Buffer.from(value, "binary")
-          currentPos = valueEnd + 1
-        } else if (isBinaryData(Buffer.from(value, "binary"))) {
-          // Regular field but contains binary data
-          headers[name] = Buffer.from(value, "binary")
-          currentPos = lineEnd + (headerBlock[lineEnd] === "\r" ? 2 : 1)
-        } else {
-          // Regular text field
-          headers[name] = value
-          currentPos = lineEnd + (headerBlock[lineEnd] === "\r" ? 2 : 1)
+      // Extract the header name
+      const name = headerBlock
+        .substring(lineStart, colonPos)
+        .trim()
+        .toLowerCase()
+
+      // Check if this looks like a valid header name
+      if (!/^[a-zA-Z0-9-]+$/.test(name) || name.length > 50) {
+        // Not a valid header, skip past this colon
+        currentPos = colonPos + 2
+        continue
+      }
+
+      // Start of value is after ": "
+      let valueStart = colonPos + 2
+
+      // Find the end of this header's value by looking for the next valid header
+      let valueEnd = headerBlock.length
+      let searchPos = valueStart
+
+      while (searchPos < headerBlock.length) {
+        let nextNewline = headerBlock.indexOf("\n", searchPos)
+        if (nextNewline === -1) break
+
+        let nextLineStart = nextNewline + 1
+        if (nextLineStart >= headerBlock.length) break
+
+        // Check if next line starts with a header pattern
+        let nextColon = headerBlock.indexOf(": ", nextLineStart)
+
+        if (nextColon > nextLineStart && nextColon < nextLineStart + 50) {
+          let possibleHeaderName = headerBlock
+            .substring(nextLineStart, nextColon)
+            .trim()
+
+          // Must be valid header name format
+          if (/^[a-zA-Z0-9-]+$/.test(possibleHeaderName)) {
+            valueEnd = nextNewline
+            break
+          }
         }
+
+        searchPos = nextNewline + 1
+      }
+
+      // Extract the value
+      let value = headerBlock.substring(valueStart, valueEnd)
+
+      // Trim trailing CRLF or LF
+      if (value.endsWith("\r\n")) {
+        value = value.substring(0, value.length - 2)
+      } else if (value.endsWith("\n")) {
+        value = value.substring(0, value.length - 1)
+      } else if (value.endsWith("\r")) {
+        value = value.substring(0, value.length - 1)
+      }
+
+      // Determine if this is binary data
+      if (value.length > 0 && isBinaryData(value)) {
+        headers[name] = Buffer.from(value, "binary")
       } else {
-        // No colon found, skip this line
-        currentPos = lineEnd + (headerBlock[lineEnd] === "\r" ? 2 : 1)
+        headers[name] = value
+      }
+
+      // Move to the end of this header's value
+      currentPos = valueEnd + 1
+      if (headerBlock[valueEnd] === "\r") {
+        currentPos++
       }
     }
 
@@ -444,8 +491,10 @@ function parseMultipart(contentType, body) {
 
       // If there's body content in the inline part, add it as 'body'
       if (partBody) {
-        // Convert back to Buffer to preserve binary data
-        result[partName] = Buffer.from(partBody, "binary")
+        // Keep as Buffer if it's binary data
+        result[partName] = isBinaryData(partBody)
+          ? Buffer.from(partBody, "binary")
+          : partBody
       }
     } else {
       // Handle named form-data parts
@@ -462,15 +511,20 @@ function parseMultipart(contentType, body) {
       delete restHeaders["content-disposition"]
 
       if (Object.keys(restHeaders).length === 0) {
-        // Convert body back to Buffer
-        result[partName] = Buffer.from(partBody, "binary")
+        // Keep as Buffer if it's binary data
+        result[partName] = isBinaryData(partBody)
+          ? Buffer.from(partBody, "binary")
+          : partBody
       } else if (!partBody) {
+        // ao-types should stay with this part, not be extracted
         result[partName] = restHeaders
       } else {
-        // Convert body back to Buffer
+        // Keep as Buffer if it's binary data
         result[partName] = {
           ...restHeaders,
-          body: Buffer.from(partBody, "binary"),
+          body: isBinaryData(partBody)
+            ? Buffer.from(partBody, "binary")
+            : partBody,
         }
       }
     }
@@ -546,21 +600,25 @@ export function httpsig_from(http) {
 
     // Convert flat structure to nested using flat.js
     const flat = {}
+    const nonFlat = {}
     for (const [key, value] of Object.entries(withBodyKeys)) {
       if (key.includes("/")) {
         flat[key] = value
+      } else {
+        nonFlat[key] = value
       }
     }
 
     if (Object.keys(flat).length > 0) {
+      // Merge non-flat keys into flat for processing
+      // This ensures flat_from can see existing objects like results: { "ao-types": "..." }
+      const combined = { ...nonFlat, ...flat }
+
       // Use flat_from to convert flat structure to nested
-      const nested = flat_from(flat)
-      for (const [key, value] of Object.entries(nested)) {
-        withBodyKeys[key] = value
-      }
-      for (const key of Object.keys(flat)) {
-        delete withBodyKeys[key]
-      }
+      const nested = flat_from(combined)
+
+      // The nested result already has everything merged
+      withBodyKeys = nested
     }
   } else if (body) {
     withBodyKeys[inlinedKey] = body

package/esm/send-utils.js

@@ -878,7 +878,9 @@ export const result = async response => {
   let headers = {}
   response.headers.forEach((v, k) => (headers[k] = v))
   const msg = await toMsg(response)
-  const out = structured_to(httpsig_from(msg))
+  const tabm = httpsig_from(msg)
+  //console.log("TABM:", JSON.stringify(tabm))
+  const out = structured_to(tabm)
   const body = Buffer.from(msg.body).toString()
   const http = { headers, body }
   const _from = from(http)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hbsig",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "main": "cjs/index.js",
   "license": "MIT",
   "devDependencies": {