FAILURE MAP
← Case archive

FA-26976 / HTTP ranges / Open access

Partial cache admission publishes complete requested fragments atomically: successful admission releases the active transaction slot · case 01

Partial cache admission publishes complete requested fragments atomically: successful admission releases the active transaction slot.

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

ROOT CAUSE

The partial-admission-transaction-commit-release 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 set(pending[2])!=pending[1]: continue visible=dict(pending[2]) 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].

THE FAILURE

The partial-admission-transaction-commit-release 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 set(pending[2])!=pending[1]: continue visible=dict(pending[2]) 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 set(pending[2])!=pending[1]: continue visible=dict(pending[2]) pending=None if pending[2] else pending 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 set(pending[2])!=pending[1]: continue
            visible=dict(pending[2])
        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-release 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-release 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-release 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-release 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-release 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-release 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-release 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-release 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-release 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-release fixture 0[[[[0, 'o'], [9, 'z']], [[0, 'a'], [1, 'b']]], [[0, 'a'], [1, 'b']], 'a'][[[[0, 'o'], [9, 'z']], [[0, 'a'], [1, 'b']]], [[0, 'a'], [1, 'b']], None]Failed
commit-release fixture 1[[[]], [], 'a'][[[]], [], 'a']Passed
commit-release fixture 2[[[]], [], 'a'][[[]], [], 'a']Passed
commit-release fixture 3[[], [[0, 'a']], 'a'][[], [[0, 'a']], None]Failed
commit-release fixture 4[[], [], None][[], [], None]Passed
commit-release fixture 5[[], [[0, 'a']], 'a'][[], [[0, 'a']], None]Failed
commit-release fixture 6[[[]], [[0, 'a']], 'a'][[[]], [[0, 'a']], None]Failed
commit-release fixture 7[[], [], 'a'][[], [[1, 'p']], None]Failed
commit-release fixture 8[[[[0, 'o']]], [[0, 'o']], None][[[[0, 'o']]], [[0, 'o']], None]Passed

SHA-256 / 8cacbcbce393c12a4f586bd236713ce70340c34ab85a3d594f1adde0ab506add

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 set(pending[2])!=pending[1]: continue
            visible=dict(pending[2])
            pending=None if pending[2] else pending
        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-release 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-release 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-release 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-release 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-release 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-release 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-release 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-release 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-release 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-release 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-release fixture 1[[[]], [], 'a'][[[]], [], 'a']Passed
commit-release fixture 2[[[]], [], 'a'][[[]], [], 'a']Passed
commit-release fixture 3[[], [[0, 'a']], None][[], [[0, 'a']], None]Passed
commit-release fixture 4[[], [], None][[], [], None]Passed
commit-release fixture 5[[], [[0, 'a']], None][[], [[0, 'a']], None]Passed
commit-release fixture 6[[[]], [[0, 'a']], None][[[]], [[0, 'a']], None]Passed
commit-release fixture 7[[], [], 'a'][[], [[1, 'p']], None]Failed
commit-release fixture 8[[[[0, 'o']]], [[0, 'o']], None][[[[0, 'o']]], [[0, 'o']], None]Passed

SHA-256 / 3bc8bc519d58d071e6047a828ecb67f5f585bb75cc57bda3e7c8a054a5300557

HELD IN THE MEMBER ARCHIVE

The verified repair and its recorded checks are member-only.

This mechanism has 9 recorded checks per implementation. The open-access tier publishes the failure and the unsuccessful fix; the repaired source that passes every check, and the observations that prove it, are available to members.

Every case sharing this mechanism uses the same contract and the same repair, so this one record is held back for all of them.

Member access is invitation-based. Sign in with your invited account to inspect the repair.

Sign in to the archive ↗

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.721754+00:00.

Case digest / 4b31e6e031a4342b6a24ff5c45cb80ac05fde979a9e2b59a012ffeba578752f6