broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(cols, order, hidden, widths, minimum, maximum, default):
    by_id = {c['id']: c for c in cols}
    ids = [c for c in order if c in by_id and c not in hidden]
    ids += [c['id'] for c in cols if False]
    resolved = {c: max(minimum.get(c, 0), min(maximum.get(c, 10000), widths.get(c, by_id[c].get('width', default)))) for c in ids}
    starts = {c: sum(resolved[x] for x in ids[:i]) for i,c in enumerate(ids)}
    return {'ids': ids, 'widths': resolved, 'starts': starts, 'total': sum(resolved.values()), 'resizable': [c for c in ids if by_id[c].get('resize', True)], 'handles': [c for c in ids[:-1] if by_id[c].get('resize', True)], 'last': ids[-1] if ids else None}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*1}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 12, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 12, 'c': 22}, 'total': 42, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 2:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*2}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 24, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 24, 'c': 34}, 'total': 54, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 3:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*3}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 36, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 36, 'c': 46}, 'total': 66, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 4:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*4}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 48, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 48, 'c': 58}, 'total': 78, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 5:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*5}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 60, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 60, 'c': 70}, 'total': 90, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(cols, order, hidden, widths, minimum, maximum, default):
    by_id = {c['id']: c for c in cols}
    ids = [c for c in order if c in by_id and c not in hidden]
    ids += [c['id'] for c in cols if c['id'] not in order]
    resolved = {c: max(minimum.get(c, 0), min(maximum.get(c, 10000), widths.get(c, by_id[c].get('width', default)))) for c in ids}
    starts = {c: sum(resolved[x] for x in ids[:i]) for i,c in enumerate(ids)}
    return {'ids': ids, 'widths': resolved, 'starts': starts, 'total': sum(resolved.values()), 'resizable': [c for c in ids if by_id[c].get('resize', True)], 'handles': [c for c in ids[:-1] if by_id[c].get('resize', True)], 'last': ids[-1] if ids else None}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*1}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 12, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 12, 'c': 22}, 'total': 42, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 2:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*2}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 24, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 24, 'c': 34}, 'total': 54, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 3:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*3}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 36, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 36, 'c': 46}, 'total': 66, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 4:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*4}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 48, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 48, 'c': 58}, 'total': 78, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 5:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*5}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 60, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 60, 'c': 70}, 'total': 90, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

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)

prompt:
The table unlisted track result violates the stipulated column track resolution contract.

Resolve unique schema IDs in saved order then append unlisted visible columns; clamp widths to per-column bounds, keep explicit zero, compute prefix starts, omit a terminal resize handle, and use None for no terminal column.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(cols, order, hidden, widths, minimum, maximum, default):
    by_id = {c['id']: c for c in cols}
    ids = [c for c in order if c in by_id and c not in hidden]
    ids += [c['id'] for c in cols if c['id'] not in order and c['id'] not in hidden]
    resolved = {c: min(minimum.get(c, 0), min(maximum.get(c, 10000), widths.get(c, by_id[c].get('width', default)))) for c in ids}
    starts = {c: sum(resolved[x] for x in ids[:i]) for i,c in enumerate(ids)}
    return {'ids': ids, 'widths': resolved, 'starts': starts, 'total': sum(resolved.values()), 'resizable': [c for c in ids if by_id[c].get('resize', True)], 'handles': [c for c in ids[:-1] if by_id[c].get('resize', True)], 'last': ids[-1] if ids else None}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*1}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 12, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 12, 'c': 22}, 'total': 42, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 2:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*2}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 24, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 24, 'c': 34}, 'total': 54, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 3:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*3}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 36, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 36, 'c': 46}, 'total': 66, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 4:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*4}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 48, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 48, 'c': 58}, 'total': 78, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 5:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*5}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 60, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 60, 'c': 70}, 'total': 90, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

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)

meaning: Fixture-count band, not measured model difficulty

deps: stdlib

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(cols, order, hidden, widths, minimum, maximum, default):
    by_id = {c['id']: c for c in cols}
    ids = [c for c in order if c in by_id and c not in hidden]
    ids += [c['id'] for c in cols if c['id'] not in order and c['id'] not in hidden]
    resolved = {c: max(0, min(maximum.get(c, 10000), widths.get(c, by_id[c].get('width', default)))) for c in ids}
    starts = {c: sum(resolved[x] for x in ids[:i]) for i,c in enumerate(ids)}
    return {'ids': ids, 'widths': resolved, 'starts': starts, 'total': sum(resolved.values()), 'resizable': [c for c in ids if by_id[c].get('resize', True)], 'handles': [c for c in ids[:-1] if by_id[c].get('resize', True)], 'last': ids[-1] if ids else None}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*1}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 12, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 12, 'c': 22}, 'total': 42, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 2:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*2}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 24, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 24, 'c': 34}, 'total': 54, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 3:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*3}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 36, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 36, 'c': 46}, 'total': 66, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 4:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*4}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 48, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 48, 'c': 58}, 'total': 78, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 5:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*5}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 60, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 60, 'c': 70}, 'total': 90, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

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)

prompt:
The table minimum width result violates the stipulated column track resolution contract.

