FAILURE MAP
← Case archive

FA-74261 / Feature flag rollout bucketing / Open access

Bootstrapped flag payload merge: An equal payload version is treated as stale · case 01

A second payload with the same version but newer per-flag versions is discarded.

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

ROOT CAUSE

The stale check requires incoming version > local version.

THE FAILURE

The stale check requires incoming version > local version.

Unsuccessful approach: Comparing the highest flag version with the payload version mixes two unrelated counters.

Case contract

Payloads are {version, flags: {key: {value, version, deleted?}}}. An incoming payload with a lower payload version than local is ignored entirely. Otherwise each incoming flag replaces the local entry only when the key is new or its flag version is strictly higher; deleted tombstones follow the same rule. Return sorted [key, value] pairs for merged flags that are not deleted.

Why this case matters

Clients bootstrap from HTML-embedded flags and then stream updates; stale data must not win.

1 / The failure

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

N = 1
observations = []
def solve(local, incoming):
    merged = dict(local['flags'])
    if incoming['version'] > local['version']:
        for k, f in incoming['flags'].items():
            cur = merged.get(k)
            if cur is None or f['version'] > cur['version']:
                merged[k] = f
    return sorted([k, f['value']] for k, f in merged.items() if not f.get('deleted'))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('equal flag version keeps the local value',
   [{'version': 1, 'flags': {'a': {'value': 'local', 'version': 2}}},
    {'version': 2, 'flags': {'a': {'value': 'remote', 'version': 2}}}],
   [['a', 'local']]),
  ('newer tombstone deletes the flag',
   [{'version': 1, 'flags': {'a': {'value': True, 'version': 1}}},
    {'version': 1, 'flags': {'a': {'value': None, 'version': 2, 'deleted': True}}}],
   []),
  ('older tombstone is ignored',
   [{'version': 1, 'flags': {'a': {'value': True, 'version': 3}}},
    {'version': 2, 'flags': {'a': {'value': None, 'version': 1, 'deleted': True}}}],
   [['a', True]]),
  ('equal payload version still merges',
   [{'version': 2, 'flags': {'a': {'value': 1, 'version': 1}}},
    {'version': 2, 'flags': {'a': {'value': 2, 'version': 2}}}],
   [['a', 2]]),
  ('stale payload is ignored',
   [{'version': 3, 'flags': {'a': {'value': 1, 'version': 1}}},
    {'version': 2, 'flags': {'a': {'value': 2, 'version': 5}}}],
   [['a', 1]]),
  ('new flag with version zero is adopted',
   [{'version': 1, 'flags': {}}, {'version': 1, 'flags': {'b': {'value': 'on', 'version': 0}}}],
   [['b', 'on']]),
  ('output is sorted by key',
   [{'version': 1, 'flags': {'c': {'value': 3, 'version': 1}}},
    {'version': 1, 'flags': {'a': {'value': 1, 'version': 1}, 'b': {'value': 2, 'version': 1}}}],
   [['a', 1], ['b', 2], ['c', 3]]),
  ('payload pair sample 1',
   [{'version': 3, 'flags': {'d': {'value': 'x', 'version': 1}, 'a': {'value': True, 'version': 0}}},
    {'version': 1,
     'flags': {'d': {'value': False, 'version': 1}, 'a': {'value': 2, 'version': 2, 'deleted': True}}}],
   [['a', True], ['d', 'x']])],
 [('newer tombstone deletes the flag',
   [{'version': 1, 'flags': {'a': {'value': True, 'version': 1}}},
    {'version': 1, 'flags': {'a': {'value': None, 'version': 2, 'deleted': True}}}],
   []),
  ('older tombstone is ignored',
   [{'version': 1, 'flags': {'a': {'value': True, 'version': 3}}},
    {'version': 2, 'flags': {'a': {'value': None, 'version': 1, 'deleted': True}}}],
   [['a', True]]),
  ('equal payload version still merges',
   [{'version': 2, 'flags': {'a': {'value': 1, 'version': 1}}},
    {'version': 2, 'flags': {'a': {'value': 2, 'version': 2}}}],
   [['a', 2]]),
  ('stale payload is ignored',
   [{'version': 3, 'flags': {'a': {'value': 1, 'version': 1}}},
    {'version': 2, 'flags': {'a': {'value': 2, 'version': 5}}}],
   [['a', 1]]),
  ('new flag with version zero is adopted',
   [{'version': 1, 'flags': {}}, {'version': 1, 'flags': {'b': {'value': 'on', 'version': 0}}}],
   [['b', 'on']]),
  ('output is sorted by key',
   [{'version': 1, 'flags': {'c': {'value': 3, 'version': 1}}},
    {'version': 1, 'flags': {'a': {'value': 1, 'version': 1}, 'b': {'value': 2, 'version': 1}}}],
   [['a', 1], ['b', 2], ['c', 3]]),
  ('payload pair sample 15',
   [{'version': 1,
     'flags': {'a': {'value': True, 'version': 0},
               'c': {'value': True, 'version': 1},
               'd': {'value': 2, 'version': 3}}},
    {'version': 1,
     'flags': {'d': {'value': 'x', 'version': 3},
               'a': {'value': False, 'version': 2},
               'b': {'value': True, 'version': 2}}}],
   [['a', False], ['b', True], ['c', True], ['d', 2]]),
  ('payload pair sample 38',
   [{'version': 2, 'flags': {'b': {'value': 'x', 'version': 2}}},
    {'version': 2,
     'flags': {'a': {'value': True, 'version': 0},
               'c': {'value': True, 'version': 0},
               'b': {'value': True, 'version': 0}}}],
   [['a', True], ['b', 'x'], ['c', True]])],
 [('older tombstone is ignored',
   [{'version': 1, 'flags': {'a': {'value': True, 'version': 3}}},
    {'version': 2, 'flags': {'a': {'value': None, 'version': 1, 'deleted': True}}}],
   [['a', True]]),
  ('equal payload version still merges',
   [{'version': 2, 'flags': {'a': {'value': 1, 'version': 1}}},
    {'version': 2, 'flags': {'a': {'value': 2, 'version': 2}}}],
   [['a', 2]]),
  ('stale payload is ignored',
   [{'version': 3, 'flags': {'a': {'value': 1, 'version': 1}}},
    {'version': 2, 'flags': {'a': {'value': 2, 'version': 5}}}],
   [['a', 1]]),
  ('new flag with version zero is adopted',
   [{'version': 1, 'flags': {}}, {'version': 1, 'flags': {'b': {'value': 'on', 'version': 0}}}],
   [['b', 'on']]),
  ('output is sorted by key',
   [{'version': 1, 'flags': {'c': {'value': 3, 'version': 1}}},
    {'version': 1, 'flags': {'a': {'value': 1, 'version': 1}, 'b': {'value': 2, 'version': 1}}}],
   [['a', 1], ['b', 2], ['c', 3]]),
  ('payload pair sample 11',
   [{'version': 2,
     'flags': {'d': {'value': 2, 'version': 2, 'deleted': True},
               'b': {'value': 'x', 'version': 2},
               'a': {'value': False, 'version': 1}}},
    {'version': 3,
     'flags': {'d': {'value': 2, 'version': 2},
               'a': {'value': 2, 'version': 2},
               'b': {'value': False, 'version': 0}}}],
   [['a', 2], ['b', 'x']]),
  ('payload pair sample 23',
   [{'version': 2,
     'flags': {'a': {'value': False, 'version': 1},
               'b': {'value': True, 'version': 0},
               'd': {'value': 2, 'version': 0}}},
    {'version': 1, 'flags': {'d': {'value': False, 'version': 2}, 'a': {'value': 'x', 'version': 3}}}],
   [['a', False], ['b', True], ['d', 2]]),
  ('payload pair sample 38',
   [{'version': 2, 'flags': {'b': {'value': 'x', 'version': 2}}},
    {'version': 2,
     'flags': {'a': {'value': True, 'version': 0},
               'c': {'value': True, 'version': 0},
               'b': {'value': True, 'version': 0}}}],
   [['a', True], ['b', 'x'], ['c', True]])],
 [('equal flag version keeps the local value',
   [{'version': 1, 'flags': {'a': {'value': 'local', 'version': 2}}},
    {'version': 2, 'flags': {'a': {'value': 'remote', 'version': 2}}}],
   [['a', 'local']]),
  ('equal payload version still merges',
   [{'version': 2, 'flags': {'a': {'value': 1, 'version': 1}}},
    {'version': 2, 'flags': {'a': {'value': 2, 'version': 2}}}],
   [['a', 2]]),
  ('stale payload is ignored',
   [{'version': 3, 'flags': {'a': {'value': 1, 'version': 1}}},
    {'version': 2, 'flags': {'a': {'value': 2, 'version': 5}}}],
   [['a', 1]]),
  ('new flag with version zero is adopted',
   [{'version': 1, 'flags': {}}, {'version': 1, 'flags': {'b': {'value': 'on', 'version': 0}}}],
   [['b', 'on']]),
  ('output is sorted by key',
   [{'version': 1, 'flags': {'c': {'value': 3, 'version': 1}}},
    {'version': 1, 'flags': {'a': {'value': 1, 'version': 1}, 'b': {'value': 2, 'version': 1}}}],
   [['a', 1], ['b', 2], ['c', 3]]),
  ('payload pair sample 16', [{'version': 2, 'flags': {}}, {'version': 3, 'flags': {}}], []),
  ('payload pair sample 17',
   [{'version': 2, 'flags': {}}, {'version': 3, 'flags': {'d': {'value': 2, 'version': 2, 'deleted': True}}}],
   []),
  ('payload pair sample 51',
   [{'version': 3,
     'flags': {'b': {'value': True, 'version': 1, 'deleted': True}, 'a': {'value': True, 'version': 0}}},
    {'version': 3, 'flags': {'a': {'value': False, 'version': 2}, 'c': {'value': False, 'version': 0}}}],
   [['a', False], ['c', False]])],
 [('equal flag version keeps the local value',
   [{'version': 1, 'flags': {'a': {'value': 'local', 'version': 2}}},
    {'version': 2, 'flags': {'a': {'value': 'remote', 'version': 2}}}],
   [['a', 'local']]),
  ('newer tombstone deletes the flag',
   [{'version': 1, 'flags': {'a': {'value': True, 'version': 1}}},
    {'version': 1, 'flags': {'a': {'value': None, 'version': 2, 'deleted': True}}}],
   []),
  ('stale payload is ignored',
   [{'version': 3, 'flags': {'a': {'value': 1, 'version': 1}}},
    {'version': 2, 'flags': {'a': {'value': 2, 'version': 5}}}],
   [['a', 1]]),
  ('new flag with version zero is adopted',
   [{'version': 1, 'flags': {}}, {'version': 1, 'flags': {'b': {'value': 'on', 'version': 0}}}],
   [['b', 'on']]),
  ('output is sorted by key',
   [{'version': 1, 'flags': {'c': {'value': 3, 'version': 1}}},
    {'version': 1, 'flags': {'a': {'value': 1, 'version': 1}, 'b': {'value': 2, 'version': 1}}}],
   [['a', 1], ['b', 2], ['c', 3]]),
  ('payload pair sample 20',
   [{'version': 2, 'flags': {'b': {'value': 2, 'version': 3}, 'd': {'value': 2, 'version': 2}}},
    {'version': 2,
     'flags': {'a': {'value': False, 'version': 0},
               'b': {'value': False, 'version': 2},
               'd': {'value': 2, 'version': 2}}}],
   [['a', False], ['b', 2], ['d', 2]]),
  ('payload pair sample 21',
   [{'version': 2,
     'flags': {'a': {'value': False, 'version': 2, 'deleted': True},
               'b': {'value': False, 'version': 1, 'deleted': True}}},
    {'version': 1,
     'flags': {'d': {'value': True, 'version': 0},
               'c': {'value': False, 'version': 3},
               'b': {'value': True, 'version': 3}}}],
   []),
  ('payload pair sample 35',
   [{'version': 2, 'flags': {'c': {'value': 2, 'version': 1}}},
    {'version': 1, 'flags': {'b': {'value': 'x', 'version': 3}, 'c': {'value': False, 'version': 1}}}],
   [['c', 2]])]]
