@@ -312,7 +312,14 @@ func toQuantity(v ref.Val) (resource.Quantity, error) {
 		if f < 0 {
 			return resource.Quantity{}, fmt.Errorf("negative reservation %v", f)
 		}
-		return *resource.NewMilliQuantity(int64(math.Ceil(f*1000)), resource.DecimalSI), nil
+		// float64(math.MaxInt64) rounds up to 2^63, so the bound is
+		// exclusive; past it the conversion would saturate into a smaller
+		// figure.
+		milli := math.Ceil(f * 1000)
+		if milli >= math.MaxInt64 {
+			return resource.Quantity{}, fmt.Errorf("%v overflows a quantity", f)
+		}
+		return *resource.NewMilliQuantity(int64(milli), resource.DecimalSI), nil
 	case types.String:
 		q, err := resource.ParseQuantity(string(t))
 		if err != nil {
@@ -429,8 +436,10 @@ func normalizeNumbers(v any) any {
 		if i, err := t.Int64(); err == nil {
 			return i
 		}
+		// 2.0 and 2e0 are integers to the schema validator; spelled that
+		// way they fail Int64 and are classified as a float64 would be.
 		f, _ := t.Float64()
-		return f
+		return normalizeNumbers(f)
 	case float64:
 		if t == math.Trunc(t) && math.Abs(t) < 1<<53 {
 			return int64(t)
 
@@ -277,6 +277,27 @@ func TestEvaluateFailsClosed(t *testing.T) {
 	if _, err := tiny.EvaluateJSON(nil, env); err == nil {
 		t.Error("small negative reservation: expected an error, not a zero")
 	}
+
+	// A double past the range of an int64 in millis must not be clamped into
+	// a smaller figure.
+	for _, expr := range []string{`1e100`, `1e308`, `9.3e15`} {
+		huge, err := Compile(&Declaration{Resources: map[string]string{"cpu": expr}}, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got, err := huge.EvaluateJSON(nil, env); err == nil {
+			t.Errorf("%s: expected an error, got %v", expr, got)
+		}
+	}
+	finite, err := Compile(&Declaration{Resources: map[string]string{"cpu": `1e3`, "memory": `0.25`}}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	got, err := finite.EvaluateJSON(nil, env)
+	if err != nil {
+		t.Fatal(err)
+	}
+	assertList(t, "finite doubles", got, rl("cpu", "1k", "memory", "250m"))
 }
 
 func TestEvaluateRejectsValuesOfTheWrongType(t *testing.T) {
@@ -323,6 +344,29 @@ func TestEvaluateRejectsValuesOfTheWrongType(t *testing.T) {
 	}
 }
 
+func TestEvaluateAcceptsIntegralSpellings(t *testing.T) {
+	env := testEnvironment(t)
+	// The Kubernetes schema validator accepts an integral number however it
+	// is spelled, so the evaluator must too.
+	ev, err := Compile(&Declaration{Resources: map[string]string{"cpu": `values.replicas`}}, shippedSchema(t, "postgres"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, raw := range []string{`{"replicas": 2}`, `{"replicas": 2.0}`, `{"replicas": 2e0}`, `{"replicas": 0.2e1}`} {
+		got, err := ev.EvaluateJSON([]byte(raw), env)
+		if err != nil {
+			t.Errorf("%s: %v", raw, err)
+			continue
+		}
+		assertList(t, raw, got, rl("cpu", "2"))
+	}
+	for _, raw := range []string{`{"replicas": 2.5}`, `{"replicas": 25e-1}`} {
+		if got, err := ev.EvaluateJSON([]byte(raw), env); err == nil {
+			t.Errorf("%s: expected an error, got %v", raw, got)
+		}
+	}
+}
+
 func TestEvaluateChecksUntypedSchemasByShape(t *testing.T) {
 	env := testEnvironment(t)
 	// BuildSchema does not require a structural schema to be typed, and