wao 0.41.3 → 0.41.5

package/hbsig/dist/cjs/httpsig.js

@@ -0,0 +1,861 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.httpsig_from = httpsig_from;
+exports.httpsig_to = httpsig_to;
+exports.structured_from = structured_from;
+exports.structured_to = structured_to;
+var _fastSha = require("fast-sha256");
+var _flat = require("./flat.js");
+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; }
+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 convert string to Uint8Array
+function stringToBytes(str) {
+  var encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "utf8";
+  if (encoding === "binary") {
+    var bytes = new Uint8Array(str.length);
+    for (var i = 0; i < str.length; i++) {
+      bytes[i] = str.charCodeAt(i) & 0xff;
+    }
+    return bytes;
+  }
+  return new TextEncoder().encode(str);
+}
+
+// Helper to convert bytes to base64url
+function bytesToBase64url(bytes) {
+  var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+  var result = "";
+  for (var i = 0; i < bytes.length; i += 3) {
+    var a = bytes[i];
+    var b = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    var c = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    var combined = a << 16 | b << 8 | c;
+    result += chars[combined >> 18 & 0x3f];
+    result += chars[combined >> 12 & 0x3f];
+    if (i + 1 < bytes.length) result += chars[combined >> 6 & 0x3f];
+    if (i + 2 < bytes.length) result += chars[combined & 0x3f];
+  }
+  return result;
+}
+
+// Helper to convert bytes to base64
+function bytesToBase64(bytes) {
+  var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  var result = "";
+  for (var i = 0; i < bytes.length; i += 3) {
+    var a = bytes[i];
+    var b = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    var c = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    var combined = a << 16 | b << 8 | c;
+    result += chars[combined >> 18 & 0x3f];
+    result += chars[combined >> 12 & 0x3f];
+    result += i + 1 < bytes.length ? chars[combined >> 6 & 0x3f] : "=";
+    result += i + 2 < bytes.length ? chars[combined & 0x3f] : "=";
+  }
+  return result;
+}
+
+// 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 using fast-sha256
+function boundaryFromParts(parts) {
+  var bodyBin = parts.map(function (p) {
+    return p.body;
+  }).join(CRLF);
+  var hashBytes = (0, _fastSha.hash)(stringToBytes(bodyBin, "binary"));
+  return bytesToBase64url(hashBytes);
+}
+
+// Helper to determine inline key - matches Erlang's inline_key/2
+function inlineKey(msg) {
+  // 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 [{
+      "ao-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;
+}
+
+// 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] : "";
+  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)) {
+        // 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;
+      } 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);
+  }
+}
+
+// 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, "\"");
+  if (_typeof(bodyPart) === "object" && bodyPart !== null && !Array.isArray(bodyPart) && !Buffer.isBuffer(bodyPart)) {
+    // 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");
+      }
+      allEntries.push({
+        key: key,
+        line: "".concat(key, ": ").concat(valueStr)
+      });
+    }
+
+    // Add content-disposition
+    allEntries.push({
+      key: "content-disposition",
+      line: "content-disposition: ".concat(disposition)
+    });
+
+    // Sort all entries by key alphabetically - matches Erlang behavior
+    allEntries.sort(function (a, b) {
+      return a.key.localeCompare(b.key);
+    });
+
+    // Build the lines
+    var lines = allEntries.map(function (entry) {
+      return entry.line;
+    });
+
+    // 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)) {
+    // 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 "";
+}
+
+// Helper to detect if a Buffer contains binary data
+function isBinaryData(buf) {
+  // Check first 512 bytes for binary indicators
+  var checkLength = Math.min(buf.length, 512);
+
+  // Any null byte means binary
+  for (var i = 0; i < checkLength; i++) {
+    if (buf[i] === 0) return true;
+  }
+
+  // Count non-text bytes
+  var controlCount = 0;
+  var highByteCount = 0;
+  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++;
+    }
+    // High byte range
+    if (_byte > 127) {
+      highByteCount++;
+    }
+  }
+
+  // If more than 5% are control chars, likely binary
+  if (controlCount / checkLength > 0.05) return true;
+
+  // If more than 20% are high bytes, likely binary
+  if (highByteCount / checkLength > 0.2) return true;
+  return false;
+}
+
+// Parse multipart body - handles binary data in headers
+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, "--");
+
+  // Use binary encoding to preserve all bytes as character codes 0-255
+  var bodyContent = typeof body === "string" ? body : body.toString("binary");
+  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;
+      // First split to find the headers/body boundary (double CRLF)
+      var headerBodySplit = part.indexOf(DOUBLE_CRLF);
+      var headerBlock = void 0,
+        partBody = void 0;
+      if (headerBodySplit !== -1) {
+        headerBlock = part.substring(0, headerBodySplit);
+        partBody = part.substring(headerBodySplit + DOUBLE_CRLF.length);
+        // Remove trailing CRLF from body
+        partBody = partBody.replace(/\r?\n?$/, "");
+      } else {
+        headerBlock = part;
+        partBody = "";
+      }
+      var headers = {};
+
+      // Parse headers more carefully to handle binary data
+      var currentPos = 0;
+      while (currentPos < headerBlock.length) {
+        // Find the next colon to identify a potential header
+        var colonPos = headerBlock.indexOf(": ", currentPos);
+        if (colonPos === -1) {
+          // No more headers
+          break;
+        }
+
+        // Look backwards from colon to find the start of this line
+        var lineStart = currentPos;
+        var searchBack = colonPos - 1;
+        while (searchBack >= currentPos) {
+          if (headerBlock[searchBack] === "\n") {
+            lineStart = searchBack + 1;
+            break;
+          }
+          searchBack--;
+        }
+
+        // Extract the header name
+        var name = headerBlock.substring(lineStart, colonPos).trim().toLowerCase();
+
+        // Check if this looks like a valid header name
+        if (!/^[a-zA-Z0-9-]+$/.test(name) || name.length > 50) {
+          // Not a valid header, skip past this colon
+          currentPos = colonPos + 2;
+          continue;
+        }
+
+        // Start of value is after ": "
+        var valueStart = colonPos + 2;
+
+        // Find the end of this header's value by looking for the next valid header
+        var valueEnd = headerBlock.length;
+        var searchPos = valueStart;
+        while (searchPos < headerBlock.length) {
+          var nextNewline = headerBlock.indexOf("\n", searchPos);
+          if (nextNewline === -1) break;
+          var nextLineStart = nextNewline + 1;
+          if (nextLineStart >= headerBlock.length) break;
+
+          // Check if next line starts with a header pattern
+          var nextColon = headerBlock.indexOf(": ", nextLineStart);
+          if (nextColon > nextLineStart && nextColon < nextLineStart + 50) {
+            var possibleHeaderName = headerBlock.substring(nextLineStart, nextColon).trim();
+
+            // Must be valid header name format
+            if (/^[a-zA-Z0-9-]+$/.test(possibleHeaderName)) {
+              valueEnd = nextNewline;
+              break;
+            }
+          }
+          searchPos = nextNewline + 1;
+        }
+
+        // Extract the value - valueEnd points to \n which is NOT part of the value
+        var value = headerBlock.substring(valueStart, valueEnd);
+
+        // Determine if this is binary data FIRST (before trimming)
+        var isBinary = value.length > 0 && isBinaryData(Buffer.from(value, "binary"));
+        if (isBinary) {
+          // Binary data: only remove trailing \r if it's part of CRLF separator
+          // (when valueEnd points to \n and value ends with \r)
+          if (valueEnd < headerBlock.length && headerBlock[valueEnd] === "\n" && value.endsWith("\r")) {
+            value = value.substring(0, value.length - 1);
+          }
+          headers[name] = Buffer.from(value, "binary");
+        } else {
+          // Text data: remove all trailing CRLF/LF (these are line separators, not data)
+          value = value.replace(/[\r\n]+$/, "");
+          headers[name] = value;
+        }
+
+        // Move to the end of this header's value
+        currentPos = valueEnd;
+        if (currentPos < headerBlock.length && headerBlock[currentPos] === "\n") {
+          currentPos++;
+        }
+        if (currentPos < headerBlock.length && headerBlock[currentPos] === "\r") {
+          currentPos++;
+        }
+      }
+      var disposition = headers["content-disposition"];
+      if (!disposition) continue;
+      var partName = void 0;
+      if (disposition === "inline") {
+        // This is the inline part
+        partName = "body";
+        bodyKeysList.push("body");
+
+        // Extract all headers from inline part as top-level fields
+        var restHeaders = _objectSpread({}, headers);
+        delete restHeaders["content-disposition"];
+
+        // Add each header from the inline part to the top level of result
+        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'
+        if (partBody) {
+          // Keep as string unless it's binary data
+          result[partName] = isBinaryData(Buffer.from(partBody, "binary")) ? Buffer.from(partBody, "binary") : partBody;
+        }
+      } else {
+        // Handle named form-data parts
+        var nameMatch = disposition.match(/name="([^"]+)"/);
+        partName = nameMatch ? nameMatch[1] : null;
+        if (partName) {
+          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) {
+          // Keep as string unless it's binary data
+          result[partName] = isBinaryData(Buffer.from(partBody, "binary")) ? Buffer.from(partBody, "binary") : partBody;
+        } else if (!partBody) {
+          // ao-types should stay with this part, not be extracted
+          result[partName] = _restHeaders;
+        } else {
+          // Keep as string unless it's binary data
+          result[partName] = _objectSpread(_objectSpread({}, _restHeaders), {}, {
+            body: isBinaryData(Buffer.from(partBody, "binary")) ? Buffer.from(partBody, "binary") : partBody
+          });
+        }
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  if (bodyKeysList.length > 0) {
+    result["body-keys"] = bodyKeysList.map(function (k) {
+      return "\"".concat(k, "\"");
+    }).join(", ");
+  }
+  return result;
+}
+
+// Add content-digest header using fast-sha256
+function addContentDigest(msg) {
+  if (!msg.body) return msg;
+  var bodyBytes;
+  // Handle both string and Buffer bodies
+  if (Buffer.isBuffer(msg.body)) {
+    bodyBytes = new Uint8Array(msg.body);
+  } else {
+    // For strings, use binary encoding to match how the multipart body is encoded
+    bodyBytes = stringToBytes(msg.body, "binary");
+  }
+  var hashBytes = (0, _fastSha.hash)(bodyBytes);
+  var digest = bytesToBase64(hashBytes);
+  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 = {};
+    var nonFlat = {};
+    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 {
+        nonFlat[key] = value;
+      }
+    }
+    if (Object.keys(flat).length > 0) {
+      // Merge non-flat keys into flat for processing
+      // This ensures flat_from can see existing objects like results: { "ao-types": "..." }
+      var combined = _objectSpread(_objectSpread({}, nonFlat), flat);
+
+      // Use flat_from to convert flat structure to nested
+      var nested = (0, _flat.flat_from)(combined);
+
+      // The nested result already has everything merged
+      withBodyKeys = nested;
+    }
+  } 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 _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;
+}
+
+/**
+ * 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(bundledTabm);
+
+  // 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), 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) {
+    // 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
+    var result = _objectSpread(_objectSpread({}, inlineFieldHdrs), stripped);
+
+    // 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 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) {
+      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;
+  }
+
+  // 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 _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[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(key)] = value;
+    } else if (key !== "ao-types") {
+      // Only add to bodyMap if it's not ao-types
+      bodyMap[key] = value;
+    }
+  }
+
+  // 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 _iterator4 = _createForOfIteratorHelper(sortedEntries),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var _step4$value = _slicedToArray(_step4.value, 2),
+          _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(_key2, "/body"),
+            body: encoded
+          });
+          bodyKeysList.push(_key2);
+        } else {
+          var _encoded = encodeBodyPart(_key2, _value2, inlineKeyVal);
+          parts.push({
+            name: _key2,
+            body: _encoded
+          });
+          bodyKeysList.push(_key2);
+        }
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.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), {}, {
+      // 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
+    });
+    return addContentDigest(_result2);
+  }
+}
+
+/**
+ * Convert structured message to flat format
+ */
+function structured_to(msg) {
+  return msg;
+}
+
+/**
+ * Convert flat format to structured message
+ */
+function structured_from(msg) {
+  return msg;
+}