wao 0.41.3 → 0.41.5

package/hbsig/dist/cjs/structured.js

@@ -0,0 +1,515 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.structured_from = structured_from;
+exports.structured_to = structured_to;
+var _erl_str = require("./erl_str.js");
+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; }
+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); } /**
+ * Structured field codec for JavaScript-Erlang interoperability
+ * Implements the same behavior as dev_codec_structured.erl
+ */
+/**
+ * Convert from structured format (rich message to TABM)
+ * Mirrors Erlang's from/1 function
+ * @param {*} obj - Rich message object
+ * @returns {*} - TABM object
+ */
+function structured_from(obj) {
+  // Handle binary input
+  if (typeof obj === "string" || obj instanceof Buffer || obj instanceof Uint8Array) {
+    return obj;
+  }
+
+  // Handle non-object input
+  if (_typeof(obj) !== "object" || obj === null || Array.isArray(obj)) {
+    return obj;
+  }
+
+  // Convert rich message to TABM
+  return from(obj);
+}
+
+/**
+ * Convert to structured format (TABM to rich message)
+ * Mirrors Erlang's to/1 function
+ * @param {string|object} input - Erlang term string or TABM object
+ * @returns {object} - Rich message object
+ */
+function structured_to(input) {
+  // If input is a string (Erlang response), parse it
+  if (typeof input === "string") {
+    return (0, _erl_str.erl_str_from)(input, false);
+  }
+
+  // Otherwise convert TABM to rich message
+  return to(input);
+}
+
+/**
+ * Convert a TABM into a rich message (mirrors Erlang's to/1)
+ * @param {*} tabm - Type-Annotated-Binary-Message
+ * @returns {*} - Rich message
+ */
+function to(tabm) {
+  // Handle binary input
+  if (typeof tabm === "string" || tabm instanceof Buffer || tabm instanceof Uint8Array) {
+    return tabm;
+  }
+
+  // Handle non-object input
+  if (_typeof(tabm) !== "object" || tabm === null || Array.isArray(tabm)) {
+    return tabm;
+  }
+
+  // Parse ao-types if present
+  var aoTypesStr = tabm["ao-types"] || "";
+  var types = parseAoTypes(aoTypesStr);
+
+  // Build result with empty values first
+  var result = {};
+
+  // Add empty values based on their types (these may be overwritten if data exists)
+  for (var _i = 0, _Object$entries = Object.entries(types); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      type = _Object$entries$_i[1];
+    if (type === "empty-binary") {
+      result[key] = "";
+    } else if (type === "empty-list") {
+      result[key] = [];
+    } else if (type === "empty-message") {
+      result[key] = {};
+    }
+  }
+
+  // Process all other key-value pairs
+  for (var _i2 = 0, _Object$entries2 = Object.entries(tabm); _i2 < _Object$entries2.length; _i2++) {
+    var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+      rawKey = _Object$entries2$_i[0],
+      value = _Object$entries2$_i[1];
+    // Skip ao-types field
+    if (rawKey === "ao-types") {
+      continue;
+    }
+    var normalizedKey = rawKey.toLowerCase();
+    if (typeof value === "string" || value instanceof Buffer || value instanceof Uint8Array) {
+      var _type = types[normalizedKey];
+      if (_type) {
+        // Decode according to type
+        result[rawKey] = decodeValue(_type, value);
+      } else {
+        // No type info, keep as binary/string
+        result[rawKey] = value;
+      }
+    } else if (_typeof(value) === "object" && value !== null && !Array.isArray(value)) {
+      // Check if the child object itself indicates it's a list via .="list" in its ao-types
+      var childAoTypes = value["ao-types"] || "";
+      var childTypes = parseAoTypes(childAoTypes);
+      var isChildList = childTypes["."] === "list";
+
+      // Recursively decode child TABM
+      var childDecoded = to(value);
+
+      // Only convert numbered map to array if the child object itself
+      // declares it's a list via .="list" in its ao-types.
+      // This preserves original keys when the parent declares the type
+      // but the child doesn't have the list marker.
+      if (isChildList) {
+        // Convert numbered map back to ordered list
+        result[rawKey] = messageToOrderedList(childDecoded);
+      } else {
+        result[rawKey] = childDecoded;
+      }
+    } else {
+      // Value already has converted type
+      result[rawKey] = value;
+    }
+  }
+  return filterDefaultKeys(result);
+}
+
+/**
+ * Parse ao-types field and return map of keys to types
+ * @param {string} aoTypesStr - ao-types field content
+ * @returns {object} - Map of normalized keys to types
+ */
+function parseAoTypes(aoTypesStr) {
+  if (!aoTypesStr) {
+    return {};
+  }
+  var types = {};
+
+  // Simple parser for "key1=\"type1\", key2=\"type2\"" format
+  var pairs = aoTypesStr.split(", ");
+  var _iterator = _createForOfIteratorHelper(pairs),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var pair = _step.value;
+      var match = pair.match(/^(.+?)="(.+?)"$/);
+      if (match) {
+        var _match = _slicedToArray(match, 3),
+          key = _match[1],
+          type = _match[2];
+        // Decode escaped key and normalize
+        var decodedKey = decodeEscapedKey(key);
+        types[decodedKey.toLowerCase()] = type;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return types;
+}
+
+/**
+ * Decode escaped key (simplified version)
+ * @param {string} key - Escaped key
+ * @returns {string} - Decoded key
+ */
+function decodeEscapedKey(key) {
+  // This is a simplified decoder - in practice you'd want more robust escaping
+  return key.replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+}
+
+/**
+ * Convert numbered map back to ordered list
+ * @param {object} numberedMap - Map with numeric string keys
+ * @returns {Array} - Ordered array
+ */
+function messageToOrderedList(numberedMap) {
+  var keys = Object.keys(numberedMap).filter(function (key) {
+    return /^\d+$/.test(key);
+  }).map(function (key) {
+    return parseInt(key, 10);
+  }).sort(function (a, b) {
+    return a - b;
+  });
+  return keys.map(function (key) {
+    return numberedMap[key.toString()];
+  });
+}
+
+/**
+ * Filter default keys (simplified - removes common defaults)
+ * @param {object} message - Message object
+ * @returns {object} - Filtered message
+ */
+function filterDefaultKeys(message) {
+  // This is a placeholder - implement based on your needs
+  return message;
+}
+
+/**
+ * Decode a value based on its type
+ * @param {string} type - Type identifier
+ * @param {*} value - Encoded value
+ * @returns {*} - Decoded value
+ */
+function decodeValue(type, value) {
+  switch (type.toLowerCase()) {
+    case "integer":
+      return parseInt(parseStructuredItem(value), 10);
+    case "float":
+      return parseFloat(value);
+    case "boolean":
+      // SF boolean format: ?1 = true, ?0 = false
+      // Convert to native boolean, will be encoded as "atom" type
+      if (value === "?1") return true;
+      if (value === "?0") return false;
+      // Fallback for other formats
+      return value === "true" || value === "1";
+    case "atom":
+      var atomItem = parseStructuredItem(value);
+      var atomName = atomItem.replace(/^"|"$/g, ""); // Remove quotes
+      // Convert to Symbol to preserve atom type through round-trip
+      // Special cases for common atoms that JS has native types for
+      if (atomName === "true") return true;
+      if (atomName === "false") return false;
+      if (atomName === "null") return null;
+      return Symbol["for"](atomName);
+    case "list":
+      return parseStructuredList(value).map(function (item) {
+        if (typeof item === "string" && item.startsWith("(ao-type-")) {
+          var match = item.match(/^\(ao-type-(.+?)\) (.+)$/);
+          if (match) {
+            var _match2 = _slicedToArray(match, 3),
+              itemType = _match2[1],
+              itemValue = _match2[2];
+            return decodeValue(itemType, itemValue);
+          }
+        }
+        return item;
+      });
+    case "binary":
+      return value;
+    default:
+      return value;
+  }
+}
+
+/**
+ * Parse structured field item (simplified)
+ * @param {string} value - Structured field value
+ * @returns {*} - Parsed value
+ */
+function parseStructuredItem(value) {
+  // Handle non-string values (e.g., numbers from HyperBEAM responses)
+  if (typeof value !== "string") return String(value);
+  if (value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1); // Remove quotes
+  }
+  return value;
+}
+
+/**
+ * Parse structured field list (simplified)
+ * @param {string} value - Structured field list
+ * @returns {Array} - Parsed list
+ */
+function parseStructuredList(value) {
+  if (typeof value !== "string") return [value];
+  return value.split(", ").map(function (item) {
+    if (item.startsWith('"') && item.endsWith('"')) {
+      // Remove quotes and unescape SF string escapes
+      // In SF strings: \" = " and \\ = \
+      return item.slice(1, -1).replace(/\\"/g, '"') // \" -> "
+      .replace(/\\\\/g, '\\'); // \\ -> \
+    }
+    return item;
+  });
+}
+
+/**
+ * Convert rich message to TABM (mirrors Erlang's from/1)
+ * @param {object} msg - Rich message
+ * @returns {object} - TABM
+ */
+function from(msg) {
+  // Handle binary input - passthrough
+  if (msg instanceof Buffer || msg instanceof Uint8Array) {
+    return msg;
+  }
+
+  // Handle non-object values - passthrough
+  if (_typeof(msg) !== "object" || msg === null) {
+    return msg;
+  }
+
+  // Handle arrays - convert to numbered map with .="list" in ao-types
+  // Mirrors Erlang: from(List, Req, Opts) when is_list(List)
+  if (Array.isArray(msg)) {
+    // Convert to numbered map (1-based indexing like Erlang)
+    var numberedMap = {};
+    msg.forEach(function (item, idx) {
+      numberedMap[(idx + 1).toString()] = item;
+    });
+
+    // Recursively process the numbered map
+    var _result = from(numberedMap);
+
+    // Add .="list" to ao-types to indicate this message is a list
+    var existingAoTypes = _result["ao-types"] || "";
+    if (existingAoTypes) {
+      _result["ao-types"] = '.="list", ' + existingAoTypes;
+    } else {
+      _result["ao-types"] = '.="list"';
+    }
+    return _result;
+  }
+
+  // Process keys - preserve original case to match Erlang behavior
+  // HTTP headers are case-insensitive but JSON/map keys preserve case
+  var keysMap = {};
+  for (var _i3 = 0, _Object$entries3 = Object.entries(msg); _i3 < _Object$entries3.length; _i3++) {
+    var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
+      key = _Object$entries3$_i[0],
+      value = _Object$entries3$_i[1];
+    keysMap[key] = value;
+  }
+
+  // Get sorted keys (preserving case)
+  var sortedKeys = Object.keys(keysMap).sort();
+  var types = [];
+  var values = [];
+
+  // Process each key in sorted order
+  var _iterator2 = _createForOfIteratorHelper(sortedKeys),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _key = _step2.value;
+      var _value = keysMap[_key];
+
+      // Handle empty binaries/strings - just include as-is, no type annotation
+      // (Erlang doesn't add empty-binary type, it just keeps the empty binary)
+      if (_value === "" || _value instanceof Buffer && _value.length === 0) {
+        values.push([_key, _value]);
+        continue;
+      }
+
+      // Empty arrays - convert to numbered map with .="list" in ao-types
+      // (Erlang doesn't add empty-list type, just the list marker)
+      if (Array.isArray(_value) && _value.length === 0) {
+        values.push([_key, from(_value)]);
+        continue;
+      }
+
+      // Empty objects - just include as-is, no type annotation
+      // (Erlang doesn't add empty-message type, it just keeps the empty map)
+      if (_typeof(_value) === "object" && _value !== null && !Array.isArray(_value) && !(_value instanceof Buffer) && Object.keys(_value).length === 0) {
+        values.push([_key, _value]);
+        continue;
+      }
+
+      // Handle binary/string values
+      if (_value instanceof Buffer || _value instanceof Uint8Array) {
+        values.push([_key, _value]);
+        continue;
+      }
+      if (typeof _value === "string") {
+        values.push([_key, _value]);
+        continue;
+      }
+
+      // Handle nested maps
+      if (_typeof(_value) === "object" && !Array.isArray(_value) && _value !== null) {
+        values.push([_key, from(_value)]);
+        continue;
+      }
+
+      // Handle arrays - from() converts to numbered map with .="list" in ao-types
+      if (Array.isArray(_value) && _value.length > 0) {
+        values.push([_key, from(_value)]);
+        continue;
+      }
+
+      // Handle typed values (need encoding)
+      if (_typeof(_value) === "symbol" || typeof _value === "number" || typeof _value === "boolean" || _value === null) {
+        var _encodeValue = encodeValue(_value),
+          _encodeValue2 = _slicedToArray(_encodeValue, 2),
+          type = _encodeValue2[0],
+          encoded = _encodeValue2[1];
+        types.push([_key, type]);
+        values.push([_key, encoded]);
+        continue;
+      }
+    }
+
+    // Build result
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  var result = {};
+
+  // Add ao-types if present
+  if (types.length > 0) {
+    result["ao-types"] = types.map(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        k = _ref2[0],
+        t = _ref2[1];
+      return "".concat(k, "=\"").concat(t, "\"");
+    }).join(", ");
+  }
+
+  // Add values (but NOT empty values)
+  for (var _i4 = 0, _values = values; _i4 < _values.length; _i4++) {
+    var _values$_i = _slicedToArray(_values[_i4], 2),
+      k = _values$_i[0],
+      v = _values$_i[1];
+    result[k] = v;
+  }
+  return result;
+}
+
+/**
+ * Encode a value with its type
+ */
+function encodeValue(value) {
+  // Null (as atom) - use token format (unquoted)
+  if (value === null) {
+    return ["atom", "null"];
+  }
+
+  // Integer
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return ["integer", value.toString()];
+  }
+
+  // Float
+  if (typeof value === "number") {
+    // Format like Erlang's float_to_binary - scientific notation with full precision
+    // Erlang's float_to_binary/1 uses ~20 decimal digits and keeps trailing zeros
+    var str = value.toExponential(20);
+    // Ensure 2-digit exponent with sign
+    str = str.replace(/e([+-])(\d)$/, "e$10$2");
+    return ["float", str];
+  }
+
+  // Boolean (as atom) - use token format (unquoted)
+  if (typeof value === "boolean") {
+    return ["atom", value.toString()];
+  }
+
+  // Symbol (as atom) - use token format (unquoted)
+  if (_typeof(value) === "symbol") {
+    var name = Symbol.keyFor(value) || value.description || "";
+    return ["atom", name];
+  }
+
+  // List
+  if (Array.isArray(value)) {
+    var parts = [];
+    var _iterator3 = _createForOfIteratorHelper(value),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var item = _step3.value;
+        if (item instanceof Buffer) {
+          // Empty buffer => empty string
+          parts.push(item.length === 0 ? '""' : "\"".concat(item.toString(), "\""));
+        } else if (typeof item === "string") {
+          parts.push("\"".concat(item, "\""));
+        } else {
+          var _encodeValue3 = encodeValue(item),
+            _encodeValue4 = _slicedToArray(_encodeValue3, 2),
+            itemType = _encodeValue4[0],
+            itemEncoded = _encodeValue4[1];
+          if (itemType === "list") {
+            // Escape nested list quotes
+            var escaped = itemEncoded.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+            parts.push("\"(ao-type-list) ".concat(escaped, "\""));
+          } else if (itemType === "atom") {
+            // Escape atom quotes
+            var _escaped = itemEncoded.replace(/"/g, '\\"');
+            parts.push("\"(ao-type-atom) ".concat(_escaped, "\""));
+          } else {
+            parts.push("\"(ao-type-".concat(itemType, ") ").concat(itemEncoded, "\""));
+          }
+        }
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+    return ["list", parts.join(", ")];
+  }
+  if (value instanceof Buffer) {
+    return ["binary", value];
+  }
+  return ["unknown", String(value)];
+}

