```python
def stamp_table(dies: list) -> dict:
    """
    Builds a lookup table from dies entries where fragment is a non-empty string and price is a positive integer,
    rejecting duplicates.
    :param dies: List of [fragment, price] entries.
    :return: Dictionary mapping fragments to prices.
    :raises ValueError: If fragment is not a non-empty string or price is not a positive integer,
                        or if any fragment appears more than once.
    """
    table = {}
    for frag, price in dies:
        if not isinstance(frag, str) or not frag.strip():
            raise ValueError("Fragment must be a non-empty string.")
        if not isinstance(price, int) or price <= 0:
            raise ValueError("Price must be a positive integer.")
        if frag in table:
            raise ValueError(f"Duplicate fragment: {frag}")
        table[frag] = price
    return table

def stamp_cover(label: str, dies: list) -> int:
    """
    Finds the cheapest total price of any sequence of die presses whose fragments, laid end to end,
    spell the label exactly.
    :param label: The label as a non-empty string.
    :param dies: List of [fragment, price] entries.
    :return: The minimum cost to spell the label.
    :raises ValueError: If label is not a non-empty string or no sequence can spell it.
    """
    if not isinstance(label, str) or not label.strip():
        raise ValueError("Label must be a non-empty string.")
    
    table = stamp_table(dies)
    
    # Initialize DP table where dp[i] is the minimum cost to spell the first i characters of label
    dp = [float('inf')] * (len(label) + 1)
    dp[0] = 0
    
    for i in range(1, len(label) + 1):
        for j in range(i):
            if table.get(label[j:i], float('inf')) != float('inf'):
                dp[i] = min(dp[i], dp[j] + table[label[j:i]])
    
    return dp[-1] if dp[-1] != float('inf') else None
```