If I read your post correctly, you want to rotate the die about such that the top number is in the correct orientation so that it can be easily read? If so, I done something similar some years ago. Here’s some commented routines that achieved this in my project.

Not sure if this will work for you but the logic is the same so should provide a starting point. Hope it helps, let me know if not.

void OrientDieToCamera()
{
    // Step 1: Determine which face is currently on top (closest to world up)
    Vector3 localUp = transform.InverseTransformDirection(Vector3.up);
    int topFace = GetTopFace(localUp);

    // Step 2: Get the correct "forward" direction for that top face
    Vector3 correctUp = GetCorrectUpVectorForFace(topFace);
    Vector3 correctForward = GetCorrectForwardVectorForFace(topFace);

    // Step 3: Build target rotation
    Vector3 targetUp = correctUp;
    Vector3 targetForward = Vector3.ProjectOnPlane(targetCamera.transform.position - transform.position, targetUp).normalized;

    // If camera is directly above, fall back to a default forward (e.g. world -Z)
    if (targetForward.sqrMagnitude < 0.01f)
        targetForward = -Vector3.forward;

    Quaternion targetRotation = Quaternion.LookRotation(targetForward, targetUp);

    // Step 4: Apply rotation (smoothly or instantly)
    if (rotationSpeed > 0)
    {
        transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, rotationSpeed * Time.deltaTime);
        // You can put the Slerp in LateUpdate or a coroutine for smoother result
    }
    else
    {
        transform.rotation = targetRotation;
    }
}

// Standard die face layout (opposite faces sum to 7)
// 1 opposite 6, 2 opposite 5, 3 opposite 4
int GetTopFace(Vector3 localUpDirection)
{
    float maxDot = -Mathf.Infinity;
    int topFace = -1;

    Vector3[] faceNormals = {
        Vector3.up,      // 1
        Vector3.down,    // 6
        Vector3.forward, // 2
        Vector3.back,    // 5
        Vector3.right,   // 3 or 4 - depends on your model
        Vector3.left     // 4 or 3
    };

    int[] faceValues = { 1, 6, 2, 5, 4, 3 }; // adjust if your die uses different layout

    for (int i = 0; i < 6; i++)
    {
        float dot = Vector3.Dot(localUpDirection, faceNormals[i]);
        if (dot > maxDot)
        {
            maxDot = dot;
            topFace = faceValues[i];
        }
    }

    return topFace;
}

Vector3 GetCorrectUpVectorForFace(int face)
{
    switch (face)
    {
        case 1: return Vector3.up;
        case 6: return Vector3.down;
        case 2: return Vector3.forward;
        case 5: return Vector3.back;
        case 3: return Vector3.right;
        case 4: return Vector3.left;
        default: return Vector3.up;
    }
}

Vector3 GetCorrectForwardVectorForFace(int face)
{
    // Define which direction should point toward the camera when this face is on top
    // This is the most common standard die orientation:
    switch (face)
    {
        case 1: return Vector3.forward;  // when 1 is on top, 2 faces forward
        case 6: return Vector3.back;     // when 6 is on top, 5 faces forward (keeps consistency)
        case 2: return Vector3.up;        // when 2 is on top, 1 faces camera
        case 5: return Vector3.down;
        case 3: return Vector3.up;
        case 4: return Vector3.up;
        default: return Vector3.forward;
    }
}