FAILURE MAP
← Case archive

FA-26891 / HTTP ranges / Open access

A packed-object origin maps logical byte requests to immutable backing objects: logical placement uses extent logical base rather than pack offset · case 01

A packed-object origin maps logical byte requests to immutable backing objects: logical placement uses extent logical base rather than pack offset.

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

ROOT CAUSE

The packed-origin-map-logical-origin decision uses cells={} for logical,handle,physical,count in x['extents']: if count==0: continue if logical<0 or physical<0 or count<0: return None if handle not in x['packs']: return None pack=x['packs'][handle] if physical+count>len(pack): return None for i in range(count): at=physical+i if at in cells: return None cells[at]=pack[physical+i] if any(at not in cells for at in x['requested']): return None return ''.join(cells[at] for at in x['requested']).

VERIFIED REPAIR

Apply the bounded decision exactly: cells={} for logical,handle,physical,count in x['extents']: if count==0: continue if logical<0 or physical<0 or count<0: return None if handle not in x['packs']: return None pack=x['packs'][handle] if physical+count>len(pack): return None for i in range(count): at=logical+i if at in cells: return None cells[at]=pack[physical+i] if any(at not in cells for at in x['requested']): return None return ''.join(cells[at] for at in x['requested'])

Unsuccessful approach: The partial repair uses cells={} for logical,handle,physical,count in x['extents']: if count==0: continue if logical<0 or physical<0 or count<0: return None if handle not in x['packs']: return None pack=x['packs'][handle] if physical+count>len(pack): return None for i in range(count): at=i if at in cells: return None cells[at]=pack[physical+i] if any(at not in cells for at in x['requested']): return None return ''.join(cells[at] for at in x['requested']), which still violates the stated contract.

Case contract

x has pack strings keyed by handle, extent rows [logical-start,handle,physical-start,count], and explicit requested logical offsets. Extents may arrive unordered. Empty extents ignored. Reject negative mapping coordinates, missing handles, out-of-pack spans, or overlapping logical ownership. Return requested characters in request order, retaining repeated requested offsets; unavailable requested offsets yield None. This is a bounded storage adapter underlying HTTP range delivery, not interval normalization.

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):
    cells={}
    for logical,handle,physical,count in x['extents']:
        if count==0: continue
        if logical<0 or physical<0 or count<0: return None
        if handle not in x['packs']: return None
        pack=x['packs'][handle]
        if physical+count>len(pack): return None
        for i in range(count):
            at=physical+i
            if at in cells: return None
            cells[at]=pack[physical+i]
    if any(at not in cells for at in x['requested']): return None
    return ''.join(cells[at] for at in x['requested'])
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('logical-origin fixture 0', json.loads(json.dumps(solve({'packs':{'a':'QabcZ','b':'RxyzS'},'extents':[[3,'b',1,3],[0,'a',1,3]],'requested':[0,3,1,4,2,5]}))), json.loads(json.dumps('axbycz')))
check('logical-origin fixture 1', json.loads(json.dumps(solve({'packs':{'a':'QabcZ'},'extents':[[0,'a',1,3]],'requested':[2,0,2]}))), json.loads(json.dumps('cac')))
check('logical-origin fixture 2', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[0,'a',0,3]],'requested':[0,3]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 3', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[0,'a',0,3],[1,'a',1,1]],'requested':[1]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 4', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[0,'missing',0,0],[0,'a',0,3]],'requested':[0]}))), json.loads(json.dumps('a')))
check('logical-origin fixture 5', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[-1,'a',0,1]],'requested':[]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 6', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[0,'a',-1,1]],'requested':[0]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 7', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[0,'a',0,-1]],'requested':[]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 8', json.loads(json.dumps(solve({'packs':{},'extents':[[0,'a',0,1]],'requested':[]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 9', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[0,'a',2,2]],'requested':[0]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 10', json.loads(json.dumps(solve({'packs':{},'extents':[],'requested':[]}))), json.loads(json.dumps('')))
check('logical-origin fixture 11', json.loads(json.dumps(solve({'packs':{'a':"p"*N},'extents':[[0,'a',0,N]],'requested':[0]}))), json.loads(json.dumps('p')))
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
logical-origin fixture 0NoneaxbyczFailed
logical-origin fixture 1NonecacFailed
logical-origin fixture 2NoneNonePassed
logical-origin fixture 3NoneNonePassed
logical-origin fixture 4aaPassed
logical-origin fixture 5NoneNonePassed
logical-origin fixture 6NoneNonePassed
logical-origin fixture 7NoneNonePassed
logical-origin fixture 8NoneNonePassed
logical-origin fixture 9NoneNonePassed
logical-origin fixture 10Passed
logical-origin fixture 11ppPassed

SHA-256 / 0a06a28a6996707132d79ee1076eebe5e76d6badaa64b18ac7a0e5d2006d8857

2 / The unsuccessful fix

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

