FAILURE MAP
← Case archive

FA-33861 / Notification interfaces / Open access

Toast exposure timeout: page-hidden from hover-paused · case 01

The page-hidden event leaves a notification in hidden-paused instead of both-paused.

Verified by executionVariant 1 · 42 checks per implementationDownload source bundle ↓JSON ↗

ROOT CAUSE

Hiding the page forgets the existing hover pause.

VERIFIED REPAIR

Commit the hover-paused / page-hidden transition to both-paused; preserve the other explicitly stipulated transitions.

Unsuccessful approach: Resuming while hidden charges unobserved time.

Case contract

Toast exposure timeout is a bounded visual-notification workflow with mutable policy state {'remaining': 10, 'pause_owners': [], 'spent': 0}. Its default transition relation is {('visible', 'pointer-enter'): 'hover-paused', ('hover-paused', 'pointer-leave'): 'visible', ('visible', 'page-hidden'): 'hidden-paused', ('hidden-paused', 'page-visible'): 'visible', ('hover-paused', 'page-hidden'): 'both-paused', ('both-paused', 'page-visible'): 'hover-paused', ('both-paused', 'pointer-leave'): 'hidden-paused', ('visible', 'budget-consumed'): 'expired', ('expired', 'late-pointer-enter'): 'expired', ('hidden-paused', 'budget-callback'): 'hidden-paused'}; domain inputs can suppress or redirect transitions and update policy fields, as specified in solve. Different-generation events are inert. Batches apply in order. Optional observe returns the selected policy field alongside the phase.

Why this case matters

Visual notification lifecycle ordering can leave an inbox or toast showing the wrong actionable state even when transport succeeds.

1 / The failure

Exit 1
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(initial, events, generation, payload=None, observe=None):
    table = {('visible', 'pointer-enter'): 'hover-paused', ('hover-paused', 'pointer-leave'): 'visible', ('visible', 'page-hidden'): 'hidden-paused', ('hidden-paused', 'page-visible'): 'visible', ('hover-paused', 'page-hidden'): 'hidden-paused', ('both-paused', 'page-visible'): 'hover-paused', ('both-paused', 'pointer-leave'): 'hidden-paused', ('visible', 'budget-consumed'): 'expired', ('expired', 'late-pointer-enter'): 'expired', ('hidden-paused', 'budget-callback'): 'hidden-paused'}
    data = json.loads(json.dumps({'remaining': 10, 'pause_owners': [], 'spent': 0})) if payload is None else {**json.loads(json.dumps({'remaining': 10, 'pause_owners': [], 'spent': 0})), **json.loads(json.dumps(payload))}
    state = initial
    for delivery in events:
        event, event_generation = delivery[:2]
        arg = delivery[2] if len(delivery) > 2 else {}
        if event_generation == generation:
            previous = state
            if event == 'pointer-enter': data['pause_owners'] = sorted(set(data['pause_owners']) | {'pointer'})
            if event == 'page-hidden': data['pause_owners'] = sorted(set(data['pause_owners']) | {'page'})
            if event == 'pointer-leave': data['pause_owners'] = [x for x in data['pause_owners'] if x != 'pointer']
            if event == 'page-visible': data['pause_owners'] = [x for x in data['pause_owners'] if x != 'page']
            if event in ('budget-consumed', 'budget-callback'):
                elapsed = max(0, arg.get('elapsed', data['remaining']))
                charge = 0 if data['pause_owners'] else min(elapsed, data['remaining'])
                data['remaining'] -= charge
                data['spent'] += charge
                if data['remaining'] > 0 and event == 'budget-consumed': event = 'unknown-event'
            state = table.get((state, event), state)
            if state == 'expired': data['remaining'] = 0
    return {'phase': state, 'value': data[observe]} if observe else state
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('visible / pointer-enter', solve('visible', [('pointer-enter', N)], N), 'hover-paused')
check('hover-paused / pointer-leave', solve('hover-paused', [('pointer-leave', N)], N), 'visible')
check('visible / page-hidden', solve('visible', [('page-hidden', N)], N), 'hidden-paused')
check('hidden-paused / page-visible', solve('hidden-paused', [('page-visible', N)], N), 'visible')
check('hover-paused / page-hidden', solve('hover-paused', [('page-hidden', N)], N), 'both-paused')
check('both-paused / page-visible', solve('both-paused', [('page-visible', N)], N), 'hover-paused')
check('both-paused / pointer-leave', solve('both-paused', [('pointer-leave', N)], N), 'hidden-paused')
check('visible / budget-consumed', solve('visible', [('budget-consumed', N)], N), 'expired')
check('expired / late-pointer-enter', solve('expired', [('late-pointer-enter', N)], N), 'expired')
check('hidden-paused / budget-callback', solve('hidden-paused', [('budget-callback', N)], N), 'hidden-paused')
check('older notification incarnation', solve('visible', [('pointer-enter', N - 1)], N), 'visible')
check('future notification incarnation', solve('visible', [('pointer-enter', N + 1)], N), 'visible')
check('unknown event is inert', solve('visible', [('unknown-event', N)], N), 'visible')
check('empty delivery batch', solve('visible', [], N), 'visible')
check('N stale deliveries before current delivery', solve('visible', [('pointer-enter', N - 1)] * N + [('pointer-enter', N)], N), 'hover-paused')
check('trace pointer-enter then pointer-leave', solve('visible', [('pointer-enter', N), ('pointer-leave', N)], N), 'visible')
check('trace pointer-enter then page-hidden', solve('visible', [('pointer-enter', N), ('page-hidden', N)], N), 'both-paused')
check('trace pointer-leave then pointer-enter', solve('hover-paused', [('pointer-leave', N), ('pointer-enter', N)], N), 'hover-paused')
check('trace pointer-leave then page-hidden', solve('hover-paused', [('pointer-leave', N), ('page-hidden', N)], N), 'hidden-paused')
check('trace pointer-leave then budget-consumed', solve('hover-paused', [('pointer-leave', N), ('budget-consumed', N)], N), 'expired')
check('trace page-hidden then page-visible', solve('visible', [('page-hidden', N), ('page-visible', N)], N), 'visible')
check('trace page-hidden then budget-callback', solve('visible', [('page-hidden', N), ('budget-callback', N)], N), 'hidden-paused')
check('trace page-visible then pointer-enter', solve('hidden-paused', [('page-visible', N), ('pointer-enter', N)], N), 'hover-paused')
check('trace page-visible then page-hidden', solve('hidden-paused', [('page-visible', N), ('page-hidden', N)], N), 'hidden-paused')
check('trace page-visible then budget-consumed', solve('hidden-paused', [('page-visible', N), ('budget-consumed', N)], N), 'expired')
check('trace page-hidden then page-visible', solve('hover-paused', [('page-hidden', N), ('page-visible', N)], N), 'hover-paused')
check('trace page-hidden then pointer-leave', solve('hover-paused', [('page-hidden', N), ('pointer-leave', N)], N), 'hidden-paused')
check('trace page-visible then pointer-leave', solve('both-paused', [('page-visible', N), ('pointer-leave', N)], N), 'visible')
check('trace page-visible then page-hidden', solve('both-paused', [('page-visible', N), ('page-hidden', N)], N), 'both-paused')
check('trace pointer-leave then page-visible', solve('both-paused', [('pointer-leave', N), ('page-visible', N)], N), 'visible')
check('trace pointer-leave then budget-callback', solve('both-paused', [('pointer-leave', N), ('budget-callback', N)], N), 'hidden-paused')
check('trace budget-consumed then late-pointer-enter', solve('visible', [('budget-consumed', N), ('late-pointer-enter', N)], N), 'expired')
check('trace late-pointer-enter then late-pointer-enter', solve('expired', [('late-pointer-enter', N), ('late-pointer-enter', N)], N), 'expired')
check('trace budget-callback then page-visible', solve('hidden-paused', [('budget-callback', N), ('page-visible', N)], N), 'visible')
check('trace budget-callback then budget-callback', solve('hidden-paused', [('budget-callback', N), ('budget-callback', N)], N), 'hidden-paused')
check('domain state regression 1: remaining', solve('visible', [('budget-consumed', N, {'elapsed': 3})], N, {}, 'remaining'), {'phase': 'visible', 'value': 7})
check('domain state regression 2: spent', solve('visible', [('budget-consumed', N, {'elapsed': 20})], N, {}, 'spent'), {'phase': 'expired', 'value': 10})
check('domain state regression 3: remaining', solve('visible', [('pointer-enter', N, {}), ('budget-callback', N, {'elapsed': 20})], N, {}, 'remaining'), {'phase': 'hover-paused', 'value': 10})
check('domain state regression 4: pause_owners', solve('both-paused', [('pointer-leave', N, {})], N, {'pause_owners': ['page', 'pointer']}, 'pause_owners'), {'phase': 'hidden-paused', 'value': ['page']})
check('domain state regression 5: pause_owners', solve('both-paused', [('page-visible', N, {})], N, {'pause_owners': ['page', 'pointer']}, 'pause_owners'), {'phase': 'hover-paused', 'value': ['pointer']})
check('domain state regression 6: spent', solve('visible', [('budget-consumed', N, {'elapsed': -2})], N, {}, 'spent'), {'phase': 'visible', 'value': 0})
check('domain state regression 7: remaining', solve('visible', [('pointer-enter', N, {}), ('page-hidden', N, {}), ('pointer-leave', N, {}), ('budget-callback', N, {'elapsed': 99})], N, {}, 'remaining'), {'phase': 'hidden-paused', 'value': 10})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)
Boundary fixtureActualExpectedOutcome
visible / pointer-enterhover-pausedhover-pausedPassed
hover-paused / pointer-leavevisiblevisiblePassed
visible / page-hiddenhidden-pausedhidden-pausedPassed
hidden-paused / page-visiblevisiblevisiblePassed
hover-paused / page-hiddenhidden-pausedboth-pausedFailed
both-paused / page-visiblehover-pausedhover-pausedPassed
both-paused / pointer-leavehidden-pausedhidden-pausedPassed
visible / budget-consumedexpiredexpiredPassed
expired / late-pointer-enterexpiredexpiredPassed
hidden-paused / budget-callbackhidden-pausedhidden-pausedPassed
older notification incarnationvisiblevisiblePassed
future notification incarnationvisiblevisiblePassed
unknown event is inertvisiblevisiblePassed
empty delivery batchvisiblevisiblePassed
N stale deliveries before current deliveryhover-pausedhover-pausedPassed
trace pointer-enter then pointer-leavevisiblevisiblePassed
trace pointer-enter then page-hiddenhidden-pausedboth-pausedFailed
trace pointer-leave then pointer-enterhover-pausedhover-pausedPassed
trace pointer-leave then page-hiddenhidden-pausedhidden-pausedPassed
trace pointer-leave then budget-consumedexpiredexpiredPassed
trace page-hidden then page-visiblevisiblevisiblePassed
trace page-hidden then budget-callbackhidden-pausedhidden-pausedPassed
trace page-visible then pointer-enterhover-pausedhover-pausedPassed
trace page-visible then page-hiddenhidden-pausedhidden-pausedPassed
trace page-visible then budget-consumedexpiredexpiredPassed
trace page-hidden then page-visiblevisiblehover-pausedFailed
trace page-hidden then pointer-leavehidden-pausedhidden-pausedPassed
trace page-visible then pointer-leavevisiblevisiblePassed
trace page-visible then page-hiddenhidden-pausedboth-pausedFailed
trace pointer-leave then page-visiblevisiblevisiblePassed
trace pointer-leave then budget-callbackhidden-pausedhidden-pausedPassed
trace budget-consumed then late-pointer-enterexpiredexpiredPassed
trace late-pointer-enter then late-pointer-enterexpiredexpiredPassed
trace budget-callback then page-visiblevisiblevisiblePassed
trace budget-callback then budget-callbackhidden-pausedhidden-pausedPassed
domain state regression 1: remaining{'phase': 'visible', 'value': 7}{'phase': 'visible', 'value': 7}Passed
domain state regression 2: spent{'phase': 'expired', 'value': 10}{'phase': 'expired', 'value': 10}Passed
domain state regression 3: remaining{'phase': 'hover-paused', 'value': 10}{'phase': 'hover-paused', 'value': 10}Passed
domain state regression 4: pause_owners{'phase': 'hidden-paused', 'value': ['page']}{'phase': 'hidden-paused', 'value': ['page']}Passed
domain state regression 5: pause_owners{'phase': 'hover-paused', 'value': ['pointer']}{'phase': 'hover-paused', 'value': ['pointer']}Passed
domain state regression 6: spent{'phase': 'visible', 'value': 0}{'phase': 'visible', 'value': 0}Passed
domain state regression 7: remaining{'phase': 'hidden-paused', 'value': 10}{'phase': 'hidden-paused', 'value': 10}Passed

SHA-256 / 9898abbe42869ac17afcddc2fc61c1ee56a3fd7df147905fb12d275f83af0e74

2 / The unsuccessful fix

Exit 1
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(initial, events, generation, payload=None, observe=None):
    table = {('visible', 'pointer-enter'): 'hover-paused', ('hover-paused', 'pointer-leave'): 'visible', ('visible', 'page-hidden'): 'hidden-paused', ('hidden-paused', 'page-visible'): 'visible', ('hover-paused', 'page-hidden'): 'visible', ('both-paused', 'page-visible'): 'hover-paused', ('both-paused', 'pointer-leave'): 'hidden-paused', ('visible', 'budget-consumed'): 'expired', ('expired', 'late-pointer-enter'): 'expired', ('hidden-paused', 'budget-callback'): 'hidden-paused'}
    data = json.loads(json.dumps({'remaining': 10, 'pause_owners': [], 'spent': 0})) if payload is None else {**json.loads(json.dumps({'remaining': 10, 'pause_owners': [], 'spent': 0})), **json.loads(json.dumps(payload))}
    state = initial
    for delivery in events:
        event, event_generation = delivery[:2]
        arg = delivery[2] if len(delivery) > 2 else {}
        if event_generation == generation:
            previous = state
            if event == 'pointer-enter': data['pause_owners'] = sorted(set(data['pause_owners']) | {'pointer'})
            if event == 'page-hidden': data['pause_owners'] = sorted(set(data['pause_owners']) | {'page'})
            if event == 'pointer-leave': data['pause_owners'] = [x for x in data['pause_owners'] if x != 'pointer']
            if event == 'page-visible': data['pause_owners'] = [x for x in data['pause_owners'] if x != 'page']
            if event in ('budget-consumed', 'budget-callback'):
                elapsed = max(0, arg.get('elapsed', data['remaining']))
                charge = 0 if data['pause_owners'] else min(elapsed, data['remaining'])
                data['remaining'] -= charge
                data['spent'] += charge
                if data['remaining'] > 0 and event == 'budget-consumed': event = 'unknown-event'
            state = table.get((state, event), state)
            if state == 'expired': data['remaining'] = 0
    return {'phase': state, 'value': data[observe]} if observe else state
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('visible / pointer-enter', solve('visible', [('pointer-enter', N)], N), 'hover-paused')
check('hover-paused / pointer-leave', solve('hover-paused', [('pointer-leave', N)], N), 'visible')
check('visible / page-hidden', solve('visible', [('page-hidden', N)], N), 'hidden-paused')
check('hidden-paused / page-visible', solve('hidden-paused', [('page-visible', N)], N), 'visible')
check('hover-paused / page-hidden', solve('hover-paused', [('page-hidden', N)], N), 'both-paused')
check('both-paused / page-visible', solve('both-paused', [('page-visible', N)], N), 'hover-paused')
check('both-paused / pointer-leave', solve('both-paused', [('pointer-leave', N)], N), 'hidden-paused')
check('visible / budget-consumed', solve('visible', [('budget-consumed', N)], N), 'expired')
check('expired / late-pointer-enter', solve('expired', [('late-pointer-enter', N)], N), 'expired')
check('hidden-paused / budget-callback', solve('hidden-paused', [('budget-callback', N)], N), 'hidden-paused')
check('older notification incarnation', solve('visible', [('pointer-enter', N - 1)], N), 'visible')
check('future notification incarnation', solve('visible', [('pointer-enter', N + 1)], N), 'visible')
check('unknown event is inert', solve('visible', [('unknown-event', N)], N), 'visible')
check('empty delivery batch', solve('visible', [], N), 'visible')
check('N stale deliveries before current delivery', solve('visible', [('pointer-enter', N - 1)] * N + [('pointer-enter', N)], N), 'hover-paused')
check('trace pointer-enter then pointer-leave', solve('visible', [('pointer-enter', N), ('pointer-leave', N)], N), 'visible')
check('trace pointer-enter then page-hidden', solve('visible', [('pointer-enter', N), ('page-hidden', N)], N), 'both-paused')
check('trace pointer-leave then pointer-enter', solve('hover-paused', [('pointer-leave', N), ('pointer-enter', N)], N), 'hover-paused')
check('trace pointer-leave then page-hidden', solve('hover-paused', [('pointer-leave', N), ('page-hidden', N)], N), 'hidden-paused')
check('trace pointer-leave then budget-consumed', solve('hover-paused', [('pointer-leave', N), ('budget-consumed', N)], N), 'expired')
check('trace page-hidden then page-visible', solve('visible', [('page-hidden', N), ('page-visible', N)], N), 'visible')
check('trace page-hidden then budget-callback', solve('visible', [('page-hidden', N), ('budget-callback', N)], N), 'hidden-paused')
check('trace page-visible then pointer-enter', solve('hidden-paused', [('page-visible', N), ('pointer-enter', N)], N), 'hover-paused')
check('trace page-visible then page-hidden', solve('hidden-paused', [('page-visible', N), ('page-hidden', N)], N), 'hidden-paused')
check('trace page-visible then budget-consumed', solve('hidden-paused', [('page-visible', N), ('budget-consumed', N)], N), 'expired')
check('trace page-hidden then page-visible', solve('hover-paused', [('page-hidden', N), ('page-visible', N)], N), 'hover-paused')
check('trace page-hidden then pointer-leave', solve('hover-paused', [('page-hidden', N), ('pointer-leave', N)], N), 'hidden-paused')
check('trace page-visible then pointer-leave', solve('both-paused', [('page-visible', N), ('pointer-leave', N)], N), 'visible')
check('trace page-visible then page-hidden', solve('both-paused', [('page-visible', N), ('page-hidden', N)], N), 'both-paused')
check('trace pointer-leave then page-visible', solve('both-paused', [('pointer-leave', N), ('page-visible', N)], N), 'visible')
check('trace pointer-leave then budget-callback', solve('both-paused', [('pointer-leave', N), ('budget-callback', N)], N), 'hidden-paused')
check('trace budget-consumed then late-pointer-enter', solve('visible', [('budget-consumed', N), ('late-pointer-enter', N)], N), 'expired')
check('trace late-pointer-enter then late-pointer-enter', solve('expired', [('late-pointer-enter', N), ('late-pointer-enter', N)], N), 'expired')
check('trace budget-callback then page-visible', solve('hidden-paused', [('budget-callback', N), ('page-visible', N)], N), 'visible')
check('trace budget-callback then budget-callback', solve('hidden-paused', [('budget-callback', N), ('budget-callback', N)], N), 'hidden-paused')
check('domain state regression 1: remaining', solve('visible', [('budget-consumed', N, {'elapsed': 3})], N, {}, 'remaining'), {'phase': 'visible', 'value': 7})
check('domain state regression 2: spent', solve('visible', [('budget-consumed', N, {'elapsed': 20})], N, {}, 'spent'), {'phase': 'expired', 'value': 10})
check('domain state regression 3: remaining', solve('visible', [('pointer-enter', N, {}), ('budget-callback', N, {'elapsed': 20})], N, {}, 'remaining'), {'phase': 'hover-paused', 'value': 10})
check('domain state regression 4: pause_owners', solve('both-paused', [('pointer-leave', N, {})], N, {'pause_owners': ['page', 'pointer']}, 'pause_owners'), {'phase': 'hidden-paused', 'value': ['page']})
check('domain state regression 5: pause_owners', solve('both-paused', [('page-visible', N, {})], N, {'pause_owners': ['page', 'pointer']}, 'pause_owners'), {'phase': 'hover-paused', 'value': ['pointer']})
check('domain state regression 6: spent', solve('visible', [('budget-consumed', N, {'elapsed': -2})], N, {}, 'spent'), {'phase': 'visible', 'value': 0})
check('domain state regression 7: remaining', solve('visible', [('pointer-enter', N, {}), ('page-hidden', N, {}), ('pointer-leave', N, {}), ('budget-callback', N, {'elapsed': 99})], N, {}, 'remaining'), {'phase': 'hidden-paused', 'value': 10})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)
Boundary fixtureActualExpectedOutcome
visible / pointer-enterhover-pausedhover-pausedPassed
hover-paused / pointer-leavevisiblevisiblePassed
visible / page-hiddenhidden-pausedhidden-pausedPassed
hidden-paused / page-visiblevisiblevisiblePassed
hover-paused / page-hiddenvisibleboth-pausedFailed
both-paused / page-visiblehover-pausedhover-pausedPassed
both-paused / pointer-leavehidden-pausedhidden-pausedPassed
visible / budget-consumedexpiredexpiredPassed
expired / late-pointer-enterexpiredexpiredPassed
hidden-paused / budget-callbackhidden-pausedhidden-pausedPassed
older notification incarnationvisiblevisiblePassed
future notification incarnationvisiblevisiblePassed
unknown event is inertvisiblevisiblePassed
empty delivery batchvisiblevisiblePassed
N stale deliveries before current deliveryhover-pausedhover-pausedPassed
trace pointer-enter then pointer-leavevisiblevisiblePassed
trace pointer-enter then page-hiddenvisibleboth-pausedFailed
trace pointer-leave then pointer-enterhover-pausedhover-pausedPassed
trace pointer-leave then page-hiddenhidden-pausedhidden-pausedPassed
trace pointer-leave then budget-consumedexpiredexpiredPassed
trace page-hidden then page-visiblevisiblevisiblePassed
trace page-hidden then budget-callbackhidden-pausedhidden-pausedPassed
trace page-visible then pointer-enterhover-pausedhover-pausedPassed
trace page-visible then page-hiddenhidden-pausedhidden-pausedPassed
trace page-visible then budget-consumedexpiredexpiredPassed
trace page-hidden then page-visiblevisiblehover-pausedFailed
trace page-hidden then pointer-leavevisiblehidden-pausedFailed
trace page-visible then pointer-leavevisiblevisiblePassed
trace page-visible then page-hiddenvisibleboth-pausedFailed
trace pointer-leave then page-visiblevisiblevisiblePassed
trace pointer-leave then budget-callbackhidden-pausedhidden-pausedPassed
trace budget-consumed then late-pointer-enterexpiredexpiredPassed
trace late-pointer-enter then late-pointer-enterexpiredexpiredPassed
trace budget-callback then page-visiblevisiblevisiblePassed
trace budget-callback then budget-callbackhidden-pausedhidden-pausedPassed
domain state regression 1: remaining{'phase': 'visible', 'value': 7}{'phase': 'visible', 'value': 7}Passed
domain state regression 2: spent{'phase': 'expired', 'value': 10}{'phase': 'expired', 'value': 10}Passed
domain state regression 3: remaining{'phase': 'hover-paused', 'value': 10}{'phase': 'hover-paused', 'value': 10}Passed
domain state regression 4: pause_owners{'phase': 'hidden-paused', 'value': ['page']}{'phase': 'hidden-paused', 'value': ['page']}Passed
domain state regression 5: pause_owners{'phase': 'hover-paused', 'value': ['pointer']}{'phase': 'hover-paused', 'value': ['pointer']}Passed
domain state regression 6: spent{'phase': 'visible', 'value': 0}{'phase': 'visible', 'value': 0}Passed
domain state regression 7: remaining{'phase': 'visible', 'value': 10}{'phase': 'hidden-paused', 'value': 10}Failed

SHA-256 / 310e7980ba10eb99d9773ed6c77671a5b9832540d50514e924a0c7cb7bc03fe2

3 / The verified repair

Exit 0
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(initial, events, generation, payload=None, observe=None):
    table = {('visible', 'pointer-enter'): 'hover-paused', ('hover-paused', 'pointer-leave'): 'visible', ('visible', 'page-hidden'): 'hidden-paused', ('hidden-paused', 'page-visible'): 'visible', ('hover-paused', 'page-hidden'): 'both-paused', ('both-paused', 'page-visible'): 'hover-paused', ('both-paused', 'pointer-leave'): 'hidden-paused', ('visible', 'budget-consumed'): 'expired', ('expired', 'late-pointer-enter'): 'expired', ('hidden-paused', 'budget-callback'): 'hidden-paused'}
    data = json.loads(json.dumps({'remaining': 10, 'pause_owners': [], 'spent': 0})) if payload is None else {**json.loads(json.dumps({'remaining': 10, 'pause_owners': [], 'spent': 0})), **json.loads(json.dumps(payload))}
    state = initial
    for delivery in events:
        event, event_generation = delivery[:2]
        arg = delivery[2] if len(delivery) > 2 else {}
        if event_generation == generation:
            previous = state
            if event == 'pointer-enter': data['pause_owners'] = sorted(set(data['pause_owners']) | {'pointer'})
            if event == 'page-hidden': data['pause_owners'] = sorted(set(data['pause_owners']) | {'page'})
            if event == 'pointer-leave': data['pause_owners'] = [x for x in data['pause_owners'] if x != 'pointer']
            if event == 'page-visible': data['pause_owners'] = [x for x in data['pause_owners'] if x != 'page']
            if event in ('budget-consumed', 'budget-callback'):
                elapsed = max(0, arg.get('elapsed', data['remaining']))
                charge = 0 if data['pause_owners'] else min(elapsed, data['remaining'])
                data['remaining'] -= charge
                data['spent'] += charge
                if data['remaining'] > 0 and event == 'budget-consumed': event = 'unknown-event'
            state = table.get((state, event), state)
            if state == 'expired': data['remaining'] = 0
    return {'phase': state, 'value': data[observe]} if observe else state
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('visible / pointer-enter', solve('visible', [('pointer-enter', N)], N), 'hover-paused')
check('hover-paused / pointer-leave', solve('hover-paused', [('pointer-leave', N)], N), 'visible')
check('visible / page-hidden', solve('visible', [('page-hidden', N)], N), 'hidden-paused')
check('hidden-paused / page-visible', solve('hidden-paused', [('page-visible', N)], N), 'visible')
check('hover-paused / page-hidden', solve('hover-paused', [('page-hidden', N)], N), 'both-paused')
check('both-paused / page-visible', solve('both-paused', [('page-visible', N)], N), 'hover-paused')
check('both-paused / pointer-leave', solve('both-paused', [('pointer-leave', N)], N), 'hidden-paused')
check('visible / budget-consumed', solve('visible', [('budget-consumed', N)], N), 'expired')
check('expired / late-pointer-enter', solve('expired', [('late-pointer-enter', N)], N), 'expired')
check('hidden-paused / budget-callback', solve('hidden-paused', [('budget-callback', N)], N), 'hidden-paused')
check('older notification incarnation', solve('visible', [('pointer-enter', N - 1)], N), 'visible')
check('future notification incarnation', solve('visible', [('pointer-enter', N + 1)], N), 'visible')
check('unknown event is inert', solve('visible', [('unknown-event', N)], N), 'visible')
check('empty delivery batch', solve('visible', [], N), 'visible')
check('N stale deliveries before current delivery', solve('visible', [('pointer-enter', N - 1)] * N + [('pointer-enter', N)], N), 'hover-paused')
check('trace pointer-enter then pointer-leave', solve('visible', [('pointer-enter', N), ('pointer-leave', N)], N), 'visible')
check('trace pointer-enter then page-hidden', solve('visible', [('pointer-enter', N), ('page-hidden', N)], N), 'both-paused')
check('trace pointer-leave then pointer-enter', solve('hover-paused', [('pointer-leave', N), ('pointer-enter', N)], N), 'hover-paused')
check('trace pointer-leave then page-hidden', solve('hover-paused', [('pointer-leave', N), ('page-hidden', N)], N), 'hidden-paused')
check('trace pointer-leave then budget-consumed', solve('hover-paused', [('pointer-leave', N), ('budget-consumed', N)], N), 'expired')
check('trace page-hidden then page-visible', solve('visible', [('page-hidden', N), ('page-visible', N)], N), 'visible')
check('trace page-hidden then budget-callback', solve('visible', [('page-hidden', N), ('budget-callback', N)], N), 'hidden-paused')
check('trace page-visible then pointer-enter', solve('hidden-paused', [('page-visible', N), ('pointer-enter', N)], N), 'hover-paused')
check('trace page-visible then page-hidden', solve('hidden-paused', [('page-visible', N), ('page-hidden', N)], N), 'hidden-paused')
check('trace page-visible then budget-consumed', solve('hidden-paused', [('page-visible', N), ('budget-consumed', N)], N), 'expired')
check('trace page-hidden then page-visible', solve('hover-paused', [('page-hidden', N), ('page-visible', N)], N), 'hover-paused')
check('trace page-hidden then pointer-leave', solve('hover-paused', [('page-hidden', N), ('pointer-leave', N)], N), 'hidden-paused')
check('trace page-visible then pointer-leave', solve('both-paused', [('page-visible', N), ('pointer-leave', N)], N), 'visible')
check('trace page-visible then page-hidden', solve('both-paused', [('page-visible', N), ('page-hidden', N)], N), 'both-paused')
check('trace pointer-leave then page-visible', solve('both-paused', [('pointer-leave', N), ('page-visible', N)], N), 'visible')
check('trace pointer-leave then budget-callback', solve('both-paused', [('pointer-leave', N), ('budget-callback', N)], N), 'hidden-paused')
check('trace budget-consumed then late-pointer-enter', solve('visible', [('budget-consumed', N), ('late-pointer-enter', N)], N), 'expired')
check('trace late-pointer-enter then late-pointer-enter', solve('expired', [('late-pointer-enter', N), ('late-pointer-enter', N)], N), 'expired')
check('trace budget-callback then page-visible', solve('hidden-paused', [('budget-callback', N), ('page-visible', N)], N), 'visible')
check('trace budget-callback then budget-callback', solve('hidden-paused', [('budget-callback', N), ('budget-callback', N)], N), 'hidden-paused')
check('domain state regression 1: remaining', solve('visible', [('budget-consumed', N, {'elapsed': 3})], N, {}, 'remaining'), {'phase': 'visible', 'value': 7})
check('domain state regression 2: spent', solve('visible', [('budget-consumed', N, {'elapsed': 20})], N, {}, 'spent'), {'phase': 'expired', 'value': 10})
check('domain state regression 3: remaining', solve('visible', [('pointer-enter', N, {}), ('budget-callback', N, {'elapsed': 20})], N, {}, 'remaining'), {'phase': 'hover-paused', 'value': 10})
check('domain state regression 4: pause_owners', solve('both-paused', [('pointer-leave', N, {})], N, {'pause_owners': ['page', 'pointer']}, 'pause_owners'), {'phase': 'hidden-paused', 'value': ['page']})
check('domain state regression 5: pause_owners', solve('both-paused', [('page-visible', N, {})], N, {'pause_owners': ['page', 'pointer']}, 'pause_owners'), {'phase': 'hover-paused', 'value': ['pointer']})
check('domain state regression 6: spent', solve('visible', [('budget-consumed', N, {'elapsed': -2})], N, {}, 'spent'), {'phase': 'visible', 'value': 0})
check('domain state regression 7: remaining', solve('visible', [('pointer-enter', N, {}), ('page-hidden', N, {}), ('pointer-leave', N, {}), ('budget-callback', N, {'elapsed': 99})], N, {}, 'remaining'), {'phase': 'hidden-paused', 'value': 10})
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)
Boundary fixtureActualExpectedOutcome
visible / pointer-enterhover-pausedhover-pausedPassed
hover-paused / pointer-leavevisiblevisiblePassed
visible / page-hiddenhidden-pausedhidden-pausedPassed
hidden-paused / page-visiblevisiblevisiblePassed
hover-paused / page-hiddenboth-pausedboth-pausedPassed
both-paused / page-visiblehover-pausedhover-pausedPassed
both-paused / pointer-leavehidden-pausedhidden-pausedPassed
visible / budget-consumedexpiredexpiredPassed
expired / late-pointer-enterexpiredexpiredPassed
hidden-paused / budget-callbackhidden-pausedhidden-pausedPassed
older notification incarnationvisiblevisiblePassed
future notification incarnationvisiblevisiblePassed
unknown event is inertvisiblevisiblePassed
empty delivery batchvisiblevisiblePassed
N stale deliveries before current deliveryhover-pausedhover-pausedPassed
trace pointer-enter then pointer-leavevisiblevisiblePassed
trace pointer-enter then page-hiddenboth-pausedboth-pausedPassed
trace pointer-leave then pointer-enterhover-pausedhover-pausedPassed
trace pointer-leave then page-hiddenhidden-pausedhidden-pausedPassed
trace pointer-leave then budget-consumedexpiredexpiredPassed
trace page-hidden then page-visiblevisiblevisiblePassed
trace page-hidden then budget-callbackhidden-pausedhidden-pausedPassed
trace page-visible then pointer-enterhover-pausedhover-pausedPassed
trace page-visible then page-hiddenhidden-pausedhidden-pausedPassed
trace page-visible then budget-consumedexpiredexpiredPassed
trace page-hidden then page-visiblehover-pausedhover-pausedPassed
trace page-hidden then pointer-leavehidden-pausedhidden-pausedPassed
trace page-visible then pointer-leavevisiblevisiblePassed
trace page-visible then page-hiddenboth-pausedboth-pausedPassed
trace pointer-leave then page-visiblevisiblevisiblePassed
trace pointer-leave then budget-callbackhidden-pausedhidden-pausedPassed
trace budget-consumed then late-pointer-enterexpiredexpiredPassed
trace late-pointer-enter then late-pointer-enterexpiredexpiredPassed
trace budget-callback then page-visiblevisiblevisiblePassed
trace budget-callback then budget-callbackhidden-pausedhidden-pausedPassed
domain state regression 1: remaining{'phase': 'visible', 'value': 7}{'phase': 'visible', 'value': 7}Passed
domain state regression 2: spent{'phase': 'expired', 'value': 10}{'phase': 'expired', 'value': 10}Passed
domain state regression 3: remaining{'phase': 'hover-paused', 'value': 10}{'phase': 'hover-paused', 'value': 10}Passed
domain state regression 4: pause_owners{'phase': 'hidden-paused', 'value': ['page']}{'phase': 'hidden-paused', 'value': ['page']}Passed
domain state regression 5: pause_owners{'phase': 'hover-paused', 'value': ['pointer']}{'phase': 'hover-paused', 'value': ['pointer']}Passed
domain state regression 6: spent{'phase': 'visible', 'value': 0}{'phase': 'visible', 'value': 0}Passed
domain state regression 7: remaining{'phase': 'hidden-paused', 'value': 10}{'phase': 'hidden-paused', 'value': 10}Passed

SHA-256 / 74ff3a0b031610ac4c4c9c53f1dfc4d1758371c8903cbcfed769c697fa9ff1e1

Verification & scope

Stipulated single-notification state and policy model only. Event delivery and acknowledgements are explicit test inputs. No DOM, accessibility announcements, live timers, networking, actual rendering, or production-platform conformance is simulated. This reproducer isolates one failure mechanism. Results cover the supplied fixtures. Variants within a family share a test contract and should remain grouped when constructing evaluation splits. Related mechanisms with a shared evaluation_group must also remain together; these controlled models are not independent production incidents.

Observations recorded using Python 3.12.14 at 2026-09-29T14:42:26.376839+00:00.

Case digest / f79ef8f0863e555239b53f1681039c325759720788ac3c452c39dc7de8f2104f