wao 0.27.2 → 0.27.3

package/cjs/encode.js

@@ -356,11 +356,8 @@ function collectBodyKeys(obj) {
             nestedPaths.push(fullPath);
           }
         }
-      } else if (isBytes(value)) {
-        var buffer = toBuffer(value);
-        if (buffer.length > 0) {
-          hasSimpleFields = true;
-        }
+      } else if (isBytes(value) && value.length > 0) {
+        hasSimpleFields = true;
       } else if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null || value === undefined || _typeof(value) === "symbol") {
         hasSimpleFields = true;
       }
@@ -590,15 +587,24 @@ function collectBodyKeys(obj) {
         }
       }
     } else if (isPojo(value)) {
-      console.log("[main loop] Processing object at key: \"".concat(key, "\""));
-      // Objects should be traversed, not have their fields individually added
-      traverse(value, key);
-    } else if (isBytes(value)) {
-      var buffer = toBuffer(value);
-      if (buffer.length > 0) {
-        console.log("[main loop] Adding key for non-empty bytes: \"".concat(key, "\""));
-        keys.push(key);
+      console.log("[main loop] Traversing object at key: \"".concat(key, "\""));
+      // Check if this object contains arrays with only empty elements
+      var hasArraysWithOnlyEmptyElements = false;
+      for (var _i7 = 0, _Object$entries6 = Object.entries(value); _i7 < _Object$entries6.length; _i7++) {
+        var _Object$entries6$_i = _slicedToArray(_Object$entries6[_i7], 2),
+          k = _Object$entries6$_i[0],
+          v = _Object$entries6$_i[1];
+        if (Array.isArray(v) && v.length > 0 && v.every(function (item) {
+          return Array.isArray(item) && item.length === 0 || isPojo(item) && Object.keys(item).length === 0 || typeof item === "string" && item === "";
+        })) {
+          hasArraysWithOnlyEmptyElements = true;
+          keys.push("".concat(key, "/").concat(k));
+        }
       }
+      traverse(value, key);
+    } else if (isBytes(value) && value.length > 0) {
+      console.log("[main loop] Adding key for non-empty bytes: \"".concat(key, "\""));
+      keys.push(key);
     } else if (typeof value === "string" && value.includes("\n")) {
       console.log("[main loop] Adding key for string with newline: \"".concat(key, "\""));
       keys.push(key);
@@ -667,9 +673,9 @@ function _encode() {
     var obj,
       _processValue,
       processedObj,
-      _i8,
-      _Object$entries7,
-      _Object$entries7$_i,
+      _i9,
+      _Object$entries8,
+      _Object$entries8$_i,
       k,
       v,
       objKeys,
@@ -701,15 +707,15 @@ function _encode() {
       _encoded,
       _contentDigest3,
       _base3,
-      bodyKeys,
       headers,
       headerTypes,
+      bodyKeys,
       _loop3,
-      _i9,
-      _Object$entries8,
-      _loop4,
       _i10,
       _Object$entries9,
+      _loop4,
+      _i11,
+      _Object$entries10,
       allBodyKeysAreEmptyBinaries,
       singleKey,
       pathParts,
@@ -755,10 +761,10 @@ function _encode() {
               return value.map(_processValue);
             } else if (isPojo(value)) {
               var result = {};
-              for (var _i7 = 0, _Object$entries6 = Object.entries(value); _i7 < _Object$entries6.length; _i7++) {
-                var _Object$entries6$_i = _slicedToArray(_Object$entries6[_i7], 2),
-                  k = _Object$entries6$_i[0],
-                  v = _Object$entries6$_i[1];
+              for (var _i8 = 0, _Object$entries7 = Object.entries(value); _i8 < _Object$entries7.length; _i8++) {
+                var _Object$entries7$_i = _slicedToArray(_Object$entries7[_i8], 2),
+                  k = _Object$entries7$_i[0],
+                  v = _Object$entries7$_i[1];
                 result[k] = _processValue(v);
               }
               return result;
@@ -766,8 +772,8 @@ function _encode() {
             return value;
           };
           processedObj = {};
-          for (_i8 = 0, _Object$entries7 = Object.entries(obj); _i8 < _Object$entries7.length; _i8++) {
-            _Object$entries7$_i = _slicedToArray(_Object$entries7[_i8], 2), k = _Object$entries7$_i[0], v = _Object$entries7$_i[1];
+          for (_i9 = 0, _Object$entries8 = Object.entries(obj); _i9 < _Object$entries8.length; _i9++) {
+            _Object$entries8$_i = _slicedToArray(_Object$entries8[_i9], 2), k = _Object$entries8$_i[0], v = _Object$entries8$_i[1];
             processedObj[k] = _processValue(v);
           }
           if (!(Object.keys(obj).length === 0)) {
@@ -907,15 +913,15 @@ function _encode() {
             body: _fieldValue
           });
         case 71:
-          bodyKeys = collectBodyKeys(obj);
           headers = {};
           headerTypes = [];
+          bodyKeys = collectBodyKeys(obj);
           _loop3 = /*#__PURE__*/_regeneratorRuntime().mark(function _loop3() {
-            var _Object$entries8$_i, key, value, needsBody, hasNonAsciiItems, encodedItems;
+            var _Object$entries9$_i, key, value, needsBody, hasNonAsciiItems, encodedItems;
             return _regeneratorRuntime().wrap(function _loop3$(_context3) {
               while (1) switch (_context3.prev = _context3.next) {
                 case 0:
-                  _Object$entries8$_i = _slicedToArray(_Object$entries8[_i9], 2), key = _Object$entries8$_i[0], value = _Object$entries8$_i[1];
+                  _Object$entries9$_i = _slicedToArray(_Object$entries9[_i10], 2), key = _Object$entries9$_i[0], value = _Object$entries9$_i[1];
                   needsBody = bodyKeys.includes(key) || bodyKeys.some(function (k) {
                     return k.startsWith("".concat(key, "/"));
                   });
@@ -1034,9 +1040,9 @@ function _encode() {
               }
             }, _loop3);
           });
-          _i9 = 0, _Object$entries8 = Object.entries(obj);
+          _i10 = 0, _Object$entries9 = Object.entries(obj);
         case 76:
-          if (!(_i9 < _Object$entries8.length)) {
+          if (!(_i10 < _Object$entries9.length)) {
             _context6.next = 83;
             break;
           }
@@ -1048,16 +1054,16 @@ function _encode() {
           }
           return _context6.abrupt("continue", 80);
         case 80:
-          _i9++;
+          _i10++;
           _context6.next = 76;
           break;
         case 83:
           _loop4 = /*#__PURE__*/_regeneratorRuntime().mark(function _loop4() {
-            var _Object$entries9$_i, key, value;
+            var _Object$entries10$_i, key, value;
             return _regeneratorRuntime().wrap(function _loop4$(_context4) {
               while (1) switch (_context4.prev = _context4.next) {
                 case 0:
-                  _Object$entries9$_i = _slicedToArray(_Object$entries9[_i10], 2), key = _Object$entries9$_i[0], value = _Object$entries9$_i[1];
+                  _Object$entries10$_i = _slicedToArray(_Object$entries10[_i11], 2), key = _Object$entries10$_i[0], value = _Object$entries10$_i[1];
                   if (Array.isArray(value)) {
                     if (bodyKeys.includes(key) || bodyKeys.some(function (k) {
                       return k.startsWith("".concat(key, "/"));
@@ -1075,15 +1081,15 @@ function _encode() {
               }
             }, _loop4);
           });
-          _i10 = 0, _Object$entries9 = Object.entries(obj);
+          _i11 = 0, _Object$entries10 = Object.entries(obj);
         case 85:
-          if (!(_i10 < _Object$entries9.length)) {
+          if (!(_i11 < _Object$entries10.length)) {
             _context6.next = 90;
             break;
           }
           return _context6.delegateYield(_loop4(), "t1", 87);
         case 87:
-          _i10++;
+          _i11++;
           _context6.next = 85;
           break;
         case 90:
@@ -1231,7 +1237,7 @@ function _encode() {
           _iterator5 = _createForOfIteratorHelper(sortedBodyKeys);
           _context6.prev = 123;
           _loop5 = /*#__PURE__*/_regeneratorRuntime().mark(function _loop5() {
-            var bodyKey, lines, pathParts, value, parent, _i11, _part, _buffer, headerText, hasOnlyEmptyElements, hasOnlyNonEmptyObjects, hasOnlyEmptyObjects, hasObjects, hasArrays, nonObjectItems, _fieldLines, _partTypes, _isInline, orderedLines, _orderedLines, isLastBodyPart, hasOnlyTypes, indicesWithOwnParts, hasNestedObjectParts, fieldLines, partTypes, hasEmptyStrings, hasEmptyObjects, hasObjectsWithOnlyEmptyValues, isMixedArray, _isInline2, _orderedLines2, _iterator6, _step6, line, _orderedLines3, _iterator7, _step7, _line, isInline, content;
+            var bodyKey, lines, pathParts, value, parent, _i12, _part, hasOnlyEmptyElements, hasOnlyNonEmptyObjects, hasOnlyEmptyObjects, hasObjects, hasArrays, nonObjectItems, _fieldLines, _partTypes, _isInline, orderedLines, _orderedLines, isLastBodyPart, hasOnlyTypes, indicesWithOwnParts, hasNestedObjectParts, fieldLines, partTypes, hasEmptyStrings, hasEmptyObjects, hasObjectsWithOnlyEmptyValues, isMixedArray, _isInline2, _orderedLines2, _iterator6, _step6, line, _orderedLines3, _iterator7, _step7, _line, parentPath, parentValue, _iterator8, _step8, _part2, _hasEmptyStrings, _hasEmptyObjects, _hasObjects, _isInline3, objectTypes, _fieldLines2, binaryFields, hasOnlyEmptyCollections, hasArraysWithOnlyEmptyElements, arrayTypes, _i13, _Object$entries11, _Object$entries11$_i, _k, _v, _i14, _Object$entries12, _Object$entries12$_i, _k2, _v2, childPath, hasOnlyEmpty, desc, _buffer3, _childPath, _hasObjects2, encodedItems, allTypes, shouldSkipObject, onlyEmptyCollections, _orderedLines4, _iterator9, _step9, _line2, binaryFieldsForInline, parts, _iterator10, _step10, _step10$value, key, _buffer4, fullBody, _isLastBodyPart, _hasOnlyTypes, _orderedLines5, hasBinaryFields, _iterator11, _step11, _line3, _parts, headerText, _i15, _binaryFields$_i, _key, _buffer5, _fullBody, isInline, _buffer6, _headerText, content;
             return _regeneratorRuntime().wrap(function _loop5$(_context5) {
               while (1) switch (_context5.prev = _context5.next) {
                 case 0:
@@ -1241,9 +1247,9 @@ function _encode() {
                   pathParts = bodyKey.split("/");
                   value = obj;
                   parent = null;
-                  for (_i11 = 0; _i11 < pathParts.length; _i11++) {
+                  for (_i12 = 0; _i12 < pathParts.length; _i12++) {
                     parent = value;
-                    _part = pathParts[_i11];
+                    _part = pathParts[_i12];
                     if (/^\d+$/.test(_part)) {
                       value = value[parseInt(_part) - 1];
                     } else {
@@ -1264,19 +1270,8 @@ function _encode() {
                   bodyParts.push(new Blob([lines.join("\r\n")]));
                   return _context5.abrupt("return", 0);
                 case 15:
-                  if (!isBytes(value)) {
-                    _context5.next = 22;
-                    break;
-                  }
-                  console.log("[Body part] Creating part for binary at ".concat(bodyKey));
-                  lines.push("content-disposition: form-data;name=\"".concat(bodyKey, "\""));
-                  _buffer = toBuffer(value);
-                  headerText = lines.join("\r\n") + "\r\n\r\n";
-                  bodyParts.push(new Blob([headerText, _buffer]));
-                  return _context5.abrupt("return", 0);
-                case 22:
                   if (!Array.isArray(value)) {
-                    _context5.next = 52;
+                    _context5.next = 45;
                     break;
                   }
                   hasOnlyEmptyElements = value.length > 0 && value.every(function (item) {
@@ -1304,13 +1299,13 @@ function _encode() {
                     return !isPojo(item);
                   });
                   if (!hasOnlyNonEmptyObjects) {
-                    _context5.next = 31;
+                    _context5.next = 24;
                     break;
                   }
                   return _context5.abrupt("return", 0);
-                case 31:
+                case 24:
                   if (!hasOnlyEmptyElements) {
-                    _context5.next = 38;
+                    _context5.next = 31;
                     break;
                   }
                   _fieldLines = [];
@@ -1361,7 +1356,7 @@ function _encode() {
                     }
                   }
                   return _context5.abrupt("return", 0);
-                case 38:
+                case 31:
                   // Build list of which indices have their own parts
                   indicesWithOwnParts = new Set();
                   sortedBodyKeys.forEach(function (key) {
@@ -1457,8 +1452,8 @@ function _encode() {
                             // Use the full encodeArrayItem for nested arrays
                             return encodeArrayItem(subItem);
                           } else if (isBytes(subItem)) {
-                            var _buffer2 = toBuffer(subItem);
-                            if (_buffer2.length === 0 || _buffer2.byteLength === 0) {
+                            var _buffer = toBuffer(subItem);
+                            if (_buffer.length === 0 || _buffer.byteLength === 0) {
                               return "\"\"";
                             }
                             return "\"(ao-type-binary)\"";
@@ -1496,8 +1491,8 @@ function _encode() {
                         fieldLines.push("".concat(index, ": ").concat(item));
                       }
                     } else if (isBytes(item)) {
-                      var _buffer3 = toBuffer(item);
-                      if (_buffer3.length === 0) {
+                      var _buffer2 = toBuffer(item);
+                      if (_buffer2.length === 0) {
                         partTypes.push("".concat(index, "=\"empty-binary\""));
                       } else {
                         partTypes.push("".concat(index, "=\"binary\""));
@@ -1563,15 +1558,401 @@ function _encode() {
                     }
                   }
                   return _context5.abrupt("return", 0);
-                case 52:
-                  // This should not be reached for binary values as they're handled above
+                case 45:
+                  if (!isPojo(value)) {
+                    _context5.next = 126;
+                    break;
+                  }
+                  if (!(Object.keys(value).length === 0)) {
+                    _context5.next = 60;
+                    break;
+                  }
+                  // Check if this is a parent array context where empty objects should get parts
+                  parentPath = pathParts.slice(0, -1).join("/");
+                  parentValue = obj;
+                  _iterator8 = _createForOfIteratorHelper(pathParts.slice(0, -1));
+                  try {
+                    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+                      _part2 = _step8.value;
+                      if (/^\d+$/.test(_part2)) {
+                        parentValue = parentValue[parseInt(_part2) - 1];
+                      } else {
+                        parentValue = parentValue[_part2];
+                      }
+                    }
+                  } catch (err) {
+                    _iterator8.e(err);
+                  } finally {
+                    _iterator8.f();
+                  }
+                  if (!Array.isArray(parentValue)) {
+                    _context5.next = 58;
+                    break;
+                  }
+                  // Check if parent array has mixed content
+                  _hasEmptyStrings = parentValue.some(function (item) {
+                    return typeof item === "string" && item === "";
+                  });
+                  _hasEmptyObjects = parentValue.some(function (item) {
+                    return isPojo(item) && Object.keys(item).length === 0;
+                  });
+                  _hasObjects = parentValue.some(function (item) {
+                    return isPojo(item);
+                  });
+                  if (!(_hasObjects && (_hasEmptyStrings || _hasEmptyObjects))) {
+                    _context5.next = 58;
+                    break;
+                  }
+                  // Special mixed array case - empty objects don't get parts
+                  console.log("[Body part] Skipping empty object in mixed array at ".concat(bodyKey));
+                  return _context5.abrupt("return", 0);
+                case 58:
+                  // Normal case - empty objects might get parts
+                  console.log("[Body part] Empty object at ".concat(bodyKey));
+                  // For now, skip empty objects
+                  return _context5.abrupt("return", 0);
+                case 60:
+                  if (!(hasSpecialDataBody && bodyKey === "data" && Object.keys(value).length === 1 && value.body && isBytes(value.body))) {
+                    _context5.next = 62;
+                    break;
+                  }
+                  return _context5.abrupt("return", 0);
+                case 62:
+                  // Handle non-empty objects
+                  _isInline3 = bodyKey === "body" && headers["inline-body-key"] === "body";
+                  if (_isInline3) {
+                    lines.push("content-disposition: inline");
+                  } else {
+                    lines.push("content-disposition: form-data;name=\"".concat(bodyKey, "\""));
+                  }
+
+                  // Continue with object processing...
+                  objectTypes = [];
+                  _fieldLines2 = [];
+                  binaryFields = []; // First check if this object only contains empty collections
+                  hasOnlyEmptyCollections = Object.entries(value).every(function (_ref8) {
+                    var _ref9 = _slicedToArray(_ref8, 2),
+                      k = _ref9[0],
+                      v = _ref9[1];
+                    return Array.isArray(v) && v.length === 0 || isPojo(v) && Object.keys(v).length === 0 || isBytes(v) && (v.length === 0 || v.byteLength === 0) || typeof v === "string" && v.length === 0;
+                  }); // Also check if it contains arrays with only empty elements
+                  hasArraysWithOnlyEmptyElements = Object.entries(value).some(function (_ref10) {
+                    var _ref11 = _slicedToArray(_ref10, 2),
+                      k = _ref11[0],
+                      v = _ref11[1];
+                    return Array.isArray(v) && v.length > 0 && v.every(function (item) {
+                      return Array.isArray(item) && item.length === 0 || isPojo(item) && Object.keys(item).length === 0 || typeof item === "string" && item === "";
+                    });
+                  }); // Collect type information for arrays in the object BEFORE processing fields
+                  arrayTypes = [];
+                  for (_i13 = 0, _Object$entries11 = Object.entries(value); _i13 < _Object$entries11.length; _i13++) {
+                    _Object$entries11$_i = _slicedToArray(_Object$entries11[_i13], 2), _k = _Object$entries11$_i[0], _v = _Object$entries11$_i[1];
+                    if (Array.isArray(_v)) {
+                      arrayTypes.push("".concat(_k.toLowerCase(), "=\"").concat(_v.length === 0 ? "empty-list" : "list", "\""));
+                    }
+                  }
+                  _i14 = 0, _Object$entries12 = Object.entries(value);
+                case 72:
+                  if (!(_i14 < _Object$entries12.length)) {
+                    _context5.next = 119;
+                    break;
+                  }
+                  _Object$entries12$_i = _slicedToArray(_Object$entries12[_i14], 2), _k2 = _Object$entries12$_i[0], _v2 = _Object$entries12$_i[1];
+                  childPath = "".concat(bodyKey, "/").concat(_k2);
+                  if (!sortedBodyKeys.includes(childPath)) {
+                    _context5.next = 77;
+                    break;
+                  }
+                  return _context5.abrupt("continue", 116);
+                case 77:
+                  if (!(Array.isArray(_v2) && _v2.some(function (item) {
+                    return isPojo(item);
+                  }))) {
+                    _context5.next = 83;
+                    break;
+                  }
+                  if (!sortedBodyKeys.includes(childPath)) {
+                    _context5.next = 80;
+                    break;
+                  }
+                  return _context5.abrupt("continue", 116);
+                case 80:
+                  // Check if array has only empty elements
+                  hasOnlyEmpty = _v2.every(function (item) {
+                    return Array.isArray(item) && item.length === 0 || isPojo(item) && Object.keys(item).length === 0 || typeof item === "string" && item === "";
+                  });
+                  if (!hasOnlyEmpty) {
+                    _context5.next = 83;
+                    break;
+                  }
+                  return _context5.abrupt("continue", 116);
+                case 83:
+                  if (Array.isArray(_v2)) {
+                    // Type info already added above in arrayTypes
+                  } else if (_v2 === null || _v2 === undefined || _typeof(_v2) === "symbol" || typeof _v2 === "boolean") {
+                    objectTypes.push("".concat(_k2.toLowerCase(), "=\"atom\""));
+                  } else if (typeof _v2 === "number") {
+                    objectTypes.push("".concat(_k2.toLowerCase(), "=\"").concat(Number.isInteger(_v2) ? "integer" : "float", "\""));
+                  } else if (typeof _v2 === "string" && _v2.length === 0) {
+                    objectTypes.push("".concat(_k2.toLowerCase(), "=\"empty-binary\""));
+                  } else if (isBytes(_v2) && (_v2.length === 0 || _v2.byteLength === 0)) {
+                    objectTypes.push("".concat(_k2.toLowerCase(), "=\"empty-binary\""));
+                  } else if (isPojo(_v2) && Object.keys(_v2).length === 0) {
+                    objectTypes.push("".concat(_k2.toLowerCase(), "=\"empty-message\""));
+                  }
+                  if (!(typeof _v2 === "string")) {
+                    _context5.next = 88;
+                    break;
+                  }
+                  if (_v2.length === 0) {
+                    // Empty strings are shown as "empty: " (with trailing space)
+                    _fieldLines2.push("".concat(_k2, ": "));
+                  } else {
+                    _fieldLines2.push("".concat(_k2, ": ").concat(_v2));
+                  }
+                  _context5.next = 116;
+                  break;
+                case 88:
+                  if (!(typeof _v2 === "number")) {
+                    _context5.next = 92;
+                    break;
+                  }
+                  _fieldLines2.push("".concat(_k2, ": ").concat(_v2));
+                  _context5.next = 116;
+                  break;
+                case 92:
+                  if (!(typeof _v2 === "boolean")) {
+                    _context5.next = 96;
+                    break;
+                  }
+                  _fieldLines2.push("".concat(_k2, ": \"").concat(_v2, "\""));
+                  _context5.next = 116;
+                  break;
+                case 96:
+                  if (!(_v2 === null)) {
+                    _context5.next = 100;
+                    break;
+                  }
+                  _fieldLines2.push("".concat(_k2, ": \"null\""));
+                  _context5.next = 116;
+                  break;
+                case 100:
+                  if (!(_v2 === undefined)) {
+                    _context5.next = 104;
+                    break;
+                  }
+                  _fieldLines2.push("".concat(_k2, ": \"undefined\""));
+                  _context5.next = 116;
+                  break;
+                case 104:
+                  if (!(_typeof(_v2) === "symbol")) {
+                    _context5.next = 109;
+                    break;
+                  }
+                  desc = _v2.description || "Symbol.for()";
+                  _fieldLines2.push("".concat(_k2, ": \"").concat(desc, "\""));
+                  _context5.next = 116;
+                  break;
+                case 109:
+                  if (!isBytes(_v2)) {
+                    _context5.next = 115;
+                    break;
+                  }
+                  _buffer3 = toBuffer(_v2);
+                  binaryFields.push({
+                    key: _k2,
+                    buffer: _buffer3
+                  });
+                  return _context5.abrupt("continue", 116);
+                case 115:
+                  if (Array.isArray(_v2)) {
+                    if (_v2.length === 0) {
+                      // Don't add field line for empty array
+                    } else {
+                      // Check if this array will have its own body part
+                      _childPath = "".concat(bodyKey, "/").concat(_k2);
+                      if (!sortedBodyKeys.includes(_childPath)) {
+                        // Check if this array contains objects - if so, don't add field line
+                        _hasObjects2 = _v2.some(function (item) {
+                          return isPojo(item);
+                        });
+                        if (!_hasObjects2) {
+                          encodedItems = _v2.map(function (item) {
+                            return encodeArrayItem(item);
+                          }).join(", ");
+                          _fieldLines2.push("".concat(_k2, ": ").concat(encodedItems));
+                        }
+                      }
+                    }
+                  } else if (isPojo(_v2) && Object.keys(_v2).length === 0) {
+                    // Empty object - don't add field line
+                  }
+                case 116:
+                  _i14++;
+                  _context5.next = 72;
+                  break;
+                case 119:
+                  // Combine arrayTypes with objectTypes
+                  allTypes = [].concat(arrayTypes, objectTypes); // Check if this object should be skipped entirely
+                  shouldSkipObject = Object.entries(value).every(function (_ref12) {
+                    var _ref13 = _slicedToArray(_ref12, 2),
+                      k = _ref13[0],
+                      v = _ref13[1];
+                    var childPath = "".concat(bodyKey, "/").concat(k);
+                    if (sortedBodyKeys.includes(childPath)) return true;
+                    if (Array.isArray(v) && v.some(function (item) {
+                      return isPojo(item);
+                    })) {
+                      // Check if array has only empty elements
+                      var _hasOnlyEmpty = v.every(function (item) {
+                        return Array.isArray(item) && item.length === 0 || isPojo(item) && Object.keys(item).length === 0 || typeof item === "string" && item === "";
+                      });
+                      return _hasOnlyEmpty || sortedBodyKeys.includes(childPath);
+                    }
+                    return false;
+                  });
+                  if (!(shouldSkipObject && !hasOnlyEmptyCollections && !hasArraysWithOnlyEmptyElements)) {
+                    _context5.next = 123;
+                    break;
+                  }
+                  return _context5.abrupt("return", 0);
+                case 123:
+                  onlyEmptyCollections = Object.entries(value).every(function (_ref14) {
+                    var _ref15 = _slicedToArray(_ref14, 2),
+                      k = _ref15[0],
+                      v = _ref15[1];
+                    var childPath = "".concat(bodyKey, "/").concat(k);
+                    if (sortedBodyKeys.includes(childPath)) return true;
+                    if (Array.isArray(v) && v.some(function (item) {
+                      return isPojo(item);
+                    })) return true;
+                    return Array.isArray(v) && v.length === 0 || isPojo(v) && Object.keys(v).length === 0 || isBytes(v) && (v.length === 0 || v.byteLength === 0);
+                  });
+                  if (_isInline3) {
+                    _orderedLines4 = []; // FIXED: For inline body, put field lines FIRST
+                    _iterator9 = _createForOfIteratorHelper(_fieldLines2);
+                    try {
+                      for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+                        _line2 = _step9.value;
+                        _orderedLines4.push(_line2);
+                      }
+                    } catch (err) {
+                      _iterator9.e(err);
+                    } finally {
+                      _iterator9.f();
+                    }
+                    if (allTypes.length > 0) {
+                      _orderedLines4.push("ao-types: ".concat(allTypes.sort().join(", ")));
+                    }
+                    _orderedLines4.push("content-disposition: inline");
+                    binaryFieldsForInline = Object.entries(value).filter(function (_ref16) {
+                      var _ref17 = _slicedToArray(_ref16, 2),
+                        k = _ref17[0],
+                        v = _ref17[1];
+                      return isBytes(v) && !sortedBodyKeys.includes("".concat(bodyKey, "/").concat(k));
+                    }).map(function (_ref18) {
+                      var _ref19 = _slicedToArray(_ref18, 2),
+                        k = _ref19[0],
+                        v = _ref19[1];
+                      return {
+                        key: k,
+                        buffer: toBuffer(v)
+                      };
+                    });
+                    if (binaryFieldsForInline.length > 0) {
+                      parts = [];
+                      parts.push(Buffer.from(_orderedLines4.join("\r\n")));
+                      _iterator10 = _createForOfIteratorHelper(binaryFieldsForInline);
+                      try {
+                        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+                          _step10$value = _step10.value, key = _step10$value.key, _buffer4 = _step10$value.buffer;
+                          parts.push(Buffer.from("\r\n".concat(key, ": ")));
+                          parts.push(_buffer4);
+                        }
+                      } catch (err) {
+                        _iterator10.e(err);
+                      } finally {
+                        _iterator10.f();
+                      }
+                      parts.push(Buffer.from("\r\n"));
+                      fullBody = Buffer.concat(parts);
+                      bodyParts.push(new Blob([fullBody]));
+                    } else {
+                      // Check if this is the last body part for special handling
+                      _isLastBodyPart = sortedBodyKeys.indexOf(bodyKey) === sortedBodyKeys.length - 1;
+                      _hasOnlyTypes = allTypes.length > 0 && _fieldLines2.length === 0;
+                      if (_isLastBodyPart && _hasOnlyTypes) {
+                        // Don't add empty line for last part with only types
+                        bodyParts.push(new Blob([_orderedLines4.join("\r\n")]));
+                      } else if (_fieldLines2.length === 0) {
+                        bodyParts.push(new Blob([_orderedLines4.join("\r\n")]));
+                      } else {
+                        bodyParts.push(new Blob([_orderedLines4.join("\r\n") + "\r\n"]));
+                      }
+                    }
+                  } else {
+                    // Put ao-types first, then content-disposition, then field lines
+                    _orderedLines5 = [];
+                    if (allTypes.length > 0) {
+                      _orderedLines5.push("ao-types: ".concat(allTypes.sort().join(", ")));
+                    }
+                    _orderedLines5.push("content-disposition: form-data;name=\"".concat(bodyKey, "\""));
+
+                    // Check if we have any binary fields
+                    hasBinaryFields = binaryFields && binaryFields.length > 0; // Add blank line before field lines if we have binary fields or no field lines
+                    if (hasBinaryFields || _fieldLines2.length === 0) {
+                      _orderedLines5.push("");
+                    }
+
+                    // Add field lines
+                    _iterator11 = _createForOfIteratorHelper(_fieldLines2);
+                    try {
+                      for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+                        _line3 = _step11.value;
+                        _orderedLines5.push(_line3);
+                      }
+                    } catch (err) {
+                      _iterator11.e(err);
+                    } finally {
+                      _iterator11.f();
+                    }
+                    if (binaryFields && binaryFields.length > 0) {
+                      _parts = [];
+                      headerText = _orderedLines5.join("\r\n");
+                      _parts.push(Buffer.from(headerText));
+                      for (_i15 = 0; _i15 < binaryFields.length; _i15++) {
+                        _binaryFields$_i = binaryFields[_i15], _key = _binaryFields$_i.key, _buffer5 = _binaryFields$_i.buffer;
+                        if (_i15 > 0) {
+                          _parts.push(Buffer.from("\r\n"));
+                        }
+                        _parts.push(Buffer.from("".concat(_key, ": ")));
+                        _parts.push(_buffer5);
+                      }
+                      _parts.push(Buffer.from("\r\n"));
+                      _fullBody = Buffer.concat(_parts);
+                      bodyParts.push(new Blob([_fullBody]));
+                    } else {
+                      // Add trailing blank line if we have field lines
+                      if (_fieldLines2.length > 0) {
+                        bodyParts.push(new Blob([_orderedLines5.join("\r\n") + "\r\n"]));
+                      } else {
+                        bodyParts.push(new Blob([_orderedLines5.join("\r\n")]));
+                      }
+                    }
+                  }
+                  return _context5.abrupt("return", 0);
+                case 126:
                   isInline = bodyKey === "body" && headers["inline-body-key"] === "body";
                   if (isInline) {
                     lines.push("content-disposition: inline");
                   } else {
                     lines.push("content-disposition: form-data;name=\"".concat(bodyKey, "\""));
                   }
-                  if (typeof value === "string") {
+                  if (isBytes(value)) {
+                    _buffer6 = toBuffer(value);
+                    _headerText = lines.join("\r\n") + "\r\n\r\n";
+                    bodyParts.push(new Blob([_headerText, _buffer6]));
+                  } else if (typeof value === "string") {
                     lines.push("");
                     lines.push(value);
                     bodyParts.push(new Blob([lines.join("\r\n")]));
@@ -1591,7 +1972,7 @@ function _encode() {
                     lines.push(content);
                     bodyParts.push(new Blob([lines.join("\r\n")]));
                   }
-                case 55:
+                case 129:
                 case "end":
                   return _context5.stop();
               }

package/esm/encode.js

@@ -339,11 +339,8 @@ function collectBodyKeys(obj, prefix = "") {
             nestedPaths.push(fullPath)
           }
         }
-      } else if (isBytes(value)) {
-        const buffer = toBuffer(value)
-        if (buffer.length > 0) {
-          hasSimpleFields = true
-        }
+      } else if (isBytes(value) && value.length > 0) {
+        hasSimpleFields = true
       } else if (
         typeof value === "string" ||
         typeof value === "number" ||
@@ -631,15 +628,28 @@ function collectBodyKeys(obj, prefix = "") {
         }
       }
     } else if (isPojo(value)) {
-      console.log(`[main loop] Processing object at key: "${key}"`)
-      // Objects should be traversed, not have their fields individually added
-      traverse(value, key)
-    } else if (isBytes(value)) {
-      const buffer = toBuffer(value)
-      if (buffer.length > 0) {
-        console.log(`[main loop] Adding key for non-empty bytes: "${key}"`)
-        keys.push(key)
+      console.log(`[main loop] Traversing object at key: "${key}"`)
+      // Check if this object contains arrays with only empty elements
+      let hasArraysWithOnlyEmptyElements = false
+      for (const [k, v] of Object.entries(value)) {
+        if (
+          Array.isArray(v) &&
+          v.length > 0 &&
+          v.every(
+            item =>
+              (Array.isArray(item) && item.length === 0) ||
+              (isPojo(item) && Object.keys(item).length === 0) ||
+              (typeof item === "string" && item === "")
+          )
+        ) {
+          hasArraysWithOnlyEmptyElements = true
+          keys.push(`${key}/${k}`)
+        }
       }
+      traverse(value, key)
+    } else if (isBytes(value) && value.length > 0) {
+      console.log(`[main loop] Adding key for non-empty bytes: "${key}"`)
+      keys.push(key)
     } else if (typeof value === "string" && value.includes("\n")) {
       console.log(`[main loop] Adding key for string with newline: "${key}"`)
       keys.push(key)
@@ -852,10 +862,11 @@ async function encode(obj = {}) {
     }
   }
 
-  const bodyKeys = collectBodyKeys(obj)
   const headers = {}
   const headerTypes = []
 
+  const bodyKeys = collectBodyKeys(obj)
+
   for (const [key, value] of Object.entries(obj)) {
     const needsBody =
       bodyKeys.includes(key) || bodyKeys.some(k => k.startsWith(`${key}/`))
@@ -1106,16 +1117,6 @@ async function encode(obj = {}) {
       continue
     }
 
-    // Handle direct binary values
-    if (isBytes(value)) {
-      console.log(`[Body part] Creating part for binary at ${bodyKey}`)
-      lines.push(`content-disposition: form-data;name="${bodyKey}"`)
-      const buffer = toBuffer(value)
-      const headerText = lines.join("\r\n") + "\r\n\r\n"
-      bodyParts.push(new Blob([headerText, buffer]))
-      continue
-    }
-
     if (Array.isArray(value)) {
       const hasOnlyEmptyElements =
         value.length > 0 &&
@@ -1439,7 +1440,340 @@ async function encode(obj = {}) {
       continue
     }
 
-    // This should not be reached for binary values as they're handled above
+    if (isPojo(value)) {
+      // Handle non-empty objects - skip empty ones
+      if (Object.keys(value).length === 0) {
+        // Check if this is a parent array context where empty objects should get parts
+        const parentPath = pathParts.slice(0, -1).join("/")
+        let parentValue = obj
+        for (const part of pathParts.slice(0, -1)) {
+          if (/^\d+$/.test(part)) {
+            parentValue = parentValue[parseInt(part) - 1]
+          } else {
+            parentValue = parentValue[part]
+          }
+        }
+
+        if (Array.isArray(parentValue)) {
+          // Check if parent array has mixed content
+          const hasEmptyStrings = parentValue.some(
+            item => typeof item === "string" && item === ""
+          )
+          const hasEmptyObjects = parentValue.some(
+            item => isPojo(item) && Object.keys(item).length === 0
+          )
+          const hasObjects = parentValue.some(item => isPojo(item))
+
+          if (hasObjects && (hasEmptyStrings || hasEmptyObjects)) {
+            // Special mixed array case - empty objects don't get parts
+            console.log(
+              `[Body part] Skipping empty object in mixed array at ${bodyKey}`
+            )
+            continue
+          }
+        }
+
+        // Normal case - empty objects might get parts
+        console.log(`[Body part] Empty object at ${bodyKey}`)
+        // For now, skip empty objects
+        continue
+      }
+
+      // Skip the special case where bodyKey is "data" and has only body:Buffer
+      if (
+        hasSpecialDataBody &&
+        bodyKey === "data" &&
+        Object.keys(value).length === 1 &&
+        value.body &&
+        isBytes(value.body)
+      ) {
+        continue
+      }
+
+      // Handle non-empty objects
+      const isInline =
+        bodyKey === "body" && headers["inline-body-key"] === "body"
+      if (isInline) {
+        lines.push(`content-disposition: inline`)
+      } else {
+        lines.push(`content-disposition: form-data;name="${bodyKey}"`)
+      }
+
+      // Continue with object processing...
+      const objectTypes = []
+      const fieldLines = []
+      const binaryFields = []
+
+      // First check if this object only contains empty collections
+      const hasOnlyEmptyCollections = Object.entries(value).every(([k, v]) => {
+        return (
+          (Array.isArray(v) && v.length === 0) ||
+          (isPojo(v) && Object.keys(v).length === 0) ||
+          (isBytes(v) && (v.length === 0 || v.byteLength === 0)) ||
+          (typeof v === "string" && v.length === 0)
+        )
+      })
+
+      // Also check if it contains arrays with only empty elements
+      const hasArraysWithOnlyEmptyElements = Object.entries(value).some(
+        ([k, v]) => {
+          return (
+            Array.isArray(v) &&
+            v.length > 0 &&
+            v.every(
+              item =>
+                (Array.isArray(item) && item.length === 0) ||
+                (isPojo(item) && Object.keys(item).length === 0) ||
+                (typeof item === "string" && item === "")
+            )
+          )
+        }
+      )
+
+      // Collect type information for arrays in the object BEFORE processing fields
+      const arrayTypes = []
+      for (const [k, v] of Object.entries(value)) {
+        if (Array.isArray(v)) {
+          arrayTypes.push(
+            `${k.toLowerCase()}="${v.length === 0 ? "empty-list" : "list"}"`
+          )
+        }
+      }
+
+      for (const [k, v] of Object.entries(value)) {
+        const childPath = `${bodyKey}/${k}`
+
+        if (sortedBodyKeys.includes(childPath)) {
+          continue
+        }
+
+        if (Array.isArray(v) && v.some(item => isPojo(item))) {
+          // Check if this array will have its own body part
+          if (sortedBodyKeys.includes(childPath)) {
+            continue
+          }
+          // Check if array has only empty elements
+          const hasOnlyEmpty = v.every(
+            item =>
+              (Array.isArray(item) && item.length === 0) ||
+              (isPojo(item) && Object.keys(item).length === 0) ||
+              (typeof item === "string" && item === "")
+          )
+          if (hasOnlyEmpty) {
+            continue
+          }
+        }
+
+        if (Array.isArray(v)) {
+          // Type info already added above in arrayTypes
+        } else if (
+          v === null ||
+          v === undefined ||
+          typeof v === "symbol" ||
+          typeof v === "boolean"
+        ) {
+          objectTypes.push(`${k.toLowerCase()}="atom"`)
+        } else if (typeof v === "number") {
+          objectTypes.push(
+            `${k.toLowerCase()}="${Number.isInteger(v) ? "integer" : "float"}"`
+          )
+        } else if (typeof v === "string" && v.length === 0) {
+          objectTypes.push(`${k.toLowerCase()}="empty-binary"`)
+        } else if (isBytes(v) && (v.length === 0 || v.byteLength === 0)) {
+          objectTypes.push(`${k.toLowerCase()}="empty-binary"`)
+        } else if (isPojo(v) && Object.keys(v).length === 0) {
+          objectTypes.push(`${k.toLowerCase()}="empty-message"`)
+        }
+
+        if (typeof v === "string") {
+          if (v.length === 0) {
+            // Empty strings are shown as "empty: " (with trailing space)
+            fieldLines.push(`${k}: `)
+          } else {
+            fieldLines.push(`${k}: ${v}`)
+          }
+        } else if (typeof v === "number") {
+          fieldLines.push(`${k}: ${v}`)
+        } else if (typeof v === "boolean") {
+          fieldLines.push(`${k}: "${v}"`)
+        } else if (v === null) {
+          fieldLines.push(`${k}: "null"`)
+        } else if (v === undefined) {
+          fieldLines.push(`${k}: "undefined"`)
+        } else if (typeof v === "symbol") {
+          const desc = v.description || "Symbol.for()"
+          fieldLines.push(`${k}: "${desc}"`)
+        } else if (isBytes(v)) {
+          const buffer = toBuffer(v)
+          binaryFields.push({ key: k, buffer })
+          continue
+        } else if (Array.isArray(v)) {
+          if (v.length === 0) {
+            // Don't add field line for empty array
+          } else {
+            // Check if this array will have its own body part
+            const childPath = `${bodyKey}/${k}`
+            if (!sortedBodyKeys.includes(childPath)) {
+              // Check if this array contains objects - if so, don't add field line
+              const hasObjects = v.some(item => isPojo(item))
+              if (!hasObjects) {
+                const encodedItems = v
+                  .map(item => encodeArrayItem(item))
+                  .join(", ")
+                fieldLines.push(`${k}: ${encodedItems}`)
+              }
+            }
+          }
+        } else if (isPojo(v) && Object.keys(v).length === 0) {
+          // Empty object - don't add field line
+        }
+      }
+
+      // Combine arrayTypes with objectTypes
+      const allTypes = [...arrayTypes, ...objectTypes]
+
+      // Check if this object should be skipped entirely
+      const shouldSkipObject = Object.entries(value).every(([k, v]) => {
+        const childPath = `${bodyKey}/${k}`
+        if (sortedBodyKeys.includes(childPath)) return true
+        if (Array.isArray(v) && v.some(item => isPojo(item))) {
+          // Check if array has only empty elements
+          const hasOnlyEmpty = v.every(
+            item =>
+              (Array.isArray(item) && item.length === 0) ||
+              (isPojo(item) && Object.keys(item).length === 0) ||
+              (typeof item === "string" && item === "")
+          )
+          return hasOnlyEmpty || sortedBodyKeys.includes(childPath)
+        }
+        return false
+      })
+
+      if (
+        shouldSkipObject &&
+        !hasOnlyEmptyCollections &&
+        !hasArraysWithOnlyEmptyElements
+      ) {
+        continue
+      }
+
+      const onlyEmptyCollections = Object.entries(value).every(([k, v]) => {
+        const childPath = `${bodyKey}/${k}`
+        if (sortedBodyKeys.includes(childPath)) return true
+        if (Array.isArray(v) && v.some(item => isPojo(item))) return true
+
+        return (
+          (Array.isArray(v) && v.length === 0) ||
+          (isPojo(v) && Object.keys(v).length === 0) ||
+          (isBytes(v) && (v.length === 0 || v.byteLength === 0))
+        )
+      })
+
+      if (isInline) {
+        const orderedLines = []
+
+        // FIXED: For inline body, put field lines FIRST
+        for (const line of fieldLines) {
+          orderedLines.push(line)
+        }
+
+        if (allTypes.length > 0) {
+          orderedLines.push(`ao-types: ${allTypes.sort().join(", ")}`)
+        }
+
+        orderedLines.push("content-disposition: inline")
+
+        const binaryFieldsForInline = Object.entries(value)
+          .filter(
+            ([k, v]) =>
+              isBytes(v) && !sortedBodyKeys.includes(`${bodyKey}/${k}`)
+          )
+          .map(([k, v]) => ({
+            key: k,
+            buffer: toBuffer(v),
+          }))
+
+        if (binaryFieldsForInline.length > 0) {
+          const parts = []
+          parts.push(Buffer.from(orderedLines.join("\r\n")))
+
+          for (const { key, buffer } of binaryFieldsForInline) {
+            parts.push(Buffer.from(`\r\n${key}: `))
+            parts.push(buffer)
+          }
+
+          parts.push(Buffer.from("\r\n"))
+
+          const fullBody = Buffer.concat(parts)
+          bodyParts.push(new Blob([fullBody]))
+        } else {
+          // Check if this is the last body part for special handling
+          const isLastBodyPart =
+            sortedBodyKeys.indexOf(bodyKey) === sortedBodyKeys.length - 1
+          const hasOnlyTypes = allTypes.length > 0 && fieldLines.length === 0
+
+          if (isLastBodyPart && hasOnlyTypes) {
+            // Don't add empty line for last part with only types
+            bodyParts.push(new Blob([orderedLines.join("\r\n")]))
+          } else if (fieldLines.length === 0) {
+            bodyParts.push(new Blob([orderedLines.join("\r\n")]))
+          } else {
+            bodyParts.push(new Blob([orderedLines.join("\r\n") + "\r\n"]))
+          }
+        }
+      } else {
+        // Put ao-types first, then content-disposition, then field lines
+        const orderedLines = []
+
+        if (allTypes.length > 0) {
+          orderedLines.push(`ao-types: ${allTypes.sort().join(", ")}`)
+        }
+
+        orderedLines.push(`content-disposition: form-data;name="${bodyKey}"`)
+
+        // Check if we have any binary fields
+        const hasBinaryFields = binaryFields && binaryFields.length > 0
+
+        // Add blank line before field lines if we have binary fields or no field lines
+        if (hasBinaryFields || fieldLines.length === 0) {
+          orderedLines.push("")
+        }
+
+        // Add field lines
+        for (const line of fieldLines) {
+          orderedLines.push(line)
+        }
+
+        if (binaryFields && binaryFields.length > 0) {
+          const parts = []
+          const headerText = orderedLines.join("\r\n")
+          parts.push(Buffer.from(headerText))
+
+          for (let i = 0; i < binaryFields.length; i++) {
+            const { key, buffer } = binaryFields[i]
+            if (i > 0) {
+              parts.push(Buffer.from("\r\n"))
+            }
+            parts.push(Buffer.from(`${key}: `))
+            parts.push(buffer)
+          }
+
+          parts.push(Buffer.from("\r\n"))
+          const fullBody = Buffer.concat(parts)
+          bodyParts.push(new Blob([fullBody]))
+        } else {
+          // Add trailing blank line if we have field lines
+          if (fieldLines.length > 0) {
+            bodyParts.push(new Blob([orderedLines.join("\r\n") + "\r\n"]))
+          } else {
+            bodyParts.push(new Blob([orderedLines.join("\r\n")]))
+          }
+        }
+      }
+
+      continue
+    }
+
     const isInline = bodyKey === "body" && headers["inline-body-key"] === "body"
     if (isInline) {
       lines.push(`content-disposition: inline`)
@@ -1447,7 +1781,11 @@ async function encode(obj = {}) {
       lines.push(`content-disposition: form-data;name="${bodyKey}"`)
     }
 
-    if (typeof value === "string") {
+    if (isBytes(value)) {
+      const buffer = toBuffer(value)
+      const headerText = lines.join("\r\n") + "\r\n\r\n"
+      bodyParts.push(new Blob([headerText, buffer]))
+    } else if (typeof value === "string") {
       lines.push("")
       lines.push(value)
       bodyParts.push(new Blob([lines.join("\r\n")]))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wao",
-  "version": "0.27.2",
+  "version": "0.27.3",
   "bin": {
     "wao": "./cjs/cli.js",
     "wao-esm": "./esm/cli.js"