@@ -329,6 +329,7 @@ java_library(
     deps = [
         ":base_proto_cel_value_converter",
         ":optimized_selectable",
+        ":preadapted_list",
         ":select_field",
         ":values",
         "//:auto_value",
@@ -360,6 +361,7 @@ cel_android_library(
     deps = [
         ":base_proto_cel_value_converter_android",
         ":optimized_selectable_android",
+        ":preadapted_list_android",
         ":select_field_android",
         ":values_android",
         "//:auto_value",
 
@@ -25,6 +25,7 @@
 import com.google.protobuf.ByteString;
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.ExtensionRegistryLite;
+import com.google.protobuf.Internal.EnumLite;
 import com.google.protobuf.InvalidProtocolBufferException;
 import com.google.protobuf.MessageLite;
 import com.google.protobuf.WireFormat;
@@ -118,34 +119,39 @@ private Object readLengthDelimitedField(
         return CelByteString.of(inputStream.readByteArray());
       case MESSAGE:
         return mergeOrReadMessageField(
-            inputStream.readBytes(), fieldDescriptor.getFieldProtoTypeName(), existingValue);
+            inputStream.readBytes(),
+            fieldDescriptor.getFieldProtoTypeName(),
+            existingValue,
+            /* isView= */ true);
       case STRING:
         return inputStream.readStringRequireUtf8();
       default:
         throw new IllegalStateException("Unexpected field type: " + fieldType);
     }
   }
 
+  // Reads bytes of their own, not a view of another message's.
   private Object readMessageField(ByteString bytes, String fieldProtoTypeName) {
-    return mergeOrReadMessageField(bytes, fieldProtoTypeName, /* existingValue= */ null);
+    return mergeOrReadMessageField(
+        bytes, fieldProtoTypeName, /* existingValue= */ null, /* isView= */ false);
   }
 
   private Object mergeOrReadMessageField(
-      ByteString bytes, String fieldProtoTypeName, @Nullable Object existingValue) {
+      ByteString bytes, String fieldProtoTypeName, @Nullable Object existingValue, boolean isView) {
     MessageLiteDescriptor descriptor =
         descriptorPool.findDescriptor(fieldProtoTypeName).orElse(null);
     if (descriptor == null) {
       if (existingValue instanceof RawProtoMessageLiteValue) {
         bytes = ((RawProtoMessageLiteValue) existingValue).toByteString().concat(bytes);
       }
-      return RawProtoMessageLiteValue.create(bytes, fieldProtoTypeName, this, /* isView= */ true);
+      return RawProtoMessageLiteValue.create(bytes, fieldProtoTypeName, this, isView);
     }
     WellKnownProto wellKnownProto = WellKnownProto.getByTypeName(fieldProtoTypeName).orElse(null);
     if (isStructLike(wellKnownProto)) {
       if (existingValue instanceof ProtoMessageLiteValue) {
         bytes = ((ProtoMessageLiteValue) existingValue).toByteString().concat(bytes);
       }
-      return ProtoMessageLiteValue.create(bytes, fieldProtoTypeName, this);
+      return ProtoMessageLiteValue.create(bytes, descriptor, this);
     }
     if (existingValue instanceof MessageLite) {
       return mergeMessageLite(((MessageLite) existingValue).toBuilder(), bytes, fieldProtoTypeName);
@@ -163,24 +169,19 @@ Object getDefaultCelValue(FieldLiteDescriptor fieldDescriptor) {
     return toRuntimeValue(getDefaultValue(fieldDescriptor));
   }
 
-  private Optional<FieldLiteDescriptor> findFieldDescriptor(String protoTypeName, int fieldNumber) {
-    return descriptorPool
-        .findDescriptor(protoTypeName)
-        .flatMap(desc -> desc.findByFieldNumber(fieldNumber));
+  // A selected field's default value: the one in the SelectField, else its type's.
+  Object getDefaultCelValue(SelectField field, FieldLiteDescriptor fieldDescriptor) {
+    return field.defaultValue() != null
+        ? field.defaultValue()
+        : getDefaultCelValue(fieldDescriptor);
   }
 
-  Optional<FieldLiteDescriptor> findFieldDescriptor(String protoTypeName, String fieldName) {
-    return descriptorPool
-        .findDescriptor(protoTypeName)
-        .flatMap(desc -> desc.findByFieldName(fieldName));
+  private @Nullable FieldLiteDescriptor findFieldDescriptor(String protoTypeName, int fieldNumber) {
+    MessageLiteDescriptor descriptor = descriptorPool.findDescriptor(protoTypeName).orElse(null);
+    return descriptor == null ? null : descriptor.findByFieldNumber(fieldNumber);
   }
 
-  MessageLite parseMessageLite(ByteString bytes, String protoTypeName) {
-    MessageLiteDescriptor descriptor = descriptorPool.getDescriptorOrThrow(protoTypeName);
-    return parseMessageLite(bytes, descriptor);
-  }
-
-  private static MessageLite parseMessageLite(ByteString bytes, MessageLiteDescriptor descriptor) {
+  static MessageLite parseMessageLite(ByteString bytes, MessageLiteDescriptor descriptor) {
     if (bytes.isEmpty()) {
       return descriptor.newMessageBuilder().getDefaultInstanceForType();
     }
@@ -216,7 +217,7 @@ private Object toRuntimeValue(MessageLite msg, MessageLiteDescriptor descriptor)
     WellKnownProto wellKnownProto =
         WellKnownProto.getByTypeName(descriptor.getProtoTypeName()).orElse(null);
     if (isStructLike(wellKnownProto)) {
-      return ProtoMessageLiteValue.create(msg, descriptor.getProtoTypeName(), this);
+      return ProtoMessageLiteValue.create(msg, descriptor, this);
     }
 
     return fromWellKnownProto(msg, checkNotNull(wellKnownProto));
@@ -316,15 +317,8 @@ private Map.Entry<Object, Object> readSingleMapEntry(
     return scanField(bytes, protoTypeName, fieldDescriptor, null, null);
   }
 
-  /** Reads {@code field}, by its own type information if {@code fieldDescriptor} is null. */
-  private @Nullable Object readField(
-      ByteString bytes,
-      String protoTypeName,
-      @Nullable FieldLiteDescriptor fieldDescriptor,
-      SelectField field) {
-    if (fieldDescriptor != null) {
-      return readField(bytes, protoTypeName, fieldDescriptor);
-    }
+  /** Reads {@code field} using the type information it carries. */
+  private @Nullable Object readField(ByteString bytes, String protoTypeName, SelectField field) {
     SelectField.MapEntrySpec mapEntrySpec = field.mapEntrySpec();
     if (mapEntrySpec == null) {
       return readField(bytes, protoTypeName, newFieldDescriptor(field));
@@ -355,6 +349,9 @@ private Map.Entry<Object, Object> readSingleMapEntry(
       FieldLiteDescriptor fieldDescriptor,
       @Nullable FieldLiteDescriptor keyDescriptor,
       @Nullable FieldLiteDescriptor valueDescriptor) {
+    if (fieldDescriptor.getProtoFieldType().equals(FieldLiteDescriptor.Type.GROUP)) {
+      throw new UnsupportedOperationException("Groups are not supported");
+    }
     CodedInputStream inputStream = bytes.newCodedInput();
     // Submessages alias bytes; unwrapping parses or copies them, so no view outlives evaluation.
     inputStream.enableAliasing(true);
@@ -400,40 +397,31 @@ private Map.Entry<Object, Object> readSingleMapEntry(
   }
 
   /**
-   * Selects {@code field} from {@code bytes}, decoding it by the type information in {@code field}
-   * for fields missing from the descriptor pool. Returns the field's default value if it's absent.
+   * Selects {@code field}, which its message's descriptor doesn't have, from {@code bytes} by the
+   * type information it carries. Returns the field's default value if it's absent.
    */
   Object selectByFieldNumber(ByteString bytes, String protoTypeName, SelectField field) {
-    FieldLiteDescriptor fieldDescriptor =
-        findFieldDescriptor(protoTypeName, field.fieldNumber()).orElse(null);
-    Object fieldValue = readField(bytes, protoTypeName, fieldDescriptor, field);
-    if (fieldValue != null) {
-      return fieldValue;
-    }
-    if (field.defaultValue() != null) {
-      return field.defaultValue();
-    }
-    return getDefaultCelValue(
-        fieldDescriptor != null ? fieldDescriptor : newFieldDescriptor(field));
+    Object fieldValue = readField(bytes, protoTypeName, field);
+    return fieldValue != null ? fieldValue : getDefaultCelValue(field, newFieldDescriptor(field));
   }
 
   /**
-   * Finds {@code field} in {@code bytes}, decoding it by the type information in {@code field} for
-   * fields missing from the descriptor pool. A field without a type code is decoded as a message.
+   * Finds {@code field}, which its message's descriptor doesn't have, in {@code bytes} by the type
+   * information it carries. A field without a type code is decoded as a message.
    */
   Optional<Object> findByFieldNumber(ByteString bytes, String protoTypeName, SelectField field) {
-    FieldLiteDescriptor fieldDescriptor =
-        findFieldDescriptor(protoTypeName, field.fieldNumber()).orElse(null);
-    return Optional.ofNullable(readField(bytes, protoTypeName, fieldDescriptor, field));
+    return Optional.ofNullable(readField(bytes, protoTypeName, field));
   }
 
   /** Returns whether {@code field} is present in {@code bytes}. */
   boolean hasFieldByNumber(ByteString bytes, String protoTypeName, SelectField field) {
-    FieldLiteDescriptor fieldDescriptor =
-        findFieldDescriptor(protoTypeName, field.fieldNumber()).orElse(null);
+    FieldLiteDescriptor fieldDescriptor = findFieldDescriptor(protoTypeName, field.fieldNumber());
     if (fieldDescriptor == null) {
       fieldDescriptor = newFieldDescriptor(field);
     }
+    if (fieldDescriptor.getProtoFieldType().equals(FieldLiteDescriptor.Type.GROUP)) {
+      throw new UnsupportedOperationException("Groups are not supported");
+    }
     boolean isPackableList =
         fieldDescriptor.getEncodingType().equals(EncodingType.LIST) && isPackable(fieldDescriptor);
     CodedInputStream inputStream = bytes.newCodedInput();
@@ -464,6 +452,103 @@ boolean hasFieldByNumber(ByteString bytes, String protoTypeName, SelectField fie
     return false;
   }
 
+  /**
+   * Reads {@code fieldDescriptor} of {@code message} with its generated getter rather than from
+   * wire bytes: its CEL value, or null if it's absent.
+   */
+  @Nullable Object readFieldByGetter(
+      ProtoMessageLiteValue message, FieldLiteDescriptor fieldDescriptor) {
+    Object value = readGetter(message, fieldDescriptor.getFieldNumber());
+    if (value == null) {
+      return null;
+    }
+    switch (fieldDescriptor.getEncodingType()) {
+      case LIST:
+        List<?> list = (List<?>) value;
+        switch (fieldDescriptor.getProtoFieldType()) {
+          case INT64:
+          case SINT64:
+          case SFIXED64:
+          case DOUBLE:
+          case BOOL:
+          case STRING:
+            // These elements are their own CEL values, so the immutable list needn't be copied.
+            return CelPreAdaptedList.wrap(list);
+          default:
+            break;
+        }
+        ImmutableList.Builder<Object> listBuilder =
+            ImmutableList.builderWithExpectedSize(list.size());
+        for (int i = 0; i < list.size(); i++) {
+          listBuilder.add(fromGetterValue(list.get(i), fieldDescriptor));
+        }
+        return listBuilder.build();
+      case MAP:
+        Map<?, ?> map = (Map<?, ?>) value;
+        MessageLiteDescriptor entryDescriptor =
+            descriptorPool.getDescriptorOrThrow(fieldDescriptor.getFieldProtoTypeName());
+        FieldLiteDescriptor keyDescriptor =
+            entryDescriptor.getByFieldNumberOrThrow(MAP_KEY_FIELD_NUMBER);
+        FieldLiteDescriptor valueDescriptor =
+            entryDescriptor.getByFieldNumberOrThrow(MAP_VALUE_FIELD_NUMBER);
+        ImmutableMap.Builder<Object, Object> mapBuilder =
+            ImmutableMap.builderWithExpectedSize(map.size());
+        for (Map.Entry<?, ?> entry : map.entrySet()) {
+          mapBuilder.put(
+              fromGetterValue(entry.getKey(), keyDescriptor),
+              fromGetterValue(entry.getValue(), valueDescriptor));
+        }
+        return mapBuilder.buildOrThrow();
+      case SINGULAR:
+        return fromGetterValue(value, fieldDescriptor);
+    }
+    throw new IllegalStateException(
+        "Unexpected encoding type: " + fieldDescriptor.getEncodingType());
+  }
+
+  /** Like {@link #hasFieldByNumber}, through the field's generated getter. */
+  boolean hasByGetter(ProtoMessageLiteValue message, SelectField field) {
+    return readGetter(message, field.fieldNumber()) != null;
+  }
+
+  // A field's value as its getter returns it, or null if it's unset or an empty repeated or map.
+  private static @Nullable Object readGetter(ProtoMessageLiteValue message, int fieldNumber) {
+    Object value =
+        message.descriptor().getFieldValue(checkNotNull(message.rawValue()), fieldNumber);
+    boolean isEmpty =
+        (value instanceof List && ((List<?>) value).isEmpty())
+            || (value instanceof Map && ((Map<?, ?>) value).isEmpty());
+    return isEmpty ? null : value;
+  }
+
+  // Converts a field's (or element's) Java value as returned by its getter to its CEL value.
+  private Object fromGetterValue(Object value, FieldLiteDescriptor fieldDescriptor) {
+    switch (fieldDescriptor.getProtoFieldType()) {
+      case UINT32:
+      case FIXED32:
+        return UnsignedLong.fromLongBits(Integer.toUnsignedLong((Integer) value));
+      case UINT64:
+      case FIXED64:
+        return UnsignedLong.fromLongBits((Long) value);
+      case ENUM:
+        // Open enums are read as their numbers; closed ones as enum constants.
+        return value instanceof Integer
+            ? ((Integer) value).longValue()
+            : (long) ((EnumLite) value).getNumber();
+      case MESSAGE:
+        MessageLite message = (MessageLite) value;
+        MessageLiteDescriptor descriptor = descriptorPool.findDescriptor(message).orElse(null);
+        // A submessage whose class has no descriptor is read from its own bytes, not its root's:
+        // by its type's descriptor if the pool has one for another class (such as an older
+        // version of it), or else descriptorless.
+        return descriptor != null
+            ? toRuntimeValue(message, descriptor)
+            : readMessageField(message.toByteString(), fieldDescriptor.getFieldProtoTypeName());
+      default:
+        return super.toRuntimeValue(value);
+    }
+  }
+
   /** Describes {@code field} by the type information it carries, built once and kept on it. */
   private static FieldLiteDescriptor newFieldDescriptor(SelectField field) {
     Object cached = field.liteFieldDescriptor();