FAILURE MAP
← Case archive

FA-31201 / Keyboard interactions / Open access

Keyboard binding registration lifecycle: Removing one binding uses a chord identifier or clears all registrations · case 01

The event trace violates the remove id rule and produces incorrect keyboard state or command output.

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

ROOT CAUSE

Removing one binding uses a chord identifier or clears all registrations.

VERIFIED REPAIR

Use the contract transition `registry.pop(ident,None)` at the remove id fault site; preserve the other state transitions.

Unsuccessful approach: The partial repair changes this transition to registry.clear(), which still violates the model contract on the explicit regression traces.

Case contract

Events [kind,id,scope,chord,priority]. Register replaces the same id with a fresh serial. Remove deletes id; clear deletes a scope. Resolve returns highest priority matching scope/chord, breaking ties by newest registration. Empty chord never resolves. Return resolution IDs and live registrations [id,scope,chord,priority,serial]. Inputs are finite ordered event traces; return the stated deterministic state. Batch entries are independent. N varies the number of independent input transactions.

Why this case matters

Controlled keyboard event processing model for debugging application event logic.

1 / The failure

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

N = 1
observations = []
def solve(cases):
    def run(c):
        registry={}; serial=0; resolved=[]
        for kind,ident,scope,chord,priority in c:
            if kind=='register':
                serial+=1
                registry[ident]=[scope,chord,priority,serial]
            elif kind=='remove':
                registry.pop(chord,None)
            elif kind=='clear':
                registry={k:v for k,v in registry.items() if v[0]!=scope}
            elif kind=='resolve':
                eligible=[(k,v) for k,v in registry.items() if v[0]==scope and v[1]==chord and chord!='']
                eligible.sort(key=lambda pair:(pair[1][2],pair[1][3]),reverse=True)
                resolved.append(eligible[0][0] if eligible else None)
        return [resolved,sorted([[k]+v for k,v in registry.items()])]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('binding-registry scenario 0', solve([[]] * N), [[[], []]] * N)
check('binding-registry scenario 1', solve([[['resolve', '', 'x', 'A', 0]]] * N), [[[None], []]] * N)
check('binding-registry scenario 2', solve([[['register', 'a', 'x', 'A', 1], ['resolve', '', 'x', 'A', 0]]] * N), [[['a'], [['a', 'x', 'A', 1, 1]]]] * N)
check('binding-registry scenario 3', solve([[['register', 'a', 'x', 'A', 2], ['register', 'b', 'x', 'A', 1], ['resolve', '', 'x', 'A', 0]]] * N), [[['a'], [['a', 'x', 'A', 2, 1], ['b', 'x', 'A', 1, 2]]]] * N)
check('binding-registry scenario 4', solve([[['register', 'a', 'x', 'A', 1], ['register', 'b', 'x', 'A', 1], ['resolve', '', 'x', 'A', 0]]] * N), [[['b'], [['a', 'x', 'A', 1, 1], ['b', 'x', 'A', 1, 2]]]] * N)
check('binding-registry scenario 5', solve([[['register', 'a', 'x', 'A', 1], ['register', 'a', 'y', 'B', 3], ['resolve', '', 'y', 'B', 0]]] * N), [[['a'], [['a', 'y', 'B', 3, 2]]]] * N)
check('binding-registry scenario 6', solve([[['register', 'a', 'x', 'A', 1], ['register', 'b', 'y', 'B', 1], ['clear', '', 'x', '', 0]]] * N), [[[], [['b', 'y', 'B', 1, 2]]]] * N)
check('binding-registry scenario 7', solve([[['register', 'a', 'x', 'A', 1], ['register', 'b', 'x', 'B', 1], ['remove', 'a', '', '', 0]]] * N), [[[], [['b', 'x', 'B', 1, 2]]]] * N)
check('binding-registry scenario 8', solve([[['register', 'a', 'x', 'AB', 1], ['resolve', '', 'x', 'A', 0]]] * N), [[[None], [['a', 'x', 'AB', 1, 1]]]] * N)
check('binding-registry scenario 9', solve([[['register', 'a', 'y', 'A', 1], ['resolve', '', 'x', 'A', 0]]] * N), [[[None], [['a', 'y', 'A', 1, 1]]]] * N)
check('binding-registry scenario 10', solve([[['register', 'a', 'x', '', 1], ['resolve', '', 'x', '', 0]]] * N), [[[None], [['a', 'x', '', 1, 1]]]] * N)
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
binding-registry scenario 0[[[], []]][[[], []]]Passed
binding-registry scenario 1[[[None], []]][[[None], []]]Passed
binding-registry scenario 2[[['a'], [['a', 'x', 'A', 1, 1]]]][[['a'], [['a', 'x', 'A', 1, 1]]]]Passed
binding-registry scenario 3[[['a'], [['a', 'x', 'A', 2, 1], ['b', 'x', 'A', 1, 2]]]][[['a'], [['a', 'x', 'A', 2, 1], ['b', 'x', 'A', 1, 2]]]]Passed
binding-registry scenario 4[[['b'], [['a', 'x', 'A', 1, 1], ['b', 'x', 'A', 1, 2]]]][[['b'], [['a', 'x', 'A', 1, 1], ['b', 'x', 'A', 1, 2]]]]Passed
binding-registry scenario 5[[['a'], [['a', 'y', 'B', 3, 2]]]][[['a'], [['a', 'y', 'B', 3, 2]]]]Passed
binding-registry scenario 6[[[], [['b', 'y', 'B', 1, 2]]]][[[], [['b', 'y', 'B', 1, 2]]]]Passed
binding-registry scenario 7[[[], [['a', 'x', 'A', 1, 1], ['b', 'x', 'B', 1, 2]]]][[[], [['b', 'x', 'B', 1, 2]]]]Failed
binding-registry scenario 8[[[None], [['a', 'x', 'AB', 1, 1]]]][[[None], [['a', 'x', 'AB', 1, 1]]]]Passed
binding-registry scenario 9[[[None], [['a', 'y', 'A', 1, 1]]]][[[None], [['a', 'y', 'A', 1, 1]]]]Passed
binding-registry scenario 10[[[None], [['a', 'x', '', 1, 1]]]][[[None], [['a', 'x', '', 1, 1]]]]Passed

