hbsig 0.2.8 → 0.3.1

package/esm/encode-utils.js

@@ -94,6 +94,8 @@ export function getValueByPath(obj, path) {
 }
 
 // Get the ao-type for a value
+// Note: dev_codec_structured.erl only supports: integer, float, atom, list, map
+// Do NOT use empty-binary, empty-list, empty-message as they cause binary_to_existing_atom errors
 export function getAoType(value) {
   if (
     typeof value === "boolean" ||
@@ -105,15 +107,19 @@ export function getAoType(value) {
   } else if (typeof value === "number") {
     return Number.isInteger(value) ? "integer" : "float"
   } else if (typeof value === "string" && value.length === 0) {
-    return "empty-binary"
+    // Empty strings become empty binaries naturally - no type annotation needed
+    return null
   } else if (isBytes(value) && (value.length === 0 || value.byteLength === 0)) {
-    return "empty-binary"
+    // Empty buffers become empty binaries naturally - no type annotation needed
+    return null
   } else if (Array.isArray(value) && value.length === 0) {
-    return "empty-list"
+    // Use "list" for empty arrays (structured codec compatible)
+    return "list"
   } else if (Array.isArray(value)) {
     return "list"
   } else if (isPojo(value) && Object.keys(value).length === 0) {
-    return "empty-message"
+    // Use "map" for empty objects (structured codec compatible)
+    return "map"
   }
   return null
 }

package/esm/encode.js

@@ -46,7 +46,16 @@ function handleSingleEmptyBinaryField(obj) {
       (fieldValue.length === 0 || fieldValue.byteLength === 0)
     ) {
       const headers = {}
-      headers["ao-types"] = `${fieldName.toLowerCase()}="empty-binary"`
+      // For 'body' field, we can't send it as a header (reserved name, gets stripped).
+      // Use inline-body-key to signal that body was present but empty.
+      // The modOut function will reconstruct body: <<>> when it sees inline-body-key: body
+      // with no actual body content.
+      if (fieldName.toLowerCase() === "body") {
+        headers["inline-body-key"] = "body"
+        return { headers, body: undefined }
+      }
+      // Include the key with empty value - empty string becomes empty binary in Erlang
+      headers[fieldName.toLowerCase()] = ""
       return { headers, body: undefined }
     }
   }