Resolve unique schema IDs in saved order then append unlisted visible columns; clamp widths to per-column bounds, keep explicit zero, compute prefix starts, omit a terminal resize handle, and use None for no terminal column.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(cols, order, hidden, widths, minimum, maximum, default):
    by_id = {c['id']: c for c in cols}
    ids = [c for c in order if c in by_id and c not in hidden]
    ids += [c['id'] for c in cols if c['id'] not in order and c['id'] not in hidden]
    resolved = {c: max(minimum.get(c, 0), min(10000, widths.get(c, by_id[c].get('width', default)))) for c in ids}
    starts = {c: sum(resolved[x] for x in ids[:i]) for i,c in enumerate(ids)}
    return {'ids': ids, 'widths': resolved, 'starts': starts, 'total': sum(resolved.values()), 'resizable': [c for c in ids if by_id[c].get('resize', True)], 'handles': [c for c in ids[:-1] if by_id[c].get('resize', True)], 'last': ids[-1] if ids else None}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*1}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 12, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 12, 'c': 22}, 'total': 42, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 2:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*2}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 24, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 24, 'c': 34}, 'total': 54, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 3:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*3}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 36, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 36, 'c': 46}, 'total': 66, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 4:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*4}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 48, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 48, 'c': 58}, 'total': 78, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 5:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*5}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 60, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 60, 'c': 70}, 'total': 90, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(cols, order, hidden, widths, minimum, maximum, default):
    by_id = {c['id']: c for c in cols}
    ids = [c for c in order if c in by_id and c not in hidden]
    ids += [c['id'] for c in cols if c['id'] not in order and c['id'] not in hidden]
    resolved = {c: max(minimum.get(c, 0), min(maximum.get(c, 10000) + 1, widths.get(c, by_id[c].get('width', default)))) for c in ids}
    starts = {c: sum(resolved[x] for x in ids[:i]) for i,c in enumerate(ids)}
    return {'ids': ids, 'widths': resolved, 'starts': starts, 'total': sum(resolved.values()), 'resizable': [c for c in ids if by_id[c].get('resize', True)], 'handles': [c for c in ids[:-1] if by_id[c].get('resize', True)], 'last': ids[-1] if ids else None}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*1}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 12, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 12, 'c': 22}, 'total': 42, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 2:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*2}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 24, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 24, 'c': 34}, 'total': 54, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 3:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*3}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 36, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 36, 'c': 46}, 'total': 66, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 4:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*4}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 48, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 48, 'c': 58}, 'total': 78, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 5:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*5}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 60, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 60, 'c': 70}, 'total': 90, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

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)

prompt:
The table maximum width result violates the stipulated column track resolution contract.

Resolve unique schema IDs in saved order then append unlisted visible columns; clamp widths to per-column bounds, keep explicit zero, compute prefix starts, omit a terminal resize handle, and use None for no terminal column.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(cols, order, hidden, widths, minimum, maximum, default):
    by_id = {c['id']: c for c in cols}
    ids = [c for c in order if c in by_id and c not in hidden]
    ids += [c['id'] for c in cols if c['id'] not in order and c['id'] not in hidden]
    resolved = {c: max(minimum.get(c, 0), min(maximum.get(c, 10000), by_id[c].get('width', default))) for c in ids}
    starts = {c: sum(resolved[x] for x in ids[:i]) for i,c in enumerate(ids)}
    return {'ids': ids, 'widths': resolved, 'starts': starts, 'total': sum(resolved.values()), 'resizable': [c for c in ids if by_id[c].get('resize', True)], 'handles': [c for c in ids[:-1] if by_id[c].get('resize', True)], 'last': ids[-1] if ids else None}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*1}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 12, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 12, 'c': 22}, 'total': 42, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 2:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*2}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 24, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 24, 'c': 34}, 'total': 54, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 3:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*3}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 36, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 36, 'c': 46}, 'total': 66, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 4:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*4}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 48, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 48, 'c': 58}, 'total': 78, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 5:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*5}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 60, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 60, 'c': 70}, 'total': 90, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(cols, order, hidden, widths, minimum, maximum, default):
    by_id = {c['id']: c for c in cols}
    ids = [c for c in order if c in by_id and c not in hidden]
    ids += [c['id'] for c in cols if c['id'] not in order and c['id'] not in hidden]
    resolved = {c: max(minimum.get(c, 0), min(maximum.get(c, 10000), widths.get(c) or by_id[c].get('width', default))) for c in ids}
    starts = {c: sum(resolved[x] for x in ids[:i]) for i,c in enumerate(ids)}
    return {'ids': ids, 'widths': resolved, 'starts': starts, 'total': sum(resolved.values()), 'resizable': [c for c in ids if by_id[c].get('resize', True)], 'handles': [c for c in ids[:-1] if by_id[c].get('resize', True)], 'last': ids[-1] if ids else None}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*1}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 12, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 12, 'c': 22}, 'total': 42, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 2:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*2}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 24, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 24, 'c': 34}, 'total': 54, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 3:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*3}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 36, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 36, 'c': 46}, 'total': 66, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 4:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*4}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 48, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 48, 'c': 58}, 'total': 78, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 5:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*5}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 60, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 60, 'c': 70}, 'total': 90, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

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)

