wao 0.24.2 → 0.25.0

package/cjs/signer.js

@@ -4,9 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createRequest = createRequest;
-exports.extractPublicKeyFromHeaders = extractPublicKeyFromHeaders;
+exports.hbEncodeValue = hbEncodeValue;
 exports.send = send;
-exports.verify = verify;
 var _base64url = _interopRequireDefault(require("base64url"));
 var _crypto = _interopRequireDefault(require("crypto"));
 var _httpMessageSignatures = require("http-message-signatures");
@@ -26,7 +25,6 @@ function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLim
 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 _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; }
-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 asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
 function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
 function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
@@ -35,27 +33,63 @@ function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r)
 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 _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 _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); }
 var verifyMessage = _httpMessageSignatures.httpbis.verifyMessage;
 var augmentHeaders = _httpMessageSignatures.httpbis.augmentHeaders,
   createSignatureBase = _httpMessageSignatures.httpbis.createSignatureBase,
   createSigningParameters = _httpMessageSignatures.httpbis.createSigningParameters,
   formatSignatureBase = _httpMessageSignatures.httpbis.formatSignatureBase;
-
-/**
- * Convert value to Buffer
- */
+function hbEncodeValue(value) {
+  if (isBytes(value)) {
+    if (value.byteLength === 0) return hbEncodeValue("");
+    return [undefined, value];
+  }
+  if (typeof value === "string") {
+    if (value.length === 0) return ["empty-binary", undefined];
+    return [undefined, value];
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) return ["empty-list", undefined];
+    if (value.some(isPojo)) {
+      throw new Error("Array with objects should have been lifted: ".concat(JSON.stringify(value)));
+    }
+    var encoded = value.map(function (v) {
+      if (typeof v === "string") {
+        if (v === "") return "\"(ao-type-empty-binary) \"";
+        var escaped = v.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+        return "\"".concat(escaped, "\"");
+      } else if (typeof v === "number") return String(v);else if (typeof v === "boolean") return v ? "?1" : "?0";else if (_typeof(v) === "symbol") {
+        var desc = v.description || "symbol";
+        var _escaped = desc.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+        return "\"(ao-type-atom) ".concat(_escaped, "\"");
+      } else if (v === null) return "\"(ao-type-atom) null\"";else if (v === undefined) return "\"(ao-type-atom) undefined\"";else if (Array.isArray(v) && v.length === 0) {
+        return "\"(ao-type-empty-list) \"";
+      }
+      return "\"".concat(String(v), "\"");
+    }).join(", ");
+    return ["list", encoded];
+  }
+  if (typeof value === "number") {
+    if (!Number.isInteger(value)) return ["float", "".concat(value)];
+    return ["integer", String(value)];
+  }
+  if (typeof value === "boolean") {
+    return ["atom", "\"".concat(value ? "true" : "false", "\"")];
+  }
+  if (_typeof(value) === "symbol") {
+    var desc = value.description || "symbol";
+    return ["atom", "\"".concat(desc, "\"")];
+  }
+  if (value === null) return ["atom", "\"null\""];
+  if (value === undefined) return ["atom", "\"undefined\""];
+  throw new Error("Cannot encode value: ".concat(String(value)));
+}
 var toView = function toView(value) {
   if (ArrayBuffer.isView(value)) {
     return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
-  } else if (typeof value === "string") {
-    return _base64url["default"].toBuffer(value);
-  }
+  } else if (typeof value === "string") return _base64url["default"].toBuffer(value);
   throw new Error("Value must be Uint8Array, ArrayBuffer, or base64url-encoded string");
 };
