hbsig 0.2.8 → 0.3.1

package/cjs/flat.js

@@ -90,6 +90,60 @@ function pathToParts(path) {
   throw new Error("Path must be a string or array");
 }
 
+/**
+ * Convert a value to string format to match Erlang codec behavior
+ * Erlang dev_codec_flat only handles binaries, so all leaf values become strings
+ * @param {*} value - Value to convert
+ * @returns {string|Object} - String for leaf values, or recursively processed object
+ */
+function valueToString(value) {
+  if (_typeof(value) === "object" && value !== null && !Array.isArray(value) && !Buffer.isBuffer(value)) {
+    // Recursively process nested objects
+    var result = {};
+    for (var _i2 = 0, _Object$entries2 = Object.entries(value); _i2 < _Object$entries2.length; _i2++) {
+      var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+        k = _Object$entries2$_i[0],
+        v = _Object$entries2$_i[1];
+      result[k] = valueToString(v);
+    }
+    return result;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "boolean") {
+    return String(value);
+  }
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    // Convert array elements to strings first, then format as Erlang list
+    // Erlang's io_lib:format("~p", [List]) produces binary syntax like [<<"a">>,<<"b">>]
+    var elements = value.map(function (v) {
+      if (typeof v === "string") {
+        return "<<\"".concat(v, "\">>");
+      } else if (typeof v === "number") {
+        return String(v);
+      } else if (typeof v === "boolean") {
+        return v ? "true" : "false";
+      } else if (v === null) {
+        return "null";
+      } else {
+        return String(v);
+      }
+    });
+    return "[".concat(elements.join(","), "]");
+  }
+  if (Buffer.isBuffer(value)) {
+    return value.toString();
+  }
+  return String(value);
+}
+
 /**
  * Helper function to inject a value at a specific path in a nested object
  * @param {Array} pathParts - Array of path parts
@@ -100,20 +154,23 @@ function injectAtPath(pathParts, value, obj) {
   if (pathParts.length === 0) {
     throw new Error("Path cannot be empty");
   }
+
+  // Convert value to match Erlang codec behavior
+  var convertedValue = valueToString(value);
   if (pathParts.length === 1) {
     var _key = pathParts[0];
     if (_key in obj) {
       var existing = obj[_key];
 
       // If both are objects, merge them
-      if (_typeof(existing) === "object" && existing !== null && _typeof(value) === "object" && value !== null && !Array.isArray(existing) && !Array.isArray(value)) {
-        obj[_key] = _objectSpread(_objectSpread({}, existing), value);
+      if (_typeof(existing) === "object" && existing !== null && _typeof(convertedValue) === "object" && convertedValue !== null && !Array.isArray(existing) && !Array.isArray(convertedValue)) {
+        obj[_key] = _objectSpread(_objectSpread({}, existing), convertedValue);
       } else {
         // Path collision
-        throw new Error("Path collision at key: ".concat(_key, ", existing: ").concat(JSON.stringify(existing), ", value: ").concat(JSON.stringify(value)));
+        throw new Error("Path collision at key: ".concat(_key, ", existing: ").concat(JSON.stringify(existing), ", value: ").concat(JSON.stringify(convertedValue)));
       }
     } else {
-      obj[_key] = value;
+      obj[_key] = convertedValue;
     }
     return;
   }
@@ -125,7 +182,7 @@ function injectAtPath(pathParts, value, obj) {
   } else if (_typeof(obj[key]) !== "object" || obj[key] === null) {
     throw new Error("Cannot create nested path at non-object key: ".concat(key));
   }
-  injectAtPath(rest, value, obj[key]);
+  injectAtPath(rest, convertedValue, obj[key]);
 }
 
 /**
@@ -137,10 +194,10 @@ function injectAtPath(pathParts, value, obj) {
 function flattenRecursive(value, currentPath, result) {
   if (_typeof(value) === "object" && value !== null && !Array.isArray(value)) {
     // It's an object, recurse into it
-    for (var _i2 = 0, _Object$entries2 = Object.entries(value); _i2 < _Object$entries2.length; _i2++) {
-      var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
-        key = _Object$entries2$_i[0],
-        subValue = _Object$entries2$_i[1];
+    for (var _i3 = 0, _Object$entries3 = Object.entries(value); _i3 < _Object$entries3.length; _i3++) {
+      var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
+        key = _Object$entries3$_i[0],
+        subValue = _Object$entries3$_i[1];
       var newPath = [].concat(_toConsumableArray(currentPath), [key]);
       flattenRecursive(subValue, newPath, result);
     }
@@ -166,10 +223,10 @@ function serialize(map) {
   try {
     var flattened = flat_to(map);
     var lines = [];
-    for (var _i3 = 0, _Object$entries3 = Object.entries(flattened); _i3 < _Object$entries3.length; _i3++) {
-      var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
-        key = _Object$entries3$_i[0],
-        value = _Object$entries3$_i[1];
+    for (var _i4 = 0, _Object$entries4 = Object.entries(flattened); _i4 < _Object$entries4.length; _i4++) {
+      var _Object$entries4$_i = _slicedToArray(_Object$entries4[_i4], 2),
+        key = _Object$entries4$_i[0],
+        value = _Object$entries4$_i[1];
       lines.push("".concat(key, ": ").concat(value));
     }
     return {

package/cjs/httpsig.js

@@ -9,10 +9,7 @@ exports.structured_from = structured_from;
 exports.structured_to = structured_to;
 var _fastSha = require("fast-sha256");
 var _flat = require("./flat.js");
-function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
-function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+var _structured = require("./structured.js");
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
@@ -143,18 +140,19 @@ function boundaryFromParts(parts) {
   return bytesToBase64url(hashBytes);
 }
 
-// Helper to determine inline key
+// Helper to determine inline key - matches Erlang's inline_key/2
 function inlineKey(msg) {
-  var inlineBodyKey = msg["inline-body-key"];
-  if (inlineBodyKey) {
-    return [{}, inlineBodyKey];
+  // Check for ao-body-key (Erlang uses ao-body-key, not inline-body-key)
+  var aoBodyKey = msg["ao-body-key"];
+  if (aoBodyKey) {
+    return [{}, aoBodyKey];
   }
   if ("body" in msg) {
     return [{}, "body"];
   }
   if ("data" in msg) {
     return [{
-      "inline-body-key": "data"
+      "ao-body-key": "data"
     }, "data"];
   }
   return [{}, "body"];
@@ -213,6 +211,13 @@ function ungroupIds(msg) {
   return result;
 }
 
+// Get the size of a map (matches Erlang's maps:size behavior)
+// This counts ALL keys including ao-types - empty means literally {}
+function mapSize(obj) {
+  if (_typeof(obj) !== "object" || obj === null) return 0;
+  return Object.keys(obj).length;
+}
+
 // Group maps for body encoding - following Erlang logic exactly
 function groupMaps(map) {
   var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
@@ -242,8 +247,19 @@ function groupMaps(map) {
       var normKey = normalizeKey(key);
       var flatK = parent ? "".concat(parent, "/").concat(normKey) : normKey;
       if (_typeof(value) === "object" && value !== null && !Array.isArray(value) && !Buffer.isBuffer(value)) {
-        // Recursively process nested objects
-        newTop = groupMaps(value, flatK, newTop);
+        // Check size of the nested object (including metadata keys like ao-types)
+        // Empty means literally {} - a map with only ao-types is NOT empty
+        var size = mapSize(value);
+        if (size === 0) {
+          // Empty map (no data keys) - add empty-message marker
+          // This matches Erlang's group_maps behavior for empty maps
+          newTop[flatK] = {
+            "ao-types": "empty-message"
+          };
+        } else {
+          // Recursively process nested objects
+          newTop = groupMaps(value, flatK, newTop);
+        }
       } else if (typeof value === "string" && value.length > MAX_HEADER_LENGTH) {
         // Value too large for header, lift to top level
         newTop[flatK] = value;
@@ -271,124 +287,74 @@ function groupMaps(map) {
   }
 }
 
+// Helper to compute content-digest for a body value
+function computePartDigest(bodyValue) {
+  var bodyBytes;
+  if (Buffer.isBuffer(bodyValue)) {
+    bodyBytes = new Uint8Array(bodyValue);
+  } else if (typeof bodyValue === "string") {
+    bodyBytes = stringToBytes(bodyValue, "binary");
+  } else {
+    bodyBytes = stringToBytes(String(bodyValue), "binary");
+  }
+  var hashBytes = (0, _fastSha.hash)(bodyBytes);
+  return "sha-256=:".concat(bytesToBase64(hashBytes), ":");
+}
+
 // Encode multipart body part
+// NOTE: This matches Erlang's encode_body_part/4 which does NOT apply inline_key
+// logic to nested parts. For nested maps, ALL fields become headers (except 'body'
+// which becomes the part body). The inline_key logic is only for top-level messages.
 function encodeBodyPart(partName, bodyPart, inlineKey) {
   var disposition = partName === inlineKey ? "inline" : "form-data;name=\"".concat(partName, "\"");
-  var isInline = partName === inlineKey;
   if (_typeof(bodyPart) === "object" && bodyPart !== null && !Array.isArray(bodyPart) && !Buffer.isBuffer(bodyPart)) {
-    // Check if this part has ao-types
-    var hasAoTypes = "ao-types" in bodyPart;
-    if (hasAoTypes) {
-      // For parts WITH ao-types: sort all entries alphabetically
-      var allEntries = [];
-
-      // Collect all entries except body
-      for (var _i6 = 0, _Object$entries6 = Object.entries(bodyPart); _i6 < _Object$entries6.length; _i6++) {
-        var _Object$entries6$_i = _slicedToArray(_Object$entries6[_i6], 2),
-          key = _Object$entries6$_i[0],
-          value = _Object$entries6$_i[1];
-        if (key === "body") continue;
-        if (key === "ao-types") {
-          // Keep ao-types as-is (Buffer or string)
-          var valueStr = value;
-          if (Buffer.isBuffer(value)) {
-            valueStr = value.toString("binary");
-          }
-          allEntries.push({
-            key: "ao-types",
-            line: "ao-types: ".concat(valueStr)
-          });
-        } else {
-          // Handle Buffer values properly
-          var _valueStr = value;
-          if (Buffer.isBuffer(value)) {
-            // Use binary/latin1 encoding to preserve all byte values 0-255
-            _valueStr = value.toString("binary");
-          }
-          allEntries.push({
-            key: key,
-            line: "".concat(key, ": ").concat(_valueStr)
-          });
-        }
+    // Collect all headers (everything except 'body' and 'priv')
+    var allEntries = [];
+    for (var _i6 = 0, _Object$entries6 = Object.entries(bodyPart); _i6 < _Object$entries6.length; _i6++) {
+      var _Object$entries6$_i = _slicedToArray(_Object$entries6[_i6], 2),
+        key = _Object$entries6$_i[0],
+        value = _Object$entries6$_i[1];
+      if (key === "body" || key === "priv") continue;
+
+      // Handle Buffer values properly
+      var valueStr = value;
+      if (Buffer.isBuffer(value)) {
+        // Use binary/latin1 encoding to preserve all byte values 0-255
+        valueStr = value.toString("binary");
       }
-
-      // Add content-disposition
       allEntries.push({
-        key: "content-disposition",
-        line: "content-disposition: ".concat(disposition)
+        key: key,
+        line: "".concat(key, ": ").concat(valueStr)
       });
+    }
 
-      // Sort alphabetically by key
-      allEntries.sort(function (a, b) {
-        return a.key.localeCompare(b.key);
-      });
+    // Add content-disposition
+    allEntries.push({
+      key: "content-disposition",
+      line: "content-disposition: ".concat(disposition)
+    });
 
-      // Build the lines
-      var lines = allEntries.map(function (entry) {
-        return entry.line;
-      });
+    // Sort all entries by key alphabetically - matches Erlang behavior
+    allEntries.sort(function (a, b) {
+      return a.key.localeCompare(b.key);
+    });
 
-      // Body handling
-      var body = bodyPart.body || "";
-      if (body) {
-        lines.push(""); // Always add empty line before body
-        lines.push(body);
-      }
-      return lines.join(CRLF);
-    } else {
-      // For parts WITHOUT ao-types
-      var _allEntries = [];
-      for (var _i7 = 0, _Object$entries7 = Object.entries(bodyPart); _i7 < _Object$entries7.length; _i7++) {
-        var _Object$entries7$_i = _slicedToArray(_Object$entries7[_i7], 2),
-          _key = _Object$entries7$_i[0],
-          _value = _Object$entries7$_i[1];
-        if (_key === "body") continue;
-        // Handle Buffer values properly
-        var _valueStr2 = _value;
-        if (Buffer.isBuffer(_value)) {
-          // Use binary/latin1 encoding to preserve all byte values 0-255
-          _valueStr2 = _value.toString("binary");
-        }
-        _allEntries.push({
-          key: _key,
-          line: "".concat(_key, ": ").concat(_valueStr2)
-        });
-      }
-      var _lines = [];
-      if (isInline) {
-        // Inline parts without ao-types: sort ALL fields alphabetically including content-disposition
-        _allEntries.push({
-          key: "content-disposition",
-          line: "content-disposition: ".concat(disposition)
-        });
-
-        // Sort by key
-        _allEntries.sort(function (a, b) {
-          return a.key.localeCompare(b.key);
-        });
-
-        // Extract the lines
-        _lines.push.apply(_lines, _toConsumableArray(_allEntries.map(function (entry) {
-          return entry.line;
-        })));
-      } else {
-        // Regular parts: content-disposition first, then fields
-        _lines.push("content-disposition: ".concat(disposition));
-        _lines.push.apply(_lines, _toConsumableArray(_allEntries.map(function (entry) {
-          return entry.line;
-        })));
-      }
+    // Build the lines
+    var lines = allEntries.map(function (entry) {
+      return entry.line;
+    });
 
-      // Body handling
-      var _body = bodyPart.body || "";
-      if (_body) {
-        _lines.push(""); // Always add empty line before body
-        _lines.push(_body);
-      }
-      return _lines.join(CRLF);
+    // Only the 'body' field (if present) becomes the part body
+    var body = bodyPart.body;
+    if (body !== "" && body !== undefined && body !== null) {
+      lines.push(""); // Always add empty line before body
+      lines.push(Buffer.isBuffer(body) ? body.toString("binary") : String(body));
     }
+    return lines.join(CRLF);
   } else if (typeof bodyPart === "string" || Buffer.isBuffer(bodyPart)) {
-    return "content-disposition: ".concat(disposition).concat(DOUBLE_CRLF).concat(bodyPart);
+    // Use binary/latin1 encoding to preserve byte values 0-255
+    var bodyStr = Buffer.isBuffer(bodyPart) ? bodyPart.toString("binary") : bodyPart;
+    return "content-disposition: ".concat(disposition).concat(DOUBLE_CRLF).concat(bodyStr);
   }
   return "";
 }
@@ -406,8 +372,8 @@ function isBinaryData(buf) {
   // Count non-text bytes
   var controlCount = 0;
   var highByteCount = 0;
-  for (var _i8 = 0; _i8 < checkLength; _i8++) {
-    var _byte = buf[_i8];
+  for (var _i7 = 0; _i7 < checkLength; _i7++) {
+    var _byte = buf[_i7];
     // Non-printable chars (except CR/LF/TAB)
     if (_byte < 32 && _byte !== 9 && _byte !== 10 && _byte !== 13) {
       controlCount++;
@@ -561,11 +527,11 @@ function parseMultipart(contentType, body) {
         delete restHeaders["content-disposition"];
 
         // Add each header from the inline part to the top level of result
-        for (var _i9 = 0, _Object$entries8 = Object.entries(restHeaders); _i9 < _Object$entries8.length; _i9++) {
-          var _Object$entries8$_i = _slicedToArray(_Object$entries8[_i9], 2),
-            key = _Object$entries8$_i[0],
-            _value2 = _Object$entries8$_i[1];
-          result[key] = _value2;
+        for (var _i8 = 0, _Object$entries7 = Object.entries(restHeaders); _i8 < _Object$entries7.length; _i8++) {
+          var _Object$entries7$_i = _slicedToArray(_Object$entries7[_i8], 2),
+            key = _Object$entries7$_i[0],
+            _value = _Object$entries7$_i[1];
+          result[key] = _value;
         }
 
         // If there's body content in the inline part, add it as 'body'
@@ -670,10 +636,10 @@ function httpsig_from(http) {
     // Convert flat structure to nested using flat.js
     var flat = {};
     var nonFlat = {};
-    for (var _i0 = 0, _Object$entries9 = Object.entries(withBodyKeys); _i0 < _Object$entries9.length; _i0++) {
-      var _Object$entries9$_i = _slicedToArray(_Object$entries9[_i0], 2),
-        key = _Object$entries9$_i[0],
-        value = _Object$entries9$_i[1];
+    for (var _i9 = 0, _Object$entries8 = Object.entries(withBodyKeys); _i9 < _Object$entries8.length; _i9++) {
+      var _Object$entries8$_i = _slicedToArray(_Object$entries8[_i9], 2),
+        key = _Object$entries8$_i[0],
+        value = _Object$entries8$_i[1];
       if (key.includes("/")) {
         flat[key] = value;
       } else {
@@ -706,10 +672,10 @@ function httpsig_from(http) {
   delete result["content-digest"];
 
   // Extract hashpaths if any
-  for (var _i1 = 0, _Object$keys = Object.keys(result); _i1 < _Object$keys.length; _i1++) {
-    var _key2 = _Object$keys[_i1];
-    if (_key2.startsWith("hashpath")) {
-      delete result[_key2];
+  for (var _i0 = 0, _Object$keys = Object.keys(result); _i0 < _Object$keys.length; _i0++) {
+    var _key = _Object$keys[_i0];
+    if (_key.startsWith("hashpath")) {
+      delete result[_key];
     }
   }
   return result;
@@ -717,12 +683,20 @@ function httpsig_from(http) {
 
 /**
  * Convert TABM to HTTP message
+ * Implements bundle mode like Erlang's dev_codec_httpsig_conv:to/3 with bundle=true
  */
 function httpsig_to(tabm) {
   if (typeof tabm === "string") return tabm;
 
+  // Bundle logic: TABM → structured → TABM
+  // This matches Erlang's behavior when bundle=true:
+  // 1. Convert TABM to structured@1.0 (interprets ao-types, decodes to native types)
+  // 2. Convert back to TABM (re-encodes with ao-types)
+  var structured = (0, _structured.structured_to)(tabm);
+  var bundledTabm = (0, _structured.structured_from)(structured);
+
   // Group IDs
-  var withGroupedIds = groupIds(tabm);
+  var withGroupedIds = groupIds(bundledTabm);
 
   // Remove private and signature-related keys
   var stripped = _objectSpread({}, withGroupedIds);
@@ -736,24 +710,25 @@ function httpsig_to(tabm) {
     inlineKeyVal = _inlineKey4[1];
 
   // Check if this is a flat structure that should stay as headers
-  // A flat structure has no nested objects (maps)
+  // A flat structure has no nested objects (maps), excluding:
+  // - Arrays (JS arrays, not numbered maps)
+  // - Buffers
+  // Note: List-encoded maps (numbered maps with .="list") ARE nested maps
+  // and should trigger multipart encoding, matching Erlang's behavior
   var hasNestedMaps = Object.values(stripped).some(function (value) {
-    return _typeof(value) === "object" && value !== null && !Array.isArray(value) && !Buffer.isBuffer(value);
+    // Not an object
+    if (_typeof(value) !== "object" || value === null) return false;
+    // Arrays and Buffers are not nested maps
+    if (Array.isArray(value) || Buffer.isBuffer(value)) return false;
+    // Any other object (including list-encoded maps) is a nested map
+    return true;
   });
 
   // If it's just a flat map with strings/primitives, keep as headers
   // This matches Erlang's behavior where flat maps don't become multipart
   if (!hasNestedMaps) {
     // For flat structures, just return with normalized keys
-    // This matches Erlang which returns the map unchanged
-    var result = _objectSpread({}, inlineFieldHdrs);
-    for (var _i10 = 0, _Object$entries0 = Object.entries(stripped); _i10 < _Object$entries0.length; _i10++) {
-      var _Object$entries0$_i = _slicedToArray(_Object$entries0[_i10], 2),
-        key = _Object$entries0$_i[0],
-        value = _Object$entries0$_i[1];
-      // Keep Buffers as Buffers - don't convert to strings
-      result[key] = value;
-    }
+    var result = _objectSpread(_objectSpread({}, inlineFieldHdrs), stripped);
 
     // Handle inline body key - move data from inline key to body
     if (inlineKeyVal && inlineKeyVal !== "body" && result[inlineKeyVal]) {
@@ -761,9 +736,22 @@ function httpsig_to(tabm) {
       delete result[inlineKeyVal];
     }
 
-    // If there's a body, add content-digest
+    // If the only field is ao-types (no actual data), return empty object
+    // This matches Erlang's behavior where ao-types-only messages become empty
+    var dataKeys = Object.keys(result).filter(function (k) {
+      return k !== "ao-types" && k !== "ao-ids" && k !== "inline-body-key" && k !== "ao-body-key";
+    });
+    if (dataKeys.length === 0) {
+      return {};
+    }
+
+    // If there's a non-empty body, add content-digest
+    // Erlang doesn't add content-digest for empty bodies (<<>>)
     if (result.body) {
-      return addContentDigest(result);
+      var bodyIsEmpty = Buffer.isBuffer(result.body) ? result.body.length === 0 : typeof result.body === "string" && result.body.length === 0;
+      if (!bodyIsEmpty) {
+        return addContentDigest(result);
+      }
     }
     return result;
   }
@@ -773,26 +761,26 @@ function httpsig_to(tabm) {
   var headers = _objectSpread({}, inlineFieldHdrs);
 
   // Process each field - ao-types at top level should go to headers
-  for (var _i11 = 0, _Object$entries1 = Object.entries(stripped); _i11 < _Object$entries1.length; _i11++) {
-    var _Object$entries1$_i = _slicedToArray(_Object$entries1[_i11], 2),
-      _key3 = _Object$entries1$_i[0],
-      _value3 = _Object$entries1$_i[1];
-    if (_key3 === "ao-types") {
+  for (var _i1 = 0, _Object$entries9 = Object.entries(stripped); _i1 < _Object$entries9.length; _i1++) {
+    var _Object$entries9$_i = _slicedToArray(_Object$entries9[_i1], 2),
+      key = _Object$entries9$_i[0],
+      value = _Object$entries9$_i[1];
+    if (key === "ao-types") {
       // Top-level ao-types goes to headers only
       // Keep as Buffer if it's a Buffer, otherwise use as-is
-      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") {
+      headers[key] = value;
+    } else if (key === "body" || key === inlineKeyVal) {
+      bodyMap[key === inlineKeyVal ? inlineKeyVal : "body"] = value;
+    } else if (_typeof(value) === "object" && value !== null && !Array.isArray(value) && !Buffer.isBuffer(value)) {
+      bodyMap[key] = value;
+    } else if (typeof value === "string" && value.length <= MAX_HEADER_LENGTH && key !== "ao-types") {
+      headers[normalizeKey(key)] = value;
+    } else if (Buffer.isBuffer(value) && value.length <= MAX_HEADER_LENGTH && key !== "ao-types") {
       // Keep buffers as buffers for headers
-      headers[normalizeKey(_key3)] = _value3;
-    } else if (_key3 !== "ao-types") {
+      headers[normalizeKey(key)] = value;
+    } else if (key !== "ao-types") {
       // Only add to bodyMap if it's not ao-types
-      bodyMap[_key3] = _value3;
+      bodyMap[key] = value;
     }
   }
 
@@ -821,22 +809,22 @@ function httpsig_to(tabm) {
     try {
       for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
         var _step4$value = _slicedToArray(_step4.value, 2),
-          _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");
+          _key2 = _step4$value[0],
+          _value2 = _step4$value[1];
+        if (_typeof(_value2) === "object" && _value2 !== null && Object.keys(_value2).length === 1 && "body" in _value2) {
+          var encoded = encodeBodyPart("".concat(_key2, "/body"), _value2, "body");
           parts.push({
-            name: "".concat(_key4, "/body"),
+            name: "".concat(_key2, "/body"),
             body: encoded
           });
-          bodyKeysList.push(_key4);
+          bodyKeysList.push(_key2);
         } else {
-          var _encoded = encodeBodyPart(_key4, _value4, inlineKeyVal);
+          var _encoded = encodeBodyPart(_key2, _value2, inlineKeyVal);
           parts.push({
-            name: _key4,
+            name: _key2,
             body: _encoded
           });
-          bodyKeysList.push(_key4);
+          bodyKeysList.push(_key2);
         }
       }
     } catch (err) {
@@ -850,9 +838,7 @@ function httpsig_to(tabm) {
     });
     var finalBody = bodyParts.join(CRLF) + "".concat(CRLF, "--").concat(boundary, "--");
     var _result2 = _objectSpread(_objectSpread({}, headers), {}, {
-      "body-keys": bodyKeysList.map(function (k) {
-        return "\"".concat(k, "\"");
-      }).join(", "),
+      // Note: body-keys is NOT included in httpsig output - it's only used for parsing
       "content-type": "multipart/form-data; boundary=\"".concat(boundary, "\""),
       body: finalBody
     });