@@ -208,14 +217,17 @@ function processHeaderFields(obj, bodyKeys, headers, headerTypes) {
         )
       } else if (typeof value === "string") {
         if (value.length === 0) {
-          headerTypes.push(`${key.toLowerCase()}="empty-binary"`)
+          // Empty string becomes empty binary in Erlang - no ao-types needed
+          headers[key] = ""
         } else if (hasNonAscii(value)) {
           continue
         } else {
           headers[key] = value
         }
       } else if (Array.isArray(value) && value.length === 0) {
-        headerTypes.push(`${key.toLowerCase()}="empty-list"`)
+        // Empty array - use list type annotation
+        headers[key] = ""
+        headerTypes.push(`${key.toLowerCase()}="list"`)
       } else if (Array.isArray(value) && !value.some(item => isPojo(item))) {
         const hasNonAsciiItems = value.some(
           item => typeof item === "string" && hasNonAscii(item)
@@ -231,9 +243,18 @@ function processHeaderFields(obj, bodyKeys, headers, headerTypes) {
         isBytes(value) &&
         (value.length === 0 || value.byteLength === 0)
       ) {
-        headerTypes.push(`${key.toLowerCase()}="empty-binary"`)
+        // Empty buffer becomes empty binary in Erlang - no ao-types needed
+        // For 'body' field, we can't send it as a header (reserved name, gets stripped).
+        // Use inline-body-key to signal that body was present but empty.
+        if (key.toLowerCase() === "body") {
+          headers["inline-body-key"] = "body"
+        } else {
+          headers[key] = ""
+        }
       } else if (isPojo(value) && Object.keys(value).length === 0) {
-        headerTypes.push(`${key.toLowerCase()}="empty-message"`)
+        // Empty object - use map type annotation
+        headers[key] = ""
+        headerTypes.push(`${key.toLowerCase()}="map"`)
       }
     } else {
       // Fields that need body still get type annotations
@@ -290,6 +311,14 @@ async function handleSingleBodyKeyOptimization(
   headers,
   headerTypes
 ) {
+  // Skip this optimization if there are other header fields - need full multipart encoding
+  // to be compatible with HyperBEAM scheduler endpoint
+  const otherFields = Object.keys(obj).filter(k => !bodyKeys.includes(k) && !bodyKeys.some(bk => bk.startsWith(`${k}/`)))
+  if (otherFields.length > 0 && bodyKeys.length === 1) {
+    // Have other header fields + single body key = need multipart, skip optimization
+    return null
+  }
+
   if (bodyKeys.length === 1) {
     const singleKey = bodyKeys[0]
     const value = getValueByPath(obj, singleKey)
@@ -489,14 +518,16 @@ function processArrayItems(
     }
 
     if (typeof item === "string" && item === "") {
-      partTypes.push(`${index}="empty-binary"`)
+      // Empty strings become empty binaries naturally - no type annotation needed
     } else if (isPojo(item) && Object.keys(item).length === 0) {
-      partTypes.push(`${index}="empty-message"`)
+      // Use "map" instead of "empty-message" for structured codec compatibility
+      partTypes.push(`${index}="map"`)
     } else if (isPojo(item)) {
       // Non-empty objects are handled elsewhere
     } else if (Array.isArray(item)) {
       if (item.length === 0) {
-        partTypes.push(`${index}="empty-list"`)
+        // Use "list" instead of "empty-list" for structured codec compatibility
+        partTypes.push(`${index}="list"`)
       } else {
         partTypes.push(`${index}="list"`)
         const encodedItems = item
@@ -567,7 +598,7 @@ function processArrayItems(
     } else if (isBytes(item)) {
       const buffer = toBuffer(item)
       if (buffer.length === 0) {
-        partTypes.push(`${index}="empty-binary"`)
+        // Empty buffers become empty binaries naturally - no type annotation needed
       } else {
         partTypes.push(`${index}="binary"`)
       }
@@ -656,11 +687,10 @@ function processObjectFields(value, bodyKey, sortedBodyKeys) {
   const arrayTypes = []
 
   // First collect array types
+  // Note: Use "list" for both empty and non-empty arrays for structured codec compatibility
   for (const [k, v] of Object.entries(value)) {
     if (Array.isArray(v)) {
-      arrayTypes.push(
-        `${k.toLowerCase()}="${v.length === 0 ? "empty-list" : "list"}"`
-      )
+      arrayTypes.push(`${k.toLowerCase()}="list"`)
     }
   }
 
@@ -693,11 +723,12 @@ function processObjectFields(value, bodyKey, sortedBodyKeys) {
         `${k.toLowerCase()}="${Number.isInteger(v) ? "integer" : "float"}"`
       )
     } else if (typeof v === "string" && v.length === 0) {
-      objectTypes.push(`${k.toLowerCase()}="empty-binary"`)
+      // Empty strings become empty binaries naturally - no type annotation needed
     } else if (isBytes(v) && (v.length === 0 || v.byteLength === 0)) {
-      objectTypes.push(`${k.toLowerCase()}="empty-binary"`)
+      // Empty buffers become empty binaries naturally - no type annotation needed
     } else if (isPojo(v) && Object.keys(v).length === 0) {
-      objectTypes.push(`${k.toLowerCase()}="empty-message"`)
+      // Use "map" instead of "empty-message" for structured codec compatibility
+      objectTypes.push(`${k.toLowerCase()}="map"`)
     }
 
     if (typeof v === "string") {
@@ -720,6 +751,12 @@ function processObjectFields(value, bodyKey, sortedBodyKeys) {
     } else if (isBytes(v)) {
       const buffer = toBuffer(v)
       binaryFields.push({ key: k, buffer })
+    } else if (Array.isArray(v) && v.length === 0) {
+      // Empty array - include the key so Erlang knows it exists
+      fieldLines.push(`${k}: `)
+    } else if (isPojo(v) && Object.keys(v).length === 0) {
+      // Empty object - include the key so Erlang knows it exists
+      fieldLines.push(`${k}: `)
     } else if (Array.isArray(v) && v.length > 0) {
       const childPath = `${bodyKey}/${k}`
       if (!sortedBodyKeys.includes(childPath)) {

package/esm/erl_json.js

@@ -61,7 +61,10 @@ export function normalize(obj, binaryMode = false) {
 
     if (binaryMode) {
       // In binary mode, convert strings to buffers
-      return Buffer.from(obj, "utf8")
+      // Use binary/latin1 encoding only if all chars are <= 255 (preserves raw bytes)
+      // Use UTF-8 for strings with chars > 255 (proper multi-byte encoding)
+      const needsUtf8 = [...obj].some(ch => ch.codePointAt(0) > 255)
+      return Buffer.from(obj, needsUtf8 ? "utf8" : "binary")
     } else {
       // In string mode, strings stay as strings
       return obj

package/esm/erl_str.js

@@ -10,6 +10,11 @@
  * @returns {*} JavaScript value
  */
 export function erl_str_from(str, binaryMode = false) {
+  // Handle null/undefined input
+  if (str === null || str === undefined) {
+    return null
+  }
+
   // Handle the new response format
   if (str.startsWith("#erl_response{")) {
     const rawMatch = str.match(/#erl_response\{raw=(.*?),formatted=(.*?)\}$/s)

package/esm/flat.js

@@ -70,6 +70,57 @@ function pathToParts(path) {
   throw new Error("Path must be a string or array")
 }
 
+/**
+ * Convert a value to string format to match Erlang codec behavior
+ * Erlang dev_codec_flat only handles binaries, so all leaf values become strings
+ * @param {*} value - Value to convert
+ * @returns {string|Object} - String for leaf values, or recursively processed object
+ */
+function valueToString(value) {
+  if (typeof value === "object" && value !== null && !Array.isArray(value) && !Buffer.isBuffer(value)) {
+    // Recursively process nested objects
+    const result = {}
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = valueToString(v)
+    }
+    return result
+  }
+  if (typeof value === "string") {
+    return value
+  }
+  if (typeof value === "number") {
+    return String(value)
+  }
+  if (typeof value === "boolean") {
+    return String(value)
+  }
+  if (value === null) {
+    return "null"
+  }
+  if (Array.isArray(value)) {
+    // Convert array elements to strings first, then format as Erlang list
+    // Erlang's io_lib:format("~p", [List]) produces binary syntax like [<<"a">>,<<"b">>]
+    const elements = value.map(v => {
+      if (typeof v === "string") {
+        return `<<"${v}">>`
+      } else if (typeof v === "number") {
+        return String(v)
+      } else if (typeof v === "boolean") {
+        return v ? "true" : "false"
+      } else if (v === null) {
+        return "null"
+      } else {
+        return String(v)
+      }
+    })
+    return `[${elements.join(",")}]`
+  }
+  if (Buffer.isBuffer(value)) {
+    return value.toString()
+  }
+  return String(value)
+}
+
 /**
  * Helper function to inject a value at a specific path in a nested object
  * @param {Array} pathParts - Array of path parts
@@ -81,6 +132,9 @@ function injectAtPath(pathParts, value, obj) {
     throw new Error("Path cannot be empty")
   }
 
+  // Convert value to match Erlang codec behavior
+  const convertedValue = valueToString(value)
+
   if (pathParts.length === 1) {
     const key = pathParts[0]
 
@@ -91,20 +145,20 @@ function injectAtPath(pathParts, value, obj) {
       if (
         typeof existing === "object" &&
         existing !== null &&
-        typeof value === "object" &&
-        value !== null &&
+        typeof convertedValue === "object" &&
+        convertedValue !== null &&
         !Array.isArray(existing) &&
-        !Array.isArray(value)
+        !Array.isArray(convertedValue)
       ) {
-        obj[key] = { ...existing, ...value }
+        obj[key] = { ...existing, ...convertedValue }
       } else {
         // Path collision
         throw new Error(
-          `Path collision at key: ${key}, existing: ${JSON.stringify(existing)}, value: ${JSON.stringify(value)}`
+          `Path collision at key: ${key}, existing: ${JSON.stringify(existing)}, value: ${JSON.stringify(convertedValue)}`
         )
       }
     } else {
-      obj[key] = value
+      obj[key] = convertedValue
     }
     return
   }
@@ -117,7 +171,7 @@ function injectAtPath(pathParts, value, obj) {
     throw new Error(`Cannot create nested path at non-object key: ${key}`)
   }
 
-  injectAtPath(rest, value, obj[key])
+  injectAtPath(rest, convertedValue, obj[key])
 }
 
 /**

package/esm/httpsig.js

@@ -2,6 +2,7 @@
 
 import { hash } from "fast-sha256"
 import { flat_from, flat_to } from "./flat.js"
+import { structured_from as structuredFrom, structured_to as structuredTo } from "./structured.js"
 
 const CRLF = "\r\n"
 const DOUBLE_CRLF = CRLF + CRLF
@@ -120,17 +121,18 @@ function boundaryFromParts(parts) {
   return bytesToBase64url(hashBytes)
 }
 
-// Helper to determine inline key
+// Helper to determine inline key - matches Erlang's inline_key/2
 function inlineKey(msg) {
-  const inlineBodyKey = msg["inline-body-key"]
-  if (inlineBodyKey) {
-    return [{}, inlineBodyKey]
+  // Check for ao-body-key (Erlang uses ao-body-key, not inline-body-key)
+  const aoBodyKey = msg["ao-body-key"]
+  if (aoBodyKey) {
+    return [{}, aoBodyKey]
   }
   if ("body" in msg) {
     return [{}, "body"]
   }
   if ("data" in msg) {
-    return [{ "inline-body-key": "data" }, "data"]
+    return [{ "ao-body-key": "data" }, "data"]
   }
   return [{}, "body"]
 }
@@ -182,6 +184,13 @@ function ungroupIds(msg) {
   return result
 }
 
+// Get the size of a map (matches Erlang's maps:size behavior)
+// This counts ALL keys including ao-types - empty means literally {}
+function mapSize(obj) {
+  if (typeof obj !== "object" || obj === null) return 0
+  return Object.keys(obj).length
+}
+
 // Group maps for body encoding - following Erlang logic exactly
 function groupMaps(map, parent = "", top = {}) {
   if (
@@ -210,8 +219,18 @@ function groupMaps(map, parent = "", top = {}) {
       !Array.isArray(value) &&
       !Buffer.isBuffer(value)
     ) {
-      // Recursively process nested objects
-      newTop = groupMaps(value, flatK, newTop)
+      // Check size of the nested object (including metadata keys like ao-types)
+      // Empty means literally {} - a map with only ao-types is NOT empty
+      const size = mapSize(value)
+
+      if (size === 0) {
+        // Empty map (no data keys) - add empty-message marker
+        // This matches Erlang's group_maps behavior for empty maps
+        newTop[flatK] = { "ao-types": "empty-message" }
+      } else {
+        // Recursively process nested objects
+        newTop = groupMaps(value, flatK, newTop)
+      }
     } else if (typeof value === "string" && value.length > MAX_HEADER_LENGTH) {
       // Value too large for header, lift to top level
       newTop[flatK] = value
@@ -235,11 +254,27 @@ function groupMaps(map, parent = "", top = {}) {
   }
 }
 
+// Helper to compute content-digest for a body value
+function computePartDigest(bodyValue) {
+  let bodyBytes
+  if (Buffer.isBuffer(bodyValue)) {
+    bodyBytes = new Uint8Array(bodyValue)
+  } else if (typeof bodyValue === "string") {
+    bodyBytes = stringToBytes(bodyValue, "binary")
+  } else {
+    bodyBytes = stringToBytes(String(bodyValue), "binary")
+  }
+  const hashBytes = hash(bodyBytes)
+  return `sha-256=:${bytesToBase64(hashBytes)}:`
+}
+
 // Encode multipart body part
+// NOTE: This matches Erlang's encode_body_part/4 which does NOT apply inline_key
+// logic to nested parts. For nested maps, ALL fields become headers (except 'body'
+// which becomes the part body). The inline_key logic is only for top-level messages.
 function encodeBodyPart(partName, bodyPart, inlineKey) {
   const disposition =
     partName === inlineKey ? "inline" : `form-data;name="${partName}"`
-  const isInline = partName === inlineKey
 
   if (
     typeof bodyPart === "object" &&
@@ -247,101 +282,45 @@ function encodeBodyPart(partName, bodyPart, inlineKey) {
     !Array.isArray(bodyPart) &&
     !Buffer.isBuffer(bodyPart)
   ) {
-    // Check if this part has ao-types
-    const hasAoTypes = "ao-types" in bodyPart
-
-    if (hasAoTypes) {
-      // For parts WITH ao-types: sort all entries alphabetically
-      const allEntries = []
-
-      // Collect all entries except body
-      for (const [key, value] of Object.entries(bodyPart)) {
-        if (key === "body") continue
-
-        if (key === "ao-types") {
-          // Keep ao-types as-is (Buffer or string)
-          let valueStr = value
-          if (Buffer.isBuffer(value)) {
-            valueStr = value.toString("binary")
-          }
-          allEntries.push({ key: "ao-types", line: `ao-types: ${valueStr}` })
-        } else {
-          // Handle Buffer values properly
-          let valueStr = value
-          if (Buffer.isBuffer(value)) {
-            // Use binary/latin1 encoding to preserve all byte values 0-255
-            valueStr = value.toString("binary")
-          }
-          allEntries.push({ key: key, line: `${key}: ${valueStr}` })
-        }
-      }
-
-      // Add content-disposition
-      allEntries.push({
-        key: "content-disposition",
-        line: `content-disposition: ${disposition}`,
-      })
+    // Collect all headers (everything except 'body' and 'priv')
+    const allEntries = []
 
-      // Sort alphabetically by key
-      allEntries.sort((a, b) => a.key.localeCompare(b.key))
+    for (const [key, value] of Object.entries(bodyPart)) {
+      if (key === "body" || key === "priv") continue
 
-      // Build the lines
-      const lines = allEntries.map(entry => entry.line)
-
-      // Body handling
-      const body = bodyPart.body || ""
-      if (body) {
-        lines.push("") // Always add empty line before body
-        lines.push(body)
-      }
-
-      return lines.join(CRLF)
-    } else {
-      // For parts WITHOUT ao-types
-      const allEntries = []
-
-      for (const [key, value] of Object.entries(bodyPart)) {
-        if (key === "body") continue
-        // Handle Buffer values properly
-        let valueStr = value
-        if (Buffer.isBuffer(value)) {
-          // Use binary/latin1 encoding to preserve all byte values 0-255
-          valueStr = value.toString("binary")
-        }
-        allEntries.push({ key: key, line: `${key}: ${valueStr}` })
+      // Handle Buffer values properly
+      let valueStr = value
+      if (Buffer.isBuffer(value)) {
+        // Use binary/latin1 encoding to preserve all byte values 0-255
+        valueStr = value.toString("binary")
       }
+      allEntries.push({ key: key, line: `${key}: ${valueStr}` })
+    }
 
-      const lines = []
-
-      if (isInline) {
-        // Inline parts without ao-types: sort ALL fields alphabetically including content-disposition
-        allEntries.push({
-          key: "content-disposition",
-          line: `content-disposition: ${disposition}`,
-        })
+    // Add content-disposition
+    allEntries.push({
+      key: "content-disposition",
+      line: `content-disposition: ${disposition}`,
+    })
 
-        // Sort by key
-        allEntries.sort((a, b) => a.key.localeCompare(b.key))
+    // Sort all entries by key alphabetically - matches Erlang behavior
+    allEntries.sort((a, b) => a.key.localeCompare(b.key))
 
-        // Extract the lines
-        lines.push(...allEntries.map(entry => entry.line))
-      } else {
-        // Regular parts: content-disposition first, then fields
-        lines.push(`content-disposition: ${disposition}`)
-        lines.push(...allEntries.map(entry => entry.line))
-      }
+    // Build the lines
+    const lines = allEntries.map(entry => entry.line)
 
-      // Body handling
-      const body = bodyPart.body || ""
-      if (body) {
-        lines.push("") // Always add empty line before body
-        lines.push(body)
-      }
-
-      return lines.join(CRLF)
+    // Only the 'body' field (if present) becomes the part body
+    const body = bodyPart.body
+    if (body !== "" && body !== undefined && body !== null) {
+      lines.push("") // Always add empty line before body
+      lines.push(Buffer.isBuffer(body) ? body.toString("binary") : String(body))
     }
+
+    return lines.join(CRLF)
   } else if (typeof bodyPart === "string" || Buffer.isBuffer(bodyPart)) {
-    return `content-disposition: ${disposition}${DOUBLE_CRLF}${bodyPart}`
+    // Use binary/latin1 encoding to preserve byte values 0-255
+    const bodyStr = Buffer.isBuffer(bodyPart) ? bodyPart.toString("binary") : bodyPart
+    return `content-disposition: ${disposition}${DOUBLE_CRLF}${bodyStr}`
   }
   return ""
 }
@@ -696,12 +675,20 @@ export function httpsig_from(http) {
 
 /**
  * Convert TABM to HTTP message
+ * Implements bundle mode like Erlang's dev_codec_httpsig_conv:to/3 with bundle=true
  */
 export function httpsig_to(tabm) {
   if (typeof tabm === "string") return tabm
 
+  // Bundle logic: TABM → structured → TABM
+  // This matches Erlang's behavior when bundle=true:
+  // 1. Convert TABM to structured@1.0 (interprets ao-types, decodes to native types)
+  // 2. Convert back to TABM (re-encodes with ao-types)
+  const structured = structuredTo(tabm)
+  const bundledTabm = structuredFrom(structured)
+
   // Group IDs
-  const withGroupedIds = groupIds(tabm)
+  const withGroupedIds = groupIds(bundledTabm)
 
   // Remove private and signature-related keys
   const stripped = { ...withGroupedIds }
@@ -713,26 +700,25 @@ export function httpsig_to(tabm) {
   const [inlineFieldHdrs, inlineKeyVal] = inlineKey(tabm)
 
   // Check if this is a flat structure that should stay as headers
-  // A flat structure has no nested objects (maps)
-  const hasNestedMaps = Object.values(stripped).some(
-    value =>
-      typeof value === "object" &&
-      value !== null &&
-      !Array.isArray(value) &&
-      !Buffer.isBuffer(value)
-  )
+  // A flat structure has no nested objects (maps), excluding:
+  // - Arrays (JS arrays, not numbered maps)
+  // - Buffers
+  // Note: List-encoded maps (numbered maps with .="list") ARE nested maps
+  // and should trigger multipart encoding, matching Erlang's behavior
+  const hasNestedMaps = Object.values(stripped).some(value => {
+    // Not an object
+    if (typeof value !== "object" || value === null) return false
+    // Arrays and Buffers are not nested maps
+    if (Array.isArray(value) || Buffer.isBuffer(value)) return false
+    // Any other object (including list-encoded maps) is a nested map
+    return true
+  })
 
   // If it's just a flat map with strings/primitives, keep as headers
   // This matches Erlang's behavior where flat maps don't become multipart
   if (!hasNestedMaps) {
     // For flat structures, just return with normalized keys
-    // This matches Erlang which returns the map unchanged
-    const result = { ...inlineFieldHdrs }
-
-    for (const [key, value] of Object.entries(stripped)) {
-      // Keep Buffers as Buffers - don't convert to strings
-      result[key] = value
-    }
+    const result = { ...inlineFieldHdrs, ...stripped }
 
     // Handle inline body key - move data from inline key to body
     if (inlineKeyVal && inlineKeyVal !== "body" && result[inlineKeyVal]) {
@@ -740,9 +726,28 @@ export function httpsig_to(tabm) {
       delete result[inlineKeyVal]
     }
 
-    // If there's a body, add content-digest
+    // If the only field is ao-types (no actual data), return empty object
+    // This matches Erlang's behavior where ao-types-only messages become empty
+    const dataKeys = Object.keys(result).filter(k =>
+      k !== "ao-types" &&
+      k !== "ao-ids" &&
+      k !== "inline-body-key" &&
+      k !== "ao-body-key"
+    )
+    if (dataKeys.length === 0) {
+      return {}
+    }
+
+    // If there's a non-empty body, add content-digest
+    // Erlang doesn't add content-digest for empty bodies (<<>>)
     if (result.body) {
-      return addContentDigest(result)
+      const bodyIsEmpty = Buffer.isBuffer(result.body)
+        ? result.body.length === 0
+        : (typeof result.body === "string" && result.body.length === 0)
+
+      if (!bodyIsEmpty) {
+        return addContentDigest(result)
+      }
     }
 
     return result
@@ -837,7 +842,7 @@ export function httpsig_to(tabm) {
 
     const result = {
       ...headers,
-      "body-keys": bodyKeysList.map(k => `"${k}"`).join(", "),
+      // Note: body-keys is NOT included in httpsig output - it's only used for parsing
       "content-type": `multipart/form-data; boundary="${boundary}"`,
       body: finalBody,
     }