wao 0.32.2 → 0.33.0

package/cjs/{httpsig.js → httpsig2.js}

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.verifyContentDigest = exports.toBuffer = exports.hasValidSignature = exports.getSignatureNames = exports.from = exports.extractKeys = void 0;
 var _ramda = require("ramda");
-var _signerUtils = require("./signer-utils.js");
+var _hbsig = require("hbsig");
 var _base64url = _interopRequireDefault(require("base64url"));
 var _utils = require("./utils.js");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
@@ -666,7 +666,7 @@ var parseStructuredItem = function parseStructuredItem(item) {
  * Parse structured field dictionary
  */
 var parseStructuredDict = function parseStructuredDict(value) {
-  var decoded = (0, _signerUtils.decodeSigInput)(value);
+  var decoded = (0, _hbsig.decodeSigInput)(value);
   var result = {};
   for (var _i9 = 0, _Object$entries9 = Object.entries(decoded); _i9 < _Object$entries9.length; _i9++) {
     var _Object$entries9$_i = _slicedToArray(_Object$entries9[_i9], 2),
@@ -920,7 +920,7 @@ var from = exports.from = function from(http) {
   }
 
   // Decode signature inputs
-  var inputs = (0, _signerUtils.decodeSigInput)(input);
+  var inputs = (0, _hbsig.decodeSigInput)(input);
   // Process the first signature (following the original logic)
   for (var k in inputs) {
     var _sigData$params$tag, _sigData$params;
@@ -1019,7 +1019,7 @@ var extractKeys = exports.extractKeys = function extractKeys(http) {
   }
 
   // Decode all signature inputs
-  var inputs = (0, _signerUtils.decodeSigInput)(signatureInput);
+  var inputs = (0, _hbsig.decodeSigInput)(signatureInput);
 
   // Parse signature header to extract actual signatures
   // Format: sig1=:base64signature:, sig2=:base64signature:
@@ -1155,6 +1155,6 @@ var verifyContentDigest = exports.verifyContentDigest = function verifyContentDi
 var getSignatureNames = exports.getSignatureNames = function getSignatureNames(http) {
   var signatureInput = http.headers["signature-input"] || http.headers["Signature-Input"];
   if (!signatureInput) return [];
-  var inputs = (0, _signerUtils.decodeSigInput)(signatureInput);
+  var inputs = (0, _hbsig.decodeSigInput)(signatureInput);
   return Object.keys(inputs);
 };

package/cjs/hyperbeam.js

@@ -33,6 +33,7 @@ _dotenv["default"].config({
 });
 var HyperBEAM = exports["default"] = /*#__PURE__*/function () {
   function HyperBEAM() {
+    var _process$env$CWD;
     var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
       _ref$port = _ref.port,
       port = _ref$port === void 0 ? 10001 : _ref$port,
@@ -44,7 +45,7 @@ var HyperBEAM = exports["default"] = /*#__PURE__*/function () {
       wallet = _ref$wallet === void 0 ? ".wallet.json" : _ref$wallet,
       reset = _ref.reset,
       _ref$cwd = _ref.cwd,
-      cwd = _ref$cwd === void 0 ? "./HyperBEAM" : _ref$cwd,
+      cwd = _ref$cwd === void 0 ? (_process$env$CWD = process.env.CWD) !== null && _process$env$CWD !== void 0 ? _process$env$CWD : "./HyperBEAM" : _ref$cwd,
       c = _ref.c,
       cmake = _ref.cmake,
       faff = _ref.faff,

package/cjs/utils.js

@@ -3,49 +3,16 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.allChecked = exports.action = void 0;
-Object.defineProperty(exports, "base", {
-  enumerable: true,
-  get: function get() {
-    return _id.base;
-  }
-});
-exports.getTagVal = exports.getTag = exports.dirname = exports.checkTag = exports.buildTags = void 0;
-Object.defineProperty(exports, "hashpath", {
-  enumerable: true,
-  get: function get() {
-    return _id.hashpath;
-  }
-});
-Object.defineProperty(exports, "hmacid", {
-  enumerable: true,
-  get: function get() {
-    return _id.hmacid;
-  }
-});
-Object.defineProperty(exports, "id", {
-  enumerable: true,
-  get: function get() {
-    return _id.id;
-  }
-});
-exports.isData = exports.isCheckComplete = void 0;
+exports.isData = exports.isCheckComplete = exports.getTagVal = exports.getTag = exports.dirname = exports.checkTag = exports.buildTags = exports.allChecked = exports.action = void 0;
 exports.isJSON = isJSON;
 exports.optServer = exports.optAO = exports.mergeOut = exports.mergeChecks = exports.ltags = exports.jsonToStr = exports.isRegExp = exports.isOutComplete = exports.isLocalhost = void 0;
 exports.parseSignatureInput = parseSignatureInput;
-Object.defineProperty(exports, "rsaid", {
-  enumerable: true,
-  get: function get() {
-    return _id.rsaid;
-  }
-});
-exports.tags = exports.tagEq = exports.tag = exports.srcs = exports.searchTag = void 0;
+exports.tags = exports.tagEq = exports.tag = exports.srcs = exports.seed = exports.searchTag = void 0;
 exports.toANS104Request = toANS104Request;
 exports.toAddr = toAddr;
 exports.wait = exports.validAddress = exports.udl = exports.toGraphObj = void 0;
 var _graphql = require("graphql");
 var _fastSha = _interopRequireDefault(require("fast-sha256"));
-var _id = require("./id.js");
 var _ramda = require("ramda");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
 function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
@@ -864,4 +831,9 @@ function toAddr(n) {
   var pubBytes = base64urlDecode(n);
   var hash = (0, _fastSha["default"])(pubBytes);
   return base64urlEncode(hash);
-}
+}
+var seed = exports.seed = function seed(num) {
+  var array = new Array(num);
+  for (var i = 0; i < num; i++) array[i] = Math.floor(Math.random() * 256);
+  return Buffer.from(array).toString("base64");
+};

package/esm/erl_json.js

@@ -0,0 +1,289 @@
+/**
+ * Codec for converting between JS objects with Erlang types and annotated JSON
+ * Only handles types that HyperBEAM supports
+ */
+
+/**
+ * Convert annotated JSON to JS object with Erlang types
+ * @param {Object} json - Annotated JSON object
+ * @returns {*} - JS object with Buffer for binaries, Symbol for atoms
+ */
+export function erl_json_from(json) {
+  return convertFromAnnotatedJSON(json)
+}
+
+/**
+ * Convert JS object with Erlang types to annotated JSON
+ * @param {*} jsObj - JS object with Erlang types
+ * @returns {Object} - Annotated JSON object
+ */
+export function erl_json_to(jsObj) {
+  return convertToAnnotatedJSON(jsObj)
+}
+
+/**
+ * Normalize JS values to match what comes back from Erlang through erl_str_from
+ * This function is deterministic and matches the behavior of the Erlang round-trip
+ * @param {*} obj - JS object to normalize
+ * @param {boolean} binaryMode - true for binary mode, false for string mode (default)
+ * @returns {*} - Normalized JS object
+ */
+export function normalize(obj, binaryMode = false) {
+  if (obj === null) return null
+  if (obj === undefined) return undefined
+
+  // Handle symbols - convert to their special cases or match erl_str_from behavior
+  if (typeof obj === "symbol") {
+    const key = Symbol.keyFor(obj)
+    const name = key || obj.description || obj.toString().slice(7, -1)
+
+    // Special symbols that become primitives
+    if (name === "null") return null
+    if (name === "true") return true
+    if (name === "false") return false
+
+    // Note: Symbol('undefined') stays as Symbol.for('undefined')
+    // It does NOT become JavaScript undefined
+    // This matches what erl_str_from actually returns
+
+    // For all symbols (including 'undefined'), convert to global symbol
+    // This is because non-global symbols can't round-trip through JSON
+    // Symbol('ok') -> '%ok%' -> Symbol.for('ok')
+    return Symbol.for(name)
+  }
+
+  // Strings
+  if (typeof obj === "string") {
+    // Special case: "::" becomes empty buffer through Erlang
+    if (obj === "::") {
+      return Buffer.alloc(0)
+    }
+
+    if (binaryMode) {
+      // In binary mode, convert strings to buffers
+      return Buffer.from(obj, "utf8")
+    } else {
+      // In string mode, strings stay as strings
+      return obj
+    }
+  }
+
+  // Other primitives pass through
+  if (typeof obj === "number" || typeof obj === "boolean") {
+    return obj
+  }
+
+  // Buffers pass through
+  if (obj instanceof Buffer || obj instanceof Uint8Array) {
+    return Buffer.from(obj)
+  }
+
+  // Arrays - normalize each element
+  if (Array.isArray(obj)) {
+    return obj.map(item => {
+      // undefined in arrays becomes null (JSON behavior)
+      if (item === undefined) {
+        return null
+      }
+      return normalize(item, binaryMode)
+    })
+  }
+
+  // Objects - normalize each value and remove undefined values
+  if (typeof obj === "object" && obj !== null) {
+    const result = {}
+    for (const [k, v] of Object.entries(obj)) {
+      const normalized = normalize(v, binaryMode)
+      // Skip undefined values in objects
+      if (normalized !== undefined) {
+        result[k] = normalized
+      }
+    }
+    return result
+  }
+
+  return obj
+}
+
+// Convert from annotated JSON to JS with Erlang types
+function convertFromAnnotatedJSON(json) {
+  // Handle null/undefined
+  if (json === null) {
+    return null
+  }
+
+  if (json === undefined) {
+    return undefined
+  }
+
+  // Handle booleans
+  if (json === true || json === false) {
+    return json
+  }
+
+  // Handle numbers and strings
+  if (typeof json === "number") {
+    return json
+  }
+
+  if (typeof json === "string") {
+    // Check for binary structured field format :base64:
+    if (json.startsWith(":") && json.endsWith(":") && json.length >= 2) {
+      try {
+        // Handle empty binary special case
+        if (json === "::") {
+          return Buffer.alloc(0)
+        }
+        // Simple base64 decode for structured field binaries
+        const base64 = json.slice(1, -1)
+        return Buffer.from(base64, "base64")
+      } catch (e) {
+        // Not valid base64, return as-is
+        return json
+      }
+    }
+    // Check for token structured field format %token%
+    if (json.startsWith("%") && json.endsWith("%") && json.length >= 2) {
+      // Handle empty token special case
+      if (json === "%%") {
+        return Symbol.for("")
+      }
+      // Extract token and convert to symbol
+      const token = json.slice(1, -1)
+      return Symbol.for(token)
+    }
+    // Handle empty string from empty binary conversion
+    if (json === "") {
+      // In context, this might be an empty binary, but we can't be sure
+      // so we return it as-is
+      return json
+    }
+    return json
+  }
+
+  // Handle arrays
+  if (Array.isArray(json)) {
+    return json.map(item => convertFromAnnotatedJSON(item))
+  }
+
+  // Handle objects
+  if (json && typeof json === "object") {
+    const keys = Object.keys(json)
+
+    // Check for type annotations (single key objects)
+    if (keys.length === 1) {
+      const [key] = keys
+      const value = json[key]
+
+      switch (key) {
+        case "$empty":
+          switch (value) {
+            case "binary":
+              return Buffer.alloc(0)
+            case "list":
+              return []
+            case "map":
+              return {}
+            default:
+              return json
+          }
+      }
+    }
+
+    // Regular object - convert recursively
+    const result = {}
+    for (const [k, v] of Object.entries(json)) {
+      result[k] = convertFromAnnotatedJSON(v)
+    }
+    return result
+  }
+
+  // Fallback
+  return json
+}
+
+// Convert from JS with Erlang types to annotated JSON
+function convertToAnnotatedJSON(obj) {
+  // Handle null - pass through as JSON null
+  if (obj === null) {
+    return null
+  }
+
+  // Handle undefined - convert to null (JSON doesn't support undefined)
+  if (obj === undefined) {
+    return null
+  }
+
+  // Handle booleans - pass through as JSON booleans
+  if (typeof obj === "boolean") {
+    return obj
+  }
+
+  // Handle numbers - pass through
+  if (typeof obj === "number") {
+    return obj
+  }
+
+  // Handle strings - pass through
+  if (typeof obj === "string") {
+    return obj
+  }
+
+  // Handle symbols (atoms) - use token structured field format
+  if (typeof obj === "symbol") {
+    // Try to get the key from the global symbol registry
+    const key = Symbol.keyFor(obj)
+    // If it's not a global symbol, use its description
+    const name = key || obj.description || obj.toString().slice(7, -1)
+
+    // Special atoms that become JSON values
+    if (name === "null") return null
+    if (name === "true") return true
+    if (name === "false") return false
+
+    // Other atoms become token structured fields
+    return `%${name}%`
+  }
+
+  // Handle Buffers/Uint8Arrays (binaries)
+  if (obj instanceof Buffer || obj instanceof Uint8Array) {
+    if (obj.length === 0) {
+      return { $empty: "binary" }
+    }
+    // Use structured fields format for binaries
+    return `:${Buffer.from(obj).toString("base64")}:`
+  }
+
+  // Handle arrays
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) {
+      return { $empty: "list" }
+    }
+    return obj.map(item => convertToAnnotatedJSON(item))
+  }
+
+  // Handle objects
+  if (typeof obj === "object" && obj !== null) {
+    const result = {}
+    let hasKeys = false
+
+    for (const [k, v] of Object.entries(obj)) {
+      // Skip undefined values completely
+      if (v === undefined) {
+        continue
+      }
+      hasKeys = true
+      result[k] = convertToAnnotatedJSON(v)
+    }
+
+    // Return $empty annotation if no keys remain
+    if (!hasKeys) {
+      return { $empty: "map" }
+    }
+
+    return result
+  }
+
+  // Fallback
+  return obj
+}