N = 1
observations = []
def solve(x):
    cells={}
    for logical,handle,physical,count in x['extents']:
        if count==0: continue
        if logical<0 or physical<0 or count<0: return None
        if handle not in x['packs']: return None
        pack=x['packs'][handle]
        if physical+count>len(pack): return None
        for i in range(count):
            at=i
            if at in cells: return None
            cells[at]=pack[physical+i]
    if any(at not in cells for at in x['requested']): return None
    return ''.join(cells[at] for at in x['requested'])
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('logical-origin fixture 0', json.loads(json.dumps(solve({'packs':{'a':'QabcZ','b':'RxyzS'},'extents':[[3,'b',1,3],[0,'a',1,3]],'requested':[0,3,1,4,2,5]}))), json.loads(json.dumps('axbycz')))
check('logical-origin fixture 1', json.loads(json.dumps(solve({'packs':{'a':'QabcZ'},'extents':[[0,'a',1,3]],'requested':[2,0,2]}))), json.loads(json.dumps('cac')))
check('logical-origin fixture 2', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[0,'a',0,3]],'requested':[0,3]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 3', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[0,'a',0,3],[1,'a',1,1]],'requested':[1]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 4', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[0,'missing',0,0],[0,'a',0,3]],'requested':[0]}))), json.loads(json.dumps('a')))
check('logical-origin fixture 5', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[-1,'a',0,1]],'requested':[]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 6', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[0,'a',-1,1]],'requested':[0]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 7', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[0,'a',0,-1]],'requested':[]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 8', json.loads(json.dumps(solve({'packs':{},'extents':[[0,'a',0,1]],'requested':[]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 9', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[0,'a',2,2]],'requested':[0]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 10', json.loads(json.dumps(solve({'packs':{},'extents':[],'requested':[]}))), json.loads(json.dumps('')))
check('logical-origin fixture 11', json.loads(json.dumps(solve({'packs':{'a':"p"*N},'extents':[[0,'a',0,N]],'requested':[0]}))), json.loads(json.dumps('p')))
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
logical-origin fixture 0NoneaxbyczFailed
logical-origin fixture 1caccacPassed
logical-origin fixture 2NoneNonePassed
logical-origin fixture 3NoneNonePassed
logical-origin fixture 4aaPassed
logical-origin fixture 5NoneNonePassed
logical-origin fixture 6NoneNonePassed
logical-origin fixture 7NoneNonePassed
logical-origin fixture 8NoneNonePassed
logical-origin fixture 9NoneNonePassed
logical-origin fixture 10Passed
logical-origin fixture 11ppPassed

SHA-256 / d9ad96642701b47fbe9f381ac7e05303ff856c64feeb3b3fb08192d926cae0e3

3 / The verified repair

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

N = 1
observations = []
def solve(x):
    cells={}
    for logical,handle,physical,count in x['extents']:
        if count==0: continue
        if logical<0 or physical<0 or count<0: return None
        if handle not in x['packs']: return None
        pack=x['packs'][handle]
        if physical+count>len(pack): return None
        for i in range(count):
            at=logical+i
            if at in cells: return None
            cells[at]=pack[physical+i]
    if any(at not in cells for at in x['requested']): return None
    return ''.join(cells[at] for at in x['requested'])
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('logical-origin fixture 0', json.loads(json.dumps(solve({'packs':{'a':'QabcZ','b':'RxyzS'},'extents':[[3,'b',1,3],[0,'a',1,3]],'requested':[0,3,1,4,2,5]}))), json.loads(json.dumps('axbycz')))
check('logical-origin fixture 1', json.loads(json.dumps(solve({'packs':{'a':'QabcZ'},'extents':[[0,'a',1,3]],'requested':[2,0,2]}))), json.loads(json.dumps('cac')))
check('logical-origin fixture 2', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[0,'a',0,3]],'requested':[0,3]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 3', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[0,'a',0,3],[1,'a',1,1]],'requested':[1]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 4', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[0,'missing',0,0],[0,'a',0,3]],'requested':[0]}))), json.loads(json.dumps('a')))
check('logical-origin fixture 5', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[-1,'a',0,1]],'requested':[]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 6', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[0,'a',-1,1]],'requested':[0]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 7', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[0,'a',0,-1]],'requested':[]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 8', json.loads(json.dumps(solve({'packs':{},'extents':[[0,'a',0,1]],'requested':[]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 9', json.loads(json.dumps(solve({'packs':{'a':'abc'},'extents':[[0,'a',2,2]],'requested':[0]}))), json.loads(json.dumps(None)))
check('logical-origin fixture 10', json.loads(json.dumps(solve({'packs':{},'extents':[],'requested':[]}))), json.loads(json.dumps('')))
check('logical-origin fixture 11', json.loads(json.dumps(solve({'packs':{'a':"p"*N},'extents':[[0,'a',0,N]],'requested':[0]}))), json.loads(json.dumps('p')))
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
logical-origin fixture 0axbyczaxbyczPassed
logical-origin fixture 1caccacPassed
logical-origin fixture 2NoneNonePassed
logical-origin fixture 3NoneNonePassed
logical-origin fixture 4aaPassed
logical-origin fixture 5NoneNonePassed
logical-origin fixture 6NoneNonePassed
logical-origin fixture 7NoneNonePassed
logical-origin fixture 8NoneNonePassed
logical-origin fixture 9NoneNonePassed
logical-origin fixture 10Passed
logical-origin fixture 11ppPassed

SHA-256 / be911031011b26e0304870957aaafc3150324f58f44f509d4e0c2e24c46f777c

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

Case digest / d353cc50c6bc5080064141d90eeb1b9d56c16545caa888d4da74e1213870c444