FA-79441 / Barcode symbology encoding / Open access

SHIFT encodes its character in the current set · case 01

A lowercase letter shifted inside set A comes out as a control code.

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

ROOT CAUSE

The shifted character is looked up in the current set rather than the opposite of A/B.

VERIFIED REPAIR

Encode the shifted character in B when in A and in A when in B.

Unsuccessful approach: Always shifting to A breaks shifts made from set A.

Case contract

Turn planned Code 128 segments into symbol values (without the checksum). Segments are [set, text], ["FNC1"] or ["SHIFT", char]. The first set segment emits its start (A 103, B 104, C 105); later set changes emit Code A 101, Code B 100 or Code C 99. Set A encodes 32..95 as ord-32 and 0..31 as ord+64; set B encodes 32..127 as ord-32; set C encodes even-length ASCII digit text as pair values. FNC1 is 102 and needs a prior start; SHIFT (98) is only valid in A or B and encodes one character in the other of A/B. Errors: no-start, bad-shift, bad-c, unencodable.

Why this case matters

Retail, logistics, pharmacy and document workflows depend on encoders that produce exactly the module pattern, code-set switches, separators and quiet zones scanners expect; one misplaced module or separator makes a label unreadable or, worse, scan as different data.

1 / The failure

Exit 1

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