for label, args, expected in fixtures[N - 1]:
    check(label, solve(*args), expected)
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
equal flag version keeps the local value[['a', 'local']][['a', 'local']]Passed
newer tombstone deletes the flag[['a', True]][]Failed
older tombstone is ignored[['a', True]][['a', True]]Passed
equal payload version still merges[['a', 1]][['a', 2]]Failed
stale payload is ignored[['a', 1]][['a', 1]]Passed
new flag with version zero is adopted[][['b', 'on']]Failed
output is sorted by key[['c', 3]][['a', 1], ['b', 2], ['c', 3]]Failed
payload pair sample 1[['a', True], ['d', 'x']][['a', True], ['d', 'x']]Passed

SHA-256 / 75dbe6c968ea4641684121108f262c89dee2bc079a8c03ef4b8d881dccb6af06

2 / The unsuccessful fix

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

N = 1
observations = []
def solve(local, incoming):
    merged = dict(local['flags'])
    if max([f['version'] for f in incoming['flags'].values()] or [0]) >= local['version']:
        for k, f in incoming['flags'].items():
            cur = merged.get(k)
            if cur is None or f['version'] > cur['version']:
                merged[k] = f
    return sorted([k, f['value']] for k, f in merged.items() if not f.get('deleted'))
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('equal flag version keeps the local value',
   [{'version': 1, 'flags': {'a': {'value': 'local', 'version': 2}}},
    {'version': 2, 'flags': {'a': {'value': 'remote', 'version': 2}}}],
   [['a', 'local']]),
  ('newer tombstone deletes the flag',
   [{'version': 1, 'flags': {'a': {'value': True, 'version': 1}}},
    {'version': 1, 'flags': {'a': {'value': None, 'version': 2, 'deleted': True}}}],
   []),
  ('older tombstone is ignored',
   [{'version': 1, 'flags': {'a': {'value': True, 'version': 3}}},
    {'version': 2, 'flags': {'a': {'value': None, 'version': 1, 'deleted': True}}}],
   [['a', True]]),
  ('equal payload version still merges',
   [{'version': 2, 'flags': {'a': {'value': 1, 'version': 1}}},
    {'version': 2, 'flags': {'a': {'value': 2, 'version': 2}}}],
   [['a', 2]]),
  ('stale payload is ignored',
   [{'version': 3, 'flags': {'a': {'value': 1, 'version': 1}}},
    {'version': 2, 'flags': {'a': {'value': 2, 'version': 5}}}],
   [['a', 1]]),
  ('new flag with version zero is adopted',
   [{'version': 1, 'flags': {}}, {'version': 1, 'flags': {'b': {'value': 'on', 'version': 0}}}],
   [['b', 'on']]),
  ('output is sorted by key',
   [{'version': 1, 'flags': {'c': {'value': 3, 'version': 1}}},
    {'version': 1, 'flags': {'a': {'value': 1, 'version': 1}, 'b': {'value': 2, 'version': 1}}}],
   [['a', 1], ['b', 2], ['c', 3]]),
  ('payload pair sample 1',
   [{'version': 3, 'flags': {'d': {'value': 'x', 'version': 1}, 'a': {'value': True, 'version': 0}}},
    {'version': 1,
     'flags': {'d': {'value': False, 'version': 1}, 'a': {'value': 2, 'version': 2, 'deleted': True}}}],
   [['a', True], ['d', 'x']])],
 [('newer tombstone deletes the flag',
   [{'version': 1, 'flags': {'a': {'value': True, 'version': 1}}},
    {'version': 1, 'flags': {'a': {'value': None, 'version': 2, 'deleted': True}}}],
   []),
  ('older tombstone is ignored',
   [{'version': 1, 'flags': {'a': {'value': True, 'version': 3}}},
    {'version': 2, 'flags': {'a': {'value': None, 'version': 1, 'deleted': True}}}],
   [['a', True]]),
  ('equal payload version still merges',
   [{'version': 2, 'flags': {'a': {'value': 1, 'version': 1}}},
    {'version': 2, 'flags': {'a': {'value': 2, 'version': 2}}}],
   [['a', 2]]),
  ('stale payload is ignored',
   [{'version': 3, 'flags': {'a': {'value': 1, 'version': 1}}},
    {'version': 2, 'flags': {'a': {'value': 2, 'version': 5}}}],
   [['a', 1]]),
  ('new flag with version zero is adopted',
   [{'version': 1, 'flags': {}}, {'version': 1, 'flags': {'b': {'value': 'on', 'version': 0}}}],
   [['b', 'on']]),
  ('output is sorted by key',
   [{'version': 1, 'flags': {'c': {'value': 3, 'version': 1}}},
    {'version': 1, 'flags': {'a': {'value': 1, 'version': 1}, 'b': {'value': 2, 'version': 1}}}],
   [['a', 1], ['b', 2], ['c', 3]]),
  ('payload pair sample 15',
   [{'version': 1,
     'flags': {'a': {'value': True, 'version': 0},
               'c': {'value': True, 'version': 1},
               'd': {'value': 2, 'version': 3}}},
    {'version': 1,
     'flags': {'d': {'value': 'x', 'version': 3},
               'a': {'value': False, 'version': 2},
               'b': {'value': True, 'version': 2}}}],
   [['a', False], ['b', True], ['c', True], ['d', 2]]),
  ('payload pair sample 38',
   [{'version': 2, 'flags': {'b': {'value': 'x', 'version': 2}}},
    {'version': 2,
     'flags': {'a': {'value': True, 'version': 0},
               'c': {'value': True, 'version': 0},
               'b': {'value': True, 'version': 0}}}],
   [['a', True], ['b', 'x'], ['c', True]])],
 [('older tombstone is ignored',
   [{'version': 1, 'flags': {'a': {'value': True, 'version': 3}}},
    {'version': 2, 'flags': {'a': {'value': None, 'version': 1, 'deleted': True}}}],
   [['a', True]]),
  ('equal payload version still merges',
   [{'version': 2, 'flags': {'a': {'value': 1, 'version': 1}}},
    {'version': 2, 'flags': {'a': {'value': 2, 'version': 2}}}],
   [['a', 2]]),
  ('stale payload is ignored',
   [{'version': 3, 'flags': {'a': {'value': 1, 'version': 1}}},
    {'version': 2, 'flags': {'a': {'value': 2, 'version': 5}}}],
   [['a', 1]]),
  ('new flag with version zero is adopted',
   [{'version': 1, 'flags': {}}, {'version': 1, 'flags': {'b': {'value': 'on', 'version': 0}}}],
   [['b', 'on']]),
  ('output is sorted by key',
   [{'version': 1, 'flags': {'c': {'value': 3, 'version': 1}}},
    {'version': 1, 'flags': {'a': {'value': 1, 'version': 1}, 'b': {'value': 2, 'version': 1}}}],
   [['a', 1], ['b', 2], ['c', 3]]),
  ('payload pair sample 11',
   [{'version': 2,
     'flags': {'d': {'value': 2, 'version': 2, 'deleted': True},
               'b': {'value': 'x', 'version': 2},
               'a': {'value': False, 'version': 1}}},
    {'version': 3,
     'flags': {'d': {'value': 2, 'version': 2},
               'a': {'value': 2, 'version': 2},
               'b': {'value': False, 'version': 0}}}],
   [['a', 2], ['b', 'x']]),
  ('payload pair sample 23',
   [{'version': 2,
     'flags': {'a': {'value': False, 'version': 1},
               'b': {'value': True, 'version': 0},
               'd': {'value': 2, 'version': 0}}},
    {'version': 1, 'flags': {'d': {'value': False, 'version': 2}, 'a': {'value': 'x', 'version': 3}}}],
   [['a', False], ['b', True], ['d', 2]]),
  ('payload pair sample 38',
   [{'version': 2, 'flags': {'b': {'value': 'x', 'version': 2}}},
    {'version': 2,
     'flags': {'a': {'value': True, 'version': 0},
               'c': {'value': True, 'version': 0},
               'b': {'value': True, 'version': 0}}}],
   [['a', True], ['b', 'x'], ['c', True]])],
 [('equal flag version keeps the local value',
   [{'version': 1, 'flags': {'a': {'value': 'local', 'version': 2}}},
    {'version': 2, 'flags': {'a': {'value': 'remote', 'version': 2}}}],
   [['a', 'local']]),
  ('equal payload version still merges',
   [{'version': 2, 'flags': {'a': {'value': 1, 'version': 1}}},
    {'version': 2, 'flags': {'a': {'value': 2, 'version': 2}}}],
   [['a', 2]]),
  ('stale payload is ignored',
   [{'version': 3, 'flags': {'a': {'value': 1, 'version': 1}}},
    {'version': 2, 'flags': {'a': {'value': 2, 'version': 5}}}],
   [['a', 1]]),
  ('new flag with version zero is adopted',
   [{'version': 1, 'flags': {}}, {'version': 1, 'flags': {'b': {'value': 'on', 'version': 0}}}],
   [['b', 'on']]),
  ('output is sorted by key',
   [{'version': 1, 'flags': {'c': {'value': 3, 'version': 1}}},
    {'version': 1, 'flags': {'a': {'value': 1, 'version': 1}, 'b': {'value': 2, 'version': 1}}}],
   [['a', 1], ['b', 2], ['c', 3]]),
  ('payload pair sample 16', [{'version': 2, 'flags': {}}, {'version': 3, 'flags': {}}], []),
  ('payload pair sample 17',
   [{'version': 2, 'flags': {}}, {'version': 3, 'flags': {'d': {'value': 2, 'version': 2, 'deleted': True}}}],
   []),
  ('payload pair sample 51',
   [{'version': 3,
     'flags': {'b': {'value': True, 'version': 1, 'deleted': True}, 'a': {'value': True, 'version': 0}}},
    {'version': 3, 'flags': {'a': {'value': False, 'version': 2}, 'c': {'value': False, 'version': 0}}}],
   [['a', False], ['c', False]])],
 [('equal flag version keeps the local value',
   [{'version': 1, 'flags': {'a': {'value': 'local', 'version': 2}}},
    {'version': 2, 'flags': {'a': {'value': 'remote', 'version': 2}}}],
   [['a', 'local']]),
  ('newer tombstone deletes the flag',
   [{'version': 1, 'flags': {'a': {'value': True, 'version': 1}}},
    {'version': 1, 'flags': {'a': {'value': None, 'version': 2, 'deleted': True}}}],
   []),
  ('stale payload is ignored',
   [{'version': 3, 'flags': {'a': {'value': 1, 'version': 1}}},
    {'version': 2, 'flags': {'a': {'value': 2, 'version': 5}}}],
   [['a', 1]]),
  ('new flag with version zero is adopted',
   [{'version': 1, 'flags': {}}, {'version': 1, 'flags': {'b': {'value': 'on', 'version': 0}}}],
   [['b', 'on']]),
  ('output is sorted by key',
   [{'version': 1, 'flags': {'c': {'value': 3, 'version': 1}}},
    {'version': 1, 'flags': {'a': {'value': 1, 'version': 1}, 'b': {'value': 2, 'version': 1}}}],
   [['a', 1], ['b', 2], ['c', 3]]),
  ('payload pair sample 20',
   [{'version': 2, 'flags': {'b': {'value': 2, 'version': 3}, 'd': {'value': 2, 'version': 2}}},
    {'version': 2,
     'flags': {'a': {'value': False, 'version': 0},
               'b': {'value': False, 'version': 2},
               'd': {'value': 2, 'version': 2}}}],
   [['a', False], ['b', 2], ['d', 2]]),
  ('payload pair sample 21',
   [{'version': 2,
     'flags': {'a': {'value': False, 'version': 2, 'deleted': True},
               'b': {'value': False, 'version': 1, 'deleted': True}}},
    {'version': 1,
     'flags': {'d': {'value': True, 'version': 0},
               'c': {'value': False, 'version': 3},
               'b': {'value': True, 'version': 3}}}],
   []),
  ('payload pair sample 35',
   [{'version': 2, 'flags': {'c': {'value': 2, 'version': 1}}},
    {'version': 1, 'flags': {'b': {'value': 'x', 'version': 3}, 'c': {'value': False, 'version': 1}}}],
   [['c', 2]])]]
for label, args, expected in fixtures[N - 1]:
    check(label, solve(*args), expected)
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
equal flag version keeps the local value[['a', 'local']][['a', 'local']]Passed
newer tombstone deletes the flag[][]Passed
older tombstone is ignored[['a', True]][['a', True]]Passed
equal payload version still merges[['a', 2]][['a', 2]]Passed
stale payload is ignored[['a', 2]][['a', 1]]Failed
new flag with version zero is adopted[][['b', 'on']]Failed
output is sorted by key[['a', 1], ['b', 2], ['c', 3]][['a', 1], ['b', 2], ['c', 3]]Passed
payload pair sample 1[['a', True], ['d', 'x']][['a', True], ['d', 'x']]Passed

SHA-256 / 70692a1792e38b24f12b26c92206f0f7e50f28a66126fc42507fde2de657e451

HELD IN THE MEMBER ARCHIVE

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

This mechanism has 8 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

A deterministic toy flag-evaluation model with a stipulated contract; it does not reproduce any vendor SDK byte for byte. 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:48:55.104188+00:00.

Case digest / 40c574adc025cb75beb50dbb016e0842cea8c195c1dfe3c3f801c5d2139d4885