```python
def retry_delays(attempts, base, cap):
    if isinstance(attempts, bool) or not isinstance(attempts, int):
        raise TypeError("attempts must be a non-negative integer")
    if attempts < 0:
        raise ValueError("attempts must be non-negative")
    if base < 0:
        raise ValueError("base must be non-negative")
    if cap < 0:
        raise ValueError("cap must be non-negative")
    
    result = []
    for i in range(attempts):
        # Compute base * 2**i carefully to avoid overflow
        # If base is 0, result is 0
        if base == 0:
            value = 0
        else:
            # Check if base * 2**i exceeds cap
            # We can compare using logarithms or incremental multiplication
            # To avoid overflow, we can check if 2**i * base > cap
            # Since cap is non-negative, if base * 2**i > cap, use cap
            # We need to compute base * 2**i without overflow
            
            # Use incremental approach: start with base, multiply by 2 each step
            # But we need to handle large i without overflow
            
            # Alternative: check if base * 2**i > cap
            # If base == 0, handled above
            # If base > 0, we can check if 2**i > cap / base
            # But cap / base might be problematic if base is very small
            
            # Better approach: compute iteratively, but cap the value
            # Start with current = base
            # For each i, current = min(cap, current * 2)
            # But we need to handle the case where current * 2 overflows
            
            # Let's use a different approach:
            # If base * 2**i > cap, then value = cap
            # We can check this by seeing if 2**i > cap / base
            # But division might have precision issues
            
            # Simplest safe approach: compute iteratively with capping
            # current starts at base
            # For i=0: value = min(cap, base)
            # For i=1: value = min(cap, base * 2)
            # ...
            # We can track current value, but if it exceeds cap, all subsequent values are cap
            
            # Let's use an iterative approach that avoids overflow
            # We'll compute the value step by step
            
            # Actually, let's just compute base * 2**i but check for overflow
            # Python integers can be arbitrarily large, but converting to float can overflow
            
            # The issue is that base * 2**i might be a huge integer, and min(cap, ...) 
            # where cap is a float, causes conversion to float which overflows
            
            # Solution: if base * 2**i > cap, return cap directly without computing the full product
            
            # Check if base * 2**i > cap
            # If base == 0, handled
            # If base > 0:
            #   We need to check if base * 2**i > cap
            #   This is equivalent to 2**i > cap / base
            #   But cap / base might not be exact
            
            # Better: use logarithms
            # log2(base * 2**i) = log2(base) + i
            # If log2(base) + i > log2(cap), then base * 2**i > cap
            
            import math
            if base == 0:
                value = 0
            else:
                # Check if base * 2**i > cap
                # Use log comparison to avoid overflow
                if cap == 0:
                    value = 0
                else:
                    # log2(base * 2**i) = log2(base) + i
                    # log2(cap)
                    # If log2(base) + i > log2(cap), then base * 2**i > cap
                    log_base = math.log2(base) if base > 0 else -math.inf
                    log_cap = math.log2(cap) if cap > 0 else -math.inf
                    if log_base + i > log_cap:
                        value = cap
                    else:
                        value = base * (2 ** i)
        result.append(value)
    return result
```