-
-/**
- * Generate HTTP signature name from address
- */
 var httpSigName = function httpSigName(address) {
   var decoded = _base64url["default"].toBuffer(address);
   var hexString = _toConsumableArray(decoded.subarray(1, 9)).map(function (_byte) {
@@ -63,26 +97,23 @@ var httpSigName = function httpSigName(address) {
   }).join("");
   return "http-sig-".concat(hexString);
 };
-
-/**
- * Join URL parts
- */
 var joinUrl = function joinUrl(_ref) {
   var url = _ref.url,
     path = _ref.path;
-  // If path is already a full URL, return it as-is
   if (path.startsWith("http://") || path.startsWith("https://")) {
     return path;
   }
-
-  // Otherwise, join the base URL with the path
   return url.endsWith("/") ? url.slice(0, -1) + path : url + path;
 };
-
-/**
- * HyperBEAM Encoding Logic
- */
 var MAX_HEADER_LENGTH = 4096;
+function encode_body_keys(bodyKeys) {
+  if (!bodyKeys || bodyKeys.length === 0) return "";
+  var items = bodyKeys.map(function (key) {
+    return "\"".concat(key, "\"");
+  });
+  var result = items.join(", ");
+  return result;
+}
 function hasNewline(_x) {
   return _hasNewline.apply(this, arguments);
 }
@@ -145,43 +176,6 @@ function isBytes(value) {
 function isPojo(value) {
   return !isBytes(value) && !Array.isArray(value) && !(value instanceof Blob) && _typeof(value) === "object" && value !== null;
 }
-function hbEncodeValue(value) {
-  if (isBytes(value)) {
-    if (value.byteLength === 0) return hbEncodeValue("");
-    return [undefined, value];
-  }
-  if (typeof value === "string") {
-    if (value.length === 0) return [undefined, "empty-binary"];
-    return [undefined, value];
-  }
-  if (Array.isArray(value)) {
-    if (value.length === 0) return ["empty-list", undefined];
-    // For structured fields, just join the string values
-    var encoded = value.map(function (v) {
-      if (typeof v === "string") {
-        // Escape quotes and backslashes
-        var escaped = v.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-        return "\"".concat(escaped, "\"");
-      } else if (typeof v === "number") {
-        // Numbers should be encoded as bare items, not strings
-        return String(v);
-      } else if (typeof v === "boolean") {
-        // Booleans as structured field tokens
-        return v ? "?1" : "?0";
-      }
-      return "\"".concat(String(v), "\"");
-    }).join(", ");
-    return ["list", encoded];
-  }
-  if (typeof value === "number") {
-    if (!Number.isInteger(value)) return ["float", "".concat(value)];
-    return ["integer", String(value)];
-  }
-  if (_typeof(value) === "symbol") {
-    return ["atom", value.description];
-  }
-  throw new Error("Cannot encode value: ".concat(value.toString()));
-}
 function hbEncodeLift(obj) {
   var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
   var top = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
@@ -189,122 +183,159 @@ function hbEncodeLift(obj) {
       var _ref3 = _slicedToArray(_ref2, 2),
         key = _ref3[0],
         value = _ref3[1];
-      // For nested paths, preserve casing. For top-level, also preserve casing
       var storageKey = parent ? "".concat(parent, "/").concat(key) : key;
-
-      // skip nullish values
-      if (value == null) return acc;
-
-      // list of objects
-      if (Array.isArray(value) && value.some(isPojo)) {
-        value = value.reduce(function (indexedObj, v, idx) {
-          return Object.assign(indexedObj, _defineProperty({}, idx, v));
-        }, {});
+      if (value == null) {
+        var _hbEncodeValue = hbEncodeValue(value),
+          _hbEncodeValue2 = _slicedToArray(_hbEncodeValue, 2),
+          _type = _hbEncodeValue2[0],
+          _encoded = _hbEncodeValue2[1];
+        if (_encoded !== undefined) acc[0][key] = _encoded;
+        if (_type) acc[1][key.toLowerCase()] = _type;
+        return acc;
+      }
+      if (Array.isArray(value)) {
+        var hasObjects = value.some(isPojo);
+        var hasBinary = value.some(isBytes);
+        if (hasObjects || hasBinary) {
+          var indexedObj = value.reduce(function (obj, v, idx) {
+            return Object.assign(obj, _defineProperty({}, idx, v));
+          }, {});
+          acc[1][key.toLowerCase()] = "list";
+          hbEncodeLift(indexedObj, storageKey, top);
+          return acc;
+        } else {
+          var _hbEncodeValue3 = hbEncodeValue(value),
+            _hbEncodeValue4 = _slicedToArray(_hbEncodeValue3, 2),
+            _type2 = _hbEncodeValue4[0],
+            _encoded2 = _hbEncodeValue4[1];
+          if (_type2) acc[1][key.toLowerCase()] = _type2;
+          if (_encoded2 !== undefined) acc[0][key] = _encoded2;
+          return acc;
+        }
       }
-
-      // Store the original value for reference
       var originalValue = value;
-
-      // first/second lift object - handle nested objects
       if (isPojo(value)) {
-        // Check if this object has any nested objects or arrays with objects
+        if (Object.keys(value).length === 0) {
+          acc[1][key.toLowerCase()] = "empty-message";
+          return acc;
+        }
         var hasComplexValues = Object.values(value).some(function (v) {
           return isPojo(v) || Array.isArray(v) && v.some(function (item) {
             return isPojo(item);
           });
         });
         if (!hasComplexValues) {
-          // Simple flat object - can be encoded as structured field dictionary
           var items = [];
+          var hasAnyNonEmptyValues = Object.values(value).some(function (v) {
+            return !(v === null || v === undefined || v === "" || Array.isArray(v) && v.length === 0 || isPojo(v) && Object.keys(v).length === 0);
+          });
           Object.entries(value).forEach(function (_ref4) {
             var _ref5 = _slicedToArray(_ref4, 2),
               k = _ref5[0],
               v = _ref5[1];
             var subKey = k.toLowerCase();
-            if (typeof v === "string") {
-              var escaped = v.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-              items.push("".concat(subKey, "=\"").concat(escaped, "\""));
+            if (v === null) {
+              items.push("".concat(subKey, "=\"null\""));
+              acc[1]["".concat(key.toLowerCase(), "%2f").concat(subKey)] = "atom";
+            } else if (v === undefined) {
+              items.push("".concat(subKey, "=\"undefined\""));
+              acc[1]["".concat(key.toLowerCase(), "%2f").concat(subKey)] = "atom";
+            } else if (typeof v === "string") {
+              if (v === "") {
+                acc[1]["".concat(key.toLowerCase(), "%2f").concat(subKey)] = "empty-binary";
+              } else {
+                var escaped = v.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+                items.push("".concat(subKey, "=\"").concat(escaped, "\""));
+              }
             } else if (typeof v === "number") {
               items.push("".concat(subKey, "=").concat(v));
               if (Number.isInteger(v)) {
-                // Use URL-encoded forward slash separator
                 acc[1]["".concat(key.toLowerCase(), "%2f").concat(subKey)] = "integer";
               } else {
                 acc[1]["".concat(key.toLowerCase(), "%2f").concat(subKey)] = "float";
               }
             } else if (typeof v === "boolean") {
               items.push("".concat(subKey, "=").concat(v ? "?1" : "?0"));
+              acc[1]["".concat(key.toLowerCase(), "%2f").concat(subKey)] = "boolean";
+            } else if (_typeof(v) === "symbol") {
+              var desc = v.description || "symbol";
+              var _escaped2 = desc.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+              items.push("".concat(subKey, "=\"").concat(_escaped2, "\""));
+              acc[1]["".concat(key.toLowerCase(), "%2f").concat(subKey)] = "atom";
             } else if (Array.isArray(v) && !v.some(function (item) {
               return isPojo(item);
             })) {
-              // Simple array (no objects) - encode as structured field inner list
-              var listItems = v.map(function (item) {
-                if (typeof item === "string") {
-                  return "\"".concat(item.replace(/\\/g, "\\\\").replace(/"/g, '\\"'), "\"");
-                } else if (typeof item === "number") {
-                  return String(item);
-                } else if (typeof item === "boolean") {
-                  return item ? "?1" : "?0";
-                } else {
-                  return "\"".concat(String(item), "\"");
-                }
-              });
-              items.push("".concat(subKey, "=(").concat(listItems.join(" "), ")"));
+              if (v.length === 0) {
+                items.push("".concat(subKey, "=()"));
+                acc[1]["".concat(key.toLowerCase(), "%2f").concat(subKey)] = "empty-list";
+              } else {
+                var listItems = v.map(function (item) {
+                  if (typeof item === "string") {
+                    return "\"".concat(item.replace(/\\/g, "\\\\").replace(/"/g, '\\"'), "\"");
+                  } else if (typeof item === "number") {
+                    return String(item);
+                  } else if (typeof item === "boolean") {
+                    return item ? "?1" : "?0";
+                  } else if (_typeof(item) === "symbol") {
+                    var _desc = item.description || "symbol";
+                    return "\"".concat(_desc.replace(/\\/g, "\\\\").replace(/"/g, '\\"'), "\"");
+                  } else if (item === null) {
+                    return "\"null\"";
+                  } else if (item === undefined) {
+                    return "\"undefined\"";
+                  } else {
+                    return "\"".concat(String(item), "\"");
+                  }
+                });
+                items.push("".concat(subKey, "=(").concat(listItems.join(" "), ")"));
+              }
+            } else if (isPojo(v) && Object.keys(v).length === 0) {
+              items.push("".concat(subKey));
+              acc[1]["".concat(key.toLowerCase(), "%2f").concat(subKey)] = "empty-message";
             }
           });
           var encodedValue = items.join(", ");
-          acc[0][key] = encodedValue;
-          acc[1][key.toLowerCase()] = "map";
-        } else {
-          // Has nested objects - needs multipart encoding
-          hbEncodeLift(value, storageKey, top);
-          // Add the original object to flattened so it can be processed
-          acc[0][key] = value;
-        }
+          var hasOnlyEmptyValues = Object.entries(value).every(function (_ref6) {
+            var _ref7 = _slicedToArray(_ref6, 2),
+              k = _ref7[0],
+              v = _ref7[1];
+            return v === null || v === undefined || v === "" || Array.isArray(v) && v.length === 0 || isPojo(v) && Object.keys(v).length === 0;
+          });
+          if (!hasAnyNonEmptyValues) {
+            acc[1][key.toLowerCase()] = "map";
+          } else if (encodedValue === "") {
+            acc[1][key.toLowerCase()] = "empty-message";
+          } else {
+            acc[0][key] = encodedValue;
+            acc[1][key.toLowerCase()] = "map";
+          }
+        } else hbEncodeLift(value, storageKey, top);
         return acc;
       }
-
-      // leaf encode value
-      var _hbEncodeValue = hbEncodeValue(value),
-        _hbEncodeValue2 = _slicedToArray(_hbEncodeValue, 2),
-        type = _hbEncodeValue2[0],
-        encoded = _hbEncodeValue2[1];
+      var _hbEncodeValue5 = hbEncodeValue(value),
+        _hbEncodeValue6 = _slicedToArray(_hbEncodeValue5, 2),
+        type = _hbEncodeValue6[0],
+        encoded = _hbEncodeValue6[1];
       if (encoded !== undefined) {
-        // For binary data, check the byte length directly without converting to string
-        var byteLength = isBytes(encoded) ? encoded.byteLength : Buffer.from(String(encoded)).byteLength;
-        if (byteLength > MAX_HEADER_LENGTH) {
-          // Store large values, but preserve binary data as-is
-          top[storageKey] = isBytes(encoded) ? encoded : String(encoded);
-        } else {
-          // Preserve the original key casing
-          var httpKey = key;
-          if (type === "integer" && typeof value === "number") {
-            acc[0][httpKey] = String(value);
-          } else {
-            acc[0][httpKey] = encoded;
-          }
+        if (isBytes(encoded)) top[storageKey] = encoded;else {
+          acc[0][key] = encoded;
+          if (type) acc[1][key.toLowerCase()] = type;
         }
-      }
-      if (type) {
-        // Store type with lowercase key for ao-types dictionary
-        acc[1][key.toLowerCase()] = type;
-      }
+      } else if (type) acc[1][key.toLowerCase()] = type;
       return acc;
     }, [{}, {}]),
     _Object$entries$reduc2 = _slicedToArray(_Object$entries$reduc, 2),
     flattened = _Object$entries$reduc2[0],
     types = _Object$entries$reduc2[1];
-  if (Object.keys(flattened).length === 0) return top;
+  if (Object.keys(flattened).length === 0 && Object.keys(types).length === 0) return top;
   if (Object.keys(types).length > 0) {
-    // Format as structured fields dictionary
-    var aoTypeItems = Object.entries(types).map(function (_ref6) {
-      var _ref7 = _slicedToArray(_ref6, 2),
-        key = _ref7[0],
-        value = _ref7[1];
-      // The Erlang side expects keys with %2f for forward slashes
+    var aoTypeItems = Object.entries(types).map(function (_ref8) {
+      var _ref9 = _slicedToArray(_ref8, 2),
+        key = _ref9[0],
+        value = _ref9[1];
       var safeKey = key.toLowerCase().replace(/[^a-z0-9_\-.*\/]/g, function (c) {
         return "%" + c.charCodeAt(0).toString(16).padStart(2, "0");
-      }).replace(/\//g, "%2f"); // Replace forward slashes AFTER other encoding
+      }).replace(/\//g, "%2f");
       return "".concat(safeKey, "=\"").concat(value, "\"");
     });
     aoTypeItems.sort();
@@ -312,27 +343,20 @@ function hbEncodeLift(obj) {
     if (Buffer.from(aoTypes).byteLength > MAX_HEADER_LENGTH) {
       var flatK = parent ? "".concat(parent, "/ao-types") : "ao-types";
       top[flatK] = aoTypes;
-    } else {
-      flattened["ao-types"] = aoTypes;
-    }
-  }
-  if (parent) {
-    top[parent] = flattened;
-  } else {
-    Object.assign(top, flattened);
+    } else flattened["ao-types"] = aoTypes;
   }
+  if (parent) top[parent] = flattened;else Object.assign(top, flattened);
   return top;
 }
-function encodePart(name, _ref8) {
-  var _ref8$headers = _ref8.headers,
-    headers = _ref8$headers === void 0 ? {} : _ref8$headers,
-    body = _ref8.body;
-  // Convert headers to a plain object if it's a Headers instance
+function encodePart(name, _ref10) {
+  var _ref10$headers = _ref10.headers,
+    headers = _ref10$headers === void 0 ? {} : _ref10$headers,
+    body = _ref10.body;
   var headerEntries = headers instanceof Headers ? Array.from(headers.entries()) : Object.entries(headers || {});
-  var parts = headerEntries.reduce(function (acc, _ref9) {
-    var _ref10 = _slicedToArray(_ref9, 2),
-      name = _ref10[0],
-      value = _ref10[1];
+  var parts = headerEntries.reduce(function (acc, _ref11) {
+    var _ref12 = _slicedToArray(_ref11, 2),
+      name = _ref12[0],
+      value = _ref12[1];
     acc.push("".concat(name, ": "), value, "\r\n");
     return acc;
   }, ["content-disposition: form-data;name=\"".concat(name, "\"\r\n")]);
@@ -342,9 +366,6 @@ function encodePart(name, _ref8) {
 function encode() {
   return _encode.apply(this, arguments);
 }
-/**
- * Create HTTP signer wrapper
- */
 function _encode() {
   _encode = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee7() {
     var obj,
@@ -358,6 +379,11 @@ function _encode() {
       bodyKey,
       originalValue,
       flattenedValue,
+      hasSymbols,
+      _hbEncodeValue7,
+      _hbEncodeValue8,
+      type,
+      encoded,
       bodyParts,
       allPartsBuffer,
       hash,
@@ -383,15 +409,14 @@ function _encode() {
             body: undefined
           });
         case 3:
-          // Keep reference to original object for data field
           originalObj = obj;
           flattened = hbEncodeLift(obj);
           bodyKeys = [];
-          headerKeys = []; // Process all flattened keys
+          headerKeys = [];
           _context7.next = 9;
           return Promise.all(Object.keys(flattened).map(/*#__PURE__*/function () {
-            var _ref15 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5(key) {
-              var value, subPart, valueStr;
+            var _ref17 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5(key) {
+              var value, subPart, uint8Array, valueStr;
               return _regeneratorRuntime().wrap(function _callee5$(_context5) {
                 while (1) switch (_context5.prev = _context5.next) {
                   case 0:
@@ -415,107 +440,107 @@ function _encode() {
                     return _context5.abrupt("return");
                   case 10:
                     if (!isBytes(value)) {
-                      _context5.next = 14;
+                      _context5.next = 15;
                       break;
                     }
-                    // Binary data should always go to body
                     bodyKeys.push(key);
-                    flattened[key] = new Blob(["content-disposition: form-data;name=\"".concat(key, "\"\r\n\r\n"), new Uint8Array(value.buffer || value)]);
+                    uint8Array = value instanceof Uint8Array ? value : value instanceof ArrayBuffer ? new Uint8Array(value) : Buffer.isBuffer(value) ? new Uint8Array(value.buffer, value.byteOffset, value.length) : new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+                    flattened[key] = new Blob(["content-disposition: form-data;name=\"".concat(key, "\"\r\n\r\n"), uint8Array]);
                     return _context5.abrupt("return");
-                  case 14:
+                  case 15:
                     valueStr = String(value);
-                    _context5.next = 17;
+                    _context5.next = 18;
                     return hasNewline(valueStr);
-                  case 17:
+                  case 18:
                     _context5.t2 = _context5.sent;
                     if (_context5.t2) {
-                      _context5.next = 20;
+                      _context5.next = 21;
                       break;
                     }
                     _context5.t2 = key.includes("/");
-                  case 20:
+                  case 21:
                     _context5.t1 = _context5.t2;
                     if (_context5.t1) {
-                      _context5.next = 23;
+                      _context5.next = 24;
                       break;
                     }
                     _context5.t1 = Buffer.from(valueStr).byteLength > MAX_HEADER_LENGTH;
-                  case 23:
+                  case 24:
                     _context5.t0 = _context5.t1;
                     if (_context5.t0) {
-                      _context5.next = 26;
+                      _context5.next = 27;
                       break;
                     }
                     _context5.t0 = isPojo(value) && valueStr === "[object Object]";
-                  case 26:
+                  case 27:
                     if (!_context5.t0) {
-                      _context5.next = 30;
+                      _context5.next = 31;
                       break;
                     }
                     bodyKeys.push(key);
                     flattened[key] = new Blob(["content-disposition: form-data;name=\"".concat(key, "\"\r\n\r\n"), value]);
                     return _context5.abrupt("return");
-                  case 30:
-                    // It's a header
-                    headerKeys.push(key);
                   case 31:
+                    headerKeys.push(key);
+                  case 32:
                   case "end":
                     return _context5.stop();
                 }
               }, _callee5);
             }));
-            return function (_x9) {
-              return _ref15.apply(this, arguments);
+            return function (_x6) {
+              return _ref17.apply(this, arguments);
             };
           }()));
         case 9:
-          // Build headers object with all header keys
           headers = {};
           headerKeys.forEach(function (key) {
             headers[key] = flattened[key];
           });
-
-          // Special handling for data and body fields
           if ("data" in originalObj && !bodyKeys.includes("data")) {
             bodyKeys.push("data");
-            delete headers["data"]; // Remove from headers if it was there
+            delete headers["data"];
           }
           if ("body" in originalObj && !bodyKeys.includes("body")) {
             bodyKeys.push("body");
-            delete headers["body"]; // Remove from headers if it was there
+            delete headers["body"];
+          }
+          if (bodyKeys.length > 0) {
+            headers["body-keys"] = encode_body_keys(bodyKeys);
           }
           body = undefined;
           promoteToBody = true;
           if (!(bodyKeys.length > 0)) {
-            _context7.next = 44;
+            _context7.next = 45;
             break;
           }
           if (bodyKeys.length === 1) {
-            // If there is only one element, promote it to be the full body
             bodyKey = bodyKeys[0];
             originalValue = originalObj[bodyKey];
-            flattenedValue = flattened[bodyKey]; // Only promote if it's not a complex object
+            flattenedValue = flattened[bodyKey];
             if (!isPojo(originalValue) || isPojo(originalValue) && typeof flattenedValue === "string") {
-              // For objects that were encoded as structured fields, use the encoded value
               if ((bodyKey === "body" || bodyKey === "data") && isPojo(originalValue) && typeof flattenedValue === "string") {
                 body = new Blob([flattenedValue]);
-              } else {
-                body = new Blob([originalValue || flattenedValue]);
-              }
+              } else if (Array.isArray(originalValue)) {
+                hasSymbols = originalValue.some(function (item) {
+                  return _typeof(item) === "symbol";
+                });
+                if (hasSymbols) {
+                  _hbEncodeValue7 = hbEncodeValue(originalValue), _hbEncodeValue8 = _slicedToArray(_hbEncodeValue7, 2), type = _hbEncodeValue8[0], encoded = _hbEncodeValue8[1];
+                  body = new Blob([encoded || originalValue.toString()]);
+                } else body = new Blob([originalValue.toString()]);
+              } else body = new Blob([originalValue || flattenedValue]);
               headers["inline-body-key"] = bodyKey;
-            } else {
-              // Complex object - don't promote, create multipart
-              promoteToBody = false;
-            }
+            } else promoteToBody = false;
           }
           if (!(!promoteToBody || bodyKeys.length > 1)) {
-            _context7.next = 34;
+            _context7.next = 35;
             break;
           }
-          _context7.next = 20;
+          _context7.next = 21;
           return Promise.all(bodyKeys.map(/*#__PURE__*/function () {
-            var _ref16 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6(name) {
-              var value, _partBlob, partBlob;
+            var _ref18 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6(name) {
+              var value, _partBlob, valueToEncode, _hasSymbols, _hbEncodeValue9, _hbEncodeValue10, _type3, _encoded3, partBlob, uint8Array;
               return _regeneratorRuntime().wrap(function _callee6$(_context6) {
                 while (1) switch (_context6.prev = _context6.next) {
                   case 0:
@@ -525,8 +550,7 @@ function _encode() {
                     }
                     return _context6.abrupt("return", flattened[name]);
                   case 2:
-                    // For raw values, we need to create a proper multipart part
-                    value = originalObj[name] || flattened[name] || ""; // Special case: if this is a structured field encoded value, use the flattened value
+                    value = originalObj[name] || flattened[name] || "";
                     if (!(name === "body" && isPojo(originalObj[name]) && typeof flattened[name] === "string")) {
                       _context6.next = 6;
                       break;
@@ -534,29 +558,44 @@ function _encode() {
                     _partBlob = new Blob(["content-disposition: form-data;name=\"".concat(name, "\"\r\n\r\n"), flattened[name]]);
                     return _context6.abrupt("return", _partBlob);
                   case 6:
-                    partBlob = new Blob(["content-disposition: form-data;name=\"".concat(name, "\"\r\n\r\n"), value]);
+                    valueToEncode = value;
+                    if (Array.isArray(value)) {
+                      _hasSymbols = value.some(function (item) {
+                        return _typeof(item) === "symbol";
+                      });
+                      if (_hasSymbols) {
+                        _hbEncodeValue9 = hbEncodeValue(value), _hbEncodeValue10 = _slicedToArray(_hbEncodeValue9, 2), _type3 = _hbEncodeValue10[0], _encoded3 = _hbEncodeValue10[1];
+                        valueToEncode = _encoded3 || value.toString();
+                      }
+                    } else if (isBytes(value)) valueToEncode = value;
+                    if (isBytes(valueToEncode)) {
+                      uint8Array = valueToEncode instanceof Uint8Array ? valueToEncode : valueToEncode instanceof ArrayBuffer ? new Uint8Array(valueToEncode) : Buffer.isBuffer(valueToEncode) ? new Uint8Array(valueToEncode.buffer, valueToEncode.byteOffset, valueToEncode.length) : new Uint8Array(valueToEncode.buffer, valueToEncode.byteOffset, valueToEncode.byteLength);
+                      partBlob = new Blob(["content-disposition: form-data;name=\"".concat(name, "\"\r\n\r\n"), uint8Array]);
+                    } else {
+                      partBlob = new Blob(["content-disposition: form-data;name=\"".concat(name, "\"\r\n\r\n"), valueToEncode]);
+                    }
                     return _context6.abrupt("return", partBlob);
-                  case 8:
+                  case 10:
                   case "end":
                     return _context6.stop();
                 }
               }, _callee6);
             }));
-            return function (_x10) {
-              return _ref16.apply(this, arguments);
+            return function (_x7) {
+              return _ref18.apply(this, arguments);
             };
           }()));
-        case 20:
+        case 21:
           bodyParts = _context7.sent;
-          _context7.next = 23;
+          _context7.next = 24;
           return new Blob(bodyParts).arrayBuffer();
-        case 23:
+        case 24:
           allPartsBuffer = _context7.sent;
-          _context7.next = 26;
+          _context7.next = 27;
           return sha256(allPartsBuffer);
-        case 26:
+        case 27:
           hash = _context7.sent;
-          boundary = _base64url["default"].encode(Buffer.from(hash)); // Build the multipart body with proper boundaries
+          boundary = _base64url["default"].encode(Buffer.from(hash));
           finalParts = [];
           _iterator = _createForOfIteratorHelper(bodyParts);
           try {
@@ -574,28 +613,28 @@ function _encode() {
           finalParts.push("--".concat(boundary, "--"));
           headers["content-type"] = "multipart/form-data; boundary=\"".concat(boundary, "\"");
           body = new Blob(finalParts);
-        case 34:
+        case 35:
           if (!body) {
-            _context7.next = 44;
+            _context7.next = 45;
             break;
           }
-          _context7.next = 37;
+          _context7.next = 38;
           return body.arrayBuffer();
-        case 37:
+        case 38:
           finalContent = _context7.sent;
-          _context7.next = 40;
+          _context7.next = 41;
           return sha256(finalContent);
-        case 40:
+        case 41:
           contentDigest = _context7.sent;
-          base64 = _base64url["default"].toBase64(_base64url["default"].encode(contentDigest)); // Use lowercase to match what's in the other headers
+          base64 = _base64url["default"].toBase64(_base64url["default"].encode(contentDigest));
           headers["content-digest"] = "sha-256=:".concat(base64, ":");
           headers["content-length"] = String(finalContent.byteLength);
-        case 44:
+        case 45:
           return _context7.abrupt("return", {
             headers: headers,
             body: body
           });
-        case 45:
+        case 46:
         case "end":
           return _context7.stop();
       }
@@ -606,12 +645,12 @@ function _encode() {
 var toHttpSigner = function toHttpSigner(signer) {
   var params = ["alg", "keyid"].sort();
   return /*#__PURE__*/function () {
-    var _ref12 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref11) {
+    var _ref14 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref13) {
       var request, fields, signatureBase, signatureInput, createCalled, create, result, signatureBuffer, signedHeaders, finalHeaders, _i, _Object$entries, _Object$entries$_i, key, value;
       return _regeneratorRuntime().wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            request = _ref11.request, fields = _ref11.fields;
+            request = _ref13.request, fields = _ref13.fields;
             createCalled = false;
             create = function create(injected) {
               createCalled = true;
@@ -629,9 +668,9 @@ var toHttpSigner = function toHttpSigner(signer) {
               var signatureBaseArray = createSignatureBase({
                 fields: fields
               }, request);
-              signatureInput = (0, _structuredHeaders.serializeList)([[signatureBaseArray.map(function (_ref13) {
-                var _ref14 = _slicedToArray(_ref13, 1),
-                  item = _ref14[0];
+              signatureInput = (0, _structuredHeaders.serializeList)([[signatureBaseArray.map(function (_ref15) {
+                var _ref16 = _slicedToArray(_ref15, 1),
+                  item = _ref16[0];
                 return (0, _structuredHeaders.parseItem)(item);
               }), signingParameters]]);
               signatureBaseArray.push(['"@signature-params"', [signatureInput]]);
@@ -655,15 +694,13 @@ var toHttpSigner = function toHttpSigner(signer) {
             throw new Error("Signer must return signature and address");
           case 10:
             signatureBuffer = toView(result.signature);
-            signedHeaders = augmentHeaders(request.headers, signatureBuffer, signatureInput, httpSigName(result.address)); // Only lowercase the signature headers
+            signedHeaders = augmentHeaders(request.headers, signatureBuffer, signatureInput, httpSigName(result.address));
             finalHeaders = {};
             for (_i = 0, _Object$entries = Object.entries(signedHeaders); _i < _Object$entries.length; _i++) {
               _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2), key = _Object$entries$_i[0], value = _Object$entries$_i[1];
               if (key === "Signature" || key === "Signature-Input") {
                 finalHeaders[key.toLowerCase()] = value;
-              } else {
-                finalHeaders[key] = value;
-              }
+              } else finalHeaders[key] = value;
             }
             return _context.abrupt("return", _objectSpread(_objectSpread({}, request), {}, {
               headers: finalHeaders
@@ -675,19 +712,10 @@ var toHttpSigner = function toHttpSigner(signer) {
       }, _callee);
     }));
     return function (_x3) {
-      return _ref12.apply(this, arguments);
+      return _ref14.apply(this, arguments);
     };
   }();
 };
-
-/**
- * Create the main request function that creates signed messages locally
- *
- * @param {Object} config - Configuration object
- * @param {Function} config.signer - Signer function
- * @param {string} [config.HB_URL='http://relay.ao-hb.xyz'] - Base URL
- * @returns {Function} Request function that takes tags and returns signed message
- */
 function createRequest(config) {
   var signer = config.signer,
     _config$url = config.url,
@@ -697,46 +725,48 @@ function createRequest(config) {
   }
   return /*#__PURE__*/function () {
     var _request = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(fields) {
-      var _fields$path, path, _fields$method, method, restFields, aoFields, encoded, headersObj, body, _url, bodySize, lowercaseHeaders, _i2, _Object$entries2, _Object$entries2$_i, key, value, signingFields, signedRequest, finalHeaders, _i3, _Object$entries3, _Object$entries3$_i, _key, _value, result;
+      var _fields$path, path, _fields$method, method, restFields, aoFields, rootKeys, binaryKeys, encoded, headersObj, body, _url, bodySize, lowercaseHeaders, _i2, _Object$entries2, _Object$entries2$_i, key, value, signingFields, signedRequest, finalHeaders, _i3, _Object$entries3, _Object$entries3$_i, _key, _value, result;
       return _regeneratorRuntime().wrap(function _callee2$(_context2) {
         while (1) switch (_context2.prev = _context2.next) {
           case 0:
-            _fields$path = fields.path, path = _fields$path === void 0 ? "/relay/process" : _fields$path, _fields$method = fields.method, method = _fields$method === void 0 ? "POST" : _fields$method, restFields = _objectWithoutProperties(fields, _excluded); // Add default AO fields
-            aoFields = _objectSpread({}, restFields); // Use the HyperBEAM encode function
-            _context2.next = 4;
+            _fields$path = fields.path, path = _fields$path === void 0 ? "/relay/process" : _fields$path, _fields$method = fields.method, method = _fields$method === void 0 ? "POST" : _fields$method, restFields = _objectWithoutProperties(fields, _excluded);
+            aoFields = _objectSpread({}, restFields);
+            rootKeys = Object.keys(aoFields);
+            binaryKeys = rootKeys.filter(function (key) {
+              return isBytes(aoFields[key]);
+            });
+            if (binaryKeys.length > 1 && !aoFields.body && !aoFields.data) {
+              aoFields.body = "1984";
+            }
+            _context2.next = 7;
             return encode(aoFields);
-          case 4:
+          case 7:
             encoded = _context2.sent;
-            // If no encoding needed, create minimal structure
             headersObj = encoded ? encoded.headers : {};
             body = encoded ? encoded.body : undefined;
             _url = joinUrl({
               url: url,
               path: path
-            }); // Add Content-Length if body exists
+            });
             if (body && !headersObj["content-length"]) {
               bodySize = body.size || body.byteLength || 0;
               if (bodySize > 0) {
                 headersObj["content-length"] = String(bodySize);
               }
             }
-
-            // Create lowercase headers for signing
             lowercaseHeaders = {};
             for (_i2 = 0, _Object$entries2 = Object.entries(headersObj); _i2 < _Object$entries2.length; _i2++) {
               _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2), key = _Object$entries2$_i[0], value = _Object$entries2$_i[1];
               lowercaseHeaders[key.toLowerCase()] = value;
             }
-
-            // Get all header keys for signing (lowercase)
-            signingFields = Object.keys(lowercaseHeaders); // If there are no fields to sign, add at least the content-length
+            signingFields = Object.keys(lowercaseHeaders).filter(function (key) {
+              return key !== "body-keys";
+            });
             if (signingFields.length === 0 && !body) {
               lowercaseHeaders["content-length"] = "0";
               signingFields.push("content-length");
             }
-
-            // Sign the request with lowercase headers
-            _context2.next = 15;
+            _context2.next = 18;
             return toHttpSigner(signer)({
               request: {
                 url: _url,
@@ -745,30 +775,26 @@ function createRequest(config) {
               },
               fields: signingFields
             });
-          case 15:
+          case 18:
             signedRequest = _context2.sent;
-            // Build final headers: use original casing for all headers except signature headers
-            finalHeaders = {}; // First, add all original headers with their original casing
+            finalHeaders = {};
             for (_i3 = 0, _Object$entries3 = Object.entries(headersObj); _i3 < _Object$entries3.length; _i3++) {
               _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2), _key = _Object$entries3$_i[0], _value = _Object$entries3$_i[1];
               finalHeaders[_key] = _value;
             }
-
-            // Then add the signature headers (which should be lowercase)
             finalHeaders["signature"] = signedRequest.headers["signature"];
             finalHeaders["signature-input"] = signedRequest.headers["signature-input"];
-
-            // Return the signed message
+            if (headersObj["body-keys"]) {
+              finalHeaders["body-keys"] = headersObj["body-keys"];
+            }
             result = {
               url: _url,
               method: method,
               headers: finalHeaders
-            }; // Only add body if it exists
-            if (body) {
-              result.body = body;
-            }
+            };
+            if (body) result.body = body;
             return _context2.abrupt("return", result);
-          case 23:
+          case 27:
           case "end":
             return _context2.stop();
         }
@@ -780,393 +806,69 @@ function createRequest(config) {
     return request;
   }();
 }
-/**
- * Utility function to extract the message ID from a signed message
- * Based on the original code's hash calculation
- */
-function getMessageId(_x5) {
-  return _getMessageId.apply(this, arguments);
-}
-function _getMessageId() {
-  _getMessageId = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee8(signedMessage) {
-    var signatureHeader, match, signature, encoder, data, hashBuffer, hashArray, hashBase64;
-    return _regeneratorRuntime().wrap(function _callee8$(_context8) {
-      while (1) switch (_context8.prev = _context8.next) {
-        case 0:
-          // Extract signature from the Signature header
-          signatureHeader = signedMessage.headers.Signature || signedMessage.headers.signature;
-          match = signatureHeader.match(/Signature:\s*'http-sig-[^:]+:([^']+)'/);
-          signature = match ? match[1] : null;
-          if (signature) {
-            _context8.next = 5;
-            break;
-          }
-          throw new Error("Could not extract signature from headers");
-        case 5:
-          // Hash the signature to get message ID
-          encoder = new TextEncoder();
-          data = encoder.encode(signature);
-          _context8.next = 9;
-          return _crypto["default"].subtle.digest("SHA-256", data);
-        case 9:
-          hashBuffer = _context8.sent;
-          hashArray = Array.from(new Uint8Array(hashBuffer));
-          hashBase64 = btoa(String.fromCharCode.apply(String, hashArray));
-          return _context8.abrupt("return", hashBase64);
-        case 13:
-        case "end":
-          return _context8.stop();
-      }
-    }, _callee8);
-  }));
-  return _getMessageId.apply(this, arguments);
-}
-function send(_x6) {
+function send(_x5) {
   return _send.apply(this, arguments);
 }
-/**
- * Convert JWK modulus (n) to PEM format public key
- * @param {Buffer} nBuffer - The modulus buffer
- * @returns {string} PEM formatted public key
- */
 function _send() {
-  _send = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee9(signedMsg) {
+  _send = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee8(signedMsg) {
     var fetchImpl,
       fetchOptions,
       response,
       headers,
-      _args9 = arguments;
-    return _regeneratorRuntime().wrap(function _callee9$(_context9) {
-      while (1) switch (_context9.prev = _context9.next) {
+      _args8 = arguments;
+    return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
         case 0:
-          fetchImpl = _args9.length > 1 && _args9[1] !== undefined ? _args9[1] : fetch;
+          fetchImpl = _args8.length > 1 && _args8[1] !== undefined ? _args8[1] : fetch;
           fetchOptions = {
             method: signedMsg.method,
             headers: signedMsg.headers,
             redirect: "follow"
-          }; // Only add body if it exists and method supports it
+          };
           if (signedMsg.body !== undefined && signedMsg.method !== "GET" && signedMsg.method !== "HEAD") {
             fetchOptions.body = signedMsg.body;
           }
-          _context9.next = 5;
+          _context8.next = 5;
           return fetchImpl(signedMsg.url, fetchOptions);
         case 5:
-          response = _context9.sent;
+          response = _context8.sent;
           if (!(response.status >= 400)) {
-            _context9.next = 14;
+            _context8.next = 14;
             break;
           }
-          _context9.t0 = Error;
-          _context9.t1 = "".concat(response.status, ": ");
-          _context9.next = 11;
+          _context8.t0 = Error;
+          _context8.t1 = "".concat(response.status, ": ");
+          _context8.next = 11;
           return response.text();
         case 11:
-          _context9.t2 = _context9.sent;
-          _context9.t3 = _context9.t1.concat.call(_context9.t1, _context9.t2);
-          throw new _context9.t0(_context9.t3);
+          _context8.t2 = _context8.sent;
+          _context8.t3 = _context8.t1.concat.call(_context8.t1, _context8.t2);
+          throw new _context8.t0(_context8.t3);
         case 14:
-          // Convert Headers object to plain object
           headers = {};
           if (response.headers && typeof response.headers.forEach === "function") {
             response.headers.forEach(function (v, k) {
               return headers[k] = v;
             });
           } else headers = response.headers;
-          _context9.t4 = response;
-          _context9.t5 = headers;
-          _context9.next = 20;
+          _context8.t4 = response;
+          _context8.t5 = headers;
+          _context8.next = 20;
           return response.text();
         case 20:
-          _context9.t6 = _context9.sent;
-          _context9.t7 = response.status;
-          return _context9.abrupt("return", {
-            response: _context9.t4,
-            headers: _context9.t5,
-            body: _context9.t6,
-            status: _context9.t7
+          _context8.t6 = _context8.sent;
+          _context8.t7 = response.status;
+          return _context8.abrupt("return", {
+            response: _context8.t4,
+            headers: _context8.t5,
+            body: _context8.t6,
+            status: _context8.t7
           });
         case 23:
         case "end":
-          return _context9.stop();
+          return _context8.stop();
       }
-    }, _callee9);
+    }, _callee8);
   }));
   return _send.apply(this, arguments);
-}
-function jwkModulusToPem(nBuffer) {
-  // RSA public key with standard exponent
-  var rsaPublicKey = _crypto["default"].createPublicKey({
-    key: {
-      kty: "RSA",
-      n: _base64url["default"].encode(nBuffer),
-      e: "AQAB" // Standard exponent 65537
-    },
-    format: "jwk"
-  });
-  return rsaPublicKey["export"]({
-    type: "spki",
-    format: "pem"
-  });
-}
-
-/**
- * Extract signature name from headers
- * @param {Object} headers - Request headers
- * @returns {string|null} Signature name or null
- */
-function extractSignatureName(headers) {
-  var signatureHeader = headers["signature"] || headers["Signature"];
-  if (!signatureHeader) return null;
-
-  // Extract signature name (e.g., "http-sig-xxxxxxxx")
-  // Handle both "name:" and "name=" formats
-  var match = signatureHeader.match(/^([^:=]+)[:=]/);
-  return match ? match[1] : null;
-}
-
-/**
- * Extract public key from signature-input header
- * @param {Object} headers - Request headers
- * @param {string} [signatureName] - Optional signature name to look for
- * @returns {Buffer|null} Public key buffer or null
- */
-function extractPublicKeyFromHeaders(headers, signatureName) {
-  var signatureInput = headers["signature-input"] || headers["Signature-Input"];
-  if (!signatureInput) return null;
-
-  // If we have a signature name, look for its specific keyid
-  var keyidMatch;
-  if (signatureName) {
-    // The signature-input format is: signatureName=(...);alg="...";keyid="..."
-    // We need to match after the signature name
-    var signatureSection = signatureInput.substring(signatureInput.indexOf(signatureName));
-    keyidMatch = signatureSection.match(/keyid="([^"]+)"/);
-  } else {
-    // General keyid match
-    keyidMatch = signatureInput.match(/keyid="([^"]+)"/);
-  }
-  if (!keyidMatch) return null;
-  try {
-    return _base64url["default"].toBuffer(keyidMatch[1]);
-  } catch (error) {
-    return null;
-  }
-}
-
-/**
- * Verify an HTTP signed message using http-message-signatures
- *
- * @param {Object} signedMessage - The signed message to verify
- * @param {string} signedMessage.url - Request URL
- * @param {string} signedMessage.method - HTTP method
- * @param {Object} signedMessage.headers - Headers including signature
- * @param {string} [signedMessage.body] - Request body
- * @param {string|Buffer} [publicKey] - Optional public key (if not provided, extracts from keyid)
- * @returns {Object} Verification result
- */
-function verify(_x7, _x8) {
-  return _verify.apply(this, arguments);
-}
-/**
- * Extract public key from a signed message
- *
- * @param {Object} signedMessage - The signed message
- * @returns {Buffer|null} The public key buffer or null
- */
-function _verify() {
-  _verify = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee14(signedMessage, publicKey) {
-    var url, method, headers, body, keyLookup, pem, _signatureName, extractedKey, _pem, _request2, signatureName, extractedPublicKey, signatureInputHeader, algMatch, algorithm, verified, verificationError, verificationResult;
-    return _regeneratorRuntime().wrap(function _callee14$(_context14) {
-      while (1) switch (_context14.prev = _context14.next) {
-        case 0:
-          _context14.prev = 0;
-          url = signedMessage.url, method = signedMessage.method, headers = signedMessage.headers, body = signedMessage.body; // Determine which public key to use
-          if (!publicKey) {
-            _context14.next = 7;
-            break;
-          }
-          // Use provided public key
-          pem = typeof publicKey === "string" ? publicKey : jwkModulusToPem(publicKey);
-          keyLookup = /*#__PURE__*/function () {
-            var _ref17 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee11(keyId) {
-              return _regeneratorRuntime().wrap(function _callee11$(_context11) {
-                while (1) switch (_context11.prev = _context11.next) {
-                  case 0:
-                    return _context11.abrupt("return", {
-                      id: keyId,
-                      algs: ["rsa-pss-sha512", "rsa-pss-sha256", "rsa-v1_5-sha256"],
-                      verify: function () {
-                        var _verify2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee10(data, signature, parameters) {
-                          var verifier;
-                          return _regeneratorRuntime().wrap(function _callee10$(_context10) {
-                            while (1) switch (_context10.prev = _context10.next) {
-                              case 0:
-                                verifier = _crypto["default"].createVerify("RSA-SHA".concat(parameters.alg.includes("512") ? "512" : "256"));
-                                verifier.update(data);
-                                if (!parameters.alg.startsWith("rsa-pss")) {
-                                  _context10.next = 6;
-                                  break;
-                                }
-                                return _context10.abrupt("return", verifier.verify({
-                                  key: pem,
-                                  padding: _crypto["default"].constants.RSA_PKCS1_PSS_PADDING,
-                                  saltLength: _crypto["default"].constants.RSA_PSS_SALTLEN_DIGEST
-                                }, signature));
-                              case 6:
-                                return _context10.abrupt("return", verifier.verify(pem, signature));
-                              case 7:
-                              case "end":
-                                return _context10.stop();
-                            }
-                          }, _callee10);
-                        }));
-                        function verify(_x12, _x13, _x14) {
-                          return _verify2.apply(this, arguments);
-                        }
-                        return verify;
-                      }()
-                    });
-                  case 1:
-                  case "end":
-                    return _context11.stop();
-                }
-              }, _callee11);
-            }));
-            return function keyLookup(_x11) {
-              return _ref17.apply(this, arguments);
-            };
-          }();
-          _context14.next = 13;
-          break;
-        case 7:
-          // Extract public key from keyid
-          _signatureName = extractSignatureName(headers);
-          extractedKey = extractPublicKeyFromHeaders(headers, _signatureName);
-          if (extractedKey) {
-            _context14.next = 11;
-            break;
-          }
-          return _context14.abrupt("return", {
-            valid: false,
-            error: "No public key provided and none found in signature"
-          });
-        case 11:
-          _pem = jwkModulusToPem(extractedKey);
-          keyLookup = /*#__PURE__*/function () {
-            var _ref18 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee13(keyId) {
-              return _regeneratorRuntime().wrap(function _callee13$(_context13) {
-                while (1) switch (_context13.prev = _context13.next) {
-                  case 0:
-                    return _context13.abrupt("return", {
-                      id: keyId,
-                      algs: ["rsa-pss-sha512", "rsa-pss-sha256", "rsa-v1_5-sha256"],
-                      verify: function () {
-                        var _verify3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee12(data, signature, parameters) {
-                          var verifier, _verified;
-                          return _regeneratorRuntime().wrap(function _callee12$(_context12) {
-                            while (1) switch (_context12.prev = _context12.next) {
-                              case 0:
-                                _context12.prev = 0;
-                                verifier = _crypto["default"].createVerify("RSA-SHA".concat(parameters.alg.includes("512") ? "512" : "256"));
-                                verifier.update(data);
-                                if (parameters.alg.startsWith("rsa-pss")) {
-                                  _verified = verifier.verify({
-                                    key: _pem,
-                                    padding: _crypto["default"].constants.RSA_PKCS1_PSS_PADDING,
-                                    saltLength: _crypto["default"].constants.RSA_PSS_SALTLEN_DIGEST
-                                  }, signature);
-                                } else {
-                                  _verified = verifier.verify(_pem, signature);
-                                }
-                                return _context12.abrupt("return", _verified);
-                              case 7:
-                                _context12.prev = 7;
-                                _context12.t0 = _context12["catch"](0);
-                                console.error("Verification error:", _context12.t0);
-                                return _context12.abrupt("return", false);
-                              case 11:
-                              case "end":
-                                return _context12.stop();
-                            }
-                          }, _callee12, null, [[0, 7]]);
-                        }));
-                        function verify(_x16, _x17, _x18) {
-                          return _verify3.apply(this, arguments);
-                        }
-                        return verify;
-                      }()
-                    });
-                  case 1:
-                  case "end":
-                    return _context13.stop();
-                }
-              }, _callee13);
-            }));
-            return function keyLookup(_x15) {
-              return _ref18.apply(this, arguments);
-            };
-          }();
-        case 13:
-          // Create request object for verification
-          _request2 = {
-            method: method,
-            url: url,
-            headers: _objectSpread({}, headers)
-          }; // Extract additional info from headers
-          signatureName = extractSignatureName(headers);
-          extractedPublicKey = extractPublicKeyFromHeaders(headers, signatureName); // Extract algorithm from signature-input
-          signatureInputHeader = headers["signature-input"] || headers["Signature-Input"];
-          algMatch = signatureInputHeader === null || signatureInputHeader === void 0 ? void 0 : signatureInputHeader.match(/alg="([^"]+)"/);
-          algorithm = algMatch ? algMatch[1] : undefined; // Verify using the library
-          verified = false;
-          verificationError = null;
-          _context14.prev = 21;
-          _context14.next = 24;
-          return verifyMessage({
-            keyLookup: keyLookup,
-            requiredFields: [] // Don't require specific fields
-          }, _request2);
-        case 24:
-          verificationResult = _context14.sent;
-          // If we get here without throwing, verification succeeded
-          verified = true;
-          _context14.next = 32;
-          break;
-        case 28:
-          _context14.prev = 28;
-          _context14.t0 = _context14["catch"](21);
-          // Verification failed
-          verificationError = _context14.t0.message;
-          verified = false;
-        case 32:
-          return _context14.abrupt("return", _objectSpread({
-            valid: true,
-            // The signature format is valid
-            verified: verified,
-            // Whether the cryptographic verification passed
-            signatureName: signatureName,
-            keyId: extractedPublicKey ? _base64url["default"].encode(extractedPublicKey) : undefined,
-            algorithm: algorithm,
-            publicKeyFromHeader: extractedPublicKey
-          }, verificationError && {
-            error: verificationError
-          }));
-        case 35:
-          _context14.prev = 35;
-          _context14.t1 = _context14["catch"](0);
-          return _context14.abrupt("return", {
-            valid: false,
-            error: _context14.t1.message
-          });
-        case 38:
-        case "end":
-          return _context14.stop();
-      }
-    }, _callee14, null, [[0, 35], [21, 28]]);
-  }));
-  return _verify.apply(this, arguments);
-}
-function extractPublicKeyFromMessage(signedMessage) {
-  var signatureName = extractSignatureName(signedMessage.headers);
-  return extractPublicKeyFromHeaders(signedMessage.headers, signatureName);
 }