```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, the result is 0
        if base == 0:
            value = 0
        else:
            # Check if base * 2**i would exceed 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, we use cap
            # We need to avoid computing 2**i when i is large
            
            # Use logarithm to check if base * 2**i > cap
            # log2(base * 2**i) = log2(base) + i
            # If log2(base) + i > log2(cap), then base * 2**i > cap
            
            import math
            if cap == 0:
                value = 0
            else:
                # Check if base * 2**i > cap
                # If base == 0, handled above
                # Use math.log2
                if base == 0:
                    value = 0
                else:
                    # log2(base * 2**i) = log2(base) + i
                    # If log2(base) + i > log2(cap), then base * 2**i > cap
                    # But we need to handle edge cases
                    try:
                        log_base = math.log2(base)
                        log_cap = math.log2(cap)
                        if log_base + i > log_cap:
                            value = cap
                        else:
                            value = base * (2 ** i)
                    except (ValueError, OverflowError):
                        # If log fails, fall back to direct computation
                        # But this shouldn't happen for valid inputs
                        value = cap if base * (2 ** i) > cap else base * (2 ** i)
        
        result.append(value)
    return result
```