.toList()


private
fun applyConventionMappingTo(taskType: Class<*>, relevantFields: List<RelevantField>): List<RelevantField> =
    conventionAwareFieldsOf(taskType).toMap().let { flags ->
        relevantFields.map { relevantField ->
            relevantField.run {
                flags[field]?.let { flagField ->

    beanType: Class<*>
) : BeanStateWriter {

    private
    val relevantFields = relevantStateOf(beanType)

    /**
     * Serializes a bean by serializing the value of each of its fields.
     */
    override suspend fun WriteContext.writeStateOf(bean: Any) {
        for (relevantField in relevantFields) {
            val field = relevantField.field
            val fieldName = field.name
            val fieldValue =

        JavaRecordEncoding.takeIf { type.superclass?.canonicalName == "java.lang.Record" }

    override suspend fun ReadContext.decode(): Any? {
        val clazz = readClass()
        val fields = clazz.relevantFields

        val args = readFields(fields)
        val types = fields.map { it.type }.toTypedArray()
        return try {
            clazz.getConstructor(*types).newInstance(*args.toTypedArray())

    } else {
        constructorForSerialization.newInstance()
    }

    override suspend fun ReadContext.readStateOf(bean: Any) {
        for (relevantField in relevantFields) {
            val field = relevantField.field
            val fieldName = field.name
            relevantField.unsupportedFieldType?.let {
                reportUnsupportedFieldType(it, "deserialize", fieldName)
            }

      ImmutableSet<String> uppercaseAcronyms)
      throws IllegalAccessException {
    for (Field field : relevantFields(clazz)) {
      assertEquals(
          upperToHttpHeaderName(field.getName(), specialCases, uppercaseAcronyms), field.get(null));
    }
  }

  // Visible for other tests to use
  static ImmutableSet<Field> relevantFields(Class<?> cls) {
    ImmutableSet.Builder<Field> builder = ImmutableSet.builder();