package/hbsig/dist/cjs/test.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "toAddr", {
+  enumerable: true,
+  get: function get() {
+    return _utils.toAddr;
+  }
+});
+var _utils = require("./utils.js");

package/hbsig/dist/cjs/utils.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toAddr = toAddr;
+var _fastSha = _interopRequireDefault(require("fast-sha256"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+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 _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 _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 base64urlDecode(str) {
+  str = str.replace(/-/g, "+").replace(/_/g, "/");
+  var pad = str.length % 4;
+  if (pad === 2) str += "==";else if (pad === 3) str += "=";else if (pad !== 0) throw new Error("Invalid base64url string");
+  var bin = atob(str);
+  var bytes = new Uint8Array(bin.length);
+  for (var i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+  return bytes;
+}
+function base64urlEncode(bytes) {
+  var bin = "";
+  var _iterator = _createForOfIteratorHelper(bytes),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var b = _step.value;
+      bin += String.fromCharCode(b);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var b64 = btoa(bin);
+  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function toAddr(n) {
+  if (_typeof(n) === "object" && typeof n.n === "string") n = n.n;
+  var pubBytes = base64urlDecode(n);
+  var hash = (0, _fastSha["default"])(pubBytes);
+  return base64urlEncode(hash);
+}

package/hbsig/dist/esm/bin_to_str.js

@@ -0,0 +1,46 @@
+/**
+ * Convert a Buffer to string if it contains valid UTF-8 text
+ * @param {Buffer} buffer - Buffer to check and potentially convert
+ * @returns {string|Buffer} - String if valid UTF-8, otherwise original Buffer
+ */
+export default function bin_to_str(buffer) {
+  if (!Buffer.isBuffer(buffer)) {
+    return buffer
+  }
+
+  // Empty buffer stays as buffer
+  if (buffer.length === 0) {
+    return buffer
+  }
+
+  try {
+    const str = buffer.toString("utf8")
+    // Check if it's valid UTF-8 by seeing if it round-trips correctly
+    if (Buffer.from(str, "utf8").equals(buffer)) {
+      // Additional check: ensure all characters are printable or common whitespace
+      // This prevents converting binary data that happens to be valid UTF-8
+      let isPrintable = true
+      for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i)
+        // Allow printable ASCII (32-126) and common whitespace (tab, newline, carriage return)
+        if (
+          !(code >= 32 && code <= 126) &&
+          code !== 9 &&
+          code !== 10 &&
+          code !== 13
+        ) {
+          isPrintable = false
+          break
+        }
+      }
+
+      if (isPrintable) {
+        return str
+      }
+    }
+  } catch (e) {
+    // Not valid UTF-8, return original buffer
+  }
+
+  return buffer
+}