SHA-256 / 93ea19bff51bc8bbe293c6f9eeacc0cf5f0dac609c61543b5ebc75394f7d530f

2 / The unsuccessful fix

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

N = 1
observations = []
def solve(cases):
    def run(c):
        registry={}; serial=0; resolved=[]
        for kind,ident,scope,chord,priority in c:
            if kind=='register':
                serial+=1
                registry[ident]=[scope,chord,priority,serial]
            elif kind=='remove':
                registry.clear()
            elif kind=='clear':
                registry={k:v for k,v in registry.items() if v[0]!=scope}
            elif kind=='resolve':
                eligible=[(k,v) for k,v in registry.items() if v[0]==scope and v[1]==chord and chord!='']
                eligible.sort(key=lambda pair:(pair[1][2],pair[1][3]),reverse=True)
                resolved.append(eligible[0][0] if eligible else None)
        return [resolved,sorted([[k]+v for k,v in registry.items()])]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('binding-registry scenario 0', solve([[]] * N), [[[], []]] * N)
check('binding-registry scenario 1', solve([[['resolve', '', 'x', 'A', 0]]] * N), [[[None], []]] * N)
check('binding-registry scenario 2', solve([[['register', 'a', 'x', 'A', 1], ['resolve', '', 'x', 'A', 0]]] * N), [[['a'], [['a', 'x', 'A', 1, 1]]]] * N)
check('binding-registry scenario 3', solve([[['register', 'a', 'x', 'A', 2], ['register', 'b', 'x', 'A', 1], ['resolve', '', 'x', 'A', 0]]] * N), [[['a'], [['a', 'x', 'A', 2, 1], ['b', 'x', 'A', 1, 2]]]] * N)
check('binding-registry scenario 4', solve([[['register', 'a', 'x', 'A', 1], ['register', 'b', 'x', 'A', 1], ['resolve', '', 'x', 'A', 0]]] * N), [[['b'], [['a', 'x', 'A', 1, 1], ['b', 'x', 'A', 1, 2]]]] * N)
check('binding-registry scenario 5', solve([[['register', 'a', 'x', 'A', 1], ['register', 'a', 'y', 'B', 3], ['resolve', '', 'y', 'B', 0]]] * N), [[['a'], [['a', 'y', 'B', 3, 2]]]] * N)
check('binding-registry scenario 6', solve([[['register', 'a', 'x', 'A', 1], ['register', 'b', 'y', 'B', 1], ['clear', '', 'x', '', 0]]] * N), [[[], [['b', 'y', 'B', 1, 2]]]] * N)
check('binding-registry scenario 7', solve([[['register', 'a', 'x', 'A', 1], ['register', 'b', 'x', 'B', 1], ['remove', 'a', '', '', 0]]] * N), [[[], [['b', 'x', 'B', 1, 2]]]] * N)
check('binding-registry scenario 8', solve([[['register', 'a', 'x', 'AB', 1], ['resolve', '', 'x', 'A', 0]]] * N), [[[None], [['a', 'x', 'AB', 1, 1]]]] * N)
check('binding-registry scenario 9', solve([[['register', 'a', 'y', 'A', 1], ['resolve', '', 'x', 'A', 0]]] * N), [[[None], [['a', 'y', 'A', 1, 1]]]] * N)
check('binding-registry scenario 10', solve([[['register', 'a', 'x', '', 1], ['resolve', '', 'x', '', 0]]] * N), [[[None], [['a', 'x', '', 1, 1]]]] * N)
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
binding-registry scenario 0[[[], []]][[[], []]]Passed
binding-registry scenario 1[[[None], []]][[[None], []]]Passed
binding-registry scenario 2[[['a'], [['a', 'x', 'A', 1, 1]]]][[['a'], [['a', 'x', 'A', 1, 1]]]]Passed
binding-registry scenario 3[[['a'], [['a', 'x', 'A', 2, 1], ['b', 'x', 'A', 1, 2]]]][[['a'], [['a', 'x', 'A', 2, 1], ['b', 'x', 'A', 1, 2]]]]Passed
binding-registry scenario 4[[['b'], [['a', 'x', 'A', 1, 1], ['b', 'x', 'A', 1, 2]]]][[['b'], [['a', 'x', 'A', 1, 1], ['b', 'x', 'A', 1, 2]]]]Passed
binding-registry scenario 5[[['a'], [['a', 'y', 'B', 3, 2]]]][[['a'], [['a', 'y', 'B', 3, 2]]]]Passed
binding-registry scenario 6[[[], [['b', 'y', 'B', 1, 2]]]][[[], [['b', 'y', 'B', 1, 2]]]]Passed
binding-registry scenario 7[[[], []]][[[], [['b', 'x', 'B', 1, 2]]]]Failed
binding-registry scenario 8[[[None], [['a', 'x', 'AB', 1, 1]]]][[[None], [['a', 'x', 'AB', 1, 1]]]]Passed
binding-registry scenario 9[[[None], [['a', 'y', 'A', 1, 1]]]][[[None], [['a', 'y', 'A', 1, 1]]]]Passed
binding-registry scenario 10[[[None], [['a', 'x', '', 1, 1]]]][[[None], [['a', 'x', '', 1, 1]]]]Passed

