FAILURE MAP
← Case archive

FA-37691 / Table interactions / Open access

Saved table view restoration: view version · case 01

The table view version result violates the stipulated saved table view restoration contract.

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

ROOT CAUSE

The view version decision uses 'False' instead of "saved.get('version')!=version".

THE FAILURE

The view version decision uses 'False' instead of "saved.get('version')!=version".

Unsuccessful approach: The attempted repair "saved.get('version',version)!=version" still loses a required part of the table contract.

Case contract

Restore a table view only at matching schema version; deduplicate known order, append new schema columns, keep required columns visible, accept positive-clamped integer nonboolean widths, validate pin sides/density/page-size enums, and ignore removed columns.

Why this case matters

An offline table UI model isolates saved table view restoration, including adversarial row/column relationships.

1 / The failure

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

N = 1
observations = []
def solve(schema, saved, version, defaults):
    ids=[c['id'] for c in schema]
    if False: return defaults
    order=[]
    for c in saved.get('order',[]):
        if c in ids and c not in order: order.append(c)
    order += [c for c in ids if c not in order]
    hidden=[c for c in order if c in saved.get('hidden',[]) and not next((x for x in schema if x['id']==c),{}).get('required')]
    widths={c:max(1,w) for c,w in saved.get('widths',{}).items() if c in ids and isinstance(w,int) and not isinstance(w,bool)}
    pins={c:p for c,p in saved.get('pins',{}).items() if c in ids and p in ('left','right')}
    return {'order':order,'hidden':hidden,'widths':widths,'pins':pins,'density':saved.get('density') if saved.get('density') in ('compact','normal','comfortable') else defaults['density'],'page_size':saved.get('page_size') if saved.get('page_size') in (10,25,50) else defaults['page_size']}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('schema evolution', solve([{'id':'a','required':True},{'id':'b'},{'id':'c'}], {'version':2,'order':['b','gone','b'],'hidden':['a','b'],'widths':{'a':1+2,'b':0,'gone':8},'pins':{'a':'right','b':'middle'},'density':'comfortable','page_size':25}, 2, {'density':'normal','page_size':10}), {'order': ['b', 'a', 'c'], 'hidden': ['b'], 'widths': {'a': 3, 'b': 1}, 'pins': {'a': 'right'}, 'density': 'comfortable', 'page_size': 25})
    check('old version', solve([{'id':'a'}], {'version':1}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('missing version', solve([{'id':'a'}], {}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('invalid values', solve([{'id':'a'},{'id':'b'}], {'version':2,'widths':{'a':True,'b':2.5},'density':'wild','page_size':13}, 2, {'density':'normal','page_size':10}), {'order': ['a', 'b'], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'normal', 'page_size': 10})
    check('negative width', solve([{'id':'a'}], {'version':2,'widths':{'a':-4},'pins':{'a':'left'},'density':'normal','page_size':50}, 2, {'density':'compact','page_size':10}), {'order': ['a'], 'hidden': [], 'widths': {'a': 1}, 'pins': {'a': 'left'}, 'density': 'normal', 'page_size': 50})
    check('empty schema', solve([], {'version':2,'order':['gone'],'hidden':['gone'],'widths':{},'pins':{'gone':'left'},'density':'compact','page_size':10}, 2, {'density':'normal','page_size':25}), {'order': [], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'compact', 'page_size': 10})

if N == 2:
    check('schema evolution', solve([{'id':'a','required':True},{'id':'b'},{'id':'c'}], {'version':2,'order':['b','gone','b'],'hidden':['a','b'],'widths':{'a':2+2,'b':0,'gone':8},'pins':{'a':'right','b':'middle'},'density':'comfortable','page_size':25}, 2, {'density':'normal','page_size':10}), {'order': ['b', 'a', 'c'], 'hidden': ['b'], 'widths': {'a': 4, 'b': 1}, 'pins': {'a': 'right'}, 'density': 'comfortable', 'page_size': 25})
    check('old version', solve([{'id':'a'}], {'version':1}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('missing version', solve([{'id':'a'}], {}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('invalid values', solve([{'id':'a'},{'id':'b'}], {'version':2,'widths':{'a':True,'b':2.5},'density':'wild','page_size':13}, 2, {'density':'normal','page_size':10}), {'order': ['a', 'b'], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'normal', 'page_size': 10})
    check('negative width', solve([{'id':'a'}], {'version':2,'widths':{'a':-4},'pins':{'a':'left'},'density':'normal','page_size':50}, 2, {'density':'compact','page_size':10}), {'order': ['a'], 'hidden': [], 'widths': {'a': 1}, 'pins': {'a': 'left'}, 'density': 'normal', 'page_size': 50})
    check('empty schema', solve([], {'version':2,'order':['gone'],'hidden':['gone'],'widths':{},'pins':{'gone':'left'},'density':'compact','page_size':10}, 2, {'density':'normal','page_size':25}), {'order': [], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'compact', 'page_size': 10})

if N == 3:
    check('schema evolution', solve([{'id':'a','required':True},{'id':'b'},{'id':'c'}], {'version':2,'order':['b','gone','b'],'hidden':['a','b'],'widths':{'a':3+2,'b':0,'gone':8},'pins':{'a':'right','b':'middle'},'density':'comfortable','page_size':25}, 2, {'density':'normal','page_size':10}), {'order': ['b', 'a', 'c'], 'hidden': ['b'], 'widths': {'a': 5, 'b': 1}, 'pins': {'a': 'right'}, 'density': 'comfortable', 'page_size': 25})
    check('old version', solve([{'id':'a'}], {'version':1}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('missing version', solve([{'id':'a'}], {}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('invalid values', solve([{'id':'a'},{'id':'b'}], {'version':2,'widths':{'a':True,'b':2.5},'density':'wild','page_size':13}, 2, {'density':'normal','page_size':10}), {'order': ['a', 'b'], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'normal', 'page_size': 10})
    check('negative width', solve([{'id':'a'}], {'version':2,'widths':{'a':-4},'pins':{'a':'left'},'density':'normal','page_size':50}, 2, {'density':'compact','page_size':10}), {'order': ['a'], 'hidden': [], 'widths': {'a': 1}, 'pins': {'a': 'left'}, 'density': 'normal', 'page_size': 50})
    check('empty schema', solve([], {'version':2,'order':['gone'],'hidden':['gone'],'widths':{},'pins':{'gone':'left'},'density':'compact','page_size':10}, 2, {'density':'normal','page_size':25}), {'order': [], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'compact', 'page_size': 10})

if N == 4:
    check('schema evolution', solve([{'id':'a','required':True},{'id':'b'},{'id':'c'}], {'version':2,'order':['b','gone','b'],'hidden':['a','b'],'widths':{'a':4+2,'b':0,'gone':8},'pins':{'a':'right','b':'middle'},'density':'comfortable','page_size':25}, 2, {'density':'normal','page_size':10}), {'order': ['b', 'a', 'c'], 'hidden': ['b'], 'widths': {'a': 6, 'b': 1}, 'pins': {'a': 'right'}, 'density': 'comfortable', 'page_size': 25})
    check('old version', solve([{'id':'a'}], {'version':1}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('missing version', solve([{'id':'a'}], {}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('invalid values', solve([{'id':'a'},{'id':'b'}], {'version':2,'widths':{'a':True,'b':2.5},'density':'wild','page_size':13}, 2, {'density':'normal','page_size':10}), {'order': ['a', 'b'], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'normal', 'page_size': 10})
    check('negative width', solve([{'id':'a'}], {'version':2,'widths':{'a':-4},'pins':{'a':'left'},'density':'normal','page_size':50}, 2, {'density':'compact','page_size':10}), {'order': ['a'], 'hidden': [], 'widths': {'a': 1}, 'pins': {'a': 'left'}, 'density': 'normal', 'page_size': 50})
    check('empty schema', solve([], {'version':2,'order':['gone'],'hidden':['gone'],'widths':{},'pins':{'gone':'left'},'density':'compact','page_size':10}, 2, {'density':'normal','page_size':25}), {'order': [], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'compact', 'page_size': 10})

if N == 5:
    check('schema evolution', solve([{'id':'a','required':True},{'id':'b'},{'id':'c'}], {'version':2,'order':['b','gone','b'],'hidden':['a','b'],'widths':{'a':5+2,'b':0,'gone':8},'pins':{'a':'right','b':'middle'},'density':'comfortable','page_size':25}, 2, {'density':'normal','page_size':10}), {'order': ['b', 'a', 'c'], 'hidden': ['b'], 'widths': {'a': 7, 'b': 1}, 'pins': {'a': 'right'}, 'density': 'comfortable', 'page_size': 25})
    check('old version', solve([{'id':'a'}], {'version':1}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('missing version', solve([{'id':'a'}], {}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('invalid values', solve([{'id':'a'},{'id':'b'}], {'version':2,'widths':{'a':True,'b':2.5},'density':'wild','page_size':13}, 2, {'density':'normal','page_size':10}), {'order': ['a', 'b'], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'normal', 'page_size': 10})
    check('negative width', solve([{'id':'a'}], {'version':2,'widths':{'a':-4},'pins':{'a':'left'},'density':'normal','page_size':50}, 2, {'density':'compact','page_size':10}), {'order': ['a'], 'hidden': [], 'widths': {'a': 1}, 'pins': {'a': 'left'}, 'density': 'normal', 'page_size': 50})
    check('empty schema', solve([], {'version':2,'order':['gone'],'hidden':['gone'],'widths':{},'pins':{'gone':'left'},'density':'compact','page_size':10}, 2, {'density':'normal','page_size':25}), {'order': [], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'compact', 'page_size': 10})

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
schema evolution{'density': 'comfortable', 'hidden': ['b'], 'order': ['b', 'a', 'c'], 'page_size': 25, 'pins': {'a': 'right'}, 'widths': {'a': 3, 'b': 1}}{'density': 'comfortable', 'hidden': ['b'], 'order': ['b', 'a', 'c'], 'page_size': 25, 'pins': {'a': 'right'}, 'widths': {'a': 3, 'b': 1}}Passed
old version{'density': 'normal', 'hidden': [], 'order': ['a'], 'page_size': 10, 'pins': {}, 'widths': {}}{'density': 'normal', 'page_size': 10}Failed
missing version{'density': 'normal', 'hidden': [], 'order': ['a'], 'page_size': 10, 'pins': {}, 'widths': {}}{'density': 'normal', 'page_size': 10}Failed
invalid values{'density': 'normal', 'hidden': [], 'order': ['a', 'b'], 'page_size': 10, 'pins': {}, 'widths': {}}{'density': 'normal', 'hidden': [], 'order': ['a', 'b'], 'page_size': 10, 'pins': {}, 'widths': {}}Passed
negative width{'density': 'normal', 'hidden': [], 'order': ['a'], 'page_size': 50, 'pins': {'a': 'left'}, 'widths': {'a': 1}}{'density': 'normal', 'hidden': [], 'order': ['a'], 'page_size': 50, 'pins': {'a': 'left'}, 'widths': {'a': 1}}Passed
empty schema{'density': 'compact', 'hidden': [], 'order': [], 'page_size': 10, 'pins': {}, 'widths': {}}{'density': 'compact', 'hidden': [], 'order': [], 'page_size': 10, 'pins': {}, 'widths': {}}Passed

SHA-256 / 1245079d5663e6edd84944f4893fce9635b835bd664dc0fddb174dbec2cc1721

2 / The unsuccessful fix

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

N = 1
observations = []
def solve(schema, saved, version, defaults):
    ids=[c['id'] for c in schema]
    if saved.get('version',version)!=version: return defaults
    order=[]
    for c in saved.get('order',[]):
        if c in ids and c not in order: order.append(c)
    order += [c for c in ids if c not in order]
    hidden=[c for c in order if c in saved.get('hidden',[]) and not next((x for x in schema if x['id']==c),{}).get('required')]
    widths={c:max(1,w) for c,w in saved.get('widths',{}).items() if c in ids and isinstance(w,int) and not isinstance(w,bool)}
    pins={c:p for c,p in saved.get('pins',{}).items() if c in ids and p in ('left','right')}
    return {'order':order,'hidden':hidden,'widths':widths,'pins':pins,'density':saved.get('density') if saved.get('density') in ('compact','normal','comfortable') else defaults['density'],'page_size':saved.get('page_size') if saved.get('page_size') in (10,25,50) else defaults['page_size']}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('schema evolution', solve([{'id':'a','required':True},{'id':'b'},{'id':'c'}], {'version':2,'order':['b','gone','b'],'hidden':['a','b'],'widths':{'a':1+2,'b':0,'gone':8},'pins':{'a':'right','b':'middle'},'density':'comfortable','page_size':25}, 2, {'density':'normal','page_size':10}), {'order': ['b', 'a', 'c'], 'hidden': ['b'], 'widths': {'a': 3, 'b': 1}, 'pins': {'a': 'right'}, 'density': 'comfortable', 'page_size': 25})
    check('old version', solve([{'id':'a'}], {'version':1}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('missing version', solve([{'id':'a'}], {}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('invalid values', solve([{'id':'a'},{'id':'b'}], {'version':2,'widths':{'a':True,'b':2.5},'density':'wild','page_size':13}, 2, {'density':'normal','page_size':10}), {'order': ['a', 'b'], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'normal', 'page_size': 10})
    check('negative width', solve([{'id':'a'}], {'version':2,'widths':{'a':-4},'pins':{'a':'left'},'density':'normal','page_size':50}, 2, {'density':'compact','page_size':10}), {'order': ['a'], 'hidden': [], 'widths': {'a': 1}, 'pins': {'a': 'left'}, 'density': 'normal', 'page_size': 50})
    check('empty schema', solve([], {'version':2,'order':['gone'],'hidden':['gone'],'widths':{},'pins':{'gone':'left'},'density':'compact','page_size':10}, 2, {'density':'normal','page_size':25}), {'order': [], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'compact', 'page_size': 10})

if N == 2:
    check('schema evolution', solve([{'id':'a','required':True},{'id':'b'},{'id':'c'}], {'version':2,'order':['b','gone','b'],'hidden':['a','b'],'widths':{'a':2+2,'b':0,'gone':8},'pins':{'a':'right','b':'middle'},'density':'comfortable','page_size':25}, 2, {'density':'normal','page_size':10}), {'order': ['b', 'a', 'c'], 'hidden': ['b'], 'widths': {'a': 4, 'b': 1}, 'pins': {'a': 'right'}, 'density': 'comfortable', 'page_size': 25})
    check('old version', solve([{'id':'a'}], {'version':1}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('missing version', solve([{'id':'a'}], {}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('invalid values', solve([{'id':'a'},{'id':'b'}], {'version':2,'widths':{'a':True,'b':2.5},'density':'wild','page_size':13}, 2, {'density':'normal','page_size':10}), {'order': ['a', 'b'], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'normal', 'page_size': 10})
    check('negative width', solve([{'id':'a'}], {'version':2,'widths':{'a':-4},'pins':{'a':'left'},'density':'normal','page_size':50}, 2, {'density':'compact','page_size':10}), {'order': ['a'], 'hidden': [], 'widths': {'a': 1}, 'pins': {'a': 'left'}, 'density': 'normal', 'page_size': 50})
    check('empty schema', solve([], {'version':2,'order':['gone'],'hidden':['gone'],'widths':{},'pins':{'gone':'left'},'density':'compact','page_size':10}, 2, {'density':'normal','page_size':25}), {'order': [], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'compact', 'page_size': 10})

if N == 3:
    check('schema evolution', solve([{'id':'a','required':True},{'id':'b'},{'id':'c'}], {'version':2,'order':['b','gone','b'],'hidden':['a','b'],'widths':{'a':3+2,'b':0,'gone':8},'pins':{'a':'right','b':'middle'},'density':'comfortable','page_size':25}, 2, {'density':'normal','page_size':10}), {'order': ['b', 'a', 'c'], 'hidden': ['b'], 'widths': {'a': 5, 'b': 1}, 'pins': {'a': 'right'}, 'density': 'comfortable', 'page_size': 25})
    check('old version', solve([{'id':'a'}], {'version':1}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('missing version', solve([{'id':'a'}], {}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('invalid values', solve([{'id':'a'},{'id':'b'}], {'version':2,'widths':{'a':True,'b':2.5},'density':'wild','page_size':13}, 2, {'density':'normal','page_size':10}), {'order': ['a', 'b'], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'normal', 'page_size': 10})
    check('negative width', solve([{'id':'a'}], {'version':2,'widths':{'a':-4},'pins':{'a':'left'},'density':'normal','page_size':50}, 2, {'density':'compact','page_size':10}), {'order': ['a'], 'hidden': [], 'widths': {'a': 1}, 'pins': {'a': 'left'}, 'density': 'normal', 'page_size': 50})
    check('empty schema', solve([], {'version':2,'order':['gone'],'hidden':['gone'],'widths':{},'pins':{'gone':'left'},'density':'compact','page_size':10}, 2, {'density':'normal','page_size':25}), {'order': [], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'compact', 'page_size': 10})

if N == 4:
    check('schema evolution', solve([{'id':'a','required':True},{'id':'b'},{'id':'c'}], {'version':2,'order':['b','gone','b'],'hidden':['a','b'],'widths':{'a':4+2,'b':0,'gone':8},'pins':{'a':'right','b':'middle'},'density':'comfortable','page_size':25}, 2, {'density':'normal','page_size':10}), {'order': ['b', 'a', 'c'], 'hidden': ['b'], 'widths': {'a': 6, 'b': 1}, 'pins': {'a': 'right'}, 'density': 'comfortable', 'page_size': 25})
    check('old version', solve([{'id':'a'}], {'version':1}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('missing version', solve([{'id':'a'}], {}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('invalid values', solve([{'id':'a'},{'id':'b'}], {'version':2,'widths':{'a':True,'b':2.5},'density':'wild','page_size':13}, 2, {'density':'normal','page_size':10}), {'order': ['a', 'b'], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'normal', 'page_size': 10})
    check('negative width', solve([{'id':'a'}], {'version':2,'widths':{'a':-4},'pins':{'a':'left'},'density':'normal','page_size':50}, 2, {'density':'compact','page_size':10}), {'order': ['a'], 'hidden': [], 'widths': {'a': 1}, 'pins': {'a': 'left'}, 'density': 'normal', 'page_size': 50})
    check('empty schema', solve([], {'version':2,'order':['gone'],'hidden':['gone'],'widths':{},'pins':{'gone':'left'},'density':'compact','page_size':10}, 2, {'density':'normal','page_size':25}), {'order': [], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'compact', 'page_size': 10})

if N == 5:
    check('schema evolution', solve([{'id':'a','required':True},{'id':'b'},{'id':'c'}], {'version':2,'order':['b','gone','b'],'hidden':['a','b'],'widths':{'a':5+2,'b':0,'gone':8},'pins':{'a':'right','b':'middle'},'density':'comfortable','page_size':25}, 2, {'density':'normal','page_size':10}), {'order': ['b', 'a', 'c'], 'hidden': ['b'], 'widths': {'a': 7, 'b': 1}, 'pins': {'a': 'right'}, 'density': 'comfortable', 'page_size': 25})
    check('old version', solve([{'id':'a'}], {'version':1}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('missing version', solve([{'id':'a'}], {}, 2, {'density':'normal','page_size':10}), {'density': 'normal', 'page_size': 10})
    check('invalid values', solve([{'id':'a'},{'id':'b'}], {'version':2,'widths':{'a':True,'b':2.5},'density':'wild','page_size':13}, 2, {'density':'normal','page_size':10}), {'order': ['a', 'b'], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'normal', 'page_size': 10})
    check('negative width', solve([{'id':'a'}], {'version':2,'widths':{'a':-4},'pins':{'a':'left'},'density':'normal','page_size':50}, 2, {'density':'compact','page_size':10}), {'order': ['a'], 'hidden': [], 'widths': {'a': 1}, 'pins': {'a': 'left'}, 'density': 'normal', 'page_size': 50})
    check('empty schema', solve([], {'version':2,'order':['gone'],'hidden':['gone'],'widths':{},'pins':{'gone':'left'},'density':'compact','page_size':10}, 2, {'density':'normal','page_size':25}), {'order': [], 'hidden': [], 'widths': {}, 'pins': {}, 'density': 'compact', 'page_size': 10})

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
schema evolution{'density': 'comfortable', 'hidden': ['b'], 'order': ['b', 'a', 'c'], 'page_size': 25, 'pins': {'a': 'right'}, 'widths': {'a': 3, 'b': 1}}{'density': 'comfortable', 'hidden': ['b'], 'order': ['b', 'a', 'c'], 'page_size': 25, 'pins': {'a': 'right'}, 'widths': {'a': 3, 'b': 1}}Passed
old version{'density': 'normal', 'page_size': 10}{'density': 'normal', 'page_size': 10}Passed
missing version{'density': 'normal', 'hidden': [], 'order': ['a'], 'page_size': 10, 'pins': {}, 'widths': {}}{'density': 'normal', 'page_size': 10}Failed
invalid values{'density': 'normal', 'hidden': [], 'order': ['a', 'b'], 'page_size': 10, 'pins': {}, 'widths': {}}{'density': 'normal', 'hidden': [], 'order': ['a', 'b'], 'page_size': 10, 'pins': {}, 'widths': {}}Passed
negative width{'density': 'normal', 'hidden': [], 'order': ['a'], 'page_size': 50, 'pins': {'a': 'left'}, 'widths': {'a': 1}}{'density': 'normal', 'hidden': [], 'order': ['a'], 'page_size': 50, 'pins': {'a': 'left'}, 'widths': {'a': 1}}Passed
empty schema{'density': 'compact', 'hidden': [], 'order': [], 'page_size': 10, 'pins': {}, 'widths': {}}{'density': 'compact', 'hidden': [], 'order': [], 'page_size': 10, 'pins': {}, 'widths': {}}Passed

SHA-256 / 1d3334490246784d44d70de5b1deed892c1af3991c961e94c9e4f4039119d119

HELD IN THE MEMBER ARCHIVE

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

This mechanism has 6 recorded checks per implementation. The open-access tier publishes the failure and the unsuccessful fix; the repaired source that passes every check, and the observations that prove it, are available to members.

Every case sharing this mechanism uses the same contract and the same repair, so this one record is held back for all of them.

Member access is invitation-based. Sign in with your invited account to inspect the repair.

Sign in to the archive ↗

Verification & scope

Schema IDs are unique; settings are finite Python scalar/container values with an explicitly enumerated restoration policy. Deterministic offline table UI model; no browser, DOM, framework, or standards conformance is claimed. 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:43:04.088483+00:00.

Case digest / 06c5e6543e75f3d189328b62845e744c46c9f6ad7de5926d58dcbe530895724a