wao 0.27.2 → 0.27.4

package/esm/encode.js

@@ -1,729 +1,39 @@
 import base64url from "base64url"
-import { hash } from "fast-sha256"
-
-function isBytes(value) {
-  return (
-    value instanceof ArrayBuffer ||
-    ArrayBuffer.isView(value) ||
-    Buffer.isBuffer(value) ||
-    (value &&
-      typeof value === "object" &&
-      value.type === "Buffer" &&
-      Array.isArray(value.data))
-  )
-}
-
-function isPojo(value) {
-  return (
-    !isBytes(value) &&
-    !Array.isArray(value) &&
-    !(value instanceof Blob) &&
-    typeof value === "object" &&
-    value !== null
-  )
-}
-
+import {
+  getValueByPath,
+  getAoType,
+  isEmpty,
+  encodePrimitiveContent,
+  sortTypeAnnotations,
+  analyzeArray,
+  toBuffer,
+  formatFloat,
+  hasNonAscii,
+  sha256,
+  hasNewline,
+  isBytes,
+  isPojo,
+} from "./encode-utils.js"
+import encodeArrayItem from "./encode-array-item.js"
+import collectBodyKeys from "./collect-body-keys.js"
 const MAX_HEADER_LENGTH = 4096
 
-async function hasNewline(value) {
-  if (typeof value === "string") return value.includes("\n")
-  if (value instanceof Blob) {
-    value = await value.text()
-    return value.includes("\n")
-  }
-  if (isBytes(value)) return Buffer.from(value).includes("\n")
-  return false
-}
-
-async function sha256(data) {
-  let uint8Array
-  if (data instanceof ArrayBuffer) {
-    uint8Array = new Uint8Array(data)
-  } else if (data instanceof Uint8Array) {
-    uint8Array = data
-  } else if (ArrayBuffer.isView(data)) {
-    uint8Array = new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
-  } else {
-    throw new Error("sha256 expects ArrayBuffer or ArrayBufferView")
-  }
-
-  const hashResult = hash(uint8Array)
-  return hashResult.buffer.slice(
-    hashResult.byteOffset,
-    hashResult.byteOffset + hashResult.byteLength
-  )
-}
-
-function formatFloat(num) {
-  let exp = num.toExponential(20)
-  exp = exp.replace(/e\+(\d)$/, "e+0$1")
-  exp = exp.replace(/e-(\d)$/, "e-0$1")
-  return exp
-}
-
-function hasNonAscii(str) {
-  return /[^\x00-\x7F]/.test(str)
-}
-
-function encodeArrayItem(item) {
-  if (typeof item === "number") {
-    if (Number.isInteger(item)) {
-      return `"(ao-type-integer) ${item}"`
-    } else {
-      return `"(ao-type-float) ${formatFloat(item)}"`
-    }
-  } else if (typeof item === "string") {
-    return `"${item}"`
-  } else if (item === null) {
-    return `"(ao-type-atom) \\"null\\""`
-  } else if (item === undefined) {
-    return `"(ao-type-atom) \\"undefined\\""`
-  } else if (typeof item === "symbol") {
-    const desc = item.description || "Symbol.for()"
-    return `"(ao-type-atom) \\"${desc}\\""`
-  } else if (typeof item === "boolean") {
-    return `"(ao-type-atom) \\"${item}\\""`
-  } else if (Array.isArray(item)) {
-    const nestedItems = item
-      .map(nestedItem => {
-        if (typeof nestedItem === "number") {
-          if (Number.isInteger(nestedItem)) {
-            return `\\"(ao-type-integer) ${nestedItem}\\"`
-          } else {
-            return `\\"(ao-type-float) ${formatFloat(nestedItem)}\\"`
-          }
-        } else if (typeof nestedItem === "string") {
-          return `\\"${nestedItem}\\"`
-        } else if (nestedItem === null) {
-          return `\\"(ao-type-atom) \\\\\\"null\\\\\\"\\"`
-        } else if (nestedItem === undefined) {
-          return `\\"(ao-type-atom) \\\\\\"undefined\\\\\\"\\"`
-        } else if (typeof nestedItem === "symbol") {
-          const desc = nestedItem.description || "Symbol.for()"
-          return `\\"(ao-type-atom) \\\\\\"${desc}\\\\\\"\\"`
-        } else if (typeof nestedItem === "boolean") {
-          return `\\"(ao-type-atom) \\\\\\"${nestedItem}\\\\\\"\\"`
-        } else if (Array.isArray(nestedItem)) {
-          // Handle nested arrays recursively
-          const deeperItems = nestedItem
-            .map(deepItem => {
-              if (typeof deepItem === "number") {
-                if (Number.isInteger(deepItem)) {
-                  return `\\\\\\"(ao-type-integer) ${deepItem}\\\\\\"`
-                } else {
-                  return `\\\\\\"(ao-type-float) ${formatFloat(deepItem)}\\\\\\"`
-                }
-              } else if (typeof deepItem === "string") {
-                return `\\\\\\"${deepItem}\\\\\\"`
-              } else if (Array.isArray(deepItem)) {
-                // Even deeper nesting - need to escape more
-                const deepestItems = deepItem
-                  .map(deepestItem => {
-                    if (typeof deepestItem === "number") {
-                      if (Number.isInteger(deepestItem)) {
-                        return `\\\\\\\\\\\\\\"(ao-type-integer) ${deepestItem}\\\\\\\\\\\\\\"`
-                      } else {
-                        return `\\\\\\\\\\\\\\"(ao-type-float) ${formatFloat(deepestItem)}\\\\\\\\\\\\\\"`
-                      }
-                    } else if (typeof deepestItem === "string") {
-                      return `\\\\\\\\\\\\\\"${deepestItem}\\\\\\\\\\\\\\"`
-                    } else {
-                      return `\\\\\\\\\\\\\\"${String(deepestItem)}\\\\\\\\\\\\\\"`
-                    }
-                  })
-                  .join(", ")
-                return `\\\\\\"(ao-type-list) ${deepestItems}\\\\\\"`
-              } else if (deepItem === null) {
-                return `\\\\\\"(ao-type-atom) \\\\\\\\\\\\\\"null\\\\\\\\\\\\\\"\\\\\\"`
-              } else if (deepItem === undefined) {
-                return `\\\\\\"(ao-type-atom) \\\\\\\\\\\\\\"undefined\\\\\\\\\\\\\\"\\\\\\"`
-              } else if (typeof deepItem === "symbol") {
-                const desc = deepItem.description || "Symbol.for()"
-                return `\\\\\\"(ao-type-atom) \\\\\\\\\\\\\\"${desc}\\\\\\\\\\\\\\"\\\\\\"`
-              } else if (typeof deepItem === "boolean") {
-                return `\\\\\\"(ao-type-atom) \\\\\\\\\\\\\\"${deepItem}\\\\\\\\\\\\\\"\\\\\\"`
-              } else {
-                return `\\\\\\"${String(deepItem)}\\\\\\"`
-              }
-            })
-            .join(", ")
-          return `\\"(ao-type-list) ${deeperItems}\\"`
-        } else {
-          return `\\"${String(nestedItem)}\\"`
-        }
-      })
-      .join(", ")
-    return `"(ao-type-list) ${nestedItems}"`
-  } else if (isBytes(item)) {
-    const buffer = toBuffer(item)
-    if (buffer.length === 0 || buffer.byteLength === 0) {
-      return `""`
-    }
-    return `"(ao-type-binary)"`
-  } else if (isPojo(item)) {
-    const json = JSON.stringify(item)
-    const escaped = json.replace(/\\/g, "\\\\").replace(/"/g, '\\"')
-    return `"(ao-type-map) ${escaped}"`
-  } else {
-    return `"${String(item)}"`
-  }
-}
-
-function toBuffer(value) {
-  if (Buffer.isBuffer(value)) {
-    return value
-  } else if (
-    value &&
-    typeof value === "object" &&
-    value.type === "Buffer" &&
-    Array.isArray(value.data)
-  ) {
-    return Buffer.from(value.data)
-  } else if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
-    return Buffer.from(value)
-  } else {
-    return Buffer.from(value)
-  }
-}
-
-function collectBodyKeys(obj, prefix = "") {
-  console.log("=== collectBodyKeys START ===")
-  console.log("Input object:", JSON.stringify(obj))
-
-  const keys = []
-
-  function traverse(current, path) {
-    console.log(`[traverse] Called with path: "${path}"`)
-    let hasSimpleFields = false
-    const nestedPaths = []
-    let hasArraysWithObjects = false
-
-    for (const [key, value] of Object.entries(current)) {
-      const fullPath = path ? `${path}/${key}` : key
-
-      if (Array.isArray(value)) {
-        console.log(
-          `[traverse] Found array at ${fullPath}, length: ${value.length}`
-        )
-        const hasObjects = value.some(item => isPojo(item))
-        const hasNonObjects = value.some(item => !isPojo(item))
-
-        if (value.length === 0) {
-          console.log(
-            `[traverse] Empty array at ${fullPath} - marking parent as having simple fields`
-          )
-          hasSimpleFields = true
-        } else if (hasObjects) {
-          hasArraysWithObjects = true
-          // Check if we need special handling for mixed arrays
-          const hasEmptyStrings = value.some(
-            item => typeof item === "string" && item === ""
-          )
-          const hasEmptyObjects = value.some(
-            item => isPojo(item) && Object.keys(item).length === 0
-          )
-          const hasNonEmptyObjects = value.some(
-            item => isPojo(item) && Object.keys(item).length > 0
-          )
-
-          // Check if objects contain only empty values (not empty objects)
-          const hasObjectsWithOnlyEmptyValues = value.some(item => {
-            if (!isPojo(item) || Object.keys(item).length === 0) return false
-            return Object.values(item).every(
-              v =>
-                (typeof v === "string" && v === "") ||
-                (Array.isArray(v) && v.length === 0) ||
-                (isPojo(v) && Object.keys(v).length === 0)
-            )
-          })
-
-          // Only use special handling if we have BOTH empty elements AND non-empty objects
-          if ((hasEmptyStrings || hasEmptyObjects) && hasNonEmptyObjects) {
-            // Special case: mixed array with empty strings/objects - only non-empty objects get parts
-            value.forEach((item, index) => {
-              if (isPojo(item) && Object.keys(item).length > 0) {
-                const itemPath = `${fullPath}/${index + 1}`
-                keys.push(itemPath)
-                nestedPaths.push(itemPath)
-              }
-            })
-            if (hasNonObjects) {
-              hasSimpleFields = true
-              keys.push(fullPath)
-            }
-          } else if (hasObjectsWithOnlyEmptyValues && !hasNonObjects) {
-            // Special case: objects that contain only empty values should get parts
-            value.forEach((item, index) => {
-              if (isPojo(item)) {
-                const itemPath = `${fullPath}/${index + 1}`
-                keys.push(itemPath)
-                if (Object.keys(item).length > 0) {
-                  nestedPaths.push(itemPath)
-                }
-              }
-            })
-          } else {
-            // Normal case: all objects get parts
-            value.forEach((item, index) => {
-              if (isPojo(item)) {
-                const itemPath = `${fullPath}/${index + 1}`
-                keys.push(itemPath)
-                if (Object.keys(item).length > 0) {
-                  nestedPaths.push(itemPath)
-                }
-              }
-            })
-            if (hasNonObjects) {
-              hasSimpleFields = true
-              keys.push(fullPath)
-            }
-          }
-        } else {
-          console.log(
-            `[traverse] Non-empty array without objects at ${fullPath} - marking as simple field`
-          )
-          hasSimpleFields = true
-        }
-      } else if (isPojo(value)) {
-        if (Object.keys(value).length === 0) {
-          console.log(
-            `[traverse] Empty object at ${fullPath} - marking parent as having simple fields`
-          )
-          hasSimpleFields = true
-        } else {
-          // Don't traverse into the object if it only contains empty values
-          const containsOnlyEmptyCollections = Object.entries(value).every(
-            ([k, v]) => {
-              return (
-                (Array.isArray(v) && v.length === 0) ||
-                (isPojo(v) && Object.keys(v).length === 0) ||
-                (isBytes(v) && (v.length === 0 || v.byteLength === 0)) ||
-                (typeof v === "string" && v.length === 0)
-              )
-            }
-          )
-
-          if (containsOnlyEmptyCollections && Object.keys(value).length > 0) {
-            console.log(
-              `[traverse] Object at ${fullPath} contains only empty collections - adding as body key`
-            )
-            keys.push(fullPath)
-          } else {
-            // Check if this object contains arrays with only empty elements
-            const hasArraysWithOnlyEmptyElements = Object.entries(value).some(
-              ([k, v]) => {
-                return (
-                  Array.isArray(v) &&
-                  v.length > 0 &&
-                  v.every(
-                    item =>
-                      (Array.isArray(item) && item.length === 0) ||
-                      (isPojo(item) && Object.keys(item).length === 0) ||
-                      (typeof item === "string" && item === "")
-                  )
-                )
-              }
-            )
-
-            if (hasArraysWithOnlyEmptyElements) {
-              // This object needs a body part to show its array types
-              console.log(
-                `[traverse] Object at ${fullPath} has arrays with empty elements - adding as body key`
-              )
-              keys.push(fullPath)
-            }
-
-            console.log(
-              `[traverse] Non-empty object at ${fullPath} - will traverse into it`
-            )
-            nestedPaths.push(fullPath)
-          }
-        }
-      } else if (isBytes(value)) {
-        const buffer = toBuffer(value)
-        if (buffer.length > 0) {
-          hasSimpleFields = true
-        }
-      } else if (
-        typeof value === "string" ||
-        typeof value === "number" ||
-        typeof value === "boolean" ||
-        value === null ||
-        value === undefined ||
-        typeof value === "symbol"
-      ) {
-        hasSimpleFields = true
-      }
-    }
-
-    if (hasSimpleFields) {
-      console.log(`[traverse] Adding "${path}" to keys (has simple fields)`)
-      keys.push(path)
-    } else if (hasArraysWithObjects && path) {
-      // If the object only contains arrays with objects, we still need to add it as a body key
-      console.log(
-        `[traverse] Adding "${path}" to keys (contains arrays with objects)`
-      )
-      keys.push(path)
-    }
-
-    // Check for arrays with only empty elements that need their own body parts
-    for (const [key, value] of Object.entries(current)) {
-      const fullPath = path ? `${path}/${key}` : key
-
-      if (Array.isArray(value) && value.length > 0) {
-        const hasOnlyEmptyElements = value.every(
-          item =>
-            (Array.isArray(item) && item.length === 0) ||
-            (isPojo(item) && Object.keys(item).length === 0) ||
-            (typeof item === "string" && item === "")
-        )
-
-        if (hasOnlyEmptyElements) {
-          console.log(
-            `[traverse] Array at ${fullPath} has only empty elements - adding as body key`
-          )
-          keys.push(fullPath)
-        }
-      }
-    }
-
-    for (const nestedPath of nestedPaths) {
-      const parts = nestedPath.split("/")
-      let nestedObj = obj
-
-      for (const part of parts) {
-        if (/^\d+$/.test(part)) {
-          nestedObj = nestedObj[parseInt(part) - 1]
-        } else {
-          nestedObj = nestedObj[part]
-        }
-      }
-
-      if (isPojo(nestedObj)) {
-        traverse(nestedObj, nestedPath)
-      }
-    }
-  }
-
-  const objKeys = Object.keys(obj)
-
-  for (const [key, value] of Object.entries(obj)) {
-    console.log(`\n[main loop] Processing key: "${key}"`)
-    console.log(
-      `[main loop] Value type: ${Array.isArray(value) ? "array" : typeof value}`
-    )
-    console.log(
-      `[main loop] Array length: ${Array.isArray(value) ? value.length : "N/A"}`
-    )
-
-    if (
-      (key === "data" || key === "body") &&
-      (typeof value === "string" ||
-        typeof value === "boolean" ||
-        typeof value === "number" ||
-        value === null ||
-        value === undefined ||
-        typeof value === "symbol") &&
-      objKeys.length > 1
-    ) {
-      // Special handling: only add to body keys if there's no other data/body field with an object
-      if (
-        key === "data" &&
-        obj.body &&
-        isPojo(obj.body) &&
-        Object.keys(obj.body).length > 0
-      ) {
-        console.log(`[main loop] Skipping special data field`)
-      } else if (
-        key === "body" &&
-        obj.data &&
-        isPojo(obj.data) &&
-        Object.keys(obj.data).length > 0
-      ) {
-        console.log(`[main loop] Skipping special body field`)
-      } else {
-        console.log(`[main loop] Adding special data/body key: "${key}"`)
-        keys.push(key)
-      }
-    } else if (Array.isArray(value)) {
-      if (value.length === 0) {
-        console.log(`[main loop] SKIPPING empty array for key: "${key}"`)
-        continue
-      }
-
-      const hasObjects = value.some(item => isPojo(item))
-      const hasArrays = value.some(item => Array.isArray(item))
-      const hasNonObjects = value.some(item => !isPojo(item))
-
-      // Check if this is an array of arrays containing objects
-      const hasArraysOfObjects = value.some(
-        item => Array.isArray(item) && item.some(subItem => isPojo(subItem))
-      )
-
-      console.log(
-        `[main loop] Array analysis: hasObjects=${hasObjects}, hasArrays=${hasArrays}, hasNonObjects=${hasNonObjects}, hasArraysOfObjects=${hasArraysOfObjects}`
-      )
-
-      if (value.length > 0) {
-        let bodyPartCounter = 1 // Start counting from 1
-
-        // Check for special mixed array case
-        const hasEmptyStrings = value.some(
-          item => typeof item === "string" && item === ""
-        )
-        const hasEmptyObjects = value.some(
-          item => isPojo(item) && Object.keys(item).length === 0
-        )
-
-        // Check for objects that contain only empty values
-        const hasObjectsWithOnlyEmptyValues = value.some(item => {
-          if (!isPojo(item) || Object.keys(item).length === 0) return false
-          return Object.values(item).every(
-            v =>
-              (typeof v === "string" && v === "") ||
-              (Array.isArray(v) && v.length === 0) ||
-              (isPojo(v) && Object.keys(v).length === 0)
-          )
-        })
-
-        if (hasArraysOfObjects) {
-          // Handle arrays of arrays containing objects
-          value.forEach((item, index) => {
-            if (Array.isArray(item)) {
-              item.forEach((subItem, subIndex) => {
-                if (isPojo(subItem)) {
-                  const path = `${key}/${index + 1}/${subIndex + 1}`
-                  console.log(
-                    `[main loop] Adding nested object path: "${path}"`
-                  )
-                  keys.push(path)
-                }
-              })
-            }
-            bodyPartCounter++
-          })
-          // Always add the main array key
-          console.log(`[main loop] ADDING main array key: "${key}"`)
-          keys.push(key)
-        } else if (
-          hasObjects &&
-          (hasEmptyStrings || hasEmptyObjects) &&
-          !hasObjectsWithOnlyEmptyValues
-        ) {
-          // Special handling: only non-empty objects get parts
-          value.forEach((item, index) => {
-            if (isPojo(item) && Object.keys(item).length > 0) {
-              const path = `${key}/${bodyPartCounter}`
-              console.log(
-                `[main loop] Adding non-empty object path: "${path}" (array index ${index})`
-              )
-              keys.push(path)
-              // Add paths for nested objects
-              for (const [nestedKey, nestedValue] of Object.entries(item)) {
-                if (isPojo(nestedValue)) {
-                  const nestedPath = `${key}/${bodyPartCounter}/${nestedKey}`
-                  console.log(
-                    `[main loop] Adding nested object path: "${nestedPath}"`
-                  )
-                  keys.push(nestedPath)
-                }
-              }
-            }
-            bodyPartCounter++
-          })
-          // Always add the main array key
-          console.log(`[main loop] ADDING main array key: "${key}"`)
-          keys.push(key)
-        } else if (hasObjects) {
-          // Normal handling: all objects get parts (except if parent array has only empty elements)
-          let skipEmptyObjects = false
-
-          // Check if this array contains only empty elements
-          const arrayHasOnlyEmptyElements = value.every(
-            item =>
-              (Array.isArray(item) && item.length === 0) ||
-              (isPojo(item) && Object.keys(item).length === 0) ||
-              (typeof item === "string" && item === "")
-          )
-
-          if (arrayHasOnlyEmptyElements) {
-            skipEmptyObjects = true
-          }
-
-          value.forEach((item, index) => {
-            if (isPojo(item)) {
-              // Skip empty objects if array has only empty elements
-              if (skipEmptyObjects && Object.keys(item).length === 0) {
-                bodyPartCounter++
-                return
-              }
-
-              const path = `${key}/${bodyPartCounter}`
-              console.log(
-                `[main loop] Adding object path: "${path}" (array index ${index}, empty=${Object.keys(item).length === 0})`
-              )
-              keys.push(path)
-              // Add paths for nested objects (but not empty ones)
-              if (Object.keys(item).length > 0) {
-                for (const [nestedKey, nestedValue] of Object.entries(item)) {
-                  if (
-                    isPojo(nestedValue) &&
-                    Object.keys(nestedValue).length > 0
-                  ) {
-                    const nestedPath = `${key}/${bodyPartCounter}/${nestedKey}`
-                    console.log(
-                      `[main loop] Adding nested object path: "${nestedPath}"`
-                    )
-                    keys.push(nestedPath)
-                  }
-                }
-              }
-            } else if (typeof item === "string" && item === "") {
-              // Empty strings may get parts in some formats
-              const path = `${key}/${bodyPartCounter}`
-              console.log(
-                `[main loop] Adding empty string path: "${path}" (array index ${index})`
-              )
-              keys.push(path)
-            }
-            bodyPartCounter++
-          })
-          // Don't add main array key for arrays with only objects containing empty values
-          if (
-            !hasObjectsWithOnlyEmptyValues ||
-            value.some(item => !isPojo(item))
-          ) {
-            // Check if array has only empty elements
-            const hasOnlyEmptyElements = value.every(
-              item =>
-                (Array.isArray(item) && item.length === 0) ||
-                (isPojo(item) && Object.keys(item).length === 0) ||
-                (typeof item === "string" && item === "")
-            )
-
-            if (!hasOnlyEmptyElements) {
-              // Always add the main array key
-              console.log(`[main loop] ADDING main array key: "${key}"`)
-              keys.push(key)
-            }
-          }
-        } else {
-          // Check if array has only empty elements
-          const hasOnlyEmptyArraysOrObjects = value.every(
-            item =>
-              (Array.isArray(item) && item.length === 0) ||
-              (isPojo(item) && Object.keys(item).length === 0) ||
-              (typeof item === "string" && item === "")
-          )
-
-          if (hasOnlyEmptyArraysOrObjects && value.length > 0) {
-            // Always add the main array key for arrays with only empty elements
-            console.log(
-              `[main loop] ADDING main array key for empty elements: "${key}"`
-            )
-            keys.push(key)
-          } else if (!hasOnlyEmptyArraysOrObjects) {
-            // Always add the main array key
-            console.log(`[main loop] ADDING main array key: "${key}"`)
-            keys.push(key)
-          }
-        }
-      }
-    } else if (isPojo(value)) {
-      console.log(`[main loop] Processing object at key: "${key}"`)
-      // Objects should be traversed, not have their fields individually added
-      traverse(value, key)
-    } else if (isBytes(value)) {
-      const buffer = toBuffer(value)
-      if (buffer.length > 0) {
-        console.log(`[main loop] Adding key for non-empty bytes: "${key}"`)
-        keys.push(key)
-      }
-    } else if (typeof value === "string" && value.includes("\n")) {
-      console.log(`[main loop] Adding key for string with newline: "${key}"`)
-      keys.push(key)
-    } else if (typeof value === "string" && hasNonAscii(value)) {
-      console.log(`[main loop] Adding key for non-ASCII string: "${key}"`)
-      keys.push(key)
-    } else {
-      console.log(`[main loop] Skipping key: "${key}" (no match)`)
-    }
-  }
-
-  const result = [...new Set(keys)].filter(k => {
-    if (k === "") return false
-
-    // Check if this is a path to an empty object inside an array with only empty elements
-    const parts = k.split("/")
-    if (parts.length >= 2 && /^\d+$/.test(parts[parts.length - 1])) {
-      // This is an array element path like "maps/1"
-      const arrayPath = parts.slice(0, -1).join("/")
-      let arrayValue = obj
-
-      // Navigate to the array
-      for (const part of parts.slice(0, -1)) {
-        if (/^\d+$/.test(part)) {
-          arrayValue = arrayValue[parseInt(part) - 1]
-        } else {
-          arrayValue = arrayValue[part]
-        }
-      }
-
-      // Check if this array contains only empty elements
-      if (Array.isArray(arrayValue)) {
-        const hasOnlyEmptyElements = arrayValue.every(
-          item =>
-            (Array.isArray(item) && item.length === 0) ||
-            (isPojo(item) && Object.keys(item).length === 0) ||
-            (typeof item === "string" && item === "")
-        )
-
-        if (hasOnlyEmptyElements) {
-          // Filter out paths to individual empty elements
-          console.log(`[filter] Removing path to empty element: "${k}"`)
-          return false
-        }
-      }
-    }
-
-    return true
-  })
-  console.log("\n=== collectBodyKeys RESULT ===")
-  console.log("Final bodyKeys:", JSON.stringify(result))
-  console.log("=== collectBodyKeys END ===\n")
-
-  return result
+// Step 1: Process and normalize input values (handle symbols, nested objects/arrays)
+function processInputValues(obj) {
+  // Currently this is a no-op, but will be used for input validation/normalization
+  return obj
 }
 
-async function encode(obj = {}) {
-  console.log("\n=== ENCODE START ===")
-  console.log("Encoding object:", JSON.stringify(obj))
-
-  const processValue = value => {
-    if (typeof value === "symbol") {
-      return value.description || "Symbol.for()"
-    } else if (Array.isArray(value)) {
-      return value.map(processValue)
-    } else if (isPojo(value)) {
-      const result = {}
-      for (const [k, v] of Object.entries(value)) {
-        result[k] = processValue(v)
-      }
-      return result
-    }
-    return value
-  }
-
-  const processedObj = {}
-  for (const [k, v] of Object.entries(obj)) {
-    processedObj[k] = processValue(v)
-  }
-
+// Step 2: Handle empty object case
+function handleEmptyObject(obj) {
   if (Object.keys(obj).length === 0) {
     return { headers: {}, body: undefined }
   }
+  return null
+}
 
+// Step 3: Handle single field with empty binary
+function handleSingleEmptyBinaryField(obj) {
   const objKeys = Object.keys(obj)
 
   if (objKeys.length === 1) {
@@ -740,14 +50,11 @@ async function encode(obj = {}) {
     }
   }
 
-  if (
-    obj.body &&
-    isBytes(obj.body) &&
-    (obj.body.length === 0 || obj.body.byteLength === 0) &&
-    objKeys.length > 1
-  ) {
-  }
+  return null
+}
 
+// Step 4: Handle single field with binary data
+async function handleSingleBinaryField(obj) {
   const hasBodyBinary = obj.body && isBytes(obj.body)
   const otherFields = Object.keys(obj).filter(k => k !== "body")
 
@@ -766,28 +73,18 @@ async function encode(obj = {}) {
     return { headers, body: obj.body }
   }
 
+  return null
+}
+
+// Step 5: Handle single field with primitive value (string/number/boolean/null/undefined/symbol)
+async function handleSinglePrimitiveField(obj) {
+  const objKeys = Object.keys(obj)
+
   if (objKeys.length === 1) {
     const fieldName = objKeys[0]
     const fieldValue = obj[fieldName]
 
-    if (isBytes(fieldValue) && fieldValue.length > 0) {
-      const headers = {}
-      const bodyBuffer = toBuffer(fieldValue)
-      const bodyArrayBuffer = bodyBuffer.buffer.slice(
-        bodyBuffer.byteOffset,
-        bodyBuffer.byteOffset + bodyBuffer.byteLength
-      )
-
-      const contentDigest = await sha256(bodyArrayBuffer)
-      const base64 = base64url.toBase64(base64url.encode(contentDigest))
-      headers["content-digest"] = `sha-256=:${base64}:`
-
-      if (fieldName !== "body") {
-        headers["inline-body-key"] = fieldName
-      }
-
-      return { headers, body: fieldValue }
-    } else if (
+    if (
       (fieldName === "data" || fieldName === "body") &&
       (typeof fieldValue === "string" ||
         typeof fieldValue === "boolean" ||
@@ -797,21 +94,7 @@ async function encode(obj = {}) {
         typeof fieldValue === "symbol")
     ) {
       const headers = {}
-
-      let bodyContent
-      if (typeof fieldValue === "string") {
-        bodyContent = fieldValue
-      } else if (typeof fieldValue === "boolean") {
-        bodyContent = `"${fieldValue}"`
-      } else if (typeof fieldValue === "number") {
-        bodyContent = String(fieldValue)
-      } else if (fieldValue === null) {
-        bodyContent = '"null"'
-      } else if (fieldValue === undefined) {
-        bodyContent = '"undefined"'
-      } else if (typeof fieldValue === "symbol") {
-        bodyContent = `"${fieldValue.description || "Symbol.for()"}"`
-      }
+      const bodyContent = encodePrimitiveContent(fieldValue)
 
       const encoder = new TextEncoder()
       const encoded = encoder.encode(bodyContent)
@@ -819,16 +102,9 @@ async function encode(obj = {}) {
       const base64 = base64url.toBase64(base64url.encode(contentDigest))
       headers["content-digest"] = `sha-256=:${base64}:`
 
-      if (
-        typeof fieldValue === "boolean" ||
-        fieldValue === null ||
-        fieldValue === undefined ||
-        typeof fieldValue === "symbol"
-      ) {
-        headers["ao-types"] = `${fieldName.toLowerCase()}="atom"`
-      } else if (typeof fieldValue === "number") {
-        headers["ao-types"] =
-          `${fieldName.toLowerCase()}="${Number.isInteger(fieldValue) ? "integer" : "float"}"`
+      const aoType = getAoType(fieldValue)
+      if (aoType === "atom" || aoType === "integer" || aoType === "float") {
+        headers["ao-types"] = `${fieldName.toLowerCase()}="${aoType}"`
       }
 
       if (fieldName !== "body") {
@@ -836,7 +112,52 @@ async function encode(obj = {}) {
       }
 
       return { headers, body: bodyContent }
-    } else if (typeof fieldValue === "string" && hasNonAscii(fieldValue)) {
+    }
+  }
+
+  return null
+}
+
+// Step 6a: Handle single field with non-empty binary (not body field)
+async function handleSingleNonEmptyBinaryField(obj) {
+  const objKeys = Object.keys(obj)
+
+  if (objKeys.length === 1) {
+    const fieldName = objKeys[0]
+    const fieldValue = obj[fieldName]
+
+    if (isBytes(fieldValue) && fieldValue.length > 0) {
+      const headers = {}
+      const bodyBuffer = toBuffer(fieldValue)
+      const bodyArrayBuffer = bodyBuffer.buffer.slice(
+        bodyBuffer.byteOffset,
+        bodyBuffer.byteOffset + bodyBuffer.byteLength
+      )
+
+      const contentDigest = await sha256(bodyArrayBuffer)
+      const base64 = base64url.toBase64(base64url.encode(contentDigest))
+      headers["content-digest"] = `sha-256=:${base64}:`
+
+      if (fieldName !== "body") {
+        headers["inline-body-key"] = fieldName
+      }
+
+      return { headers, body: fieldValue }
+    }
+  }
+
+  return null
+}
+
+// Step 6: Handle single field with non-ASCII string
+async function handleSingleNonAsciiStringField(obj) {
+  const objKeys = Object.keys(obj)
+
+  if (objKeys.length === 1) {
+    const fieldName = objKeys[0]
+    const fieldValue = obj[fieldName]
+
+    if (typeof fieldValue === "string" && hasNonAscii(fieldValue)) {
       const headers = {}
       const encoder = new TextEncoder()
       const encoded = encoder.encode(fieldValue)
@@ -852,10 +173,16 @@ async function encode(obj = {}) {
     }
   }
 
-  const bodyKeys = collectBodyKeys(obj)
-  const headers = {}
-  const headerTypes = []
+  return null
+}
+
+// Step 7: Collect all keys that need to go in body
+function collectBodyKeysStep(obj) {
+  return collectBodyKeys(obj)
+}
 
+// Step 8: Process fields that can go in headers
+function processHeaderFields(obj, bodyKeys, headers, headerTypes) {
   for (const [key, value] of Object.entries(obj)) {
     const needsBody =
       bodyKeys.includes(key) || bodyKeys.some(k => k.startsWith(`${key}/`))
@@ -908,29 +235,15 @@ async function encode(obj = {}) {
         headerTypes.push(`${key.toLowerCase()}="empty-message"`)
       }
     } else {
-      if (isBytes(value) && (value.length === 0 || value.byteLength === 0)) {
-        headerTypes.push(`${key.toLowerCase()}="empty-binary"`)
-      } else if (typeof value === "string" && value.length === 0) {
-        headerTypes.push(`${key.toLowerCase()}="empty-binary"`)
-      } else if (Array.isArray(value) && value.length === 0) {
-        headerTypes.push(`${key.toLowerCase()}="empty-list"`)
-      } else if (isPojo(value) && Object.keys(value).length === 0) {
-        headerTypes.push(`${key.toLowerCase()}="empty-message"`)
-      } else if (
-        typeof value === "boolean" ||
-        value === null ||
-        value === undefined ||
-        typeof value === "symbol"
-      ) {
-        headerTypes.push(`${key.toLowerCase()}="atom"`)
-      } else if (typeof value === "number") {
-        headerTypes.push(
-          `${key.toLowerCase()}="${Number.isInteger(value) ? "integer" : "float"}"`
-        )
+      // Fields that need body still get type annotations
+      const aoType = getAoType(value)
+      if (aoType) {
+        headerTypes.push(`${key.toLowerCase()}="${aoType}"`)
       }
     }
   }
 
+  // Second pass for array type annotations
   for (const [key, value] of Object.entries(obj)) {
     if (Array.isArray(value)) {
       if (
@@ -943,9 +256,11 @@ async function encode(obj = {}) {
       }
     }
   }
+}
 
+// Step 9: Handle case where all body keys are empty binaries
+function handleAllEmptyBinaryBodyKeys(obj, bodyKeys, headers, headerTypes) {
   if (bodyKeys.length === 0) {
-    console.log("No bodyKeys, returning headers only")
     if (headerTypes.length > 0) {
       headers["ao-types"] = headerTypes.sort().join(", ")
     }
@@ -953,19 +268,7 @@ async function encode(obj = {}) {
   }
 
   const allBodyKeysAreEmptyBinaries = bodyKeys.every(key => {
-    const pathParts = key.split("/")
-    let value = obj
-    for (const part of pathParts) {
-      if (/^\d+$/.test(part)) {
-        const index = parseInt(part) - 1
-        console.log(
-          `[Body part] Getting array element at index ${index} from part ${part}`
-        )
-        value = value[index]
-      } else {
-        value = value[part]
-      }
-    }
+    const value = getValueByPath(obj, key)
     return isBytes(value) && (value.length === 0 || value.byteLength === 0)
   })
 
@@ -976,26 +279,23 @@ async function encode(obj = {}) {
     return { headers, body: undefined }
   }
 
+  return null
+}
+
+// Step 10: Handle single body key optimization
+async function handleSingleBodyKeyOptimization(
+  obj,
+  bodyKeys,
+  headers,
+  headerTypes
+) {
   if (bodyKeys.length === 1) {
     const singleKey = bodyKeys[0]
-    const pathParts = singleKey.split("/")
-    let value = obj
-    for (const part of pathParts) {
-      if (/^\d+$/.test(part)) {
-        value = value[parseInt(part) - 1]
-      } else {
-        value = value[part]
-      }
-    }
+    const value = getValueByPath(obj, singleKey)
 
     const otherFieldsAreEmpty = Object.entries(obj).every(([key, val]) => {
       if (key === singleKey) return true
-      return (
-        (Array.isArray(val) && val.length === 0) ||
-        (isPojo(val) && Object.keys(val).length === 0) ||
-        (isBytes(val) && (val.length === 0 || val.byteLength === 0)) ||
-        (typeof val === "string" && val.length === 0)
-      )
+      return isEmpty(val)
     })
 
     if (otherFieldsAreEmpty && isBytes(value) && value.length > 0) {
@@ -1021,23 +321,23 @@ async function encode(obj = {}) {
     }
   }
 
-  // Sort body keys: main array comes first, then element parts by index
-  const sortedBodyKeys = bodyKeys.sort((a, b) => {
+  return null
+}
+
+// Step 11: Sort body keys
+function sortBodyKeys(bodyKeys) {
+  return bodyKeys.sort((a, b) => {
     const aIsArrayElement = /\/\d+$/.test(a)
     const bIsArrayElement = /\/\d+$/.test(b)
     const aBase = a.split("/")[0]
     const bBase = b.split("/")[0]
-
-    // If both are for the same array
     if (aBase === bBase) {
-      // Main array comes before element parts
       if (!aIsArrayElement && bIsArrayElement) {
-        return -1 // main array comes first
+        return -1
       }
       if (aIsArrayElement && !bIsArrayElement) {
-        return 1 // element parts come after
+        return 1
       }
-      // Both are elements - sort by index
       if (aIsArrayElement && bIsArrayElement) {
         const aIndex = parseInt(a.split("/")[1])
         const bIndex = parseInt(b.split("/")[1])
@@ -1045,13 +345,13 @@ async function encode(obj = {}) {
       }
       return a.localeCompare(b)
     }
-
-    // Different arrays, sort by base name
     return a.localeCompare(b)
   })
+}
 
-  // Check if we have the special case where data contains body with bytes and body contains data with bytes
-  const hasSpecialDataBody =
+// Step 12: Check for special data/body case
+function checkSpecialDataBodyCase(obj, sortedBodyKeys) {
+  return (
     sortedBodyKeys.includes("data") &&
     sortedBodyKeys.includes("body") &&
     obj.data &&
@@ -1060,424 +360,593 @@ async function encode(obj = {}) {
     obj.body &&
     obj.body.data &&
     isBytes(obj.body.data)
+  )
+}
 
-  headers["body-keys"] = sortedBodyKeys.map(k => `"${k}"`).join(", ")
+// Step 13.2.2: Handle empty string in nested path
+function handleEmptyStringInNestedPath(bodyKey, value, pathParts) {
+  if (typeof value === "string" && value === "" && pathParts.length > 1) {
+    const lines = []
+    lines.push(`content-disposition: form-data;name="${bodyKey}"`)
+    lines.push("")
+    lines.push("")
+    return new Blob([lines.join("\r\n")])
+  }
+  return null
+}
 
-  if (!hasSpecialDataBody) {
-    if (sortedBodyKeys.includes("body") && sortedBodyKeys.length === 1) {
-      headers["inline-body-key"] = "body"
+// Step 13.2.3.2: Handle arrays with only empty elements
+function handleArrayWithOnlyEmptyElements(
+  bodyKey,
+  value,
+  headers,
+  sortedBodyKeys
+) {
+  const fieldLines = []
+  const partTypes = []
+
+  value.forEach((item, idx) => {
+    const index = idx + 1
+    const itemType = getAoType(item)
+    if (itemType) {
+      partTypes.push(`${index}="${itemType}"`)
     }
-  }
+  })
 
-  if (headerTypes.length > 0) {
-    headers["ao-types"] = headerTypes.sort().join(", ")
+  const isInline = bodyKey === "body" && headers["inline-body-key"] === "body"
+
+  if (isInline) {
+    const orderedLines = []
+    if (partTypes.length > 0) {
+      orderedLines.push(
+        `ao-types: ${sortTypeAnnotations(partTypes).join(", ")}`
+      )
+    }
+    orderedLines.push("content-disposition: inline")
+    orderedLines.push("")
+    return new Blob([orderedLines.join("\r\n")])
+  } else {
+    const orderedLines = []
+    if (partTypes.length > 0) {
+      orderedLines.push(
+        `ao-types: ${sortTypeAnnotations(partTypes).join(", ")}`
+      )
+    }
+    orderedLines.push(`content-disposition: form-data;name="${bodyKey}"`)
+
+    const isLastBodyPart =
+      sortedBodyKeys.indexOf(bodyKey) === sortedBodyKeys.length - 1
+    const hasOnlyTypes = partTypes.length > 0 && fieldLines.length === 0
+
+    if (isLastBodyPart && hasOnlyTypes) {
+      return new Blob([orderedLines.join("\r\n")])
+    } else {
+      orderedLines.push("")
+      return new Blob([orderedLines.join("\r\n")])
+    }
   }
+}
 
-  const bodyParts = []
+// Step 13.2.3.3: Build indices with own parts
+function buildIndicesWithOwnParts(bodyKey, sortedBodyKeys) {
+  const indicesWithOwnParts = new Set()
+  sortedBodyKeys.forEach(key => {
+    if (key.startsWith(bodyKey + "/")) {
+      const subPath = key.substring(bodyKey.length + 1)
+      const match = subPath.match(/^(\d+)/)
+      if (match) {
+        indicesWithOwnParts.add(parseInt(match[1]))
+      }
+    }
+  })
+  return indicesWithOwnParts
+}
 
-  for (const bodyKey of sortedBodyKeys) {
-    console.log(`\n[Body part] Processing bodyKey: ${bodyKey}`)
-    const lines = []
+// Step 13.2.3.4: Process array items
+function processArrayItems(
+  value,
+  indicesWithOwnParts,
+  hasNestedObjectParts,
+  pathParts
+) {
+  const fieldLines = []
+  const partTypes = []
+
+  if (hasNestedObjectParts) {
+    value.forEach((item, idx) => {
+      const index = idx + 1
+      if (Array.isArray(item)) {
+        partTypes.push(`${index}="list"`)
+      }
+    })
+  }
 
-    const pathParts = bodyKey.split("/")
-    let value = obj
-    let parent = null
+  value.forEach((item, idx) => {
+    const index = idx + 1
 
-    for (let i = 0; i < pathParts.length; i++) {
-      parent = value
-      const part = pathParts[i]
+    if (indicesWithOwnParts.has(index)) {
+      return
+    }
+    if (
+      hasNestedObjectParts &&
+      Array.isArray(item) &&
+      item.some(subItem => isPojo(subItem))
+    ) {
+      return
+    }
 
-      if (/^\d+$/.test(part)) {
-        value = value[parseInt(part) - 1]
+    if (typeof item === "string" && item === "") {
+      partTypes.push(`${index}="empty-binary"`)
+    } else if (isPojo(item) && Object.keys(item).length === 0) {
+      partTypes.push(`${index}="empty-message"`)
+    } else if (isPojo(item)) {
+      // Non-empty objects are handled elsewhere
+    } else if (Array.isArray(item)) {
+      if (item.length === 0) {
+        partTypes.push(`${index}="empty-list"`)
+      } else {
+        partTypes.push(`${index}="list"`)
+        const encodedItems = item
+          .map(subItem => {
+            if (typeof subItem === "number") {
+              if (Number.isInteger(subItem)) {
+                return `"(ao-type-integer) ${subItem}"`
+              } else {
+                return `"(ao-type-float) ${formatFloat(subItem)}"`
+              }
+            } else if (typeof subItem === "string") {
+              return `"${subItem}"`
+            } else if (subItem === null) {
+              return `"(ao-type-atom) \\"null\\""`
+            } else if (subItem === undefined) {
+              return `"(ao-type-atom) \\"undefined\\""`
+            } else if (typeof subItem === "symbol") {
+              const desc = subItem.description || "Symbol.for()"
+              return `"(ao-type-atom) \\"${desc}\\""`
+            } else if (typeof subItem === "boolean") {
+              return `"(ao-type-atom) \\"${subItem}\\""`
+            } else if (Array.isArray(subItem)) {
+              return encodeArrayItem(subItem)
+            } else if (isBytes(subItem)) {
+              const buffer = toBuffer(subItem)
+              if (buffer.length === 0 || buffer.byteLength === 0) {
+                return `""`
+              }
+              return `"(ao-type-binary)"`
+            } else if (isPojo(subItem)) {
+              const json = JSON.stringify(subItem)
+              const escaped = json.replace(/\\/g, "\\\\").replace(/"/g, '\\"')
+              return `"(ao-type-map) ${escaped}"`
+            } else {
+              return `"${String(subItem)}"`
+            }
+          })
+          .join(", ")
+        fieldLines.push(`${index}: ${encodedItems}`)
+      }
+    } else if (typeof item === "number") {
+      if (Number.isInteger(item)) {
+        partTypes.push(`${index}="integer"`)
+        fieldLines.push(`${index}: ${item}`)
+      } else {
+        partTypes.push(`${index}="float"`)
+        fieldLines.push(`${index}: ${formatFloat(item)}`)
+      }
+    } else if (typeof item === "string") {
+      fieldLines.push(`${index}: ${item}`)
+    } else if (
+      item === null ||
+      item === undefined ||
+      typeof item === "symbol" ||
+      typeof item === "boolean"
+    ) {
+      partTypes.push(`${index}="atom"`)
+      if (item === null) {
+        fieldLines.push(`${index}: null`)
+      } else if (item === undefined) {
+        fieldLines.push(`${index}: undefined`)
+      } else if (typeof item === "symbol") {
+        const desc = item.description || "Symbol.for()"
+        fieldLines.push(`${index}: ${desc}`)
       } else {
-        value = value[part]
+        fieldLines.push(`${index}: ${item}`)
+      }
+    } else if (isBytes(item)) {
+      const buffer = toBuffer(item)
+      if (buffer.length === 0) {
+        partTypes.push(`${index}="empty-binary"`)
+      } else {
+        partTypes.push(`${index}="binary"`)
       }
     }
+  })
 
-    console.log(`[Body part] Value at ${bodyKey}:`, JSON.stringify(value))
+  return { fieldLines, partTypes }
+}
 
-    // Special handling for empty strings in arrays
-    if (typeof value === "string" && value === "" && pathParts.length > 1) {
-      console.log(`[Body part] Creating part for empty string at ${bodyKey}`)
-      lines.push(`content-disposition: form-data;name="${bodyKey}"`)
-      lines.push("")
-      lines.push("")
-      bodyParts.push(new Blob([lines.join("\r\n")]))
-      continue
-    }
+// Step 13.2.3.5: Create array body part
+function createArrayBodyPart(bodyKey, fieldLines, partTypes, headers) {
+  const isInline = bodyKey === "body" && headers["inline-body-key"] === "body"
 
-    // Handle direct binary values
-    if (isBytes(value)) {
-      console.log(`[Body part] Creating part for binary at ${bodyKey}`)
-      lines.push(`content-disposition: form-data;name="${bodyKey}"`)
-      const buffer = toBuffer(value)
-      const headerText = lines.join("\r\n") + "\r\n\r\n"
-      bodyParts.push(new Blob([headerText, buffer]))
-      continue
+  if (isInline) {
+    const orderedLines = []
+    if (partTypes.length > 0) {
+      orderedLines.push(
+        `ao-types: ${sortTypeAnnotations(partTypes).join(", ")}`
+      )
     }
-
-    if (Array.isArray(value)) {
-      const hasOnlyEmptyElements =
-        value.length > 0 &&
-        value.every(
-          item =>
-            (Array.isArray(item) && item.length === 0) ||
-            (isPojo(item) && Object.keys(item).length === 0) ||
-            (typeof item === "string" && item === "")
-        )
-      const hasOnlyNonEmptyObjects =
-        value.length > 0 &&
-        value.every(item => isPojo(item) && Object.keys(item).length > 0)
-      const hasOnlyEmptyObjects =
-        value.length > 0 &&
-        value.every(item => isPojo(item) && Object.keys(item).length === 0)
-      const hasObjects = value.some(item => isPojo(item))
-      const hasArrays = value.some(item => Array.isArray(item))
-      const nonObjectItems = value
-        .map((item, index) => ({ item, index: index + 1 }))
-        .filter(({ item }) => !isPojo(item))
-
-      if (hasOnlyNonEmptyObjects) {
-        continue
+    orderedLines.push("content-disposition: inline")
+    if (fieldLines.length > 0) {
+      orderedLines.push("")
+      for (const line of fieldLines) {
+        orderedLines.push(line)
       }
+    }
+    return new Blob([orderedLines.join("\r\n") + "\r\n"])
+  } else {
+    const orderedLines = []
+    if (partTypes.length > 0) {
+      orderedLines.push(
+        `ao-types: ${sortTypeAnnotations(partTypes).join(", ")}`
+      )
+    }
+    orderedLines.push(`content-disposition: form-data;name="${bodyKey}"`)
+    for (const line of fieldLines) {
+      orderedLines.push(line)
+    }
+    if (fieldLines.length > 0) {
+      return new Blob([orderedLines.join("\r\n") + "\r\n"])
+    } else {
+      return new Blob([orderedLines.join("\r\n")])
+    }
+  }
+}
 
-      // For arrays containing only empty elements, we still need to show type info
-      if (hasOnlyEmptyElements) {
-        const fieldLines = []
-        const partTypes = []
-
-        // Process items for type information
-        value.forEach((item, idx) => {
-          const index = idx + 1
-          if (Array.isArray(item) && item.length === 0) {
-            partTypes.push(`${index}="empty-list"`)
-          } else if (isPojo(item) && Object.keys(item).length === 0) {
-            partTypes.push(`${index}="empty-message"`)
-          } else if (typeof item === "string" && item === "") {
-            partTypes.push(`${index}="empty-binary"`)
-          }
-        })
-
-        const isInline =
-          bodyKey === "body" && headers["inline-body-key"] === "body"
-
-        if (isInline) {
-          const orderedLines = []
-          if (partTypes.length > 0) {
-            orderedLines.push(
-              `ao-types: ${partTypes
-                .sort((a, b) => {
-                  const aNum = parseInt(a.split("=")[0])
-                  const bNum = parseInt(b.split("=")[0])
-                  return aNum - bNum
-                })
-                .join(", ")}`
-            )
-          }
-          orderedLines.push("content-disposition: inline")
-          orderedLines.push("")
-          bodyParts.push(new Blob([orderedLines.join("\r\n")]))
-        } else {
-          const orderedLines = []
-          if (partTypes.length > 0) {
-            orderedLines.push(
-              `ao-types: ${partTypes
-                .sort((a, b) => {
-                  const aNum = parseInt(a.split("=")[0])
-                  const bNum = parseInt(b.split("=")[0])
-                  return aNum - bNum
-                })
-                .join(", ")}`
-            )
-          }
-          orderedLines.push(`content-disposition: form-data;name="${bodyKey}"`)
-
-          // Check if this is the last body part
-          const isLastBodyPart =
-            sortedBodyKeys.indexOf(bodyKey) === sortedBodyKeys.length - 1
-          const hasOnlyTypes = partTypes.length > 0 && fieldLines.length === 0
-
-          if (isLastBodyPart && hasOnlyTypes) {
-            // Don't add empty line for last part with only types
-            bodyParts.push(new Blob([orderedLines.join("\r\n")]))
-          } else {
-            orderedLines.push("")
-            bodyParts.push(new Blob([orderedLines.join("\r\n")]))
-          }
-        }
-        continue
-      }
+// Step 13.2.3: Handle array values
+function handleArrayValue(bodyKey, value, headers, sortedBodyKeys, pathParts) {
+  const arrayInfo = analyzeArray(value)
 
-      // Build list of which indices have their own parts
-      const indicesWithOwnParts = new Set()
-      sortedBodyKeys.forEach(key => {
-        if (key.startsWith(bodyKey + "/")) {
-          const subPath = key.substring(bodyKey.length + 1)
-          const match = subPath.match(/^(\d+)/)
-          if (match) {
-            indicesWithOwnParts.add(parseInt(match[1]))
-          }
-        }
-      })
+  if (arrayInfo.hasOnlyNonEmptyObjects) {
+    return null
+  }
 
-      // Check if this array contains sub-arrays with objects that have their own parts
-      const hasNestedObjectParts = sortedBodyKeys.some(
-        key =>
-          key.startsWith(bodyKey + "/") &&
-          key.split("/").length > pathParts.length + 1
-      )
+  if (arrayInfo.hasOnlyEmptyElements) {
+    return handleArrayWithOnlyEmptyElements(
+      bodyKey,
+      value,
+      headers,
+      sortedBodyKeys
+    )
+  }
 
-      const fieldLines = []
-      const partTypes = []
-
-      // For arrays that contain sub-arrays with objects, we need to add type info for the sub-arrays
-      if (hasNestedObjectParts) {
-        value.forEach((item, idx) => {
-          const index = idx + 1
-          if (Array.isArray(item)) {
-            partTypes.push(`${index}="list"`)
-          }
-        })
-      }
+  const indicesWithOwnParts = buildIndicesWithOwnParts(bodyKey, sortedBodyKeys)
+  const hasNestedObjectParts = sortedBodyKeys.some(
+    key =>
+      key.startsWith(bodyKey + "/") &&
+      key.split("/").length > pathParts.length + 1
+  )
 
-      // Check if this array has mixed content with empty strings/objects
-      const hasEmptyStrings = value.some(
-        item => typeof item === "string" && item === ""
-      )
-      const hasEmptyObjects = value.some(
-        item => isPojo(item) && Object.keys(item).length === 0
+  const { fieldLines, partTypes } = processArrayItems(
+    value,
+    indicesWithOwnParts,
+    hasNestedObjectParts,
+    pathParts
+  )
+  return createArrayBodyPart(bodyKey, fieldLines, partTypes, headers)
+}
+
+// Step 13.2.4.3: Process object fields
+function processObjectFields(value, bodyKey, sortedBodyKeys) {
+  const objectTypes = []
+  const fieldLines = []
+  const binaryFields = []
+  const arrayTypes = []
+
+  // First collect array types
+  for (const [k, v] of Object.entries(value)) {
+    if (Array.isArray(v)) {
+      arrayTypes.push(
+        `${k.toLowerCase()}="${v.length === 0 ? "empty-list" : "list"}"`
       )
+    }
+  }
 
-      // Check if we have objects with only empty values (like {empty: ""})
-      const hasObjectsWithOnlyEmptyValues = value.some(item => {
-        if (!isPojo(item) || Object.keys(item).length === 0) return false
-        return Object.values(item).every(
-          v =>
-            (typeof v === "string" && v === "") ||
-            (Array.isArray(v) && v.length === 0) ||
-            (isPojo(v) && Object.keys(v).length === 0)
-        )
-      })
+  // Then process other fields
+  for (const [k, v] of Object.entries(value)) {
+    const childPath = `${bodyKey}/${k}`
 
-      const isMixedArray =
-        hasObjects &&
-        (hasEmptyStrings || hasEmptyObjects) &&
-        !hasObjectsWithOnlyEmptyValues
+    if (sortedBodyKeys.includes(childPath)) {
+      continue
+    }
 
-      // Process ALL items for type information
-      value.forEach((item, idx) => {
-        const index = idx + 1
+    if (Array.isArray(v) && v.some(item => isPojo(item))) {
+      const hasOnlyEmpty = v.every(item => isEmpty(item))
+      if (hasOnlyEmpty) {
+        continue
+      }
+    }
 
-        // Skip type info for elements that have their own parts
-        if (indicesWithOwnParts.has(index)) {
-          return
-        }
+    if (Array.isArray(v)) {
+      // Type already added in arrayTypes
+    } else if (
+      v === null ||
+      v === undefined ||
+      typeof v === "symbol" ||
+      typeof v === "boolean"
+    ) {
+      objectTypes.push(`${k.toLowerCase()}="atom"`)
+    } else if (typeof v === "number") {
+      objectTypes.push(
+        `${k.toLowerCase()}="${Number.isInteger(v) ? "integer" : "float"}"`
+      )
+    } else if (typeof v === "string" && v.length === 0) {
+      objectTypes.push(`${k.toLowerCase()}="empty-binary"`)
+    } else if (isBytes(v) && (v.length === 0 || v.byteLength === 0)) {
+      objectTypes.push(`${k.toLowerCase()}="empty-binary"`)
+    } else if (isPojo(v) && Object.keys(v).length === 0) {
+      objectTypes.push(`${k.toLowerCase()}="empty-message"`)
+    }
 
-        // If we have nested object parts and this is an array with objects, skip processing it inline
-        if (
-          hasNestedObjectParts &&
-          Array.isArray(item) &&
-          item.some(subItem => isPojo(subItem))
-        ) {
-          // Type info already added above
-          return
+    if (typeof v === "string") {
+      if (v.length === 0) {
+        fieldLines.push(`${k}: `)
+      } else {
+        fieldLines.push(`${k}: ${v}`)
+      }
+    } else if (typeof v === "number") {
+      fieldLines.push(`${k}: ${v}`)
+    } else if (typeof v === "boolean") {
+      fieldLines.push(`${k}: "${v}"`)
+    } else if (v === null) {
+      fieldLines.push(`${k}: "null"`)
+    } else if (v === undefined) {
+      fieldLines.push(`${k}: "undefined"`)
+    } else if (typeof v === "symbol") {
+      const desc = v.description || "Symbol.for()"
+      fieldLines.push(`${k}: "${desc}"`)
+    } else if (isBytes(v)) {
+      const buffer = toBuffer(v)
+      binaryFields.push({ key: k, buffer })
+    } else if (Array.isArray(v) && v.length > 0) {
+      const childPath = `${bodyKey}/${k}`
+      if (!sortedBodyKeys.includes(childPath)) {
+        const hasObjects = v.some(item => isPojo(item))
+        if (!hasObjects) {
+          const encodedItems = v.map(item => encodeArrayItem(item)).join(", ")
+          fieldLines.push(`${k}: ${encodedItems}`)
         }
+      }
+    }
+  }
 
-        // For all arrays (not just mixed ones), we need to process all items
-        if (typeof item === "string" && item === "") {
-          // Empty strings get type annotation but no field line
-          partTypes.push(`${index}="empty-binary"`)
-        } else if (isPojo(item) && Object.keys(item).length === 0) {
-          // Empty objects don't get field lines but do get type annotations
-          partTypes.push(`${index}="empty-message"`)
-        } else if (isPojo(item)) {
-          // Non-empty objects might have parts
-        } else if (Array.isArray(item)) {
-          if (item.length === 0) {
-            // Empty arrays don't get field lines but do get type annotations
-            partTypes.push(`${index}="empty-list"`)
-          } else {
-            partTypes.push(`${index}="list"`)
-            // Encode array
-            const encodedItems = item
-              .map(subItem => {
-                if (typeof subItem === "number") {
-                  if (Number.isInteger(subItem)) {
-                    return `"(ao-type-integer) ${subItem}"`
-                  } else {
-                    return `"(ao-type-float) ${formatFloat(subItem)}"`
-                  }
-                } else if (typeof subItem === "string") {
-                  return `"${subItem}"`
-                } else if (subItem === null) {
-                  return `"(ao-type-atom) \\"null\\""`
-                } else if (subItem === undefined) {
-                  return `"(ao-type-atom) \\"undefined\\""`
-                } else if (typeof subItem === "symbol") {
-                  const desc = subItem.description || "Symbol.for()"
-                  return `"(ao-type-atom) \\"${desc}\\""`
-                } else if (typeof subItem === "boolean") {
-                  return `"(ao-type-atom) \\"${subItem}\\""`
-                } else if (Array.isArray(subItem)) {
-                  // Use the full encodeArrayItem for nested arrays
-                  return encodeArrayItem(subItem)
-                } else if (isBytes(subItem)) {
-                  const buffer = toBuffer(subItem)
-                  if (buffer.length === 0 || buffer.byteLength === 0) {
-                    return `""`
-                  }
-                  return `"(ao-type-binary)"`
-                } else if (isPojo(subItem)) {
-                  const json = JSON.stringify(subItem)
-                  const escaped = json
-                    .replace(/\\/g, "\\\\")
-                    .replace(/"/g, '\\"')
-                  return `"(ao-type-map) ${escaped}"`
-                } else {
-                  return `"${String(subItem)}"`
-                }
-              })
-              .join(", ")
-            fieldLines.push(`${index}: ${encodedItems}`)
-          }
-        } else if (typeof item === "number") {
-          if (Number.isInteger(item)) {
-            partTypes.push(`${index}="integer"`)
-            fieldLines.push(`${index}: ${item}`)
-          } else {
-            partTypes.push(`${index}="float"`)
-            fieldLines.push(`${index}: ${formatFloat(item)}`)
-          }
-        } else if (typeof item === "string") {
-          // Non-empty strings just get field lines, no type annotation
-          fieldLines.push(`${index}: ${item}`)
-        } else if (
-          item === null ||
-          item === undefined ||
-          typeof item === "symbol" ||
-          typeof item === "boolean"
-        ) {
-          partTypes.push(`${index}="atom"`)
-          if (item === null) {
-            fieldLines.push(`${index}: null`)
-          } else if (item === undefined) {
-            fieldLines.push(`${index}: undefined`)
-          } else if (typeof item === "symbol") {
-            const desc = item.description || "Symbol.for()"
-            fieldLines.push(`${index}: ${desc}`)
-          } else {
-            fieldLines.push(`${index}: ${item}`)
-          }
-        } else if (isBytes(item)) {
-          const buffer = toBuffer(item)
-          if (buffer.length === 0) {
-            partTypes.push(`${index}="empty-binary"`)
-          } else {
-            partTypes.push(`${index}="binary"`)
-          }
-        }
-      })
-
-      const isInline =
-        bodyKey === "body" && headers["inline-body-key"] === "body"
-
-      if (isInline) {
-        const orderedLines = []
-
-        if (partTypes.length > 0) {
-          orderedLines.push(
-            `ao-types: ${partTypes
-              .sort((a, b) => {
-                const aNum = parseInt(a.split("=")[0])
-                const bNum = parseInt(b.split("=")[0])
-                return aNum - bNum
-              })
-              .join(", ")}`
-          )
-        }
+  const allTypes = [...arrayTypes, ...objectTypes]
+  return { allTypes, fieldLines, binaryFields }
+}
 
-        orderedLines.push("content-disposition: inline")
+// Step 13.2.4.5: Create object body part
+function createObjectBodyPart(
+  bodyKey,
+  value,
+  allTypes,
+  fieldLines,
+  binaryFields,
+  headers,
+  sortedBodyKeys
+) {
+  const isInline = bodyKey === "body" && headers["inline-body-key"] === "body"
+  const lines = []
+
+  if (isInline) {
+    lines.push(`content-disposition: inline`)
+  } else {
+    lines.push(`content-disposition: form-data;name="${bodyKey}"`)
+  }
 
-        if (fieldLines.length > 0) {
-          orderedLines.push("")
-          for (const line of fieldLines) {
-            orderedLines.push(line)
-          }
-        }
+  if (isInline) {
+    const orderedLines = []
+    for (const line of fieldLines) {
+      orderedLines.push(line)
+    }
+    if (allTypes.length > 0) {
+      orderedLines.push(`ao-types: ${allTypes.sort().join(", ")}`)
+    }
+    orderedLines.push("content-disposition: inline")
 
-        bodyParts.push(new Blob([orderedLines.join("\r\n") + "\r\n"]))
+    const binaryFieldsForInline = Object.entries(value)
+      .filter(
+        ([k, v]) => isBytes(v) && !sortedBodyKeys.includes(`${bodyKey}/${k}`)
+      )
+      .map(([k, v]) => ({
+        key: k,
+        buffer: toBuffer(v),
+      }))
+
+    if (binaryFieldsForInline.length > 0) {
+      const parts = []
+      parts.push(Buffer.from(orderedLines.join("\r\n")))
+      for (const { key, buffer } of binaryFieldsForInline) {
+        parts.push(Buffer.from(`\r\n${key}: `))
+        parts.push(buffer)
+      }
+      parts.push(Buffer.from("\r\n"))
+      const fullBody = Buffer.concat(parts)
+      return new Blob([fullBody])
+    } else {
+      const isLastBodyPart =
+        sortedBodyKeys.indexOf(bodyKey) === sortedBodyKeys.length - 1
+      const hasOnlyTypes = allTypes.length > 0 && fieldLines.length === 0
+      if (isLastBodyPart && hasOnlyTypes) {
+        return new Blob([orderedLines.join("\r\n")])
+      } else if (fieldLines.length === 0) {
+        return new Blob([orderedLines.join("\r\n")])
       } else {
-        // Put ao-types first, then content-disposition, then field lines
-        const orderedLines = []
-
-        if (partTypes.length > 0) {
-          orderedLines.push(
-            `ao-types: ${partTypes
-              .sort((a, b) => {
-                const aNum = parseInt(a.split("=")[0])
-                const bNum = parseInt(b.split("=")[0])
-                return aNum - bNum
-              })
-              .join(", ")}`
-          )
-        }
+        return new Blob([orderedLines.join("\r\n") + "\r\n"])
+      }
+    }
+  } else {
+    const orderedLines = []
+    if (allTypes.length > 0) {
+      orderedLines.push(`ao-types: ${allTypes.sort().join(", ")}`)
+    }
+    orderedLines.push(`content-disposition: form-data;name="${bodyKey}"`)
 
-        orderedLines.push(`content-disposition: form-data;name="${bodyKey}"`)
+    const hasBinaryFields = binaryFields && binaryFields.length > 0
+    if (hasBinaryFields || fieldLines.length === 0) {
+      orderedLines.push("")
+    }
 
-        // Add field lines directly without blank line
-        for (const line of fieldLines) {
-          orderedLines.push(line)
-        }
+    for (const line of fieldLines) {
+      orderedLines.push(line)
+    }
 
-        // Add trailing blank line if we have field lines
-        if (fieldLines.length > 0) {
-          bodyParts.push(new Blob([orderedLines.join("\r\n") + "\r\n"]))
-        } else {
-          bodyParts.push(new Blob([orderedLines.join("\r\n")]))
+    if (binaryFields && binaryFields.length > 0) {
+      const parts = []
+      const headerText = orderedLines.join("\r\n")
+      parts.push(Buffer.from(headerText))
+      for (let i = 0; i < binaryFields.length; i++) {
+        const { key, buffer } = binaryFields[i]
+        if (i > 0) {
+          parts.push(Buffer.from("\r\n"))
         }
+        parts.push(Buffer.from(`${key}: `))
+        parts.push(buffer)
       }
-      continue
-    }
-
-    // This should not be reached for binary values as they're handled above
-    const isInline = bodyKey === "body" && headers["inline-body-key"] === "body"
-    if (isInline) {
-      lines.push(`content-disposition: inline`)
+      parts.push(Buffer.from("\r\n"))
+      const fullBody = Buffer.concat(parts)
+      return new Blob([fullBody])
     } else {
-      lines.push(`content-disposition: form-data;name="${bodyKey}"`)
+      if (fieldLines.length > 0) {
+        return new Blob([orderedLines.join("\r\n") + "\r\n"])
+      } else {
+        return new Blob([orderedLines.join("\r\n")])
+      }
     }
+  }
+}
 
-    if (typeof value === "string") {
-      lines.push("")
-      lines.push(value)
-      bodyParts.push(new Blob([lines.join("\r\n")]))
-    } else if (
-      typeof value === "boolean" ||
-      typeof value === "number" ||
-      value === null ||
-      value === undefined ||
-      typeof value === "symbol"
-    ) {
-      let content
-      if (typeof value === "boolean") {
-        content = `"${value}"`
-      } else if (typeof value === "number") {
-        content = String(value)
-      } else if (value === null) {
-        content = '"null"'
-      } else if (value === undefined) {
-        content = '"undefined"'
-      } else if (typeof value === "symbol") {
-        content = `"${value.description || "Symbol.for()"}"`
+// Step 13.2.4: Handle object values
+function handleObjectValue(
+  obj,
+  bodyKey,
+  value,
+  headers,
+  sortedBodyKeys,
+  pathParts,
+  hasSpecialDataBody
+) {
+  if (Object.keys(value).length === 0) {
+    // Skip empty objects in certain contexts
+    const parentPath = pathParts.slice(0, -1).join("/")
+    const parentValue = parentPath ? getValueByPath(obj, parentPath) : obj
+
+    if (Array.isArray(parentValue)) {
+      const parentArrayInfo = analyzeArray(parentValue)
+      if (
+        parentArrayInfo.hasObjects &&
+        (parentArrayInfo.hasEmptyStrings || parentArrayInfo.hasEmptyObjects)
+      ) {
+        return null
       }
+    }
+    return null
+  }
+
+  // Skip special data/body case
+  if (
+    hasSpecialDataBody &&
+    bodyKey === "data" &&
+    Object.keys(value).length === 1 &&
+    value.body &&
+    isBytes(value.body)
+  ) {
+    return null
+  }
+
+  const { allTypes, fieldLines, binaryFields } = processObjectFields(
+    value,
+    bodyKey,
+    sortedBodyKeys
+  )
+
+  // Check if object should be skipped
+  const hasOnlyEmptyCollections = Object.entries(value).every(([k, v]) =>
+    isEmpty(v)
+  )
+  const hasArraysWithOnlyEmptyElements = Object.entries(value).some(
+    ([k, v]) =>
+      Array.isArray(v) && v.length > 0 && v.every(item => isEmpty(item))
+  )
 
-      lines.push("")
-      lines.push(content)
-      bodyParts.push(new Blob([lines.join("\r\n")]))
+  const shouldSkipObject = Object.entries(value).every(([k, v]) => {
+    const childPath = `${bodyKey}/${k}`
+    if (sortedBodyKeys.includes(childPath)) return true
+    if (Array.isArray(v) && v.some(item => isPojo(item))) {
+      const hasOnlyEmpty = v.every(item => isEmpty(item))
+      return hasOnlyEmpty || sortedBodyKeys.includes(childPath)
     }
+    return false
+  })
+
+  if (
+    shouldSkipObject &&
+    !hasOnlyEmptyCollections &&
+    !hasArraysWithOnlyEmptyElements
+  ) {
+    return null
+  }
+
+  return createObjectBodyPart(
+    bodyKey,
+    value,
+    allTypes,
+    fieldLines,
+    binaryFields,
+    headers,
+    sortedBodyKeys
+  )
+}
+
+// Step 13.2.5: Handle primitive values
+function handlePrimitiveValue(bodyKey, value, headers) {
+  const isInline = bodyKey === "body" && headers["inline-body-key"] === "body"
+  const lines = []
+
+  if (isInline) {
+    lines.push(`content-disposition: inline`)
+  } else {
+    lines.push(`content-disposition: form-data;name="${bodyKey}"`)
   }
 
-  // Add the special data/body part if needed
+  if (typeof value === "string") {
+    lines.push("")
+    lines.push(value)
+    return new Blob([lines.join("\r\n")])
+  } else {
+    const content = encodePrimitiveContent(value)
+    lines.push("")
+    lines.push(content)
+    return new Blob([lines.join("\r\n")])
+  }
+}
+
+// Step 13.2.6: Handle binary values
+function handleBinaryValue(bodyKey, value, headers) {
+  const isInline = bodyKey === "body" && headers["inline-body-key"] === "body"
+  const lines = []
+
+  if (isInline) {
+    lines.push(`content-disposition: inline`)
+  } else {
+    lines.push(`content-disposition: form-data;name="${bodyKey}"`)
+  }
+
+  const buffer = toBuffer(value)
+  const headerText = lines.join("\r\n") + "\r\n\r\n"
+  return new Blob([headerText, buffer])
+}
+
+// Step 13.3: Handle special data/body case
+function handleSpecialDataBodyCase(obj, hasSpecialDataBody) {
   if (
     hasSpecialDataBody &&
     obj.data &&
@@ -1490,14 +959,108 @@ async function encode(obj = {}) {
       "",
       "",
     ].join("\r\n")
-    bodyParts.push(new Blob([specialPart, buffer]))
+    return new Blob([specialPart, buffer])
   }
+  return null
+}
+
+// Step 13: Build body parts for each body key
+function buildBodyParts(obj, sortedBodyKeys, headers, hasSpecialDataBody) {
+  // Step 13.1: Initialize body parts collection
+  const bodyParts = []
+
+  // Step 13.2: Process each body key
+  for (const bodyKey of sortedBodyKeys) {
+    // Step 13.2.1: Get value for current body key
+    const value = getValueByPath(obj, bodyKey)
+    const pathParts = bodyKey.split("/")
+
+    // Step 13.2.2: Handle empty string in nested path
+    const emptyStringPart = handleEmptyStringInNestedPath(
+      bodyKey,
+      value,
+      pathParts
+    )
+    if (emptyStringPart) {
+      bodyParts.push(emptyStringPart)
+      continue
+    }
+
+    // Step 13.2.3: Handle array values
+    if (Array.isArray(value)) {
+      const arrayPart = handleArrayValue(
+        bodyKey,
+        value,
+        headers,
+        sortedBodyKeys,
+        pathParts
+      )
+      if (arrayPart) {
+        bodyParts.push(arrayPart)
+      }
+      continue
+    }
+
+    // Step 13.2.4: Handle object values
+    if (isPojo(value)) {
+      const objectPart = handleObjectValue(
+        obj,
+        bodyKey,
+        value,
+        headers,
+        sortedBodyKeys,
+        pathParts,
+        hasSpecialDataBody
+      )
+      if (objectPart) {
+        bodyParts.push(objectPart)
+      }
+      continue
+    }
 
+    // Step 13.2.5: Handle primitive values
+    if (
+      typeof value === "string" ||
+      typeof value === "boolean" ||
+      typeof value === "number" ||
+      value === null ||
+      value === undefined ||
+      typeof value === "symbol"
+    ) {
+      const primitivePart = handlePrimitiveValue(bodyKey, value, headers)
+      bodyParts.push(primitivePart)
+      continue
+    }
+
+    // Step 13.2.6: Handle binary values
+    if (isBytes(value)) {
+      const binaryPart = handleBinaryValue(bodyKey, value, headers)
+      bodyParts.push(binaryPart)
+      continue
+    }
+  }
+
+  // Step 13.3: Handle special data/body case
+  const specialPart = handleSpecialDataBodyCase(obj, hasSpecialDataBody)
+  if (specialPart) {
+    bodyParts.push(specialPart)
+  }
+
+  // Step 13.4: Return body parts
+  return bodyParts
+}
+
+// Step 14: Generate multipart boundary
+async function generateBoundary(bodyParts) {
   const partsContent = await Promise.all(bodyParts.map(part => part.text()))
   const allContent = partsContent.join("")
   const boundaryHash = await sha256(new TextEncoder().encode(allContent))
   const boundary = base64url.encode(Buffer.from(boundaryHash))
+  return boundary
+}
 
+// Step 15: Assemble final multipart body
+function assembleMultipartBody(bodyParts, boundary) {
   const finalParts = []
   for (let i = 0; i < bodyParts.length; i++) {
     if (i === 0) {
@@ -1509,20 +1072,130 @@ async function encode(obj = {}) {
   }
   finalParts.push(new Blob([`\r\n--${boundary}--`]))
 
-  headers["content-type"] = `multipart/form-data; boundary="${boundary}"`
-  const body = new Blob(finalParts)
+  return new Blob(finalParts)
+}
 
+// Step 16: Calculate content digest
+async function calculateContentDigest(body) {
   const finalContent = await body.arrayBuffer()
 
   if (finalContent.byteLength > 0) {
     const contentDigest = await sha256(finalContent)
     const base64 = base64url.toBase64(base64url.encode(contentDigest))
-    headers["content-digest"] = `sha-256=:${base64}:`
+    return { digest: base64, byteLength: finalContent.byteLength }
   }
 
-  headers["content-length"] = String(finalContent.byteLength)
+  return { digest: null, byteLength: finalContent.byteLength }
+}
+
+// Step 17: Set final headers (content-type, content-length)
+function setFinalHeaders(headers, boundary, contentDigest, byteLength) {
+  headers["content-type"] = `multipart/form-data; boundary="${boundary}"`
+
+  if (contentDigest) {
+    headers["content-digest"] = `sha-256=:${contentDigest}:`
+  }
+
+  headers["content-length"] = String(byteLength)
+}
+
+async function encode(obj = {}) {
+  // Step 1: Process and normalize input values
+  const processedObj = processInputValues(obj)
+
+  // Step 2: Handle empty object case
+  const emptyResult = handleEmptyObject(processedObj)
+  if (emptyResult) return emptyResult
+
+  // Step 3: Handle single field with empty binary
+  const emptyBinaryResult = handleSingleEmptyBinaryField(processedObj)
+  if (emptyBinaryResult) return emptyBinaryResult
+
+  // Step 4: Handle single field with binary data
+  const singleBinaryResult = await handleSingleBinaryField(processedObj)
+  if (singleBinaryResult) return singleBinaryResult
+
+  // Step 5: Handle single field with primitive value
+  const primitiveResult = await handleSinglePrimitiveField(processedObj)
+  if (primitiveResult) return primitiveResult
+
+  // Step 6a: Handle single field with non-empty binary
+  const nonEmptyBinaryResult =
+    await handleSingleNonEmptyBinaryField(processedObj)
+  if (nonEmptyBinaryResult) return nonEmptyBinaryResult
+
+  // Step 6: Handle single field with non-ASCII string
+  const nonAsciiResult = await handleSingleNonAsciiStringField(processedObj)
+  if (nonAsciiResult) return nonAsciiResult
+
+  // Step 7: Collect all keys that need to go in body
+  const bodyKeys = collectBodyKeysStep(processedObj)
+
+  const objKeys = Object.keys(obj)
+  const headers = {}
+  const headerTypes = []
+
+  // Step 8: Process fields that can go in headers
+  processHeaderFields(obj, bodyKeys, headers, headerTypes)
+
+  // Step 9: Handle case where all body keys are empty binaries
+  const emptyBinaryBodyResult = handleAllEmptyBinaryBodyKeys(
+    obj,
+    bodyKeys,
+    headers,
+    headerTypes
+  )
+  if (emptyBinaryBodyResult) return emptyBinaryBodyResult
+
+  // Step 10: Handle single body key optimization
+  const singleBodyKeyResult = await handleSingleBodyKeyOptimization(
+    obj,
+    bodyKeys,
+    headers,
+    headerTypes
+  )
+  if (singleBodyKeyResult) return singleBodyKeyResult
+
+  // Step 11: Sort body keys
+  const sortedBodyKeys = sortBodyKeys(bodyKeys)
+
+  // Step 12: Check for special data/body case
+  const hasSpecialDataBody = checkSpecialDataBodyCase(obj, sortedBodyKeys)
+
+  headers["body-keys"] = sortedBodyKeys.map(k => `"${k}"`).join(", ")
+
+  if (!hasSpecialDataBody) {
+    if (sortedBodyKeys.includes("body") && sortedBodyKeys.length === 1) {
+      headers["inline-body-key"] = "body"
+    }
+  }
+
+  if (headerTypes.length > 0) {
+    headers["ao-types"] = headerTypes.sort().join(", ")
+  }
+
+  // Step 13: Build body parts for each body key
+  const bodyParts = buildBodyParts(
+    obj,
+    sortedBodyKeys,
+    headers,
+    hasSpecialDataBody
+  )
+
+  // Step 14: Generate multipart boundary
+  const boundary = await generateBoundary(bodyParts)
+
+  // Step 15: Assemble final multipart body
+  const body = assembleMultipartBody(bodyParts, boundary)
+
+  // Step 16: Calculate content digest
+  const { digest: contentDigest, byteLength } =
+    await calculateContentDigest(body)
+
+  // Step 17: Set final headers (content-type, content-length)
+  setFinalHeaders(headers, boundary, contentDigest, byteLength)
 
-  console.log("=== ENCODE END ===\n")
+  // Step 18: Return result
   return { headers, body }
 }