SHA-256 / 4d9f0ca8b5d43041257d60d0551b3a02b5b53e7762e35400d89cebce7fc966c0

3 / The verified repair

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

N = 1
observations = []
def solve(cases):
    def run(c):
        registry={}; serial=0; resolved=[]
        for kind,ident,scope,chord,priority in c:
            if kind=='register':
                serial+=1
                registry[ident]=[scope,chord,priority,serial]
            elif kind=='remove':
                registry.pop(ident,None)
            elif kind=='clear':
                registry={k:v for k,v in registry.items() if v[0]!=scope}
            elif kind=='resolve':
                eligible=[(k,v) for k,v in registry.items() if v[0]==scope and v[1]==chord and chord!='']
                eligible.sort(key=lambda pair:(pair[1][2],pair[1][3]),reverse=True)
                resolved.append(eligible[0][0] if eligible else None)
        return [resolved,sorted([[k]+v for k,v in registry.items()])]
    return [run(c) for c in cases]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('binding-registry scenario 0', solve([[]] * N), [[[], []]] * N)
check('binding-registry scenario 1', solve([[['resolve', '', 'x', 'A', 0]]] * N), [[[None], []]] * N)
check('binding-registry scenario 2', solve([[['register', 'a', 'x', 'A', 1], ['resolve', '', 'x', 'A', 0]]] * N), [[['a'], [['a', 'x', 'A', 1, 1]]]] * N)
check('binding-registry scenario 3', solve([[['register', 'a', 'x', 'A', 2], ['register', 'b', 'x', 'A', 1], ['resolve', '', 'x', 'A', 0]]] * N), [[['a'], [['a', 'x', 'A', 2, 1], ['b', 'x', 'A', 1, 2]]]] * N)
check('binding-registry scenario 4', solve([[['register', 'a', 'x', 'A', 1], ['register', 'b', 'x', 'A', 1], ['resolve', '', 'x', 'A', 0]]] * N), [[['b'], [['a', 'x', 'A', 1, 1], ['b', 'x', 'A', 1, 2]]]] * N)
check('binding-registry scenario 5', solve([[['register', 'a', 'x', 'A', 1], ['register', 'a', 'y', 'B', 3], ['resolve', '', 'y', 'B', 0]]] * N), [[['a'], [['a', 'y', 'B', 3, 2]]]] * N)
check('binding-registry scenario 6', solve([[['register', 'a', 'x', 'A', 1], ['register', 'b', 'y', 'B', 1], ['clear', '', 'x', '', 0]]] * N), [[[], [['b', 'y', 'B', 1, 2]]]] * N)
check('binding-registry scenario 7', solve([[['register', 'a', 'x', 'A', 1], ['register', 'b', 'x', 'B', 1], ['remove', 'a', '', '', 0]]] * N), [[[], [['b', 'x', 'B', 1, 2]]]] * N)
check('binding-registry scenario 8', solve([[['register', 'a', 'x', 'AB', 1], ['resolve', '', 'x', 'A', 0]]] * N), [[[None], [['a', 'x', 'AB', 1, 1]]]] * N)
check('binding-registry scenario 9', solve([[['register', 'a', 'y', 'A', 1], ['resolve', '', 'x', 'A', 0]]] * N), [[[None], [['a', 'y', 'A', 1, 1]]]] * N)
check('binding-registry scenario 10', solve([[['register', 'a', 'x', '', 1], ['resolve', '', 'x', '', 0]]] * N), [[[None], [['a', 'x', '', 1, 1]]]] * N)
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
binding-registry scenario 0[[[], []]][[[], []]]Passed
binding-registry scenario 1[[[None], []]][[[None], []]]Passed
binding-registry scenario 2[[['a'], [['a', 'x', 'A', 1, 1]]]][[['a'], [['a', 'x', 'A', 1, 1]]]]Passed
binding-registry scenario 3[[['a'], [['a', 'x', 'A', 2, 1], ['b', 'x', 'A', 1, 2]]]][[['a'], [['a', 'x', 'A', 2, 1], ['b', 'x', 'A', 1, 2]]]]Passed
binding-registry scenario 4[[['b'], [['a', 'x', 'A', 1, 1], ['b', 'x', 'A', 1, 2]]]][[['b'], [['a', 'x', 'A', 1, 1], ['b', 'x', 'A', 1, 2]]]]Passed
binding-registry scenario 5[[['a'], [['a', 'y', 'B', 3, 2]]]][[['a'], [['a', 'y', 'B', 3, 2]]]]Passed
binding-registry scenario 6[[[], [['b', 'y', 'B', 1, 2]]]][[[], [['b', 'y', 'B', 1, 2]]]]Passed
binding-registry scenario 7[[[], [['b', 'x', 'B', 1, 2]]]][[[], [['b', 'x', 'B', 1, 2]]]]Passed
binding-registry scenario 8[[[None], [['a', 'x', 'AB', 1, 1]]]][[[None], [['a', 'x', 'AB', 1, 1]]]]Passed
binding-registry scenario 9[[[None], [['a', 'y', 'A', 1, 1]]]][[[None], [['a', 'y', 'A', 1, 1]]]]Passed
binding-registry scenario 10[[[None], [['a', 'x', '', 1, 1]]]][[[None], [['a', 'x', '', 1, 1]]]]Passed

SHA-256 / 0ef8ddddc20512d9714b2c91e32ce370d8586d10601425fc30790a1c5c0cf2e0

Verification & scope

Offline stipulated event model, not a browser implementation or web standard conformance claim. 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:59.879422+00:00.

Case digest / 48831244c467206bea7a2c002545aff1bfe1d95b3836f643a18d8def09bc9ca0