hbsig 0.0.1

package/cjs/httpsig.js

@@ -0,0 +1,716 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.httpsig_from = httpsig_from;
+exports.httpsig_to = httpsig_to;
+var _crypto = _interopRequireDefault(require("crypto"));
+var _flat = require("./flat.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _toArray(r) { return _arrayWithHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableRest(); }
+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); }
+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; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; } // httpsig.js - JavaScript implementation of HTTP Signature codec
+var CRLF = "\r\n";
+var DOUBLE_CRLF = CRLF + CRLF;
+var MAX_HEADER_LENGTH = 4096;
+
+// Helper to normalize keys (lowercase only, no underscore conversion)
+function normalizeKey(key) {
+  if (typeof key === "string") {
+    return key.toLowerCase();
+  }
+  return String(key).toLowerCase();
+}
+
+// Helper to check if a value is an ID (43 character base64url string)
+function isId(value) {
+  return typeof value === "string" && value.length === 43 && /^[A-Za-z0-9_-]+$/.test(value);
+}
+
+// Helper to encode structured field dictionary
+function encodeSfDict(dict) {
+  var items = [];
+  for (var _i = 0, _Object$entries = Object.entries(dict); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      value = _Object$entries$_i[1];
+    if (typeof value === "string") {
+      items.push("".concat(key, "=\"").concat(value, "\""));
+    } else {
+      items.push("".concat(key, "=").concat(value));
+    }
+  }
+  return items.join(", ");
+}
+
+// Helper to parse structured field dictionary
+function parseSfDict(str) {
+  var dict = {};
+  if (!str) return dict;
+  var parts = str.split(/,\s*/);
+  var _iterator = _createForOfIteratorHelper(parts),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var part = _step.value;
+      var match = part.match(/^([^=]+)=(.+)$/);
+      if (match) {
+        var key = match[1].trim();
+        var value = match[2].trim();
+        if (value.startsWith('"') && value.endsWith('"')) {
+          value = value.slice(1, -1);
+        }
+        dict[key] = value;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return dict;
+}
+
+// Helper to generate boundary from parts
+function boundaryFromParts(parts) {
+  var bodyBin = parts.map(function (p) {
+    return p.body;
+  }).join(CRLF);
+  var hash = _crypto["default"].createHash("sha256");
+  hash.update(bodyBin);
+  return hash.digest("base64url");
+}
+
+// Helper to determine inline key
+function inlineKey(msg) {
+  var inlineBodyKey = msg["inline-body-key"];
+  if (inlineBodyKey) {
+    return [{}, inlineBodyKey];
+  }
+  if ("body" in msg) {
+    return [{}, "body"];
+  }
+  if ("data" in msg) {
+    return [{
+      "inline-body-key": "data"
+    }, "data"];
+  }
+  return [{}, "body"];
+}
+
+// Group IDs into ao-ids field
+function groupIds(map) {
+  var idDict = {};
+  var stripped = {};
+  for (var _i2 = 0, _Object$entries2 = Object.entries(map); _i2 < _Object$entries2.length; _i2++) {
+    var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+      key = _Object$entries2$_i[0],
+      value = _Object$entries2$_i[1];
+    if (isId(key) && typeof value === "string") {
+      // Store with lowercase key as in Erlang
+      idDict[key.toLowerCase()] = value;
+    } else {
+      stripped[key] = value;
+    }
+  }
+  if (Object.keys(idDict).length > 0) {
+    var items = [];
+    for (var _i3 = 0, _Object$entries3 = Object.entries(idDict); _i3 < _Object$entries3.length; _i3++) {
+      var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
+        k = _Object$entries3$_i[0],
+        v = _Object$entries3$_i[1];
+      items.push("".concat(k, "=\"").concat(v, "\""));
+    }
+    stripped["ao-ids"] = items.join(", ");
+  }
+
+  // Return IDs as lowercase in the result since they will be normalized
+  // when processed as headers
+  for (var _i4 = 0, _Object$entries4 = Object.entries(idDict); _i4 < _Object$entries4.length; _i4++) {
+    var _Object$entries4$_i = _slicedToArray(_Object$entries4[_i4], 2),
+      _k = _Object$entries4$_i[0],
+      _v = _Object$entries4$_i[1];
+    stripped[_k] = _v;
+  }
+  return stripped;
+}
+
+// Ungroup IDs from ao-ids field
+function ungroupIds(msg) {
+  if (!msg["ao-ids"]) return msg;
+  var result = _objectSpread({}, msg);
+  delete result["ao-ids"];
+  var dict = parseSfDict(msg["ao-ids"]);
+  for (var _i5 = 0, _Object$entries5 = Object.entries(dict); _i5 < _Object$entries5.length; _i5++) {
+    var _Object$entries5$_i = _slicedToArray(_Object$entries5[_i5], 2),
+      key = _Object$entries5$_i[0],
+      value = _Object$entries5$_i[1];
+    // ao-ids keys are lowercase, use them as-is
+    result[key] = value;
+  }
+  return result;
+}
+
+// Group maps for body encoding - following Erlang logic exactly
+function groupMaps(map) {
+  var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+  var top = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (_typeof(map) !== "object" || map === null || Array.isArray(map) || Buffer.isBuffer(map)) {
+    return top;
+  }
+  var flattened = {};
+  var newTop = _objectSpread({}, top);
+
+  // Process entries in sorted order for consistency
+  var entries = Object.entries(map).sort(function (_ref, _ref2) {
+    var _ref3 = _slicedToArray(_ref, 1),
+      a = _ref3[0];
+    var _ref4 = _slicedToArray(_ref2, 1),
+      b = _ref4[0];
+    return a.localeCompare(b);
+  });
+  var _iterator2 = _createForOfIteratorHelper(entries),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _step2$value = _slicedToArray(_step2.value, 2),
+        key = _step2$value[0],
+        value = _step2$value[1];
+      // Normalize keys to lowercase
+      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);
+      } else if (typeof value === "string" && value.length > MAX_HEADER_LENGTH) {
+        // Value too large for header, lift to top level
+        newTop[flatK] = value;
+      } else if (Buffer.isBuffer(value) && value.length > MAX_HEADER_LENGTH) {
+        // Large buffers also get lifted to top level
+        newTop[flatK] = value;
+      } else {
+        // Keep in current flattened map
+        flattened[normKey] = value;
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  if (Object.keys(flattened).length === 0) {
+    return newTop;
+  } else if (parent) {
+    // Add flattened map under parent key
+    return _objectSpread(_objectSpread({}, newTop), {}, _defineProperty({}, parent, flattened));
+  } else {
+    // Merge flattened with top level
+    return _objectSpread(_objectSpread({}, newTop), flattened);
+  }
+}
+
+// Encode multipart body part
+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") {
+          allEntries.push({
+            key: "ao-types",
+            line: "ao-types: ".concat(value)
+          });
+        } 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)
+          });
+        }
+      }
+
+      // Add content-disposition
+      allEntries.push({
+        key: "content-disposition",
+        line: "content-disposition: ".concat(disposition)
+      });
+
+      // Sort alphabetically by key
+      allEntries.sort(function (a, b) {
+        return a.key.localeCompare(b.key);
+      });
+
+      // 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);
+    } 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 _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)
+        });
+      }
+      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;
+        })));
+      }
+
+      // Body handling
+      var _body = bodyPart.body || "";
+      if (_body) {
+        _lines.push(""); // Always add empty line before body
+        _lines.push(_body);
+      }
+      return _lines.join(CRLF);
+    }
+  } else if (typeof bodyPart === "string" || Buffer.isBuffer(bodyPart)) {
+    return "content-disposition: ".concat(disposition).concat(DOUBLE_CRLF).concat(bodyPart);
+  }
+  return "";
+}
+
+// Parse multipart body
+function parseMultipart(contentType, body) {
+  var boundaryMatch = contentType.match(/boundary="?([^";\s]+)"?/);
+  if (!boundaryMatch) return {};
+  var boundary = boundaryMatch[1];
+  var boundaryDelim = "--".concat(boundary);
+  var endBoundary = "--".concat(boundary, "--");
+
+  // Remove the final boundary terminator if present
+  var bodyContent = body;
+  if (bodyContent.endsWith(endBoundary)) {
+    bodyContent = bodyContent.substring(0, bodyContent.lastIndexOf(endBoundary));
+  }
+  var parts = bodyContent.split(new RegExp("\\r?\\n?".concat(boundaryDelim, "\\r?\\n"))).filter(function (p) {
+    return p && p.trim() && !p.startsWith("--");
+  });
+  var result = {};
+  var bodyKeysList = [];
+  var _iterator3 = _createForOfIteratorHelper(parts),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var part = _step3.value;
+      var _part$split = part.split(DOUBLE_CRLF),
+        _part$split2 = _toArray(_part$split),
+        headerBlock = _part$split2[0],
+        bodyParts = _part$split2.slice(1);
+      var partBody = bodyParts.join(DOUBLE_CRLF);
+
+      // Remove trailing CRLF
+      partBody = partBody.replace(/\r?\n?$/, "");
+      var headers = {};
+      var headerLines = headerBlock.split(/\r?\n/);
+      var _iterator4 = _createForOfIteratorHelper(headerLines),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var line = _step4.value;
+          var colonIndex = line.indexOf(": ");
+          if (colonIndex > 0) {
+            var name = line.substring(0, colonIndex).toLowerCase();
+            var value = line.substring(colonIndex + 2);
+            headers[name] = value;
+          }
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+      var disposition = headers["content-disposition"];
+      if (!disposition) continue;
+      var partName = void 0;
+      if (disposition === "inline") {
+        partName = "body";
+        bodyKeysList.push("body");
+      } else {
+        var nameMatch = disposition.match(/name="([^"]+)"/);
+        partName = nameMatch ? nameMatch[1] : null;
+        if (partName) {
+          // Add the top-level key for this part
+          var topLevelKey = partName.split("/")[0];
+          bodyKeysList.push(topLevelKey);
+        }
+      }
+      if (!partName) continue;
+      var restHeaders = _objectSpread({}, headers);
+      delete restHeaders["content-disposition"];
+      if (Object.keys(restHeaders).length === 0) {
+        result[partName] = partBody;
+      } else if (!partBody) {
+        result[partName] = restHeaders;
+      } else {
+        result[partName] = _objectSpread(_objectSpread({}, restHeaders), {}, {
+          body: partBody
+        });
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  if (bodyKeysList.length > 0) {
+    // Format as structured field list, preserving order and duplicates
+    result["body-keys"] = bodyKeysList.map(function (k) {
+      return "\"".concat(k, "\"");
+    }).join(", ");
+  }
+  return result;
+}
+
+// Add content-digest header
+function addContentDigest(msg) {
+  if (!msg.body) return msg;
+  var hash = _crypto["default"].createHash("sha256");
+
+  // Handle both string and Buffer bodies
+  if (Buffer.isBuffer(msg.body)) {
+    hash.update(msg.body);
+  } else {
+    // For strings, use binary encoding to match how the multipart body is encoded
+    hash.update(msg.body, "binary");
+  }
+  var digest = hash.digest("base64");
+  return _objectSpread(_objectSpread({}, msg), {}, {
+    "content-digest": "sha-256=:".concat(digest, ":")
+  });
+}
+
+/**
+ * Convert HTTP message to TABM
+ */
+function httpsig_from(http) {
+  if (typeof http === "string") return http;
+  var body = http.body || "";
+  var _inlineKey = inlineKey(http),
+    _inlineKey2 = _slicedToArray(_inlineKey, 2),
+    inlinedFieldHdrs = _inlineKey2[0],
+    inlinedKey = _inlineKey2[1];
+  var headers = _objectSpread({}, http);
+  delete headers.body;
+  delete headers["body-keys"];
+  var contentType = headers["content-type"];
+  var withBodyKeys = headers;
+
+  // Parse multipart body if present
+  if (body && contentType && contentType.includes("multipart")) {
+    var parsed = parseMultipart(contentType, body);
+
+    // Handle the body-keys from the original HTTP message
+    if (http["body-keys"]) {
+      // Parse the existing body-keys and ensure they're in quoted format
+      var bodyKeys = http["body-keys"];
+      if (typeof bodyKeys === "string") {
+        if (!bodyKeys.includes('"')) {
+          // Convert unquoted format to quoted format
+          parsed["body-keys"] = bodyKeys.split(/,\s*/).map(function (k) {
+            return "\"".concat(k.trim(), "\"");
+          }).join(", ");
+        } else {
+          // Already quoted, use as-is
+          parsed["body-keys"] = bodyKeys;
+        }
+      }
+    }
+    withBodyKeys = _objectSpread(_objectSpread({}, headers), parsed);
+
+    // Convert flat structure to nested using flat.js
+    var flat = {};
+    for (var _i8 = 0, _Object$entries8 = Object.entries(withBodyKeys); _i8 < _Object$entries8.length; _i8++) {
+      var _Object$entries8$_i = _slicedToArray(_Object$entries8[_i8], 2),
+        key = _Object$entries8$_i[0],
+        value = _Object$entries8$_i[1];
+      if (key.includes("/")) {
+        flat[key] = value;
+      }
+    }
+    if (Object.keys(flat).length > 0) {
+      // Use flat_from to convert flat structure to nested
+      var nested = (0, _flat.flat_from)(flat);
+      for (var _i9 = 0, _Object$entries9 = Object.entries(nested); _i9 < _Object$entries9.length; _i9++) {
+        var _Object$entries9$_i = _slicedToArray(_Object$entries9[_i9], 2),
+          _key2 = _Object$entries9$_i[0],
+          _value2 = _Object$entries9$_i[1];
+        withBodyKeys[_key2] = _value2;
+      }
+      for (var _i0 = 0, _Object$keys = Object.keys(flat); _i0 < _Object$keys.length; _i0++) {
+        var _key3 = _Object$keys[_i0];
+        delete withBodyKeys[_key3];
+      }
+    }
+  } else if (body) {
+    withBodyKeys[inlinedKey] = body;
+  }
+
+  // Ungroup IDs
+  var withIds = ungroupIds(withBodyKeys);
+
+  // Remove signature-related headers and content-digest
+  var result = _objectSpread({}, withIds);
+  delete result.signature;
+  delete result["signature-input"];
+  delete result.commitments;
+  delete result["content-digest"];
+
+  // Extract hashpaths if any
+  for (var _i1 = 0, _Object$keys2 = Object.keys(result); _i1 < _Object$keys2.length; _i1++) {
+    var _key4 = _Object$keys2[_i1];
+    if (_key4.startsWith("hashpath")) {
+      delete result[_key4];
+    }
+  }
+  return result;
+}
+
+/**
+ * Convert TABM to HTTP message
+ */
+function httpsig_to(tabm) {
+  if (typeof tabm === "string") return tabm;
+
+  // Group IDs
+  var withGroupedIds = groupIds(tabm);
+
+  // Remove private and signature-related keys
+  var stripped = _objectSpread({}, withGroupedIds);
+  delete stripped.commitments;
+  delete stripped.signature;
+  delete stripped["signature-input"];
+  delete stripped.priv;
+  var _inlineKey3 = inlineKey(tabm),
+    _inlineKey4 = _slicedToArray(_inlineKey3, 2),
+    inlineFieldHdrs = _inlineKey4[0],
+    inlineKeyVal = _inlineKey4[1];
+
+  // Check if this is a flat structure that should stay as headers
+  // A flat structure has no nested objects (maps)
+  var hasNestedMaps = Object.values(stripped).some(function (value) {
+    return _typeof(value) === "object" && value !== null && !Array.isArray(value) && !Buffer.isBuffer(value);
+  });
+
+  // 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];
+      // Convert Buffers to strings if they're UTF-8 text
+      if (Buffer.isBuffer(value)) {
+        try {
+          var str = value.toString("utf8");
+          // Check if it's valid UTF-8 that can be safely converted
+          if (Buffer.from(str, "utf8").equals(value)) {
+            // Check if all characters are printable
+            var isPrintable = true;
+            for (var i = 0; i < str.length; i++) {
+              var code = str.charCodeAt(i);
+              if (!(code >= 32 && code <= 126) && code !== 9 && code !== 10 && code !== 13) {
+                isPrintable = false;
+                break;
+              }
+            }
+            if (isPrintable) {
+              result[key] = str;
+            } else {
+              result[key] = value;
+            }
+          } else {
+            result[key] = value;
+          }
+        } catch (e) {
+          result[key] = value;
+        }
+      } else {
+        result[key] = value;
+      }
+    }
+
+    // Handle inline body key - move data from inline key to body
+    if (inlineKeyVal && inlineKeyVal !== "body" && result[inlineKeyVal]) {
+      result.body = result[inlineKeyVal];
+      delete result[inlineKeyVal];
+    }
+
+    // If there's a body, add content-digest
+    if (result.body) {
+      return addContentDigest(result);
+    }
+    return result;
+  }
+
+  // Original multipart logic for nested structures
+  var bodyMap = {};
+  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),
+      _key5 = _Object$entries1$_i[0],
+      _value3 = _Object$entries1$_i[1];
+    if (_key5 === "ao-types") {
+      // Top-level ao-types goes to headers only
+      // Convert Buffer to string if needed
+      if (Buffer.isBuffer(_value3)) {
+        headers[_key5] = _value3.toString("utf8");
+      } else {
+        headers[_key5] = _value3;
+      }
+    } else if (_key5 === "body" || _key5 === inlineKeyVal) {
+      bodyMap[_key5 === inlineKeyVal ? inlineKeyVal : "body"] = _value3;
+    } else if (_typeof(_value3) === "object" && _value3 !== null && !Array.isArray(_value3) && !Buffer.isBuffer(_value3)) {
+      bodyMap[_key5] = _value3;
+    } else if (typeof _value3 === "string" && _value3.length <= MAX_HEADER_LENGTH && _key5 !== "ao-types") {
+      headers[normalizeKey(_key5)] = _value3;
+    } else if (Buffer.isBuffer(_value3) && _value3.length <= MAX_HEADER_LENGTH && _key5 !== "ao-types") {
+      // Convert Buffers to strings for headers
+      var _str = _value3.toString("utf8");
+      headers[normalizeKey(_key5)] = _str;
+    } else if (_key5 !== "ao-types") {
+      // Only add to bodyMap if it's not ao-types
+      bodyMap[_key5] = _value3;
+    }
+  }
+
+  // Handle body encoding
+  var groupedBodyMap = groupMaps(bodyMap);
+  if (Object.keys(groupedBodyMap).length === 0) {
+    return headers;
+  } else if (Object.keys(groupedBodyMap).length === 1 && groupedBodyMap[inlineKeyVal] && typeof groupedBodyMap[inlineKeyVal] === "string") {
+    var _result = _objectSpread(_objectSpread({}, headers), {}, {
+      body: groupedBodyMap[inlineKeyVal]
+    });
+    return addContentDigest(_result);
+  } else {
+    // Multipart body
+    var parts = [];
+    var bodyKeysList = [];
+    var sortedEntries = Object.entries(groupedBodyMap).sort(function (_ref5, _ref6) {
+      var _ref7 = _slicedToArray(_ref5, 1),
+        a = _ref7[0];
+      var _ref8 = _slicedToArray(_ref6, 1),
+        b = _ref8[0];
+      return a.localeCompare(b);
+    });
+    var _iterator5 = _createForOfIteratorHelper(sortedEntries),
+      _step5;
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        var _step5$value = _slicedToArray(_step5.value, 2),
+          _key6 = _step5$value[0],
+          _value4 = _step5$value[1];
+        if (_typeof(_value4) === "object" && _value4 !== null && Object.keys(_value4).length === 1 && "body" in _value4) {
+          var encoded = encodeBodyPart("".concat(_key6, "/body"), _value4, "body");
+          parts.push({
+            name: "".concat(_key6, "/body"),
+            body: encoded
+          });
+          bodyKeysList.push(_key6);
+        } else {
+          var _encoded = encodeBodyPart(_key6, _value4, inlineKeyVal);
+          parts.push({
+            name: _key6,
+            body: _encoded
+          });
+          bodyKeysList.push(_key6);
+        }
+      }
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
+    }
+    var boundary = boundaryFromParts(parts);
+    var bodyParts = parts.map(function (p) {
+      return "--".concat(boundary).concat(CRLF).concat(p.body);
+    });
+    var finalBody = bodyParts.join(CRLF) + "".concat(CRLF, "--").concat(boundary, "--");
+    var _result2 = _objectSpread(_objectSpread({}, headers), {}, {
+      "body-keys": bodyKeysList.map(function (k) {
+        return "\"".concat(k, "\"");
+      }).join(", "),
+      "content-type": "multipart/form-data; boundary=\"".concat(boundary, "\""),
+      body: finalBody
+    });
+    return addContentDigest(_result2);
+  }
+}