@@ -16,6 +16,7 @@
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Defaults;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
@@ -29,6 +30,7 @@
 import com.google.protobuf.MessageLite;
 import com.google.protobuf.WireFormat;
 import dev.cel.common.annotations.Internal;
+import dev.cel.common.exceptions.CelAttributeNotFoundException;
 import dev.cel.common.internal.CelLiteDescriptorPool;
 import dev.cel.common.internal.WellKnownProto;
 import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor;
@@ -59,6 +61,8 @@
 public final class ProtoLiteCelValueConverter extends BaseProtoCelValueConverter {
   private static final String MAP_KEY_FIELD_NAME = "key";
   private static final String MAP_VALUE_FIELD_NAME = "value";
+  private static final int MAP_KEY_FIELD_NUMBER = 1;
+  private static final int MAP_VALUE_FIELD_NUMBER = 2;
 
   private final CelLiteDescriptorPool descriptorPool;
 
@@ -157,11 +161,6 @@ private static boolean isStructLike(@Nullable WellKnownProto wellKnownProto) {
     return wellKnownProto == null || wellKnownProto == WellKnownProto.FIELD_MASK;
   }
 
-  Object getDefaultCelValue(String protoTypeName, String fieldName) {
-    MessageLiteDescriptor messageDescriptor = descriptorPool.getDescriptorOrThrow(protoTypeName);
-    return getDefaultCelValue(messageDescriptor.getByFieldNameOrThrow(fieldName));
-  }
-
   Object getDefaultCelValue(FieldLiteDescriptor fieldDescriptor) {
     return toRuntimeValue(getDefaultValue(fieldDescriptor));
   }
@@ -172,6 +171,12 @@ Optional<FieldLiteDescriptor> findFieldDescriptor(String protoTypeName, int fiel
         .flatMap(desc -> desc.findByFieldNumber(fieldNumber));
   }
 
+  Optional<FieldLiteDescriptor> findFieldDescriptor(String protoTypeName, String fieldName) {
+    return descriptorPool
+        .findDescriptor(protoTypeName)
+        .flatMap(desc -> desc.findByFieldName(fieldName));
+  }
+
   MessageLite parseMessageLite(ByteString bytes, String protoTypeName) {
     MessageLiteDescriptor descriptor = descriptorPool.getDescriptorOrThrow(protoTypeName);
     return parseMessageLite(bytes, descriptor);
@@ -194,21 +199,6 @@ private static MessageLite mergeMessageLite(
     }
   }
 
-  Optional<Object> tryDecodeProtoMessage(ByteString bytes, String protoTypeName) {
-    return descriptorPool
-        .findDescriptor(protoTypeName)
-        .map(descriptor -> decodeProtoMessage(bytes, protoTypeName, descriptor));
-  }
-
-  private Object decodeProtoMessage(
-      ByteString bytes, String protoTypeName, MessageLiteDescriptor descriptor) {
-    WellKnownProto wellKnownProto = WellKnownProto.getByTypeName(protoTypeName).orElse(null);
-    if (isStructLike(wellKnownProto)) {
-      return ProtoMessageLiteValue.create(bytes, protoTypeName, this);
-    }
-    return fromWellKnownProto(parseMessageLite(bytes, descriptor), checkNotNull(wellKnownProto));
-  }
-
   @Override
   public Object toRuntimeValue(Object value) {
     checkNotNull(value);
@@ -284,12 +274,10 @@ private Object getScalarDefaultValue(FieldLiteDescriptor fieldDescriptor) {
   }
 
   private Map.Entry<Object, Object> readSingleMapEntry(
-      CodedInputStream inputStream, FieldLiteDescriptor fieldDescriptor) throws IOException {
-    String entryTypeName = fieldDescriptor.getFieldProtoTypeName();
-    MessageLiteDescriptor entryDescriptor = descriptorPool.getDescriptorOrThrow(entryTypeName);
-    FieldLiteDescriptor keyDescriptor = entryDescriptor.getByFieldNameOrThrow(MAP_KEY_FIELD_NAME);
-    FieldLiteDescriptor valueDescriptor =
-        entryDescriptor.getByFieldNameOrThrow(MAP_VALUE_FIELD_NAME);
+      CodedInputStream inputStream,
+      FieldLiteDescriptor keyDescriptor,
+      FieldLiteDescriptor valueDescriptor)
+      throws IOException {
     int length = inputStream.readInt32();
     int oldLimit = inputStream.pushLimit(length);
     Object key = null;
@@ -317,6 +305,11 @@ private Map.Entry<Object, Object> readSingleMapEntry(
     return new AbstractMap.SimpleImmutableEntry<>(key, value);
   }
 
+  /**
+   * Decodes only {@code fieldDescriptor}'s occurrences in {@code bytes} into its CEL value,
+   * skipping every other field. Returns null if the field is absent (or a repeated field has only
+   * empty packed records on the wire).
+   */
   @Nullable Object readSingleField(ByteString bytes, FieldLiteDescriptor fieldDescriptor)
       throws IOException {
     CodedInputStream inputStream = bytes.newCodedInput();
@@ -331,20 +324,13 @@ private Map.Entry<Object, Object> readSingleMapEntry(
       int tagWireType = WireFormat.getTagWireType(tag);
       fieldValue = readFieldValue(tagWireType, inputStream, fieldDescriptor, fieldValue);
     }
-    // Only this field is decoded, so unlike readAllFields, a failed conversion can't affect access
-    // to any other field.
     return fieldValue == null ? null : resolveFieldValue(finalizeFieldValue(fieldValue));
   }
 
   boolean hasSingleField(ByteString bytes, FieldLiteDescriptor fieldDescriptor) throws IOException {
-    return hasSingleField(
-        bytes,
-        fieldDescriptor.getFieldNumber(),
-        fieldDescriptor.getEncodingType().equals(EncodingType.LIST) && isPackable(fieldDescriptor));
-  }
-
-  static boolean hasSingleField(ByteString bytes, int targetFieldNumber, boolean isPackableList)
-      throws IOException {
+    int targetFieldNumber = fieldDescriptor.getFieldNumber();
+    boolean isPackableList =
+        fieldDescriptor.getEncodingType().equals(EncodingType.LIST) && isPackable(fieldDescriptor);
     CodedInputStream inputStream = bytes.newCodedInput();
     for (int tag = inputStream.readTag(); tag != 0; tag = inputStream.readTag()) {
       int fieldNumber = WireFormat.getTagFieldNumber(tag);
@@ -371,48 +357,127 @@ static boolean hasSingleField(ByteString bytes, int targetFieldNumber, boolean i
   }
 
   /**
-   * Decodes every known field in {@code bytes}, keyed by field name. Each value must be passed to
-   * {@link #resolveFieldValue} to obtain its CEL value.
+   * 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.
+   * Throws {@link CelAttributeNotFoundException} if {@code field} has no type code.
    */
-  ImmutableMap<String, Object> readAllFields(ByteString bytes, String protoTypeName)
-      throws IOException {
-    MessageLiteDescriptor messageDescriptor = descriptorPool.getDescriptorOrThrow(protoTypeName);
-    if (bytes.isEmpty()) {
-      return ImmutableMap.of();
+  Object selectByFieldNumber(ByteString bytes, SelectField field) throws IOException {
+    if (field.typeCode() == SelectField.NO_TYPE_CODE) {
+      throw CelAttributeNotFoundException.forFieldResolution(field.fieldName());
+    }
+    Object fieldValue = readFieldByNumber(bytes, field);
+    if (fieldValue != null) {
+      return fieldValue;
     }
-    return readAllFields(bytes.newCodedInput(), messageDescriptor);
+    if (field.defaultValue() != null) {
+      return field.defaultValue();
+    }
+    return getDefaultCelValue(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.
+   */
+  Optional<Object> findByFieldNumber(ByteString bytes, SelectField field) throws IOException {
+    return Optional.ofNullable(readFieldByNumber(bytes, field));
+  }
+
+  /** Returns whether {@code field} is present in {@code bytes}. */
+  boolean hasFieldByNumber(ByteString bytes, SelectField field) throws IOException {
+    return hasSingleField(bytes, newFieldDescriptor(field));
   }
 
-  private ImmutableMap<String, Object> readAllFields(
-      CodedInputStream inputStream, MessageLiteDescriptor messageDescriptor) throws IOException {
-    Map<String, Object> fieldValues = new LinkedHashMap<>();
+  private @Nullable Object readFieldByNumber(ByteString bytes, SelectField field)
+      throws IOException {
+    FieldLiteDescriptor fieldDescriptor = newFieldDescriptor(field);
+    SelectField.MapEntrySpec mapEntrySpec = field.mapEntrySpec();
+    if (mapEntrySpec == null) {
+      return readSingleField(bytes, fieldDescriptor);
+    }
+    // The map entry type has no descriptor either, so its key and value are described by the spec.
+    FieldLiteDescriptor keyDescriptor =
+        newFieldDescriptor(
+            MAP_KEY_FIELD_NUMBER,
+            MAP_KEY_FIELD_NAME,
+            EncodingType.SINGULAR,
+            mapEntrySpec.keyTypeCode(),
+            /* protoTypeName= */ "");
+    FieldLiteDescriptor valueDescriptor =
+        newFieldDescriptor(
+            MAP_VALUE_FIELD_NUMBER,
+            MAP_VALUE_FIELD_NAME,
+            EncodingType.SINGULAR,
+            mapEntrySpec.valueTypeCode(),
+            field.protoTypeName());
+    CodedInputStream inputStream = bytes.newCodedInput();
+    Map<Object, Object> mapValues = null;
     for (int tag = inputStream.readTag(); tag != 0; tag = inputStream.readTag()) {
-      int tagWireType = WireFormat.getTagWireType(tag);
-      int fieldNumber = WireFormat.getTagFieldNumber(tag);
-      FieldLiteDescriptor fieldDescriptor =
-          messageDescriptor.findByFieldNumber(fieldNumber).orElse(null);
-      if (fieldDescriptor == null) {
+      if (WireFormat.getTagFieldNumber(tag) != field.fieldNumber()) {
         skipWireField(tag, inputStream);
         continue;
       }
-
-      String fieldName = fieldDescriptor.getFieldName();
-      Object fieldValue =
-          readFieldValue(tagWireType, inputStream, fieldDescriptor, fieldValues.get(fieldName));
-      if (fieldValue != null) {
-        fieldValues.put(fieldName, fieldValue);
-      }
-    }
-
-    fieldValues.replaceAll((fieldName, fieldValue) -> finalizeFieldValue(fieldValue));
-    return ImmutableMap.copyOf(fieldValues);
-  }
-
-  /**
-   * Returns the CEL value of a field decoded by {@link #readAllFields}, completing any conversion
-   * that was deferred.
-   */
-  Object resolveFieldValue(Object fieldValue) {
+      mapValues =
+          readMapField(
+              WireFormat.getTagWireType(tag),
+              inputStream,
+              fieldDescriptor,
+              keyDescriptor,
+              valueDescriptor,
+              mapValues);
+    }
+    return mapValues == null ? null : resolveFieldValue(finalizeFieldValue(mapValues));
+  }
+
+  /** Describes {@code field} by the type information it carries. */
+  private static FieldLiteDescriptor newFieldDescriptor(SelectField field) {
+    if (field.mapEntrySpec() != null) {
+      // SelectField doesn't name the map entry type; its protoTypeName() is the map's value type.
+      return newFieldDescriptor(
+          field.fieldNumber(),
+          field.fieldName(),
+          EncodingType.MAP,
+          SelectField.MESSAGE_TYPE_CODE,
+          /* protoTypeName= */ "");
+    }
+    if (field.typeCode() == SelectField.NO_TYPE_CODE) {
+      // Only presence tests omit the type code. Their presence check doesn't depend on the type,
+      // and the fields they navigate through are always messages.
+      return newFieldDescriptor(
+          field.fieldNumber(),
+          field.fieldName(),
+          EncodingType.SINGULAR,
+          SelectField.MESSAGE_TYPE_CODE,
+          /* protoTypeName= */ "");
+    }
+    return newFieldDescriptor(
+        field.fieldNumber(),
+        field.fieldName(),
+        field.defaultValue() instanceof List ? EncodingType.LIST : EncodingType.SINGULAR,
+        field.typeCode(),
+        field.protoTypeName());
+  }
+
+  private static FieldLiteDescriptor newFieldDescriptor(
+      int fieldNumber,
+      String fieldName,
+      EncodingType encodingType,
+      int typeCode,
+      String protoTypeName) {
+    FieldLiteDescriptor.Type protoFieldType = FieldLiteDescriptor.Type.forNumber(typeCode);
+    return new FieldLiteDescriptor(
+        fieldNumber,
+        fieldName,
+        // FieldLiteDescriptor.JavaType's constants match WireFormat.JavaType's by name.
+        JavaType.valueOf(protoFieldType.toWireFormatFieldType().getJavaType().name()),
+        encodingType,
+        protoFieldType,
+        /* isPacked= */ false,
+        protoTypeName);
+  }
+
+  /** Returns the CEL value of a scanned field, completing any conversion that was deferred. */
+  private Object resolveFieldValue(Object fieldValue) {
     if (fieldValue instanceof DeferredConversion) {
       return toRuntimeValue(((DeferredConversion) fieldValue).value);
     }
@@ -520,18 +585,38 @@ private Object readSingularField(
     return repeatedValues;
   }
 
+  private Map<Object, Object> readMapField(
+      int tagWireType,
+      CodedInputStream inputStream,
+      FieldLiteDescriptor fieldDescriptor,
+      @Nullable Object existingValue)
+      throws IOException {
+    MessageLiteDescriptor entryDescriptor =
+        descriptorPool.getDescriptorOrThrow(fieldDescriptor.getFieldProtoTypeName());
+    return readMapField(
+        tagWireType,
+        inputStream,
+        fieldDescriptor,
+        entryDescriptor.getByFieldNameOrThrow(MAP_KEY_FIELD_NAME),
+        entryDescriptor.getByFieldNameOrThrow(MAP_VALUE_FIELD_NAME),
+        existingValue);
+  }
+
   // Safe because MAP fields only ever store a LinkedHashMap as their accumulated value.
   @SuppressWarnings("unchecked")
   private Map<Object, Object> readMapField(
       int tagWireType,
       CodedInputStream inputStream,
       FieldLiteDescriptor fieldDescriptor,
+      FieldLiteDescriptor keyDescriptor,
+      FieldLiteDescriptor valueDescriptor,
       @Nullable Object existingValue)
       throws IOException {
     checkWireType(tagWireType, fieldDescriptor);
     Map<Object, Object> mapValues =
         existingValue != null ? (Map<Object, Object>) existingValue : new LinkedHashMap<>();
-    Map.Entry<Object, Object> mapEntry = readSingleMapEntry(inputStream, fieldDescriptor);
+    Map.Entry<Object, Object> mapEntry =
+        readSingleMapEntry(inputStream, keyDescriptor, valueDescriptor);
     mapValues.put(mapEntry.getKey(), mapEntry.getValue());
     return mapValues;
   }
@@ -565,6 +650,7 @@ private static boolean isPackable(FieldLiteDescriptor fieldDescriptor) {
     return fieldDescriptor.getProtoFieldType().toWireFormatFieldType().isPackable();
   }
 
+  @VisibleForTesting
   static void skipWireField(int tag, CodedInputStream inputStream) throws IOException {
     int tagWireType = WireFormat.getTagWireType(tag);
     switch (tagWireType) {
@@ -582,25 +668,6 @@ static void skipWireField(int tag, CodedInputStream inputStream) throws IOExcept
     }
   }
 
-  static Object readUnknownField(int tagWireType, CodedInputStream inputStream) throws IOException {
-    switch (tagWireType) {
-      case WireFormat.WIRETYPE_VARINT:
-        return inputStream.readInt64();
-      case WireFormat.WIRETYPE_FIXED64:
-        return inputStream.readFixed64();
-      case WireFormat.WIRETYPE_LENGTH_DELIMITED:
-        return inputStream.readBytes();
-      case WireFormat.WIRETYPE_FIXED32:
-        return inputStream.readFixed32();
-      case WireFormat.WIRETYPE_START_GROUP:
-      case WireFormat.WIRETYPE_END_GROUP:
-        // TODO: Support groups
-        throw new UnsupportedOperationException("Groups are not supported");
-      default:
-        throw new IllegalArgumentException("Unknown wire type: " + tagWireType);
-    }
-  }
-
   /**
    * A field value holding well-known type messages, whose conversion to CEL values is deferred
    * until {@link #resolveFieldValue}.