fix(operations): preserve numeric precision in typeReport (#738)

This was raised as part of a support request -
https://chainlink-core.slack.com/archives/C08QF1BEW4T/p1771021085387719

## What changed
- Updated `typeReport` to decode intermediate JSON using `UseNumber` so
numeric values that pass through `any` are not coerced to `float64`.
- Added tests

## Why
- Without `UseNumber`, large integers (for example values originating
from `big.Int`) lose precision when decoded through `any` because they
become `float64`.
- This fix ensures typed report reconstruction preserves numeric
fidelity.

Jira: https://smartcontract-it.atlassian.net/browse/OPT-416

Author: graham-chainlink

.changeset/humble-pears-rule.md

@@ -0,0 +1,5 @@
+---
+"chainlink-deployments-framework": patch
+---
+
+fix(operations): preserve numeric precision in typeReport

operations/report.go

@@ -1,6 +1,7 @@
 package operations
 
 import (
+	"bytes"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -286,7 +287,7 @@ func typeReport[IN, OUT any](r Report[any, any]) (Report[IN, OUT], bool) {
 		return Report[IN, OUT]{}, false
 	}
 	var input IN
-	if err = json.Unmarshal(inputBytes, &input); err != nil {
+	if err = decode(inputBytes, &input); err != nil {
 		return Report[IN, OUT]{}, false
 	}
 
@@ -296,7 +297,7 @@ func typeReport[IN, OUT any](r Report[any, any]) (Report[IN, OUT], bool) {
 	}
 
 	var output OUT
-	if err := json.Unmarshal(outputBytes, &output); err != nil {
+	if err := decode(outputBytes, &output); err != nil {
 		return Report[IN, OUT]{}, false
 	}
 
@@ -311,3 +312,10 @@ func typeReport[IN, OUT any](r Report[any, any]) (Report[IN, OUT], bool) {
 		ExecutionSeries:       r.ExecutionSeries,
 	}, true
 }
+
+func decode(data []byte, out any) error {
+	dec := json.NewDecoder(bytes.NewReader(data))
+	dec.UseNumber()
+
+	return dec.Decode(out)
+}

operations/report_test.go

@@ -3,6 +3,7 @@ package operations
 import (
 	"encoding/json"
 	"errors"
+	"math/big"
 	"testing"
 	"time"
 
@@ -137,7 +138,7 @@ func Test_typeReport(t *testing.T) {
 	assert.True(t, ok)
 	assert.Equal(t, "1", res.ID)
 	assert.Equal(t, Definition{}, res.Def)
-	assert.Equal(t, map[string]interface{}{"a": float64(1)}, res.Input)
+	assert.Equal(t, map[string]interface{}{"a": json.Number("1")}, res.Input)
 	assert.InEpsilon(t, float64(2), res.Output, 0)
 	assert.Equal(t, &now, res.Timestamp)
 	assert.Nil(t, res.Err)
@@ -157,6 +158,26 @@ func Test_typeReport(t *testing.T) {
 	assert.False(t, ok)
 }
 
+func Test_typeReport_PreservesBigIntInInputAndOutput(t *testing.T) {
+	t.Parallel()
+
+	report := Report[any, any]{
+		ID:  "1",
+		Def: Definition{},
+		Input: map[string]interface{}{
+			"a": big.NewInt(1000000000000000000),
+		},
+		Output: map[string]interface{}{
+			"b": big.NewInt(2000000000000000000),
+		},
+	}
+
+	res, ok := typeReport[map[string]interface{}, map[string]interface{}](report)
+	assert.True(t, ok)
+	assert.Equal(t, map[string]interface{}{"a": json.Number("1000000000000000000")}, res.Input)
+	assert.Equal(t, map[string]interface{}{"b": json.Number("2000000000000000000")}, res.Output)
+}
+
 var reportJSON = `
 {
   "id" : "6c5d66ad-f1e8-45b6-b83b-4f289b04045f",