prompt:
The table user width result violates the stipulated column track resolution contract.

Resolve unique schema IDs in saved order then append unlisted visible columns; clamp widths to per-column bounds, keep explicit zero, compute prefix starts, omit a terminal resize handle, and use None for no terminal column.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(cols, order, hidden, widths, minimum, maximum, default):
    by_id = {c['id']: c for c in cols}
    ids = [c for c in order if c in by_id and c not in hidden]
    ids += [c['id'] for c in cols if c['id'] not in order and c['id'] not in hidden]
    resolved = {c: max(minimum.get(c, 0), min(maximum.get(c, 10000), widths.get(c, by_id[c].get('width', default)))) for c in ids}
    starts = {c: sum(resolved[x] for x in ids[:i+1]) for i,c in enumerate(ids)}
    return {'ids': ids, 'widths': resolved, 'starts': starts, 'total': sum(resolved.values()), 'resizable': [c for c in ids if by_id[c].get('resize', True)], 'handles': [c for c in ids[:-1] if by_id[c].get('resize', True)], 'last': ids[-1] if ids else None}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*1}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 12, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 12, 'c': 22}, 'total': 42, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 2:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*2}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 24, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 24, 'c': 34}, 'total': 54, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 3:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*3}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 36, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 36, 'c': 46}, 'total': 66, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 4:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*4}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 48, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 48, 'c': 58}, 'total': 78, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 5:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*5}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 60, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 60, 'c': 70}, 'total': 90, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(cols, order, hidden, widths, minimum, maximum, default):
    by_id = {c['id']: c for c in cols}
    ids = [c for c in order if c in by_id and c not in hidden]
    ids += [c['id'] for c in cols if c['id'] not in order and c['id'] not in hidden]
    resolved = {c: max(minimum.get(c, 0), min(maximum.get(c, 10000), widths.get(c, by_id[c].get('width', default)))) for c in ids}
    starts = {c: sum(resolved[x] for x in ids[:max(0,i-1)]) for i,c in enumerate(ids)}
    return {'ids': ids, 'widths': resolved, 'starts': starts, 'total': sum(resolved.values()), 'resizable': [c for c in ids if by_id[c].get('resize', True)], 'handles': [c for c in ids[:-1] if by_id[c].get('resize', True)], 'last': ids[-1] if ids else None}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*1}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 12, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 12, 'c': 22}, 'total': 42, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 2:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*2}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 24, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 24, 'c': 34}, 'total': 54, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 3:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*3}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 36, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 36, 'c': 46}, 'total': 66, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 4:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*4}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 48, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 48, 'c': 58}, 'total': 78, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

if N == 5:
    check('mixed schema', solve([{'id':'a','width':8,'resize':False},{'id':'b'},{'id':'c','width':30}], ['b','gone','a'], [], {'b':12*5}, {'a':10}, {'c':20}, 7), {'ids': ['b', 'a', 'c'], 'widths': {'b': 60, 'a': 10, 'c': 20}, 'starts': {'b': 0, 'a': 60, 'c': 70}, 'total': 90, 'resizable': ['b', 'c'], 'handles': ['b'], 'last': 'c'})
    check('zero override', solve([{'id':'a','width':8},{'id':'b','width':9}], ['a','b'], [], {'a':0}, {}, {}, 5), {'ids': ['a', 'b'], 'widths': {'a': 0, 'b': 9}, 'starts': {'a': 0, 'b': 0}, 'total': 9, 'resizable': ['a', 'b'], 'handles': ['a'], 'last': 'b'})
    check('multiple hidden', solve([{'id':'a'},{'id':'b'},{'id':'c'},{'id':'d'}], ['a','b','c'], ['a','b','d'], {}, {}, {}, 6), {'ids': ['c'], 'widths': {'c': 6}, 'starts': {'c': 0}, 'total': 6, 'resizable': ['c'], 'handles': [], 'last': 'c'})
    check('empty table', solve([], [], [], {}, {}, {}, 5), {'ids': [], 'widths': {}, 'starts': {}, 'total': 0, 'resizable': [], 'handles': [], 'last': None})
    check('fixed singleton', solve([{'id':'x','resize':False}], ['x'], [], {}, {'x':11}, {'x':11}, 3), {'ids': ['x'], 'widths': {'x': 11}, 'starts': {'x': 0}, 'total': 11, 'resizable': [], 'handles': [], 'last': 'x'})
    check('default tracks', solve([{'id':'q'},{'id':'r'}], [], [], {}, {}, {}, 4), {'ids': ['q', 'r'], 'widths': {'q': 4, 'r': 4}, 'starts': {'q': 0, 'r': 4}, 'total': 8, 'resizable': ['q', 'r'], 'handles': ['q'], 'last': 'r'})

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)

prompt:
The table prefix position result violates the stipulated column track resolution contract.

Resolve unique schema IDs in saved order then append unlisted visible columns; clamp widths to per-column bounds, keep explicit zero, compute prefix starts, omit a terminal resize handle, and use None for no terminal column.

split: open-access