google · copybara-service · Feb 26, 2026
diff --git a/common/src/main/java/dev/cel/common/exceptions/CelInvalidArgumentException.java b/common/src/main/java/dev/cel/common/exceptions/CelInvalidArgumentException.java
@@ -24,4 +24,8 @@ public final class CelInvalidArgumentException extends CelRuntimeException {
   public CelInvalidArgumentException(Throwable cause) {
     super(cause, CelErrorCode.INVALID_ARGUMENT);
   }
+
+  public CelInvalidArgumentException(String message) {
+    super(message, CelErrorCode.INVALID_ARGUMENT);
+  }
 }
diff --git a/common/src/main/java/dev/cel/common/values/CelValueConverter.java b/common/src/main/java/dev/cel/common/values/CelValueConverter.java
@@ -41,24 +41,39 @@ public static CelValueConverter getDefaultInstance() {
     return DEFAULT_INSTANCE;
   }
 
-  /** Adapts a {@link CelValue} to a plain old Java Object. */
-  public Object unwrap(CelValue celValue) {
-    Preconditions.checkNotNull(celValue);
+  /**
+   * Unwraps the {@code value} into its plain old Java Object representation.
+   *
+   * <p>The value may be a {@link CelValue}, a {@link Collection} or a {@link Map}.
+   */
+  public Object maybeUnwrap(Object value) {
+    if (value instanceof CelValue) {
+      return unwrap((CelValue) value);
+    }
 
-    if (celValue instanceof OptionalValue) {
-      OptionalValue<Object, Object> optionalValue = (OptionalValue<Object, Object>) celValue;
-      if (optionalValue.isZeroValue()) {
-        return Optional.empty();
+    if (value instanceof Collection) {
+      Collection<Object> collection = (Collection<Object>) value;
+      ImmutableList.Builder<Object> builder =
+          ImmutableList.builderWithExpectedSize(collection.size());
+      for (Object element : collection) {
+        builder.add(maybeUnwrap(element));
       }
 
-      return Optional.of(optionalValue.value());
+      return builder.build();
     }
 
-    if (celValue instanceof ErrorValue) {
-      return celValue;
+    if (value instanceof Map) {
+      Map<Object, Object> map = (Map<Object, Object>) value;
+      ImmutableMap.Builder<Object, Object> builder =
+          ImmutableMap.builderWithExpectedSize(map.size());
+      for (Map.Entry<Object, Object> entry : map.entrySet()) {
+        builder.put(maybeUnwrap(entry.getKey()), maybeUnwrap(entry.getValue()));
+      }
+
+      return builder.buildOrThrow();
     }
 
-    return celValue.value();
+    return value;
   }
 
   /**
@@ -101,6 +116,26 @@ protected Object normalizePrimitive(Object value) {
     return value;
   }
 
+  /** Adapts a {@link CelValue} to a plain old Java Object. */
+  private static Object unwrap(CelValue celValue) {
+    Preconditions.checkNotNull(celValue);
+
+    if (celValue instanceof OptionalValue) {
+      OptionalValue<Object, Object> optionalValue = (OptionalValue<Object, Object>) celValue;
+      if (optionalValue.isZeroValue()) {
+        return Optional.empty();
+      }
+
+      return Optional.of(optionalValue.value());
+    }
+
+    if (celValue instanceof ErrorValue) {
+      return celValue;
+    }
+
+    return celValue.value();
+  }
+
   private ImmutableList<Object> toListValue(Collection<Object> iterable) {
     Preconditions.checkNotNull(iterable);
 

diff --git a/common/src/test/java/dev/cel/common/values/CelValueConverterTest.java b/common/src/test/java/dev/cel/common/values/CelValueConverterTest.java
@@ -37,15 +37,16 @@ public void toRuntimeValue_optionalValue() {
   @Test
   @SuppressWarnings("unchecked") // Test only
   public void unwrap_optionalValue() {
-    Optional<Long> result = (Optional<Long>) CEL_VALUE_CONVERTER.unwrap(OptionalValue.create(2L));
+    Optional<Long> result =
+        (Optional<Long>) CEL_VALUE_CONVERTER.maybeUnwrap(OptionalValue.create(2L));
 
     assertThat(result).isEqualTo(Optional.of(2L));
   }
 
   @Test
   @SuppressWarnings("unchecked") // Test only
   public void unwrap_emptyOptionalValue() {
-    Optional<Long> result = (Optional<Long>) CEL_VALUE_CONVERTER.unwrap(OptionalValue.EMPTY);
+    Optional<Long> result = (Optional<Long>) CEL_VALUE_CONVERTER.maybeUnwrap(OptionalValue.EMPTY);
 
     assertThat(result).isEqualTo(Optional.empty());
   }

diff --git a/common/src/test/java/dev/cel/common/values/ProtoCelValueConverterTest.java b/common/src/test/java/dev/cel/common/values/ProtoCelValueConverterTest.java
@@ -35,7 +35,7 @@ public class ProtoCelValueConverterTest {
 
   @Test
   public void unwrap_nullValue() {
-    NullValue nullValue = (NullValue) PROTO_CEL_VALUE_CONVERTER.unwrap(NullValue.NULL_VALUE);
+    NullValue nullValue = (NullValue) PROTO_CEL_VALUE_CONVERTER.maybeUnwrap(NullValue.NULL_VALUE);
 
     // Note: No conversion is attempted. We're using dev.cel.common.values.NullValue.NULL_VALUE as
     // the

diff --git a/conformance/src/test/java/dev/cel/conformance/BUILD.bazel b/conformance/src/test/java/dev/cel/conformance/BUILD.bazel
@@ -175,18 +175,7 @@ _TESTS_TO_SKIP_PLANNER = [
     "timestamps/timestamp_range/sub_time_duration_under",
 
     # Skip until fixed.
-    "fields/qualified_identifier_resolution/map_key_float",
-    "fields/qualified_identifier_resolution/map_key_null",
-    "fields/qualified_identifier_resolution/map_value_repeat_key_heterogeneous",
-    "optionals/optionals/map_null_entry_no_such_key",
-    "optionals/optionals/map_present_key_invalid_field",
     "parse/receiver_function_names",
-    "proto2/extensions_get/package_scoped_test_all_types_ext",
-    "proto2/extensions_get/package_scoped_repeated_test_all_types",
-    "proto2/extensions_get/message_scoped_nested_ext",
-    "proto2/extensions_get/message_scoped_repeated_test_all_types",
-    "proto2_ext/get_ext/package_scoped_repeated_test_all_types",
-    "proto2_ext/get_ext/message_scoped_repeated_test_all_types",
 
     # TODO: Fix null assignment to a field
     "proto2/set_null/single_message",

diff --git a/extensions/src/test/java/dev/cel/extensions/CelProtoExtensionsTest.java b/extensions/src/test/java/dev/cel/extensions/CelProtoExtensionsTest.java
@@ -46,6 +46,7 @@
 import dev.cel.runtime.CelFunctionBinding;
 import dev.cel.runtime.CelRuntime;
 import dev.cel.runtime.CelRuntimeFactory;
+import dev.cel.runtime.CelRuntimeImpl;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
@@ -60,9 +61,14 @@ public final class CelProtoExtensionsTest {
           .addVar("msg", StructTypeReference.create("cel.expr.conformance.proto2.TestAllTypes"))
           .setContainer(CelContainer.ofName("cel.expr.conformance.proto2"))
           .build();
-
   private static final CelRuntime CEL_RUNTIME =
-      CelRuntimeFactory.standardCelRuntimeBuilder()
+      CelRuntimeImpl.newBuilder()
+          .setOptions(
+              CelOptions.current()
+                  .enableTimestampEpoch(true)
+                  .enableHeterogeneousNumericComparisons(true)
+                  .build())
+          // CEL-Internal-2
           .addFileTypes(TestAllTypesExtensions.getDescriptor())
           .build();
 

diff --git a/runtime/src/main/java/dev/cel/runtime/CelValueRuntimeTypeProvider.java b/runtime/src/main/java/dev/cel/runtime/CelValueRuntimeTypeProvider.java
@@ -22,7 +22,6 @@
 import dev.cel.common.exceptions.CelAttributeNotFoundException;
 import dev.cel.common.values.BaseProtoCelValueConverter;
 import dev.cel.common.values.BaseProtoMessageValueProvider;
-import dev.cel.common.values.CelValue;
 import dev.cel.common.values.CelValueProvider;
 import dev.cel.common.values.CombinedCelValueProvider;
 import dev.cel.common.values.SelectableValue;
@@ -64,7 +63,7 @@ static CelValueRuntimeTypeProvider newInstance(CelValueProvider valueProvider) {
 
   @Override
   public Object createMessage(String messageName, Map<String, Object> values) {
-    return maybeUnwrapCelValue(
+    return protoCelValueConverter.maybeUnwrap(
         valueProvider
             .newValue(messageName, values)
             .orElseThrow(
@@ -87,7 +86,7 @@ public Object selectField(Object message, String fieldName) {
     SelectableValue<String> selectableValue = getSelectableValueOrThrow(message, fieldName);
     Object value = selectableValue.select(fieldName);
 
-    return maybeUnwrapCelValue(value);
+    return protoCelValueConverter.maybeUnwrap(value);
   }
 
   @Override
@@ -120,24 +119,12 @@ public Object adapt(String messageName, Object message) {
     }
 
     if (message instanceof MessageLite) {
-      return maybeUnwrapCelValue(protoCelValueConverter.toRuntimeValue(message));
+      return protoCelValueConverter.maybeUnwrap(protoCelValueConverter.toRuntimeValue(message));
     }
 
     return message;
   }
 
-  /**
-   * DefaultInterpreter cannot handle CelValue and instead expects plain Java objects.
-   *
-   * <p>This will become unnecessary once we introduce a rewrite of a Cel runtime.
-   */
-  private Object maybeUnwrapCelValue(Object object) {
-    if (object instanceof CelValue) {
-      return protoCelValueConverter.unwrap((CelValue) object);
-    }
-    return object;
-  }
-
   private static void throwInvalidFieldSelection(String fieldName) {
     throw CelAttributeNotFoundException.forFieldResolution(fieldName);
   }

diff --git a/runtime/src/main/java/dev/cel/runtime/planner/BUILD.bazel b/runtime/src/main/java/dev/cel/runtime/planner/BUILD.bazel
@@ -128,7 +128,6 @@ java_library(
         "//common/types",
         "//common/types:type_providers",
         "//common/values",
-        "//common/values:cel_value",
         "//runtime:interpretable",
         "@maven//:com_google_errorprone_error_prone_annotations",
         "@maven//:com_google_guava_guava",
@@ -334,6 +333,7 @@ java_library(
         ":localized_evaluation_exception",
         ":planned_interpretable",
         "//common/exceptions:duplicate_key",
+        "//common/exceptions:invalid_argument",
         "//runtime:evaluation_exception",
         "//runtime:interpretable",
         "@maven//:com_google_errorprone_error_prone_annotations",
@@ -379,7 +379,6 @@ java_library(
         "//common:error_codes",
         "//common/exceptions:runtime_exception",
         "//common/values",
-        "//common/values:cel_value",
         "//runtime:evaluation_exception",
         "//runtime:interpretable",
         "//runtime:resolved_overload",

diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalCreateMap.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalCreateMap.java
@@ -17,8 +17,10 @@
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Sets;
+import com.google.common.primitives.UnsignedLong;
 import com.google.errorprone.annotations.Immutable;
 import dev.cel.common.exceptions.CelDuplicateKeyException;
+import dev.cel.common.exceptions.CelInvalidArgumentException;
 import dev.cel.runtime.CelEvaluationException;
 import dev.cel.runtime.GlobalResolver;
 import java.util.HashSet;
@@ -46,13 +48,37 @@ public Object eval(GlobalResolver resolver, ExecutionFrame frame) throws CelEval
     HashSet<Object> keysSeen = Sets.newHashSetWithExpectedSize(keys.length);
 
     for (int i = 0; i < keys.length; i++) {
-      Object key = keys[i].eval(resolver, frame);
-      Object val = values[i].eval(resolver, frame);
+      PlannedInterpretable keyInterpretable = keys[i];
+      Object key = keyInterpretable.eval(resolver, frame);
+      if (!(key instanceof String
+          || key instanceof Long
+          || key instanceof UnsignedLong
+          || key instanceof Boolean)) {
+        throw new LocalizedEvaluationException(
+            new CelInvalidArgumentException("Unsupported key type: " + key),
+            keyInterpretable.exprId());
+      }
 
-      if (!keysSeen.add(key)) {
-        throw new LocalizedEvaluationException(CelDuplicateKeyException.of(key), keys[i].exprId());
+      boolean isDuplicate = !keysSeen.add(key);
+      if (!isDuplicate) {
+        if (key instanceof Long) {
+          long longVal = (Long) key;
+          if (longVal >= 0) {
+            isDuplicate = keysSeen.contains(UnsignedLong.valueOf(longVal));
+          }
+        } else if (key instanceof UnsignedLong) {
+          UnsignedLong ulongVal = (UnsignedLong) key;
+          isDuplicate = keysSeen.contains(ulongVal.longValue());
+        }
       }
 
+      if (isDuplicate) {
+        throw new LocalizedEvaluationException(
+            CelDuplicateKeyException.of(key), keyInterpretable.exprId());
+      }
+
+      Object val = values[i].eval(resolver, frame);
+
       if (isOptional[i]) {
         if (!(val instanceof Optional)) {
           throw new IllegalArgumentException(

diff --git a/runtime/src/main/java/dev/cel/runtime/planner/EvalHelpers.java b/runtime/src/main/java/dev/cel/runtime/planner/EvalHelpers.java
@@ -17,7 +17,6 @@
 import com.google.common.base.Joiner;
 import dev.cel.common.CelErrorCode;
 import dev.cel.common.exceptions.CelRuntimeException;
-import dev.cel.common.values.CelValue;
 import dev.cel.common.values.CelValueConverter;
 import dev.cel.common.values.ErrorValue;
 import dev.cel.runtime.CelEvaluationException;
@@ -56,23 +55,21 @@ static Object evalStrictly(
     }
   }
 
-  static Object dispatch(CelResolvedOverload overload, CelValueConverter valueConverter, Object[] args) throws CelEvaluationException {
+  static Object dispatch(
+      CelResolvedOverload overload, CelValueConverter valueConverter, Object[] args)
+      throws CelEvaluationException {
     try {
       Object result = overload.getDefinition().apply(args);
-      Object runtimeValue = valueConverter.toRuntimeValue(result);
-      if (runtimeValue instanceof CelValue) {
-        return valueConverter.unwrap((CelValue) runtimeValue);
-      }
-
-      return runtimeValue;
+      return valueConverter.maybeUnwrap(valueConverter.toRuntimeValue(result));
     } catch (CelRuntimeException e) {
       // Function dispatch failure that's already been handled -- just propagate.
       throw e;
     } catch (RuntimeException e) {
       // Unexpected function dispatch failure.
-      throw new IllegalArgumentException(String.format(
-          "Function '%s' failed with arg(s) '%s'",
-          overload.getOverloadId(), Joiner.on(", ").join(args)),
+      throw new IllegalArgumentException(
+          String.format(
+              "Function '%s' failed with arg(s) '%s'",
+              overload.getOverloadId(), Joiner.on(", ").join(args)),
           e);
     }
   }

diff --git a/runtime/src/main/java/dev/cel/runtime/planner/NamespacedAttribute.java b/runtime/src/main/java/dev/cel/runtime/planner/NamespacedAttribute.java
@@ -22,7 +22,6 @@
 import dev.cel.common.types.EnumType;
 import dev.cel.common.types.SimpleType;
 import dev.cel.common.types.TypeType;
-import dev.cel.common.values.CelValue;
 import dev.cel.common.values.CelValueConverter;
 import dev.cel.runtime.GlobalResolver;
 import java.util.NoSuchElementException;
@@ -148,11 +147,7 @@ private static Object applyQualifiers(
       obj = qualifier.qualify(obj);
     }
 
-    if (obj instanceof CelValue) {
-      obj = celValueConverter.unwrap((CelValue) obj);
-    }
-
-    return obj;
+    return celValueConverter.maybeUnwrap(obj);
   }
 
   static NamespacedAttribute create(

diff --git a/runtime/src/main/java/dev/cel/runtime/planner/RelativeAttribute.java b/runtime/src/main/java/dev/cel/runtime/planner/RelativeAttribute.java
@@ -16,7 +16,6 @@
 
 import com.google.common.collect.ImmutableList;
 import com.google.errorprone.annotations.Immutable;
-import dev.cel.common.values.CelValue;
 import dev.cel.common.values.CelValueConverter;
 import dev.cel.runtime.GlobalResolver;
 
@@ -41,10 +40,7 @@ public Object resolve(GlobalResolver ctx, ExecutionFrame frame) {
     }
 
     // TODO: Handle unknowns
-    if (obj instanceof CelValue) {
-      obj = celValueConverter.unwrap((CelValue) obj);
-    }
-    return obj;
+    return celValueConverter.maybeUnwrap(obj);
   }
 
   @Override