N = 1
observations = []
def solve(segs):
    out = []
    cur = None
    starts = {'A': 103, 'B': 104, 'C': 105}
    switch = {'A': 101, 'B': 100, 'C': 99}
    def val(s, ch):
        o = ord(ch)
        if s == 'A':
            if 32 <= o <= 95:
                return o - 32
            if 0 <= o <= 31:
                return o + 64
            return None
        if 32 <= o <= 127:
            return o - 32
        return None
    for seg in segs:
        kind = seg[0]
        if kind == 'FNC1':
            if cur is None:
                return {'error': 'no-start'}
            out.append(102)
            continue
        if kind == 'SHIFT':
            if cur not in ('A', 'B'):
                return {'error': 'bad-shift'}
            other = cur
            v = val(other, seg[1])
            if v is None:
                return {'error': 'unencodable', 'char': seg[1]}
            out += [98, v]
            continue
        s, text = seg
        if cur is None:
            out.append(starts[s])
        elif s != cur:
            out.append(switch[s])
        cur = s
        if s == 'C':
            if len(text) % 2 or not all(c in '0123456789' for c in text):
                return {'error': 'bad-c'}
            out += [int(text[j:j + 2]) for j in range(0, len(text), 2)]
        else:
            for ch in text:
                v = val(s, ch)
                if v is None:
                    return {'error': 'unencodable', 'char': ch}
                out.append(v)
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[[[['B', '{x}'], ['SHIFT', '\t'], ['C', '1'], ['A', '\x00Q']], {'error': 'bad-c'}], [[['B', 'ab'], ['A', '\x00Q'], ['SHIFT', '\t'], ['FNC1']], {'error': 'unencodable', 'char': '\t'}], [[['A', '\t'], ['A', '\t'], ['SHIFT', 'a']], [103, 73, 73, 98, 65]], [[['C', '12'], ['A', 'HELLO']], [105, 12, 101, 40, 37, 44, 44, 47]], [[['B', 'Q'], ['B', '{x}'], ['C', '123']], {'error': 'bad-c'}], [[['C', '123'], ['FNC1']], {'error': 'bad-c'}], [[['B', 'Lot 7'], ['A', '\x00Q'], ['FNC1'], ['C', '4711']], [104, 44, 79, 84, 0, 23, 101, 64, 49, 102, 99, 47, 11]], [[['A', '\x00Q'], ['SHIFT', 'a'], ['SHIFT', '\t']], {'error': 'unencodable', 'char': '\t'}]], [[[['B', 'z~'], ['SHIFT', 'z'], ['FNC1']], {'error': 'unencodable', 'char': 'z'}], [[['A', 'X\x1d1'], ['SHIFT', '\t'], ['A', 'A`'], ['SHIFT', '\t']], {'error': 'unencodable', 'char': '\t'}], [[['C', '12'], ['A', 'HELLO'], ['SHIFT', '\x1d']], {'error': 'unencodable', 'char': '\x1d'}], [[['C', '1'], ['C', '12']], {'error': 'bad-c'}], [[['A', 'AB'], ['B', 'Q'], ['B', 'z~']], [103, 33, 34, 100, 49, 90, 94]], [[['A', 'AB'], ['FNC1']], [103, 33, 34, 102]], [[['C', ' 1'], ['C', '0099'], ['FNC1'], ['SHIFT', '\x1d']], {'error': 'bad-c'}], [[['A', 'X\x1d1'], ['SHIFT', 'z']], [103, 56, 93, 17, 98, 90]]], [[[['B', '{x}'], ['SHIFT', '\x1d']], [104, 91, 88, 93, 98, 93]], [[['A', 'HELLO'], ['SHIFT', '\t'], ['SHIFT', 'a'], ['A', 'A`']], {'error': 'unencodable', 'char': '\t'}], [[['A', '_^'], ['SHIFT', '\t']], {'error': 'unencodable', 'char': '\t'}], [[['B', 'Lot 7']], [104, 44, 79, 84, 0, 23]], [[['C', '0099']], [105, 0, 99]], [[['A', 'AB']], [103, 33, 34]], [[['A', 'X\x1d1']], [103, 56, 93, 17]], [[['B', 'Q'], ['SHIFT', 'z']], {'error': 'unencodable', 'char': 'z'}]], [[[['B', 'ab'], ['FNC1'], ['SHIFT', 'z']], {'error': 'unencodable', 'char': 'z'}], [[['B', 'Q'], ['A', 'AB'], ['SHIFT', '\x1d'], ['A', 'AB']], {'error': 'unencodable', 'char': '\x1d'}], [[['A', 'AB'], ['A', '_^'], ['SHIFT', 'z'], ['FNC1']], [103, 33, 34, 63, 62, 98, 90, 102]], [[['C', '4711'], ['B', 'ab'], ['A', 'X\x1d1']], [105, 47, 11, 100, 65, 66, 101, 56, 93, 17]], [[['B', 'z~']], [104, 90, 94]], [[['C', ' 1'], ['FNC1'], ['C', ' 1'], ['A', '_^']], {'error': 'bad-c'}], [[['C', ' 1'], ['C', '0099']], {'error': 'bad-c'}], [[['B', '{x}'], ['SHIFT', 'z'], ['SHIFT', '\x1d'], ['A', '\x00Q']], {'error': 'unencodable', 'char': 'z'}]], [[[['A', '\x00Q'], ['SHIFT', 'a']], [103, 64, 49, 98, 65]], [[['C', '12'], ['A', 'AB'], ['A', 'AB'], ['SHIFT', '\x1d']], {'error': 'unencodable', 'char': '\x1d'}], [[['A', 'HELLO'], ['FNC1'], ['SHIFT', 'a']], [103, 40, 37, 44, 44, 47, 102, 98, 65]], [[['B', 'Q']], [104, 49]], [[['A', '\t'], ['C', '0099']], [103, 73, 99, 0, 99]], [[['FNC1'], ['A', 'HELLO']], {'error': 'no-start'}], [[['C', '4711'], ['B', 'Q'], ['B', '{x}']], [105, 47, 11, 100, 49, 91, 88, 93]], [[['B', 'z~'], ['SHIFT', 'a']], {'error': 'unencodable', 'char': 'a'}]]]
labels = ["regression: shift target set", "repair trap", "combined fault", "control", "control", "boundary", "boundary", "control"]
for i, (args, expected) in enumerate(fixtures[N-1]):
    check("%s %d" % (labels[i % len(labels)], i), solve(args), expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
regression: shift target set 0	`{'char': '\t', 'error': 'unencodable'}`	`{'error': 'bad-c'}`	Failed
repair trap 1	`[104, 65, 66, 101, 64, 49, 98, 73, 102]`	`{'char': '\t', 'error': 'unencodable'}`	Failed
combined fault 2	`{'char': 'a', 'error': 'unencodable'}`	`[103, 73, 73, 98, 65]`	Failed
control 3	`[105, 12, 101, 40, 37, 44, 44, 47]`	`[105, 12, 101, 40, 37, 44, 44, 47]`	Passed
control 4	`{'error': 'bad-c'}`	`{'error': 'bad-c'}`	Passed
boundary 5	`{'error': 'bad-c'}`	`{'error': 'bad-c'}`	Passed
boundary 6	`[104, 44, 79, 84, 0, 23, 101, 64, 49, 102, 99, 47, 11]`	`[104, 44, 79, 84, 0, 23, 101, 64, 49, 102, 99, 47, 11]`	Passed
control 7	`{'char': 'a', 'error': 'unencodable'}`	`{'char': '\t', 'error': 'unencodable'}`	Failed

SHA-256 / 8d937d448746cb7233e6a431ecdeca8cd7880423cbfea7a9fd8bead550dc7a93

2 / The unsuccessful fix

Exit 1

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

N = 1
observations = []
def solve(segs):
    out = []
    cur = None
    starts = {'A': 103, 'B': 104, 'C': 105}
    switch = {'A': 101, 'B': 100, 'C': 99}
    def val(s, ch):
        o = ord(ch)
        if s == 'A':
            if 32 <= o <= 95:
                return o - 32
            if 0 <= o <= 31:
                return o + 64
            return None
        if 32 <= o <= 127:
            return o - 32
        return None
    for seg in segs:
        kind = seg[0]
        if kind == 'FNC1':
            if cur is None:
                return {'error': 'no-start'}
            out.append(102)
            continue
        if kind == 'SHIFT':
            if cur not in ('A', 'B'):
                return {'error': 'bad-shift'}
            other = 'A'
            v = val(other, seg[1])
            if v is None:
                return {'error': 'unencodable', 'char': seg[1]}
            out += [98, v]
            continue
        s, text = seg
        if cur is None:
            out.append(starts[s])
        elif s != cur:
            out.append(switch[s])
        cur = s
        if s == 'C':
            if len(text) % 2 or not all(c in '0123456789' for c in text):
                return {'error': 'bad-c'}
            out += [int(text[j:j + 2]) for j in range(0, len(text), 2)]
        else:
            for ch in text:
                v = val(s, ch)
                if v is None:
                    return {'error': 'unencodable', 'char': ch}
                out.append(v)
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[[[['B', '{x}'], ['SHIFT', '\t'], ['C', '1'], ['A', '\x00Q']], {'error': 'bad-c'}], [[['B', 'ab'], ['A', '\x00Q'], ['SHIFT', '\t'], ['FNC1']], {'error': 'unencodable', 'char': '\t'}], [[['A', '\t'], ['A', '\t'], ['SHIFT', 'a']], [103, 73, 73, 98, 65]], [[['C', '12'], ['A', 'HELLO']], [105, 12, 101, 40, 37, 44, 44, 47]], [[['B', 'Q'], ['B', '{x}'], ['C', '123']], {'error': 'bad-c'}], [[['C', '123'], ['FNC1']], {'error': 'bad-c'}], [[['B', 'Lot 7'], ['A', '\x00Q'], ['FNC1'], ['C', '4711']], [104, 44, 79, 84, 0, 23, 101, 64, 49, 102, 99, 47, 11]], [[['A', '\x00Q'], ['SHIFT', 'a'], ['SHIFT', '\t']], {'error': 'unencodable', 'char': '\t'}]], [[[['B', 'z~'], ['SHIFT', 'z'], ['FNC1']], {'error': 'unencodable', 'char': 'z'}], [[['A', 'X\x1d1'], ['SHIFT', '\t'], ['A', 'A`'], ['SHIFT', '\t']], {'error': 'unencodable', 'char': '\t'}], [[['C', '12'], ['A', 'HELLO'], ['SHIFT', '\x1d']], {'error': 'unencodable', 'char': '\x1d'}], [[['C', '1'], ['C', '12']], {'error': 'bad-c'}], [[['A', 'AB'], ['B', 'Q'], ['B', 'z~']], [103, 33, 34, 100, 49, 90, 94]], [[['A', 'AB'], ['FNC1']], [103, 33, 34, 102]], [[['C', ' 1'], ['C', '0099'], ['FNC1'], ['SHIFT', '\x1d']], {'error': 'bad-c'}], [[['A', 'X\x1d1'], ['SHIFT', 'z']], [103, 56, 93, 17, 98, 90]]], [[[['B', '{x}'], ['SHIFT', '\x1d']], [104, 91, 88, 93, 98, 93]], [[['A', 'HELLO'], ['SHIFT', '\t'], ['SHIFT', 'a'], ['A', 'A`']], {'error': 'unencodable', 'char': '\t'}], [[['A', '_^'], ['SHIFT', '\t']], {'error': 'unencodable', 'char': '\t'}], [[['B', 'Lot 7']], [104, 44, 79, 84, 0, 23]], [[['C', '0099']], [105, 0, 99]], [[['A', 'AB']], [103, 33, 34]], [[['A', 'X\x1d1']], [103, 56, 93, 17]], [[['B', 'Q'], ['SHIFT', 'z']], {'error': 'unencodable', 'char': 'z'}]], [[[['B', 'ab'], ['FNC1'], ['SHIFT', 'z']], {'error': 'unencodable', 'char': 'z'}], [[['B', 'Q'], ['A', 'AB'], ['SHIFT', '\x1d'], ['A', 'AB']], {'error': 'unencodable', 'char': '\x1d'}], [[['A', 'AB'], ['A', '_^'], ['SHIFT', 'z'], ['FNC1']], [103, 33, 34, 63, 62, 98, 90, 102]], [[['C', '4711'], ['B', 'ab'], ['A', 'X\x1d1']], [105, 47, 11, 100, 65, 66, 101, 56, 93, 17]], [[['B', 'z~']], [104, 90, 94]], [[['C', ' 1'], ['FNC1'], ['C', ' 1'], ['A', '_^']], {'error': 'bad-c'}], [[['C', ' 1'], ['C', '0099']], {'error': 'bad-c'}], [[['B', '{x}'], ['SHIFT', 'z'], ['SHIFT', '\x1d'], ['A', '\x00Q']], {'error': 'unencodable', 'char': 'z'}]], [[[['A', '\x00Q'], ['SHIFT', 'a']], [103, 64, 49, 98, 65]], [[['C', '12'], ['A', 'AB'], ['A', 'AB'], ['SHIFT', '\x1d']], {'error': 'unencodable', 'char': '\x1d'}], [[['A', 'HELLO'], ['FNC1'], ['SHIFT', 'a']], [103, 40, 37, 44, 44, 47, 102, 98, 65]], [[['B', 'Q']], [104, 49]], [[['A', '\t'], ['C', '0099']], [103, 73, 99, 0, 99]], [[['FNC1'], ['A', 'HELLO']], {'error': 'no-start'}], [[['C', '4711'], ['B', 'Q'], ['B', '{x}']], [105, 47, 11, 100, 49, 91, 88, 93]], [[['B', 'z~'], ['SHIFT', 'a']], {'error': 'unencodable', 'char': 'a'}]]]
labels = ["regression: shift target set", "repair trap", "combined fault", "control", "control", "boundary", "boundary", "control"]
for i, (args, expected) in enumerate(fixtures[N-1]):
    check("%s %d" % (labels[i % len(labels)], i), solve(args), expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
regression: shift target set 0	`{'error': 'bad-c'}`	`{'error': 'bad-c'}`	Passed
repair trap 1	`[104, 65, 66, 101, 64, 49, 98, 73, 102]`	`{'char': '\t', 'error': 'unencodable'}`	Failed
combined fault 2	`{'char': 'a', 'error': 'unencodable'}`	`[103, 73, 73, 98, 65]`	Failed
control 3	`[105, 12, 101, 40, 37, 44, 44, 47]`	`[105, 12, 101, 40, 37, 44, 44, 47]`	Passed
control 4	`{'error': 'bad-c'}`	`{'error': 'bad-c'}`	Passed
boundary 5	`{'error': 'bad-c'}`	`{'error': 'bad-c'}`	Passed
boundary 6	`[104, 44, 79, 84, 0, 23, 101, 64, 49, 102, 99, 47, 11]`	`[104, 44, 79, 84, 0, 23, 101, 64, 49, 102, 99, 47, 11]`	Passed
control 7	`{'char': 'a', 'error': 'unencodable'}`	`{'char': '\t', 'error': 'unencodable'}`	Failed

SHA-256 / f97e16a24fe1a473c35e7ca502f299a4599e47ebb950204c20f93922a2a392eb

3 / The verified repair

Exit 0

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

N = 1
observations = []
def solve(segs):
    out = []
    cur = None
    starts = {'A': 103, 'B': 104, 'C': 105}
    switch = {'A': 101, 'B': 100, 'C': 99}
    def val(s, ch):
        o = ord(ch)
        if s == 'A':
            if 32 <= o <= 95:
                return o - 32
            if 0 <= o <= 31:
                return o + 64
            return None
        if 32 <= o <= 127:
            return o - 32
        return None
    for seg in segs:
        kind = seg[0]
        if kind == 'FNC1':
            if cur is None:
                return {'error': 'no-start'}
            out.append(102)
            continue
        if kind == 'SHIFT':
            if cur not in ('A', 'B'):
                return {'error': 'bad-shift'}
            other = 'B' if cur == 'A' else 'A'
            v = val(other, seg[1])
            if v is None:
                return {'error': 'unencodable', 'char': seg[1]}
            out += [98, v]
            continue
        s, text = seg
        if cur is None:
            out.append(starts[s])
        elif s != cur:
            out.append(switch[s])
        cur = s
        if s == 'C':
            if len(text) % 2 or not all(c in '0123456789' for c in text):
                return {'error': 'bad-c'}
            out += [int(text[j:j + 2]) for j in range(0, len(text), 2)]
        else:
            for ch in text:
                v = val(s, ch)
                if v is None:
                    return {'error': 'unencodable', 'char': ch}
                out.append(v)
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[[[['B', '{x}'], ['SHIFT', '\t'], ['C', '1'], ['A', '\x00Q']], {'error': 'bad-c'}], [[['B', 'ab'], ['A', '\x00Q'], ['SHIFT', '\t'], ['FNC1']], {'error': 'unencodable', 'char': '\t'}], [[['A', '\t'], ['A', '\t'], ['SHIFT', 'a']], [103, 73, 73, 98, 65]], [[['C', '12'], ['A', 'HELLO']], [105, 12, 101, 40, 37, 44, 44, 47]], [[['B', 'Q'], ['B', '{x}'], ['C', '123']], {'error': 'bad-c'}], [[['C', '123'], ['FNC1']], {'error': 'bad-c'}], [[['B', 'Lot 7'], ['A', '\x00Q'], ['FNC1'], ['C', '4711']], [104, 44, 79, 84, 0, 23, 101, 64, 49, 102, 99, 47, 11]], [[['A', '\x00Q'], ['SHIFT', 'a'], ['SHIFT', '\t']], {'error': 'unencodable', 'char': '\t'}]], [[[['B', 'z~'], ['SHIFT', 'z'], ['FNC1']], {'error': 'unencodable', 'char': 'z'}], [[['A', 'X\x1d1'], ['SHIFT', '\t'], ['A', 'A`'], ['SHIFT', '\t']], {'error': 'unencodable', 'char': '\t'}], [[['C', '12'], ['A', 'HELLO'], ['SHIFT', '\x1d']], {'error': 'unencodable', 'char': '\x1d'}], [[['C', '1'], ['C', '12']], {'error': 'bad-c'}], [[['A', 'AB'], ['B', 'Q'], ['B', 'z~']], [103, 33, 34, 100, 49, 90, 94]], [[['A', 'AB'], ['FNC1']], [103, 33, 34, 102]], [[['C', ' 1'], ['C', '0099'], ['FNC1'], ['SHIFT', '\x1d']], {'error': 'bad-c'}], [[['A', 'X\x1d1'], ['SHIFT', 'z']], [103, 56, 93, 17, 98, 90]]], [[[['B', '{x}'], ['SHIFT', '\x1d']], [104, 91, 88, 93, 98, 93]], [[['A', 'HELLO'], ['SHIFT', '\t'], ['SHIFT', 'a'], ['A', 'A`']], {'error': 'unencodable', 'char': '\t'}], [[['A', '_^'], ['SHIFT', '\t']], {'error': 'unencodable', 'char': '\t'}], [[['B', 'Lot 7']], [104, 44, 79, 84, 0, 23]], [[['C', '0099']], [105, 0, 99]], [[['A', 'AB']], [103, 33, 34]], [[['A', 'X\x1d1']], [103, 56, 93, 17]], [[['B', 'Q'], ['SHIFT', 'z']], {'error': 'unencodable', 'char': 'z'}]], [[[['B', 'ab'], ['FNC1'], ['SHIFT', 'z']], {'error': 'unencodable', 'char': 'z'}], [[['B', 'Q'], ['A', 'AB'], ['SHIFT', '\x1d'], ['A', 'AB']], {'error': 'unencodable', 'char': '\x1d'}], [[['A', 'AB'], ['A', '_^'], ['SHIFT', 'z'], ['FNC1']], [103, 33, 34, 63, 62, 98, 90, 102]], [[['C', '4711'], ['B', 'ab'], ['A', 'X\x1d1']], [105, 47, 11, 100, 65, 66, 101, 56, 93, 17]], [[['B', 'z~']], [104, 90, 94]], [[['C', ' 1'], ['FNC1'], ['C', ' 1'], ['A', '_^']], {'error': 'bad-c'}], [[['C', ' 1'], ['C', '0099']], {'error': 'bad-c'}], [[['B', '{x}'], ['SHIFT', 'z'], ['SHIFT', '\x1d'], ['A', '\x00Q']], {'error': 'unencodable', 'char': 'z'}]], [[[['A', '\x00Q'], ['SHIFT', 'a']], [103, 64, 49, 98, 65]], [[['C', '12'], ['A', 'AB'], ['A', 'AB'], ['SHIFT', '\x1d']], {'error': 'unencodable', 'char': '\x1d'}], [[['A', 'HELLO'], ['FNC1'], ['SHIFT', 'a']], [103, 40, 37, 44, 44, 47, 102, 98, 65]], [[['B', 'Q']], [104, 49]], [[['A', '\t'], ['C', '0099']], [103, 73, 99, 0, 99]], [[['FNC1'], ['A', 'HELLO']], {'error': 'no-start'}], [[['C', '4711'], ['B', 'Q'], ['B', '{x}']], [105, 47, 11, 100, 49, 91, 88, 93]], [[['B', 'z~'], ['SHIFT', 'a']], {'error': 'unencodable', 'char': 'a'}]]]
labels = ["regression: shift target set", "repair trap", "combined fault", "control", "control", "boundary", "boundary", "control"]
for i, (args, expected) in enumerate(fixtures[N-1]):
    check("%s %d" % (labels[i % len(labels)], i), solve(args), expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
regression: shift target set 0	`{'error': 'bad-c'}`	`{'error': 'bad-c'}`	Passed
repair trap 1	`{'char': '\t', 'error': 'unencodable'}`	`{'char': '\t', 'error': 'unencodable'}`	Passed
combined fault 2	`[103, 73, 73, 98, 65]`	`[103, 73, 73, 98, 65]`	Passed
control 3	`[105, 12, 101, 40, 37, 44, 44, 47]`	`[105, 12, 101, 40, 37, 44, 44, 47]`	Passed
control 4	`{'error': 'bad-c'}`	`{'error': 'bad-c'}`	Passed
boundary 5	`{'error': 'bad-c'}`	`{'error': 'bad-c'}`	Passed
boundary 6	`[104, 44, 79, 84, 0, 23, 101, 64, 49, 102, 99, 47, 11]`	`[104, 44, 79, 84, 0, 23, 101, 64, 49, 102, 99, 47, 11]`	Passed
control 7	`{'char': '\t', 'error': 'unencodable'}`	`{'char': '\t', 'error': 'unencodable'}`	Passed

SHA-256 / efaa80897642f43db735decfd89c21b631b9143aea3c048ad33ce8bb973e981a

Verification & scope

A deterministic bounded teaching model with a stipulated contract; it makes no claim of conformance to any published specification. 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:49:44.476678+00:00.

Case digest / a0ce625df22f942d12078e6d00262b02167a009dcd78c95eea39d8a3586c371b