FAILURE MAP
← Case archive

FA-74266 / Feature flag rollout bucketing / Open access

Bootstrapped flag payload merge: Flags unknown locally are never added · case 01

Newly created flags never reach clients until a full reload.

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

ROOT CAUSE

Replacement requires an existing local entry.

VERIFIED REPAIR

Adopt incoming flags whose key is not present locally.

Unsuccessful approach: Treating a missing flag as version 0 still refuses new flags that start at version 0.

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 not None and 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 25',
   [{'version': 2, 'flags': {'b': {'value': False, 'version': 1}}},
    {'version': 2,
     'flags': {'b': {'value': 'x', 'version': 3},
               'c': {'value': 2, 'version': 0},
               'a': {'value': 'x', 'version': 1, 'deleted': True}}}],
   [['b', 'x'], ['c', 2]]),
  ('payload pair sample 32',
   [{'version': 2, 'flags': {'a': {'value': True, 'version': 3}}},
    {'version': 3, 'flags': {'b': {'value': 'x', 'version': 3}}}],
   [['a', True], ['b', 'x']])],
 [('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 50',
   [{'version': 1, 'flags': {'b': {'value': True, 'version': 1}}},
    {'version': 1,
     'flags': {'b': {'value': True, 'version': 1},
               'c': {'value': True, 'version': 2, 'deleted': True},
               'a': {'value': False, 'version': 3}}}],
   [['a', False], ['b', 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 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 22',
   [{'version': 1,
     'flags': {'b': {'value': 2, 'version': 1}, 'a': {'value': 2, 'version': 1, 'deleted': True}}},
    {'version': 2,
     'flags': {'b': {'value': True, 'version': 0, 'deleted': True}, 'c': {'value': True, 'version': 3}}}],
   [['b', 2], ['c', True]]),
  ('payload pair sample 37',
   [{'version': 2, 'flags': {}},
    {'version': 2,
     'flags': {'b': {'value': True, 'version': 3, 'deleted': True},
               'a': {'value': 2, 'version': 1},
               'd': {'value': True, 'version': 0}}}],
   [['a', 2], ['d', True]])]]
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', 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 / 32b5b3783a71547c4eb90fd7d21c6bd0bd95409d8580e5b166f3d701e059f409

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 incoming['version'] >= local['version']:
        for k, f in incoming['flags'].items():
            cur = merged.get(k)
            if (cur or {}).get('version', 0) < f['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 25',
   [{'version': 2, 'flags': {'b': {'value': False, 'version': 1}}},
    {'version': 2,
     'flags': {'b': {'value': 'x', 'version': 3},
               'c': {'value': 2, 'version': 0},
               'a': {'value': 'x', 'version': 1, 'deleted': True}}}],
   [['b', 'x'], ['c', 2]]),
  ('payload pair sample 32',
   [{'version': 2, 'flags': {'a': {'value': True, 'version': 3}}},
    {'version': 3, 'flags': {'b': {'value': 'x', 'version': 3}}}],
   [['a', True], ['b', 'x']])],
 [('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 50',
   [{'version': 1, 'flags': {'b': {'value': True, 'version': 1}}},
    {'version': 1,
     'flags': {'b': {'value': True, 'version': 1},
               'c': {'value': True, 'version': 2, 'deleted': True},
               'a': {'value': False, 'version': 3}}}],
   [['a', False], ['b', 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 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 22',
   [{'version': 1,
     'flags': {'b': {'value': 2, 'version': 1}, 'a': {'value': 2, 'version': 1, 'deleted': True}}},
    {'version': 2,
     'flags': {'b': {'value': True, 'version': 0, 'deleted': True}, 'c': {'value': True, 'version': 3}}}],
   [['b', 2], ['c', True]]),
  ('payload pair sample 37',
   [{'version': 2, 'flags': {}},
    {'version': 2,
     'flags': {'b': {'value': True, 'version': 3, 'deleted': True},
               'a': {'value': 2, 'version': 1},
               'd': {'value': True, 'version': 0}}}],
   [['a', 2], ['d', True]])]]
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', 1]][['a', 1]]Passed
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 / 7e93dcc43326d3a181dafb285cd7e784d0c2a4e63dcad89db826d1c1eed68408

3 / The verified repair

Exit 0
"""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 25',
   [{'version': 2, 'flags': {'b': {'value': False, 'version': 1}}},
    {'version': 2,
     'flags': {'b': {'value': 'x', 'version': 3},
               'c': {'value': 2, 'version': 0},
               'a': {'value': 'x', 'version': 1, 'deleted': True}}}],
   [['b', 'x'], ['c', 2]]),
  ('payload pair sample 32',
   [{'version': 2, 'flags': {'a': {'value': True, 'version': 3}}},
    {'version': 3, 'flags': {'b': {'value': 'x', 'version': 3}}}],
   [['a', True], ['b', 'x']])],
 [('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 50',
   [{'version': 1, 'flags': {'b': {'value': True, 'version': 1}}},
    {'version': 1,
     'flags': {'b': {'value': True, 'version': 1},
               'c': {'value': True, 'version': 2, 'deleted': True},
               'a': {'value': False, 'version': 3}}}],
   [['a', False], ['b', 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 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 22',
   [{'version': 1,
     'flags': {'b': {'value': 2, 'version': 1}, 'a': {'value': 2, 'version': 1, 'deleted': True}}},
    {'version': 2,
     'flags': {'b': {'value': True, 'version': 0, 'deleted': True}, 'c': {'value': True, 'version': 3}}}],
   [['b', 2], ['c', True]]),
  ('payload pair sample 37',
   [{'version': 2, 'flags': {}},
    {'version': 2,
     'flags': {'b': {'value': True, 'version': 3, 'deleted': True},
               'a': {'value': 2, 'version': 1},
               'd': {'value': True, 'version': 0}}}],
   [['a', 2], ['d', True]])]]
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', 1]][['a', 1]]Passed
new flag with version zero is adopted[['b', 'on']][['b', 'on']]Passed
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 / d2bea22fe3c883c8d942c7a67322e638d04ec79a06d617dca777b149c22548f5

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

Case digest / d59aa227faead31f6420525e3bec0fb4917dce901496efe7f46ea9968df05efb