Write the parser, run the tests, stop when they pass

"""5-field cron next_run implementation (standard library only)."""
from datetime import datetime, timedelta

__all__ = ["next_run"]


def _parse_int(token, whole):
    # Strict integer parsing: only optional leading '-' and digits.
    # int() alone would accept '+5', underscores ('1_0'), whitespace, etc.
    s = token
    if not s:
        raise ValueError(f"Invalid cron field: {whole!r}")
    body = s[1:] if s.startswith("-") else s
    if not body.isdigit():
        raise ValueError(f"Invalid cron field: {whole!r}")
    return int(s)


def _parse_field(text, lo, hi):
    if not text:
        raise ValueError("Empty cron field")
    values = set()
    for part in text.split(","):
        if not part:
            raise ValueError(f"Invalid cron field: {text!r}")
        if part.count("/") > 1:
            raise ValueError(f"Invalid cron field: {text!r}")
        if "/" in part:
            base, step_token = part.split("/", 1)
            step = _parse_int(step_token, text)
            if step <= 0:
                raise ValueError(f"Invalid step in cron field: {text!r}")
            has_step = True
        else:
            base = part
            step = 1
            has_step = False

        if not base:
            raise ValueError(f"Invalid cron field: {text!r}")

        if base == "*":
            start, end = lo, hi
        elif "-" in base:
            # Range; also catches negative numbers / malformed ranges
            # because split will produce empty or extra pieces.
            pieces = base.split("-")
            if len(pieces) != 2 or not pieces[0] or not pieces[1]:
                raise ValueError(f"Invalid range in cron field: {text!r}")
            start = _parse_int(pieces[0], text)
            end = _parse_int(pieces[1], text)
            if start < lo or end > hi or start > end:
                raise ValueError(f"Range out of bounds in cron field: {text!r}")
        else:
            val = _parse_int(base, text)
            if val < lo or val > hi:
                raise ValueError(f"Value out of bounds in cron field: {text!r}")
            if has_step:
                # Step on a plain number: from that number to field max.
                start, end = val, hi
            else:
                values.add(val)
                continue

        for v in range(start, end + 1, step):
            values.add(v)

    if not values:
        raise ValueError(f"Invalid cron field: {text!r}")
    return values


def next_run(expr: str, after: datetime) -> datetime:
    if not isinstance(expr, str):
        raise ValueError("Cron expression must be a string")
    fields = expr.split()
    if len(fields) != 5:
        raise ValueError(f"Cron expression must have 5 fields: {expr!r}")

    minute_f, hour_f, dom_f, month_f, dow_f = fields

    minutes = _parse_field(minute_f, 0, 59)
    hours = _parse_field(hour_f, 0, 23)
    dom = _parse_field(dom_f, 1, 31)
    months = _parse_field(month_f, 1, 12)
    dow = _parse_field(dow_f, 0, 6)

    dom_restricted = not dom_f.startswith("*")
    dow_restricted = not dow_f.startswith("*")
    both_restricted = dom_restricted and dow_restricted

    sorted_minutes = sorted(minutes)
    sorted_hours = sorted(hours)

    # First minute strictly after `after`, seconds/microseconds ignored.
    start = after.replace(second=0, microsecond=0) + timedelta(minutes=1)

    # Search day-by-day. Upper bound generous enough for leap-year-only
    # schedules (Feb 29) while avoiding an infinite loop for impossible
    # schedules such as Feb 31.
    # 20 years of days is cheap when iterating per-day.
    start_date = start.date()
    for offset in range(366 * 20 + 2):
        day = start_date + timedelta(days=offset)
        if day.month not in months:
            continue
        dom_match = day.day in dom
        # Python: Monday=0 .. Sunday=6 ; cron: Sunday=0 .. Saturday=6
        cron_dow = (day.weekday() + 1) % 7
        dow_match = cron_dow in dow
        if both_restricted: