FAILURE MAP
← Case archive

FA-26966 / HTTP ranges / Open access

Partial cache admission publishes complete requested fragments atomically: a prefix does not prove every promised range cell arrived · case 01

Partial cache admission publishes complete requested fragments atomically: a prefix does not prove every promised range cell arrived.

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

ROOT CAUSE

The partial-admission-transaction-commit-completeness decision uses visible=dict(x[0]) pending=None reads=[] for event in x[1]: op=event[0] if op=='begin': if pending is not None: continue pending=[event[1],set(event[2]),{}] elif op=='put': if pending is None or event[1]!=pending[0]: continue at,char=event[2:] if at not in pending[1]: continue if at in pending[2] and pending[2][at]!=char: pending=None continue pending[2][at]=char elif op=='commit': if pending is None or event[1]!=pending[0]: continue if not pending[2] and pending[1]: continue visible=dict(pending[2]) pending=None elif op=='abort': if pending is not None and event[1]==pending[0]: pending=None elif op=='read': reads.append(sorted(visible.items())) return [reads,sorted(visible.items()),pending[0] if pending is not None else None].

VERIFIED REPAIR

Apply the bounded decision exactly: visible=dict(x[0]) pending=None reads=[] for event in x[1]: op=event[0] if op=='begin': if pending is not None: continue pending=[event[1],set(event[2]),{}] elif op=='put': if pending is None or event[1]!=pending[0]: continue at,char=event[2:] if at not in pending[1]: continue if at in pending[2] and pending[2][at]!=char: pending=None continue pending[2][at]=char elif op=='commit': if pending is None or event[1]!=pending[0]: continue if set(pending[2])!=pending[1]: continue visible=dict(pending[2]) pending=None elif op=='abort': if pending is not None and event[1]==pending[0]: pending=None elif op=='read': reads.append(sorted(visible.items())) return [reads,sorted(visible.items()),pending[0] if pending is not None else None]

Unsuccessful approach: The partial repair uses visible=dict(x[0]) pending=None reads=[] for event in x[1]: op=event[0] if op=='begin': if pending is not None: continue pending=[event[1],set(event[2]),{}] elif op=='put': if pending is None or event[1]!=pending[0]: continue at,char=event[2:] if at not in pending[1]: continue if at in pending[2] and pending[2][at]!=char: pending=None continue pending[2][at]=char elif op=='commit': if pending is None or event[1]!=pending[0]: continue if not set(pending[2]).issubset(pending[1]): continue visible=dict(pending[2]) pending=None elif op=='abort': if pending is not None and event[1]==pending[0]: pending=None elif op=='read': reads.append(sorted(visible.items())) return [reads,sorted(visible.items()),pending[0] if pending is not None else None], which still violates the stated contract.

Case contract

x is [old-visible-cells,events]. Events begin(id,expected-offsets), put(id,offset,char), commit(id), abort(id), read. One transaction at a time; unknown or mismatching ids ignored. A conflicting duplicate byte invalidates the active transaction. Commit succeeds only when every expected cell is present and replaces the old generation. Readers see committed cells sorted by offset. Return [read-snapshots,final-cells,pending-id].

Why this case matters

Range responses combine representation identity, conditional requests, framing, and partial-object state.

1 / The failure

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

N = 1
observations = []
def solve(x):
    visible=dict(x[0])
    pending=None
    reads=[]
    for event in x[1]:
        op=event[0]
        if op=='begin':
            if pending is not None: continue
            pending=[event[1],set(event[2]),{}]
        elif op=='put':
            if pending is None or event[1]!=pending[0]: continue
            at,char=event[2:]
            if at not in pending[1]: continue
            if at in pending[2] and pending[2][at]!=char:
                pending=None
                continue
            pending[2][at]=char
        elif op=='commit':
            if pending is None or event[1]!=pending[0]: continue
            if not pending[2] and pending[1]: continue
            visible=dict(pending[2])
            pending=None
        elif op=='abort':
            if pending is not None and event[1]==pending[0]: pending=None
        elif op=='read':
            reads.append(sorted(visible.items()))
    return [reads,sorted(visible.items()),pending[0] if pending is not None else None]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('commit-completeness fixture 0', json.loads(json.dumps(solve([[[0,'o'],[9,'z']],[['begin','a',[0,1]],['put','a',1,'b'],['read'],['put','a',0,'a'],['commit','a'],['read']]]))), json.loads(json.dumps([[[[0,'o'],[9,'z']],[[0,'a'],[1,'b']]],[[0,'a'],[1,'b']],None])))
check('commit-completeness fixture 1', json.loads(json.dumps(solve([[],[['begin','a',[0,1]],['put','a',0,'a'],['commit','a'],['read']]]))), json.loads(json.dumps([[[]],[],'a'])))
check('commit-completeness fixture 2', json.loads(json.dumps(solve([[],[['begin','a',[0]],['put','wrong',0,'x'],['put','a',1,'y'],['commit','a'],['read']]]))), json.loads(json.dumps([[[]],[],'a'])))
check('commit-completeness fixture 3', json.loads(json.dumps(solve([[],[['begin','a',[0]],['put','a',0,'a'],['put','a',1,'b'],['commit','a']]]))), json.loads(json.dumps([[],[[0,'a']],None])))
check('commit-completeness fixture 4', json.loads(json.dumps(solve([[],[['begin','a',[0]],['put','a',0,'a'],['put','a',0,'b'],['commit','a']]]))), json.loads(json.dumps([[],[],None])))
check('commit-completeness fixture 5', json.loads(json.dumps(solve([[],[['begin','a',[0]],['begin','b',[]],['abort','b'],['put','a',0,'a'],['commit','a']]]))), json.loads(json.dumps([[],[[0,'a']],None])))
check('commit-completeness fixture 6', json.loads(json.dumps(solve([[],[['begin','a',[0]],['put','a',0,'a'],['put','a',0,'a'],['commit','wrong'],['read'],['commit','a']]]))), json.loads(json.dumps([[[]],[[0,'a']],None])))
check('commit-completeness fixture 7', json.loads(json.dumps(solve([[],[['begin','a',[]],['commit','a'],['begin','b',[N]],['put','b',N,'p'],['commit','b']]]))), json.loads(json.dumps([[],[[N,'p']],None])))
check('commit-completeness fixture 8', json.loads(json.dumps(solve([[[0,'o']],[['begin','a',[0]],['put','a',0,'a'],['abort','a'],['read']]]))), json.loads(json.dumps([[[[0,'o']]],[[0,'o']],None])))
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
commit-completeness fixture 0[[[[0, 'o'], [9, 'z']], [[0, 'a'], [1, 'b']]], [[0, 'a'], [1, 'b']], None][[[[0, 'o'], [9, 'z']], [[0, 'a'], [1, 'b']]], [[0, 'a'], [1, 'b']], None]Passed
commit-completeness fixture 1[[[[0, 'a']]], [[0, 'a']], None][[[]], [], 'a']Failed
commit-completeness fixture 2[[[]], [], 'a'][[[]], [], 'a']Passed
commit-completeness fixture 3[[], [[0, 'a']], None][[], [[0, 'a']], None]Passed
commit-completeness fixture 4[[], [], None][[], [], None]Passed
commit-completeness fixture 5[[], [[0, 'a']], None][[], [[0, 'a']], None]Passed
commit-completeness fixture 6[[[]], [[0, 'a']], None][[[]], [[0, 'a']], None]Passed
commit-completeness fixture 7[[], [[1, 'p']], None][[], [[1, 'p']], None]Passed
commit-completeness fixture 8[[[[0, 'o']]], [[0, 'o']], None][[[[0, 'o']]], [[0, 'o']], None]Passed

SHA-256 / 8071566b416c15d23cb072da4edde725fa78bb2ea157785ab6aedb08e97b4afe

2 / The unsuccessful fix

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

N = 1
observations = []
def solve(x):
    visible=dict(x[0])
    pending=None
    reads=[]
    for event in x[1]:
        op=event[0]
        if op=='begin':
            if pending is not None: continue
            pending=[event[1],set(event[2]),{}]
        elif op=='put':
            if pending is None or event[1]!=pending[0]: continue
            at,char=event[2:]
            if at not in pending[1]: continue
            if at in pending[2] and pending[2][at]!=char:
                pending=None
                continue
            pending[2][at]=char
        elif op=='commit':
            if pending is None or event[1]!=pending[0]: continue
            if not set(pending[2]).issubset(pending[1]): continue
            visible=dict(pending[2])
            pending=None
        elif op=='abort':
            if pending is not None and event[1]==pending[0]: pending=None
        elif op=='read':
            reads.append(sorted(visible.items()))
    return [reads,sorted(visible.items()),pending[0] if pending is not None else None]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('commit-completeness fixture 0', json.loads(json.dumps(solve([[[0,'o'],[9,'z']],[['begin','a',[0,1]],['put','a',1,'b'],['read'],['put','a',0,'a'],['commit','a'],['read']]]))), json.loads(json.dumps([[[[0,'o'],[9,'z']],[[0,'a'],[1,'b']]],[[0,'a'],[1,'b']],None])))
check('commit-completeness fixture 1', json.loads(json.dumps(solve([[],[['begin','a',[0,1]],['put','a',0,'a'],['commit','a'],['read']]]))), json.loads(json.dumps([[[]],[],'a'])))
check('commit-completeness fixture 2', json.loads(json.dumps(solve([[],[['begin','a',[0]],['put','wrong',0,'x'],['put','a',1,'y'],['commit','a'],['read']]]))), json.loads(json.dumps([[[]],[],'a'])))
check('commit-completeness fixture 3', json.loads(json.dumps(solve([[],[['begin','a',[0]],['put','a',0,'a'],['put','a',1,'b'],['commit','a']]]))), json.loads(json.dumps([[],[[0,'a']],None])))
check('commit-completeness fixture 4', json.loads(json.dumps(solve([[],[['begin','a',[0]],['put','a',0,'a'],['put','a',0,'b'],['commit','a']]]))), json.loads(json.dumps([[],[],None])))
check('commit-completeness fixture 5', json.loads(json.dumps(solve([[],[['begin','a',[0]],['begin','b',[]],['abort','b'],['put','a',0,'a'],['commit','a']]]))), json.loads(json.dumps([[],[[0,'a']],None])))
check('commit-completeness fixture 6', json.loads(json.dumps(solve([[],[['begin','a',[0]],['put','a',0,'a'],['put','a',0,'a'],['commit','wrong'],['read'],['commit','a']]]))), json.loads(json.dumps([[[]],[[0,'a']],None])))
check('commit-completeness fixture 7', json.loads(json.dumps(solve([[],[['begin','a',[]],['commit','a'],['begin','b',[N]],['put','b',N,'p'],['commit','b']]]))), json.loads(json.dumps([[],[[N,'p']],None])))
check('commit-completeness fixture 8', json.loads(json.dumps(solve([[[0,'o']],[['begin','a',[0]],['put','a',0,'a'],['abort','a'],['read']]]))), json.loads(json.dumps([[[[0,'o']]],[[0,'o']],None])))
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
commit-completeness fixture 0[[[[0, 'o'], [9, 'z']], [[0, 'a'], [1, 'b']]], [[0, 'a'], [1, 'b']], None][[[[0, 'o'], [9, 'z']], [[0, 'a'], [1, 'b']]], [[0, 'a'], [1, 'b']], None]Passed
commit-completeness fixture 1[[[[0, 'a']]], [[0, 'a']], None][[[]], [], 'a']Failed
commit-completeness fixture 2[[[]], [], None][[[]], [], 'a']Failed
commit-completeness fixture 3[[], [[0, 'a']], None][[], [[0, 'a']], None]Passed
commit-completeness fixture 4[[], [], None][[], [], None]Passed
commit-completeness fixture 5[[], [[0, 'a']], None][[], [[0, 'a']], None]Passed
commit-completeness fixture 6[[[]], [[0, 'a']], None][[[]], [[0, 'a']], None]Passed
commit-completeness fixture 7[[], [[1, 'p']], None][[], [[1, 'p']], None]Passed
commit-completeness fixture 8[[[[0, 'o']]], [[0, 'o']], None][[[[0, 'o']]], [[0, 'o']], None]Passed

SHA-256 / 01c09de24082c73688f4d4b741d1e719bb2978e54ec3eb42eb8887e947fa1c20

3 / The verified repair

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

N = 1
observations = []
def solve(x):
    visible=dict(x[0])
    pending=None
    reads=[]
    for event in x[1]:
        op=event[0]
        if op=='begin':
            if pending is not None: continue
            pending=[event[1],set(event[2]),{}]
        elif op=='put':
            if pending is None or event[1]!=pending[0]: continue
            at,char=event[2:]
            if at not in pending[1]: continue
            if at in pending[2] and pending[2][at]!=char:
                pending=None
                continue
            pending[2][at]=char
        elif op=='commit':
            if pending is None or event[1]!=pending[0]: continue
            if set(pending[2])!=pending[1]: continue
            visible=dict(pending[2])
            pending=None
        elif op=='abort':
            if pending is not None and event[1]==pending[0]: pending=None
        elif op=='read':
            reads.append(sorted(visible.items()))
    return [reads,sorted(visible.items()),pending[0] if pending is not None else None]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('commit-completeness fixture 0', json.loads(json.dumps(solve([[[0,'o'],[9,'z']],[['begin','a',[0,1]],['put','a',1,'b'],['read'],['put','a',0,'a'],['commit','a'],['read']]]))), json.loads(json.dumps([[[[0,'o'],[9,'z']],[[0,'a'],[1,'b']]],[[0,'a'],[1,'b']],None])))
check('commit-completeness fixture 1', json.loads(json.dumps(solve([[],[['begin','a',[0,1]],['put','a',0,'a'],['commit','a'],['read']]]))), json.loads(json.dumps([[[]],[],'a'])))
check('commit-completeness fixture 2', json.loads(json.dumps(solve([[],[['begin','a',[0]],['put','wrong',0,'x'],['put','a',1,'y'],['commit','a'],['read']]]))), json.loads(json.dumps([[[]],[],'a'])))
check('commit-completeness fixture 3', json.loads(json.dumps(solve([[],[['begin','a',[0]],['put','a',0,'a'],['put','a',1,'b'],['commit','a']]]))), json.loads(json.dumps([[],[[0,'a']],None])))
check('commit-completeness fixture 4', json.loads(json.dumps(solve([[],[['begin','a',[0]],['put','a',0,'a'],['put','a',0,'b'],['commit','a']]]))), json.loads(json.dumps([[],[],None])))
check('commit-completeness fixture 5', json.loads(json.dumps(solve([[],[['begin','a',[0]],['begin','b',[]],['abort','b'],['put','a',0,'a'],['commit','a']]]))), json.loads(json.dumps([[],[[0,'a']],None])))
check('commit-completeness fixture 6', json.loads(json.dumps(solve([[],[['begin','a',[0]],['put','a',0,'a'],['put','a',0,'a'],['commit','wrong'],['read'],['commit','a']]]))), json.loads(json.dumps([[[]],[[0,'a']],None])))
check('commit-completeness fixture 7', json.loads(json.dumps(solve([[],[['begin','a',[]],['commit','a'],['begin','b',[N]],['put','b',N,'p'],['commit','b']]]))), json.loads(json.dumps([[],[[N,'p']],None])))
check('commit-completeness fixture 8', json.loads(json.dumps(solve([[[0,'o']],[['begin','a',[0]],['put','a',0,'a'],['abort','a'],['read']]]))), json.loads(json.dumps([[[[0,'o']]],[[0,'o']],None])))
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
commit-completeness fixture 0[[[[0, 'o'], [9, 'z']], [[0, 'a'], [1, 'b']]], [[0, 'a'], [1, 'b']], None][[[[0, 'o'], [9, 'z']], [[0, 'a'], [1, 'b']]], [[0, 'a'], [1, 'b']], None]Passed
commit-completeness fixture 1[[[]], [], 'a'][[[]], [], 'a']Passed
commit-completeness fixture 2[[[]], [], 'a'][[[]], [], 'a']Passed
commit-completeness fixture 3[[], [[0, 'a']], None][[], [[0, 'a']], None]Passed
commit-completeness fixture 4[[], [], None][[], [], None]Passed
commit-completeness fixture 5[[], [[0, 'a']], None][[], [[0, 'a']], None]Passed
commit-completeness fixture 6[[[]], [[0, 'a']], None][[[]], [[0, 'a']], None]Passed
commit-completeness fixture 7[[], [[1, 'p']], None][[], [[1, 'p']], None]Passed
commit-completeness fixture 8[[[[0, 'o']]], [[0, 'o']], None][[[[0, 'o']]], [[0, 'o']], None]Passed

SHA-256 / 9a7edfa9de267a0d295d18629671babfb8108598ce987b9784e8bd17178e3822

Verification & scope

Deterministic simplified range service, with stipulated local policies and already parsed trusted inputs; not a complete HTTP implementation. 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:41:20.651219+00:00.

Case digest / d2815dff85db3f725cd1a1b035e3b3aa7236dccae8997caf8b74cc492c053d9a