```python
"""A storage report over a tree of named folders and byte-sized files."""


def check_node(node):
    if not isinstance(node, dict):
        raise ValueError("each node must be a mapping")
    name = node.get("name")
    if not isinstance(name, str) or not name or "/" in name:
        raise ValueError("each name must be a non-empty string without slashes")
    if ("bytes" in node) == ("children" in node):
        raise ValueError("a node holds either bytes or children")
    size = node.get("bytes", 0)
    if isinstance(size, bool) or not isinstance(size, int) or size < 0:
        raise ValueError("bytes must be a non-negative whole number")
    if "children" in node and not isinstance(node["children"], list):
        raise ValueError("children must be a list")


def file_paths(root: dict) -> list:
    paths = []
    stack = [(root, "")]
    while stack:
        node, prefix = stack.pop()
        check_node(node)
        path = prefix + node["name"]
        if "bytes" in node:
            paths.append(path)
        else:
            for child in reversed(node["children"]):
                stack.append((child, path + "/"))
    return paths


def tree_bytes(root: dict) -> int:
    total = 0
    stack = [root]
    while stack:
        node = stack.pop()
        check_node(node)
        if "bytes" in node:
            total += node["bytes"]
        else:
            stack.extend(node["children"])
    return total


def heavy_folders(root: dict, min_bytes: int) -> list:
    if isinstance(min_bytes, bool) or not isinstance(min_bytes, int) or min_bytes < 0:
        raise ValueError("min_bytes must be a non-negative whole number")
    
    check_node(root)
    
    if "bytes" in root:
        return []
    
    result = []
    stack = [(root, "")]
    while stack:
        node, prefix = stack.pop()
        path = prefix + node["name"]
        
        if "children" in node:
            # Calculate total bytes for this folder
            total = sum(child.get("bytes", 0) for child in node["children"])
            # Recursively sum bytes from children's subtrees
            # We need to traverse the subtree to get the full byte count
            # But tree_bytes already does this correctly for the whole tree.
            # However, we need the byte count for *this* folder and all its descendants.
            # Let's compute it properly.
            
            # Actually, tree_bytes(root) gives the total for the whole tree.
            # We need the total for the subtree rooted at 'node'.
            # Let's write a helper or re-use logic.
            
            # To avoid recursion depth issues or complex state, let's just compute
            # the subtree bytes for the current node.
            
            def get_subtree_bytes(n):
                if "bytes" in n:
                    return n["bytes"]
                else:
                    return sum(get_subtree_bytes(c) for c in n["children"])
            
            total = get_subtree_bytes(node)
            
            if total >= min_bytes:
                result.append([path, total])
            
            # Push children in reverse order to maintain file_paths order
            for child in reversed(node["children"]):
               