# Evidence: Block 3 · Service (block-3)

- block type: block
- date: 2026-08-16
- resulting state: closed/verified
- story points (combined assembled cost): 8020
- execution id: 20260816.123439.459Z-c6e09f01

## Stories built
- Parse TOML basic, literal, and multiline string values. (parser-strings) [story]
- Parse TOML key forms and enforce key-definition semantics. (parser-keys) [story]

## Acceptance tooling authorization
- FEATURE-Keys.md#keys-valid: executable=go; scope=test; authorization=existing Target environment
- FEATURE-Keys.md#keys-invalid: executable=go; scope=test; authorization=existing Target environment

## Reusable compacts
- stage_test_compact.md

## Missing context
- context: toml-v1.0.0.md

## Stacked context
- compass: COMPASS.md (SP 2942)
- implements: FEATURE-Strings.md (SP 556)
- context: stage_test.sh (SP 161)
- context: ARCHITECTURE_compact.md (SP 123)
- stack: go.md (SP 3646)
- implements: FEATURE-Keys.md (SP 477)

## Build directory changes
- internal/toml/toml.go
- internal/toml/toml_test.go
- toml-decoder

## Pre-build acceptance observation
- RED: strings-valid-suite (FEATURE-Strings.md)
  intent: The authoritative conformance suite passes every valid string case owned by this feature.
  return code: 1
  stdout:
    FAIL valid/string/ends-in-whitespace-escape
         line 1: invalid string: invalid syntax
     
         Exit 1
    
         input sent to parser-cmd (PID 1666750):
            1 │ beee = """
            2 │ heeee
            3 │ geeee\
            4 │
            5 │
            6 │       """
    
         output from parser-cmd (PID 1666750) (stderr):
            1 │ line 1: invalid string: invalid syntax
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/escape-tricky
         line 4: invalid string: invalid syntax
     
         Exit 1
    
         input sent to parser-cmd (PID 1666787):
            1 │ end_esc = "String does not end here\" but ends here\\"
            2 │ lit_end_esc = 'String ends here\'
            3 │
            4 │ multiline_unicode = """
            5 │ \u00a0"""
            6 │
            7 │ multiline_not_unicode = """
            8 │ \\u0041"""
            9 │
           10 │ multiline_end_esc = """When will it end? \"""...""\" should be here\""""
           11 │
           12 │ lit_multiline_not_unicode = '''
           13 │ \u007f'''
           14 │
           15 │ lit_multiline_end = '''There is no escape\'''
    
         output from parser-cmd (PID 1666787) (stderr):
            1 │ line 4: invalid string: invalid syntax
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/multibyte
         line 6: invalid string: invalid syntax
     
         Exit 1
    
         input sent to parser-cmd (PID 1666813):
            1 │ # Test each multibyte length: 2, 3, and 4 bytes:
            2 │ # ɑ € 𐫱
            3 │
            4 │ basic    = "ɑ € 𐫱 ɑ€𐫱"
            5 │ raw      = 'ɑ € 𐫱 ɑ€𐫱'
            6 │ ml-basic = """ɑ € 𐫱 ɑ€𐫱"""
            7 │ ml-raw   = '''ɑ € 𐫱 ɑ€𐫱'''
    
         output from parser-cmd (PID 1666813) (stderr):
            1 │ line 6: invalid string: invalid syntax
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/multibyte-escape
         line 5: invalid string: invalid syntax
     
         Exit 1
    
         input sent to parser-cmd (PID 1666727):
            1 │ # Test each multibyte length: 2, 3, and 4 bytes:
            2 │ # ɑ € 𐫱
            3 │
            4 │ basic-1    = "\u0251 \u20ac \U00010AF1 \u0251\u20ac\U00010AF1"
            5 │ ml-basic-1 = """\u0251 \u20ac \U00010AF1 \u0251\u20ac\U00010AF1"""
            6 │
            7 │ # Again, but only using \U
            8 │ basic-2    = "\U00000251 \U000020ac \U00010AF1 \U00000251\U000020ac\U00010AF1"
            9 │ ml-basic-2 = """\U00000251 \U000020ac \U00010AF1 \U00000251\U000020ac\U00010AF1"""
    
         output from parser-cmd (PID 1666727) (stderr):
            1 │ line 5: invalid string: invalid syntax
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/multiline
         line 4: invalid string: invalid syntax
     
         Exit 1
    
         input sent to parser-cmd (PID 1666783):
            1 │ # NOTE: this file includes some literal tab characters.
            2 │
            3 │ equivalent_one = "The quick brown fox jumps over the lazy dog."
            4 │ equivalent_two = """
            5 │ The quick brown \
            6 │
            7 │
            8 │   fox jumps over \
            9 │     the lazy dog."""
           10 │
           11 │ equivalent_three = """\
           12 │        The quick brown \
           13 │        fox jumps over \
           14 │        the lazy dog.\
           15 │        """
           16 │
           17 │ whitespace-after-bs = """\
           18 │        The quick brown \
           19 │        fox jumps over \
           20 │        the lazy dog.\
           21 │        """
           22 │
           23 │ no-space = """a\
           24 │     b"""
           25 │
           26 │ # Has tab character.
           27 │ keep-ws-before = """a   	\
           28 │    b"""
           29 │
           30 │ escape-bs-1 = """a \\
           31 │ b"""
           32 │
           33 │ escape-bs-2 = """a \\\
           34 │ b"""
           35 │
           36 │ escape-bs-3 = """a \\\\
           37 │   b"""
    
         output from parser-cmd (PID 1666783) (stderr):
            1 │ line 4: invalid string: invalid syntax
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/multiline-empty
         line 1: invalid string: invalid syntax
     
         Exit 1
    
         input sent to parser-cmd (PID 1666817):
            1 │ empty-1 = """"""
            2 │
            3 │ # A newline immediately following the opening delimiter will be trimmed.
            4 │ empty-2 = """
            5 │ """
            6 │
            7 │ # \ at the end of line trims newlines as well; note that last \ is followed by
            8 │ # two spaces, which are ignored.
            9 │ empty-3 = """\
           10 │     """
           11 │ empty-4 = """\
           12 │    \
           13 │    \
           14 │    """
    
         output from parser-cmd (PID 1666817) (stderr):
            1 │ line 1: invalid string: invalid syntax
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/multiline-escaped-crlf
         line 3: invalid value "\"\"\"\\"
     
         Exit 1
    
         input sent to parser-cmd (PID 1666746):
            1 │ # The following line should be an unescaped backslash followed by a Windows
            2 │ # newline sequence ("\r\n")
            3 │ 0="""\
            4 │ """
    
         output from parser-cmd (PID 1666746) (stderr):
            1 │ line 3: invalid value "\"\"\"\\"
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/multiline-quotes
         line 9: invalid string: invalid syntax
     
         Exit 1
    
         input sent to parser-cmd (PID 1666816):
            1 │ # Make sure that quotes inside multiline strings are allowed, including right
            2 │ # after the opening '''/""" and before the closing '''/"""
            3 │
            4 │ lit_one = ''''one quote''''
            5 │ lit_two = '''''two quotes'''''
            6 │ lit_one_space = ''' 'one quote' '''
            7 │ lit_two_space = ''' ''two quotes'' '''
            8 │
            9 │ one = """"one quote""""
           10 │ two = """""two quotes"""""
           11 │ one_space = """ "one quote" """
           12 │ two_space = """ ""two quotes"" """
           13 │
           14 │ mismatch1 = """aaa'''bbb"""
           15 │ mismatch2 = '''aaa"""bbb'''
           16 │
           17 │ # Three opening """, then one escaped ", then two "" (allowed), and then three
           18 │ # closing """
           19 │ escaped = """lol\""""""
           20 │
           21 │ five-quotes = """
           22 │ Closing with five quotes
           23 │ """""
           24 │ four-quotes = """
           25 │ Closing with four quotes
           26 │ """"
    
         output from parser-cmd (PID 1666816) (stderr):
            1 │ line 9: invalid string: invalid syntax
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/nl
         line 2: invalid string: invalid syntax
     
         Exit 1
    
         input sent to parser-cmd (PID 1666749):
            1 │ nl_mid = "val\nue"
            2 │ nl_end = """value\n"""
            3 │
            4 │ lit_nl_end = '''value\n'''
            5 │ lit_nl_mid = 'val\nue'
            6 │ lit_nl_uni = 'val\ue'
    
         output from parser-cmd (PID 1666749) (stderr):
            1 │ line 2: invalid string: invalid syntax
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/raw-multiline
         line 6: expected key-value pair
     
         Exit 1
    
         input sent to parser-cmd (PID 1666786):
            1 │ # Single ' should be allowed.
            2 │ oneline = '''This string has a ' quote character.'''
            3 │
            4 │ # A newline immediately following the opening delimiter will be trimmed.
            5 │ firstnl = '''
            6 │ This string has a ' quote character.'''
            7 │
            8 │ # All other whitespace and newline characters remain intact.
            9 │ multiline = '''
           10 │ This string
           11 │ has ' a quote character
           12 │ and more than
           13 │ one newline
           14 │ in it.'''
           15 │
           16 │ # Tab character in literal string does not need to be escaped
           17 │ multiline_with_tab = '''First line
           18 │ 	 Followed by a tab'''
           19 │
           20 │ this-str-has-apostrophes='''' there's one already
           21 │ '' two more
           22 │ '''''
    
         output from parser-cmd (PID 1666786) (stderr):
            1 │ line 6: expected key-value pair
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/start-mb
         line 6: invalid value "\"\"\"\\"
     
         Exit 1
    
         input sent to parser-cmd (PID 1666782):
            1 │ # Start first line with a multibyte character.
            2 │ #
            3 │ # https://github.com/marzer/tomlplusplus/issues/190
            4 │ s1 = "§"
            5 │ s2 = '§'
            6 │ s3 = """\
            7 │ §"""
            8 │ s4 = """
            9 │ §"""
           10 │ s5 = """§"""
           11 │ s6 = '''
           12 │ §'''
           13 │ s7 = '''§'''
    
         output from parser-cmd (PID 1666782) (stderr):
            1 │ line 6: invalid value "\"\"\"\\"
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/unicode-escape
         line 9: invalid string: invalid syntax
     
         Exit 1
    
         input sent to parser-cmd (PID 1666812):
            1 │ delta-1 = "\u03B4"
            2 │ delta-2 = "\U000003B4"
            3 │ a       = "\u0061"
            4 │ b       = "\u0062"
            5 │ c       = "\U00000063"
            6 │ null-1  = "\u0000"
            7 │ null-2  = "\U00000000"
            8 │
            9 │ ml-delta-1 = """\u03B4"""
           10 │ ml-delta-2 = """\U000003B4"""
           11 │ ml-a       = """\u0061"""
           12 │ ml-b       = """\u0062"""
           13 │ ml-c       = """\U00000063"""
           14 │ ml-null-1  = """\u0000"""
           15 │ ml-null-2  = """\U00000000"""
    
         output from parser-cmd (PID 1666812) (stderr):
            1 │ line 9: invalid string: invalid syntax
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/with-pound
         line 1: invalid value "\"We see no"
     
         Exit 1
    
         input sent to parser-cmd (PID 1666726):
            1 │ pound = "We see no # comments here."
            2 │ poundcomment = "But there are # some comments here." # Did I # mess you up?
    
         output from parser-cmd (PID 1666726) (stderr):
            1 │ line 1: invalid value "\"We see no"
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    toml-test v2.2.0 [/mnt/c/Users/barlo/projects/drydock/uat/Toml/runs/20260816.121804/build/toml/toml-decoder] [no encoder]
    skipped tests: 861
      valid tests:  10 passed, 13 failed
    encoder tests: no encoder command given
    invalid tests:   0 passed,  0 failed
    
    harness: /home/barlo/.local/bin/toml-test toml-test v2.2.0; go1.24.6 linux/amd64; race=false; cgo=true
  stderr:
    --- drydock: values at failure ---
      result = CompletedProcess(args=['sh', 'sources/stage_test.sh', 'valid/string/**'], returncode=1, stdout='FAIL valid/string/ends-in-whitespace-escape\n     line 1: invalid string: invalid syntax\n \n     Exit 1\n\n     input sent to parser-cmd (PID 1666750):\n        1 │\x1b[0m beee = """\n        2 │\x1b[0m heeee\n        3 │\x1b[0m geeee\\\n        4 │\x1b[0m\n        5 │\x1b[0m\n        6 │\x1b[0m       … (+12018 chars)
    --- drydock: end values ---
    Traceback (most recent call last):
      File "strings-valid-suite.py", line 10, in <module>
        assert result.returncode == 0
               ^^^^^^^^^^^^^^^^^^^^^^
    AssertionError
- RED: strings-invalid-suite (FEATURE-Strings.md)
  intent: The authoritative conformance suite rejects every invalid string case owned by this feature.
  return code: 1
  stdout:
    FAIL invalid/string/bad-escape-01
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1667198):
            1 │ invalid-escape = "This string has a bad \a escape character."
    
         output from parser-cmd (PID 1667198) (stdout):
            1 │ {
            2 │   "invalid-escape": {"type": "string", "value": "This string has a bad \u0007 escape character."}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/basic-byte-escapes
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1667131):
            1 │ answer = "\x33"
    
         output from parser-cmd (PID 1667131) (stdout):
            1 │ {
            2 │   "answer": {"type": "string", "value": "3"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/literal-multiline-quotes-01
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1667199):
            1 │ a = '''6 apostrophes: ''''''
    
         output from parser-cmd (PID 1667199) (stdout):
            1 │ {
            2 │   "a": {"type": "string", "value": "''6 apostrophes: '''''"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/literal-multiline-quotes-02
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1667361):
            1 │ a = '''15 apostrophes: ''''''''''''''''''
    
         output from parser-cmd (PID 1667361) (stdout):
            1 │ {
            2 │   "a": {"type": "string", "value": "''15 apostrophes: '''''''''''''''''"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/multiline-lit-no-close-02
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1667258):
            1 │ x='''
    
         output from parser-cmd (PID 1667258) (stdout):
            1 │ {
            2 │   "x": {"type": "string", "value": "'"}
            3 │ }
    
         want:
           Exit code 1
    
    toml-test v2.2.0 [/mnt/c/Users/barlo/projects/drydock/uat/Toml/runs/20260816.121804/build/toml/toml-decoder] [no encoder]
    skipped tests: 807
      valid tests:   0 passed,  0 failed
    encoder tests: no encoder command given
    invalid tests:  72 passed,  5 failed
    
    harness: /home/barlo/.local/bin/toml-test toml-test v2.2.0; go1.24.6 linux/amd64; race=false; cgo=true
  stderr:
    --- drydock: values at failure ---
      result = CompletedProcess(args=['sh', 'sources/stage_test.sh', 'invalid/string/**'], returncode=1, stdout='FAIL invalid/string/bad-escape-01\n     Expected an error, but no error was reported.\n\n     input sent to parser-cmd (PID 1667198):\n        1 │\x1b[0m invalid-escape = "This string has a bad \\a escape character."\n\n     output from parser-cmd (PID 1667198) (stdout):\n        1 │\x1b[0m {\n       … (+2206 chars)
    --- drydock: end values ---
    Traceback (most recent call last):
      File "strings-invalid-suite.py", line 10, in <module>
        assert result.returncode == 0
               ^^^^^^^^^^^^^^^^^^^^^^
    AssertionError
- RED: strings-bounded-suites (FEATURE-Strings.md)
  intent: Both string conformance invocations complete successfully as separate executable checks.
  return code: 1
  stdout:
    FAIL valid/string/ends-in-whitespace-escape
         line 1: invalid string: invalid syntax
     
         Exit 1
    
         input sent to parser-cmd (PID 1667702):
            1 │ beee = """
            2 │ heeee
            3 │ geeee\
            4 │
            5 │
            6 │       """
    
         output from parser-cmd (PID 1667702) (stderr):
            1 │ line 1: invalid string: invalid syntax
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/escape-tricky
         line 4: invalid string: invalid syntax
     
         Exit 1
    
         input sent to parser-cmd (PID 1667631):
            1 │ end_esc = "String does not end here\" but ends here\\"
            2 │ lit_end_esc = 'String ends here\'
            3 │
            4 │ multiline_unicode = """
            5 │ \u00a0"""
            6 │
            7 │ multiline_not_unicode = """
            8 │ \\u0041"""
            9 │
           10 │ multiline_end_esc = """When will it end? \"""...""\" should be here\""""
           11 │
           12 │ lit_multiline_not_unicode = '''
           13 │ \u007f'''
           14 │
           15 │ lit_multiline_end = '''There is no escape\'''
    
         output from parser-cmd (PID 1667631) (stderr):
            1 │ line 4: invalid string: invalid syntax
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/multibyte
         line 6: invalid string: invalid syntax
     
         Exit 1
    
         input sent to parser-cmd (PID 1667698):
            1 │ # Test each multibyte length: 2, 3, and 4 bytes:
            2 │ # ɑ € 𐫱
            3 │
            4 │ basic    = "ɑ € 𐫱 ɑ€𐫱"
            5 │ raw      = 'ɑ € 𐫱 ɑ€𐫱'
            6 │ ml-basic = """ɑ € 𐫱 ɑ€𐫱"""
            7 │ ml-raw   = '''ɑ € 𐫱 ɑ€𐫱'''
    
         output from parser-cmd (PID 1667698) (stderr):
            1 │ line 6: invalid string: invalid syntax
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/multibyte-escape
         line 5: invalid string: invalid syntax
     
         Exit 1
    
         input sent to parser-cmd (PID 1667660):
            1 │ # Test each multibyte length: 2, 3, and 4 bytes:
            2 │ # ɑ € 𐫱
            3 │
            4 │ basic-1    = "\u0251 \u20ac \U00010AF1 \u0251\u20ac\U00010AF1"
            5 │ ml-basic-1 = """\u0251 \u20ac \U00010AF1 \u0251\u20ac\U00010AF1"""
            6 │
            7 │ # Again, but only using \U
            8 │ basic-2    = "\U00000251 \U000020ac \U00010AF1 \U00000251\U000020ac\U00010AF1"
            9 │ ml-basic-2 = """\U00000251 \U000020ac \U00010AF1 \U00000251\U000020ac\U00010AF1"""
    
         output from parser-cmd (PID 1667660) (stderr):
            1 │ line 5: invalid string: invalid syntax
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/multiline
         line 4: invalid string: invalid syntax
     
         Exit 1
    
         input sent to parser-cmd (PID 1667695):
            1 │ # NOTE: this file includes some literal tab characters.
            2 │
            3 │ equivalent_one = "The quick brown fox jumps over the lazy dog."
            4 │ equivalent_two = """
            5 │ The quick brown \
            6 │
            7 │
            8 │   fox jumps over \
            9 │     the lazy dog."""
           10 │
           11 │ equivalent_three = """\
           12 │        The quick brown \
           13 │        fox jumps over \
           14 │        the lazy dog.\
           15 │        """
           16 │
           17 │ whitespace-after-bs = """\
           18 │        The quick brown \
           19 │        fox jumps over \
           20 │        the lazy dog.\
           21 │        """
           22 │
           23 │ no-space = """a\
           24 │     b"""
           25 │
           26 │ # Has tab character.
           27 │ keep-ws-before = """a   	\
           28 │    b"""
           29 │
           30 │ escape-bs-1 = """a \\
           31 │ b"""
           32 │
           33 │ escape-bs-2 = """a \\\
           34 │ b"""
           35 │
           36 │ escape-bs-3 = """a \\\\
           37 │   b"""
    
         output from parser-cmd (PID 1667695) (stderr):
            1 │ line 4: invalid string: invalid syntax
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/multiline-empty
         line 1: invalid string: invalid syntax
     
         Exit 1
    
         input sent to parser-cmd (PID 1667697):
            1 │ empty-1 = """"""
            2 │
            3 │ # A newline immediately following the opening delimiter will be trimmed.
            4 │ empty-2 = """
            5 │ """
            6 │
            7 │ # \ at the end of line trims newlines as well; note that last \ is followed by
            8 │ # two spaces, which are ignored.
            9 │ empty-3 = """\
           10 │     """
           11 │ empty-4 = """\
           12 │    \
           13 │    \
           14 │    """
    
         output from parser-cmd (PID 1667697) (stderr):
            1 │ line 1: invalid string: invalid syntax
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/multiline-escaped-crlf
         line 3: invalid value "\"\"\"\\"
     
         Exit 1
    
         input sent to parser-cmd (PID 1667696):
            1 │ # The following line should be an unescaped backslash followed by a Windows
            2 │ # newline sequence ("\r\n")
            3 │ 0="""\
            4 │ """
    
         output from parser-cmd (PID 1667696) (stderr):
            1 │ line 3: invalid value "\"\"\"\\"
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/multiline-quotes
         line 9: invalid string: invalid syntax
     
         Exit 1
    
         input sent to parser-cmd (PID 1667659):
            1 │ # Make sure that quotes inside multiline strings are allowed, including right
            2 │ # after the opening '''/""" and before the closing '''/"""
            3 │
            4 │ lit_one = ''''one quote''''
            5 │ lit_two = '''''two quotes'''''
            6 │ lit_one_space = ''' 'one quote' '''
            7 │ lit_two_space = ''' ''two quotes'' '''
            8 │
            9 │ one = """"one quote""""
           10 │ two = """""two quotes"""""
           11 │ one_space = """ "one quote" """
           12 │ two_space = """ ""two quotes"" """
           13 │
           14 │ mismatch1 = """aaa'''bbb"""
           15 │ mismatch2 = '''aaa"""bbb'''
           16 │
           17 │ # Three opening """, then one escaped ", then two "" (allowed), and then three
           18 │ # closing """
           19 │ escaped = """lol\""""""
           20 │
           21 │ five-quotes = """
           22 │ Closing with five quotes
           23 │ """""
           24 │ four-quotes = """
           25 │ Closing with four quotes
           26 │ """"
    
         output from parser-cmd (PID 1667659) (stderr):
            1 │ line 9: invalid string: invalid syntax
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/nl
         line 2: invalid string: invalid syntax
     
         Exit 1
    
         input sent to parser-cmd (PID 1667704):
            1 │ nl_mid = "val\nue"
            2 │ nl_end = """value\n"""
            3 │
            4 │ lit_nl_end = '''value\n'''
            5 │ lit_nl_mid = 'val\nue'
            6 │ lit_nl_uni = 'val\ue'
    
         output from parser-cmd (PID 1667704) (stderr):
            1 │ line 2: invalid string: invalid syntax
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/raw-multiline
         line 6: expected key-value pair
     
         Exit 1
    
         input sent to parser-cmd (PID 1667699):
            1 │ # Single ' should be allowed.
            2 │ oneline = '''This string has a ' quote character.'''
            3 │
            4 │ # A newline immediately following the opening delimiter will be trimmed.
            5 │ firstnl = '''
            6 │ This string has a ' quote character.'''
            7 │
            8 │ # All other whitespace and newline characters remain intact.
            9 │ multiline = '''
           10 │ This string
           11 │ has ' a quote character
           12 │ and more than
           13 │ one newline
           14 │ in it.'''
           15 │
           16 │ # Tab character in literal string does not need to be escaped
           17 │ multiline_with_tab = '''First line
           18 │ 	 Followed by a tab'''
           19 │
           20 │ this-str-has-apostrophes='''' there's one already
           21 │ '' two more
           22 │ '''''
    
         output from parser-cmd (PID 1667699) (stderr):
            1 │ line 6: expected key-value pair
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/start-mb
         line 6: invalid value "\"\"\"\\"
     
         Exit 1
    
         input sent to parser-cmd (PID 1667662):
            1 │ # Start first line with a multibyte character.
            2 │ #
            3 │ # https://github.com/marzer/tomlplusplus/issues/190
            4 │ s1 = "§"
            5 │ s2 = '§'
            6 │ s3 = """\
            7 │ §"""
            8 │ s4 = """
            9 │ §"""
           10 │ s5 = """§"""
           11 │ s6 = '''
           12 │ §'''
           13 │ s7 = '''§'''
    
         output from parser-cmd (PID 1667662) (stderr):
            1 │ line 6: invalid value "\"\"\"\\"
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/unicode-escape
         line 9: invalid string: invalid syntax
     
         Exit 1
    
         input sent to parser-cmd (PID 1667663):
            1 │ delta-1 = "\u03B4"
            2 │ delta-2 = "\U000003B4"
            3 │ a       = "\u0061"
            4 │ b       = "\u0062"
            5 │ c       = "\U00000063"
            6 │ null-1  = "\u0000"
            7 │ null-2  = "\U00000000"
            8 │
            9 │ ml-delta-1 = """\u03B4"""
           10 │ ml-delta-2 = """\U000003B4"""
           11 │ ml-a       = """\u0061"""
           12 │ ml-b       = """\u0062"""
           13 │ ml-c       = """\U00000063"""
           14 │ ml-null-1  = """\u0000"""
           15 │ ml-null-2  = """\U00000000"""
    
         output from parser-cmd (PID 1667663) (stderr):
            1 │ line 9: invalid string: invalid syntax
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/with-pound
         line 1: invalid value "\"We see no"
     
         Exit 1
    
         input sent to parser-cmd (PID 1667630):
            1 │ pound = "We see no # comments here."
            2 │ poundcomment = "But there are # some comments here." # Did I # mess you up?
    
         output from parser-cmd (PID 1667630) (stderr):
            1 │ line 1: invalid value "\"We see no"
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    toml-test v2.2.0 [/mnt/c/Users/barlo/projects/drydock/uat/Toml/runs/20260816.121804/build/toml/toml-decoder] [no encoder]
    skipped tests: 861
      valid tests:  10 passed, 13 failed
    encoder tests: no encoder command given
    invalid tests:   0 passed,  0 failed
    
    harness: /home/barlo/.local/bin/toml-test toml-test v2.2.0; go1.24.6 linux/amd64; race=false; cgo=true
  stderr:
    --- drydock: values at failure ---
      result = CompletedProcess(args=['sh', 'sources/stage_test.sh', 'valid/string/**'], returncode=1, stdout='FAIL valid/string/ends-in-whitespace-escape\n     line 1: invalid string: invalid syntax\n \n     Exit 1\n\n     input sent to parser-cmd (PID 1667702):\n        1 │\x1b[0m beee = """\n        2 │\x1b[0m heeee\n        3 │\x1b[0m geeee\\\n        4 │\x1b[0m\n        5 │\x1b[0m\n        6 │\x1b[0m       … (+12018 chars)
    --- drydock: end values ---
    Traceback (most recent call last):
      File "strings-bounded-suites.py", line 12, in <module>
        assert result.returncode == 0
               ^^^^^^^^^^^^^^^^^^^^^^
    AssertionError
- RED: keys-valid (FEATURE-Keys.md)
  intent: The decoder passes all authoritative valid TOML key cases owned by this feature.
  return code: 1
  stdout:
    FAIL valid/key/alphanum
         line 10: tables are not supported yet
     
         Exit 1
    
         input sent to parser-cmd (PID 1667968):
            1 │ alpha = "a"
            2 │ 123 = "num"
            3 │ 000111 = "leading"
            4 │ 10e3 = "false float"
            5 │ one1two2 = "mixed"
            6 │ with-dash = "dashed"
            7 │ under_score = "___"
            8 │ 34-11 = 23
            9 │
           10 │ [2018_10]
           11 │ 001 = 1
           12 │
           13 │ [a-a-a]
           14 │ _ = false
    
         output from parser-cmd (PID 1667968) (stderr):
            1 │ line 10: tables are not supported yet
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/key/case-sensitive
         line 3: tables are not supported yet
     
         Exit 1
    
         input sent to parser-cmd (PID 1667974):
            1 │ sectioN = "NN"
            2 │
            3 │ [section]
            4 │ name = "lower"
            5 │ NAME = "upper"
            6 │ Name = "capitalized"
            7 │
            8 │ [Section]
            9 │ name = "different section!!"
           10 │ "μ" = "greek small letter mu"
           11 │ "Μ" = "greek capital letter MU"
           12 │ M = "latin letter M"
    
         output from parser-cmd (PID 1667974) (stderr):
            1 │ line 3: tables are not supported yet
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/key/dotted-01
         Could not find key "many" in parser output.
    
         input sent to parser-cmd (PID 1667973):
            1 │ name.first = "Arthur"
            2 │ "name".'last' = "Dent"
            3 │
            4 │ many.dots.dot.dot.dot = 42
    
         output from parser-cmd (PID 1667973) (stdout):
            1 │ {
            2 │   "\"name\".'last'":       {"type": "string", "value": "Dent"},
            3 │   "many.dots.dot.dot.dot": {"type": "integer", "value": "42"},
            4 │   "name.first":            {"type": "string", "value": "Arthur"}
            5 │ }
    
         want:
            1 │ {
            2 │     "many": {
            3 │         "dots": {
            4 │             "dot": {
            5 │                 "dot": {
            6 │                     "dot": {"type": "integer", "value": "42"}
            7 │                 }
            8 │             }
            9 │         }
           10 │     },
           11 │     "name": {
           12 │         "first": {"type": "string", "value": "Arthur"},
           13 │         "last":  {"type": "string", "value": "Dent"}
           14 │     }
           15 │ }
    
    FAIL valid/key/dotted-02
         Could not find key "count" in parser output.
    
         input sent to parser-cmd (PID 1667889):
            1 │ # Note: this file contains literal tab characters.
            2 │
            3 │ # Space are ignored, and key parts can be quoted.
            4 │ count.a       = 1
            5 │ count . b     = 2
            6 │ "count"."c"   = 3
            7 │ "count" . "d" = 4
            8 │ 'count'.'e'   = 5
            9 │ 'count' . 'f' = 6
           10 │ "count".'g'   = 7
           11 │ "count" . 'h' = 8
           12 │ count.'i'     = 9
           13 │ count 	.	 'j'	   = 10
           14 │ "count".k     = 11
           15 │ "count" . l   = 12
    
         output from parser-cmd (PID 1667889) (stdout):
            1 │ {
            2 │   "\"count\" . \"d\"": {"type": "integer", "value": "4"},
            3 │   "\"count\" . 'h'": {"type": "integer", "value": "8"},
            4 │   "\"count\" . l":   {"type": "integer", "value": "12"},
            5 │   "\"count\".\"c\"": {"type": "integer", "value": "3"},
            6 │   "\"count\".'g'":   {"type": "integer", "value": "7"},
            7 │   "\"count\".k":     {"type": "integer", "value": "11"},
            8 │   "'count' . 'f'":   {"type": "integer", "value": "6"},
            9 │   "'count'.'e'":     {"type": "integer", "value": "5"},
           10 │   "count \t.\t 'j'": {"type": "integer", "value": "10"},
           11 │   "count . b":       {"type": "integer", "value": "2"},
           12 │   "count.'i'":       {"type": "integer", "value": "9"},
           13 │   "count.a":         {"type": "integer", "value": "1"}
           14 │ }
    
         want:
            1 │ {
            2 │     "count": {
            3 │         "a": {"type": "integer", "value": "1"},
            4 │         "b": {"type": "integer", "value": "2"},
            5 │         "c": {"type": "integer", "value": "3"},
            6 │         "d": {"type": "integer", "value": "4"},
            7 │         "e": {"type": "integer", "value": "5"},
            8 │         "f": {"type": "integer", "value": "6"},
            9 │         "g": {"type": "integer", "value": "7"},
           10 │         "h": {"type": "integer", "value": "8"},
           11 │         "i": {"type": "integer", "value": "9"},
           12 │         "j": {"type": "integer", "value": "10"},
           13 │         "k": {"type": "integer", "value": "11"},
           14 │         "l": {"type": "integer", "value": "12"}
           15 │     }
           16 │ }
    
    FAIL valid/key/dotted-03
         line 3: tables are not supported yet
     
         Exit 1
    
         input sent to parser-cmd (PID 1667935):
            1 │ top.key = 1
            2 │
            3 │ [tbl]
            4 │ a.b.c = 42.666
            5 │
            6 │ [a.few.dots]
            7 │ polka.dot = "again?"
            8 │ polka.dance-with = "Dot"
    
         output from parser-cmd (PID 1667935) (stderr):
            1 │ line 3: tables are not supported yet
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/key/dotted-04
         line 3: tables are not supported yet
     
         Exit 1
    
         input sent to parser-cmd (PID 1667933):
            1 │ top.key = 1
            2 │
            3 │ [[arr]]
            4 │ a.b.c=1
            5 │ a.b.d=2
            6 │
            7 │ [[arr]]
            8 │ a.b.c=3
            9 │ a.b.d=4
    
         output from parser-cmd (PID 1667933) (stderr):
            1 │ line 3: tables are not supported yet
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/key/dotted-empty
         line 3: tables are not supported yet
     
         Exit 1
    
         input sent to parser-cmd (PID 1667972):
            1 │ ''.x = "empty.x"
            2 │ x."" = "x.empty"
            3 │ [a]
            4 │ "".'' = "empty.empty"
    
         output from parser-cmd (PID 1667972) (stderr):
            1 │ line 3: tables are not supported yet
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/key/empty-01
         Could not find key "" in parser output.
    
         input sent to parser-cmd (PID 1667939):
            1 │ "" = "blank"
    
         output from parser-cmd (PID 1667939) (stdout):
            1 │ {
            2 │   "\"\"": {"type": "string", "value": "blank"}
            3 │ }
    
         want:
            1 │ {
            2 │     "": {"type": "string", "value": "blank"}
            3 │ }
    
    FAIL valid/key/empty-02
         Could not find key "" in parser output.
    
         input sent to parser-cmd (PID 1667975):
            1 │ '' = "blank"
    
         output from parser-cmd (PID 1667975) (stdout):
            1 │ {
            2 │   "''": {"type": "string", "value": "blank"}
            3 │ }
    
         want:
            1 │ {
            2 │     "": {"type": "string", "value": "blank"}
            3 │ }
    
    FAIL valid/key/empty-03
         Could not find key "" in parser output.
    
         input sent to parser-cmd (PID 1667986):
            1 │ ''=0
    
         output from parser-cmd (PID 1667986) (stdout):
            1 │ {
            2 │   "''": {"type": "integer", "value": "0"}
            3 │ }
    
         want:
            1 │ {
            2 │     "": {"type": "integer", "value": "0"}
            3 │ }
    
    FAIL valid/key/escapes
         line 6: tables are not supported yet
     
         Exit 1
    
         input sent to parser-cmd (PID 1667934):
            1 │ "\n" = "newline"
            2 │ "\b" = "bell"
            3 │ "\u00c0" = "latin capital letter A with grave"
            4 │ "\"" = "just a quote"
            5 │
            6 │ ["backsp\b\b"]
            7 │
            8 │ ["\"quoted\""]
            9 │ quote = true
           10 │
           11 │ ["a.b"."\u00c0"]
    
         output from parser-cmd (PID 1667934) (stderr):
            1 │ line 6: tables are not supported yet
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/key/like-date
         line 18: tables are not supported yet
     
         Exit 1
    
         input sent to parser-cmd (PID 1667982):
            1 │ # '-' is a valid character in keys: make a key that looks like a date.
            2 │ 2001-02-03   = 1
            3 │ "2001-02-04" = 2
            4 │ '2001-02-05' = 3
            5 │
            6 │ # Also include datetime and time for good measure; these need to be quoted as
            7 │ # ':' isn't a valid bare key.
            8 │ "2001-02-06T15:16:17+01:00" = 4
            9 │ "2001-02-07T15:16:17"       = 5
           10 │ "15:16:17"                  = 6
           11 │
           12 │ # Dotted keys
           13 │ a.2001-02-08 = 7
           14 │ a.2001-02-09.2001-02-10 = 8
           15 │ 2001-02-11.a.2001-02-12 = 9
           16 │
           17 │ # Table names
           18 │ [2002-01-02]
           19 │ k = 10
           20 │
           21 │ [2002-01-02.2024-01-03]
           22 │ k = 11
           23 │
           24 │ [[2002-01-04]]
           25 │ k = 12
    
         output from parser-cmd (PID 1667982) (stderr):
            1 │ line 18: tables are not supported yet
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/key/numeric-02
         Could not find key "1" in parser output.
    
         input sent to parser-cmd (PID 1667919):
            1 │ 1.2   = true
    
         output from parser-cmd (PID 1667919) (stdout):
            1 │ {
            2 │   "1.2": {"type": "bool", "value": "true"}
            3 │ }
    
         want:
            1 │ {
            2 │     "1": {
            3 │         "2": {"type": "bool", "value": "true"}
            4 │     }
            5 │ }
    
    FAIL valid/key/numeric-04
         Could not find key "01" in parser output.
    
         input sent to parser-cmd (PID 1667937):
            1 │ 01.23 = true
    
         output from parser-cmd (PID 1667937) (stdout):
            1 │ {
            2 │   "01.23": {"type": "bool", "value": "true"}
            3 │ }
    
         want:
            1 │ {
            2 │     "01": {
            3 │         "23": {"type": "bool", "value": "true"}
            4 │     }
            5 │ }
    
    FAIL valid/key/numeric-05
         Could not find key "23" in parser output.
    
         input sent to parser-cmd (PID 1667936):
            1 │ 23.01 = true
    
         output from parser-cmd (PID 1667936) (stdout):
            1 │ {
            2 │   "23.01": {"type": "bool", "value": "true"}
            3 │ }
    
         want:
            1 │ {
            2 │     "23": {
            3 │         "01": {"type": "bool", "value": "true"}
            4 │     }
            5 │ }
    
    FAIL valid/key/quoted-dots
         line 4: tables are not supported yet
     
         Exit 1
    
         input sent to parser-cmd (PID 1667918):
            1 │ plain = 1
            2 │ "with.dot" = 2
            3 │
            4 │ [plain_table]
            5 │ plain = 3
            6 │ "with.dot" = 4
            7 │
            8 │ [table.withdot]
            9 │ plain = 5
           10 │ "key.with.dots" = 6
           11 │ "escaped\u002edot" = 7
    
         output from parser-cmd (PID 1667918) (stderr):
            1 │ line 4: tables are not supported yet
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/key/quoted-unicode
         Could not find key "\x00" in parser output.
    
         input sent to parser-cmd (PID 1667938):
            1 │
            2 │ "\u0000" = "null"
            3 │ '\u0000' = "different key"
            4 │ "\u0008 \u000c \U00000041 \u007f \u0080 \u00ff \ud7ff \ue000 \uffff \U00010000 \U0010ffff" = "escaped key"
            5 │
            6 │ "~ € ÿ ퟿  ￿ 𐀀 􏿿" = "basic key"
            7 │ 'l ~ € ÿ ퟿  ￿ 𐀀 􏿿' = "literal key"
    
         output from parser-cmd (PID 1667938) (stdout):
            1 │ {
            2 │   "\"\\u0000\"":                                                                                {"type": "string", "value": "null"},
            3 │   "\"\\u0008 \\u000c \\U00000041 \\u007f \\u0080 \\u00ff \\ud7ff \\ue000 \\uffff \\U00010000 \\U0010ffff\"": {"type": "string", "value": "escaped key"},
            4 │   "\"~ € ÿ ퟿  ￿ 𐀀 􏿿\"":                                                                          {"type": "string", "value": "basic key"},
            5 │   "'\\u0000'":                                                                                  {"type": "string", "value": "different key"},
            6 │   "'l ~ € ÿ ퟿  ￿ 𐀀 􏿿'":                                                                          {"type": "string", "value": "literal key"}
            7 │ }
    
         want:
            1 │ {
            2 │     "\u0000":               {"type": "string", "value": "null"},
            3 │     "\b \f A  € ÿ ퟿  ￿ 𐀀 􏿿": {"type": "string", "value": "escaped key"},
            4 │     "\\u0000":              {"type": "string", "value": "different key"},
            5 │     "l ~ € ÿ ퟿  ￿ 𐀀 􏿿":      {"type": "string", "value": "literal key"},
            6 │     "~ € ÿ ퟿  ￿ 𐀀 􏿿":        {"type": "string", "value": "basic key"}
            7 │ }
    
    FAIL valid/key/space
         line 6: tables are not supported yet
     
         Exit 1
    
         input sent to parser-cmd (PID 1667971):
            1 │ # Keep whitespace inside quotes keys at all positions.
            2 │ "a b"   = 1
            3 │ " c d " = 2
            4 │ "  much 		  whitespace  	\n  \r\n  " = 3
            5 │
            6 │ [ " tbl " ]
            7 │ "\ttab\ttab\t" = "tab"
    
         output from parser-cmd (PID 1667971) (stderr):
            1 │ line 6: tables are not supported yet
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/key/special-chars
         line 1: invalid value "~!@$^&*()_+-`1234567890[]|/?><.,;:'=\" = 1"
     
         Exit 1
    
         input sent to parser-cmd (PID 1667920):
            1 │ "=~!@$^&*()_+-`1234567890[]|/?><.,;:'=" = 1
    
         output from parser-cmd (PID 1667920) (stderr):
            1 │ line 1: invalid value "~!@$^&*()_+-`1234567890[]|/?><.,;:'=\" = 1"
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/key/start
         line 4: tables are not supported yet
     
         Exit 1
    
         input sent to parser-cmd (PID 1667970):
            1 │ # Table and keys can start with any character; there is no requirement for it to
            2 │ # start with a letter.
            3 │
            4 │ [-key]
            5 │ -key = 1
            6 │
            7 │ [_key]
            8 │ _key = 2
            9 │
           10 │ [1key]
           11 │ 1key = 3
           12 │
           13 │ [-]
           14 │ - = 4
           15 │
           16 │ [_]
           17 │ _ = 5
           18 │
           19 │ [1]
           20 │ 1 = 6
           21 │
           22 │ [---]
           23 │ --- = 7
           24 │
           25 │ [___]
           26 │ ___ = 8
           27 │
           28 │ [111]
           29 │ 111 = 9
           30 │
           31 │ [inline]
           32 │ --- = {--- = 10, ___ = 11, 111 = 12}
    
         output from parser-cmd (PID 1667970) (stderr):
            1 │ line 4: tables are not supported yet
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    toml-test v2.2.0 [/mnt/c/Users/barlo/projects/drydock/uat/Toml/runs/20260816.121804/build/toml/toml-decoder] [no encoder]
    skipped tests: 856
      valid tests:   8 passed, 20 failed
    encoder tests: no encoder command given
    invalid tests:   0 passed,  0 failed
    
    harness: /home/barlo/.local/bin/toml-test toml-test v2.2.0; go1.24.6 linux/amd64; race=false; cgo=true
  stderr:
    --- drydock: values at failure ---
      result = CompletedProcess(args=['sh', 'sources/stage_test.sh', 'valid/key/**'], returncode=1, stdout='FAIL valid/key/alphanum\n     line 10: tables are not supported yet\n \n     Exit 1\n\n     input sent to parser-cmd (PID 1667968):\n        1 │\x1b[0m alpha = "a"\n        2 │\x1b[0m 123 = "num"\n        3 │\x1b[0m 000111 = "leading"\n        4 │\x1b[0m 10e3 = "false float"\n        5 │\x1b[0m one1two2 = … (+17319 chars)
    --- drydock: end values ---
    Traceback (most recent call last):
      File "keys-valid.py", line 10, in <module>
        assert result.returncode == 0
               ^^^^^^^^^^^^^^^^^^^^^^
    AssertionError
- RED: keys-invalid (FEATURE-Keys.md)
  intent: The decoder rejects all authoritative invalid TOML key cases owned by this feature.
  return code: 1
  stdout:
    FAIL invalid/key/bare-invalid-character-01
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1668300):
            1 │ ! = 123
    
         output from parser-cmd (PID 1668300) (stdout):
            1 │ {
            2 │   "!": {"type": "integer", "value": "123"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/key/bare-invalid-character-02
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1668241):
            1 │ bare!key = 123
    
         output from parser-cmd (PID 1668241) (stdout):
            1 │ {
            2 │   "bare!key": {"type": "integer", "value": "123"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/key/dot
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1668296):
            1 │ . = 1
    
         output from parser-cmd (PID 1668296) (stdout):
            1 │ {
            2 │   ".": {"type": "integer", "value": "1"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/key/dotdot
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1668238):
            1 │ .. = 1
    
         output from parser-cmd (PID 1668238) (stdout):
            1 │ {
            2 │   "..": {"type": "integer", "value": "1"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/key/dotted-redefine-table-01
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1668215):
            1 │ a = false
            2 │ a.b = true
    
         output from parser-cmd (PID 1668215) (stdout):
            1 │ {
            2 │   "a":   {"type": "bool", "value": "false"},
            3 │   "a.b": {"type": "bool", "value": "true"}
            4 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/key/dotted-redefine-table-02
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1668246):
            1 │ # Defined a.b as int
            2 │ a.b = 1
            3 │ # Tries to access it as table: error
            4 │ a.b.c = 2
    
         output from parser-cmd (PID 1668246) (stdout):
            1 │ {
            2 │   "a.b":   {"type": "integer", "value": "1"},
            3 │   "a.b.c": {"type": "integer", "value": "2"}
            4 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/key/duplicate-keys-03
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1668240):
            1 │ spelling   = "favorite"
            2 │ "spelling" = "favourite"
    
         output from parser-cmd (PID 1668240) (stdout):
            1 │ {
            2 │   "\"spelling\"": {"type": "string", "value": "favourite"},
            3 │   "spelling":   {"type": "string", "value": "favorite"}
            4 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/key/duplicate-keys-04
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1668295):
            1 │ spelling   = "favorite"
            2 │ 'spelling' = "favourite"
    
         output from parser-cmd (PID 1668295) (stdout):
            1 │ {
            2 │   "'spelling'": {"type": "string", "value": "favourite"},
            3 │   "spelling":   {"type": "string", "value": "favorite"}
            4 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/key/duplicate-keys-05
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1668197):
            1 │ a        = 1
            2 │ "\u0061" = 1
    
         output from parser-cmd (PID 1668197) (stdout):
            1 │ {
            2 │   "\"\\u0061\"": {"type": "integer", "value": "1"},
            3 │   "a":        {"type": "integer", "value": "1"}
            4 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/key/duplicate-keys-06
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1668363):
            1 │ "a'b"      = 1
            2 │ "a\u0027b" = 2
    
         output from parser-cmd (PID 1668363) (stdout):
            1 │ {
            2 │   "\"a'b\"":    {"type": "integer", "value": "1"},
            3 │   "\"a\\u0027b\"": {"type": "integer", "value": "2"}
            4 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/key/escape
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1668239):
            1 │ \u00c0 = "latin capital letter A with grave"
    
         output from parser-cmd (PID 1668239) (stdout):
            1 │ {
            2 │   "\\u00c0": {"type": "string", "value": "latin capital letter A with grave"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/key/multiline-key-01
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1668247):
            1 │ """key""" = 1
    
         output from parser-cmd (PID 1668247) (stdout):
            1 │ {
            2 │   "\"\"\"key\"\"\"": {"type": "integer", "value": "1"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/key/multiline-key-02
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1668220):
            1 │ '''key''' = 1
    
         output from parser-cmd (PID 1668220) (stdout):
            1 │ {
            2 │   "'''key'''": {"type": "integer", "value": "1"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/key/multiline-key-04
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1668244):
            1 │ '''key''' = '''v'''
    
         output from parser-cmd (PID 1668244) (stdout):
            1 │ {
            2 │   "'''key'''": {"type": "string", "value": "''v''"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/key/partial-quoted
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1668490):
            1 │ partial"quoted" = 5
    
         output from parser-cmd (PID 1668490) (stdout):
            1 │ {
            2 │   "partial\"quoted\"": {"type": "integer", "value": "5"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/key/space
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1668420):
            1 │ a b = 1
    
         output from parser-cmd (PID 1668420) (stdout):
            1 │ {
            2 │   "a b": {"type": "integer", "value": "1"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/key/special-character
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1668427):
            1 │ μ = "greek small letter mu"
    
         output from parser-cmd (PID 1668427) (stdout):
            1 │ {
            2 │   "μ": {"type": "string", "value": "greek small letter mu"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/key/start-dot
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 1668474):
            1 │ .key = 1
    
         output from parser-cmd (PID 1668474) (stdout):
            1 │ {
            2 │   ".key": {"type": "integer", "value": "1"}
            3 │ }
    
         want:
           Exit code 1
    
    toml-test v2.2.0 [/mnt/c/Users/barlo/projects/drydock/uat/Toml/runs/20260816.121804/build/toml/toml-decoder] [no encoder]
    skipped tests: 823
      valid tests:   0 passed,  0 failed
    encoder tests: no encoder command given
    invalid tests:  43 passed, 18 failed
    
    harness: /home/barlo/.local/bin/toml-test toml-test v2.2.0; go1.24.6 linux/amd64; race=false; cgo=true
  stderr:
    --- drydock: values at failure ---
      result = CompletedProcess(args=['sh', 'sources/stage_test.sh', 'invalid/key/**'], returncode=1, stdout='FAIL invalid/key/bare-invalid-character-01\n     Expected an error, but no error was reported.\n\n     input sent to parser-cmd (PID 1668300):\n        1 │\x1b[0m ! = 123\n\n     output from parser-cmd (PID 1668300) (stdout):\n        1 │\x1b[0m {\n        2 │\x1b[0m   "!": {"type": "integer", "value": "… (+7655 chars)
    --- drydock: end values ---
    Traceback (most recent call last):
      File "keys-invalid.py", line 10, in <module>
        assert result.returncode == 0
               ^^^^^^^^^^^^^^^^^^^^^^
    AssertionError

## Post-build programmatic acceptance
- PASS: strings-valid-suite (FEATURE-Strings.md)
  intent: The authoritative conformance suite passes every valid string case owned by this feature.
  target interpreter: /mnt/c/Users/barlo/projects/drydock/.venv/bin/python3
  provisioning: not required
  return code: 0
  stdout:
    toml-test v2.2.0 [/mnt/c/Users/barlo/projects/drydock/uat/Toml/runs/20260816.121804/build/toml/toml-decoder] [no encoder]
    skipped tests: 861
      valid tests:  23 passed,  0 failed
    encoder tests: no encoder command given
    invalid tests:   0 passed,  0 failed
    
    harness: /home/barlo/.local/bin/toml-test toml-test v2.2.0; go1.24.6 linux/amd64; race=false; cgo=true
- PASS: strings-invalid-suite (FEATURE-Strings.md)
  intent: The authoritative conformance suite rejects every invalid string case owned by this feature.
  target interpreter: /mnt/c/Users/barlo/projects/drydock/.venv/bin/python3
  provisioning: not required
  return code: 0
  stdout:
    toml-test v2.2.0 [/mnt/c/Users/barlo/projects/drydock/uat/Toml/runs/20260816.121804/build/toml/toml-decoder] [no encoder]
    skipped tests: 807
      valid tests:   0 passed,  0 failed
    encoder tests: no encoder command given
    invalid tests:  77 passed,  0 failed
    
    harness: /home/barlo/.local/bin/toml-test toml-test v2.2.0; go1.24.6 linux/amd64; race=false; cgo=true
- PASS: strings-bounded-suites (FEATURE-Strings.md)
  intent: Both string conformance invocations complete successfully as separate executable checks.
  target interpreter: /mnt/c/Users/barlo/projects/drydock/.venv/bin/python3
  provisioning: not required
  return code: 0
  stdout:
    toml-test v2.2.0 [/mnt/c/Users/barlo/projects/drydock/uat/Toml/runs/20260816.121804/build/toml/toml-decoder] [no encoder]
    skipped tests: 861
      valid tests:  23 passed,  0 failed
    encoder tests: no encoder command given
    invalid tests:   0 passed,  0 failed
    
    harness: /home/barlo/.local/bin/toml-test toml-test v2.2.0; go1.24.6 linux/amd64; race=false; cgo=true
    
    toml-test v2.2.0 [/mnt/c/Users/barlo/projects/drydock/uat/Toml/runs/20260816.121804/build/toml/toml-decoder] [no encoder]
    skipped tests: 807
      valid tests:   0 passed,  0 failed
    encoder tests: no encoder command given
    invalid tests:  77 passed,  0 failed
    
    harness: /home/barlo/.local/bin/toml-test toml-test v2.2.0; go1.24.6 linux/amd64; race=false; cgo=true
- PASS: keys-valid (FEATURE-Keys.md)
  intent: The decoder passes all authoritative valid TOML key cases owned by this feature.
  target interpreter: /mnt/c/Users/barlo/projects/drydock/.venv/bin/python3
  provisioning: not required
  return code: 0
  stdout:
    toml-test v2.2.0 [/mnt/c/Users/barlo/projects/drydock/uat/Toml/runs/20260816.121804/build/toml/toml-decoder] [no encoder]
    skipped tests: 856
      valid tests:  28 passed,  0 failed
    encoder tests: no encoder command given
    invalid tests:   0 passed,  0 failed
    
    harness: /home/barlo/.local/bin/toml-test toml-test v2.2.0; go1.24.6 linux/amd64; race=false; cgo=true
- PASS: keys-invalid (FEATURE-Keys.md)
  intent: The decoder rejects all authoritative invalid TOML key cases owned by this feature.
  target interpreter: /mnt/c/Users/barlo/projects/drydock/.venv/bin/python3
  provisioning: not required
  return code: 0
  stdout:
    toml-test v2.2.0 [/mnt/c/Users/barlo/projects/drydock/uat/Toml/runs/20260816.121804/build/toml/toml-decoder] [no encoder]
    skipped tests: 823
      valid tests:   0 passed,  0 failed
    encoder tests: no encoder command given
    invalid tests:  61 passed,  0 failed
    
    harness: /home/barlo/.local/bin/toml-test toml-test v2.2.0; go1.24.6 linux/amd64; race=false; cgo=true

## Repair attempts
- attempt 0 (initial build): failed; 2/5 checks; 138/138 cases model=gpt-5.6-luna; execution 20260816.122829.516Z-b05144b1
- attempt 1 (repair 1): built; 5/5 checks; 215/215 cases model=gpt-5.6-luna; execution 20260816.123439.459Z-c6e09f01

## Build summary
<reusable-compact filename="stage_test.sh">
Runs one scoped TOML conformance slice. Requires exactly one `-run` pattern argument, builds `./cmd/toml-decoder`, invokes `sources/run_conformance.sh`, and uses the command exit status as the verdict. Defaults `TOML_TEST_VERSION` to `v2.2.0`.
</reusable-compact>

RESULT: SUCCESS

FILES CHANGED:
- internal/toml/toml.go
- toml-decoder

SUMMARY:
Fixed multiline quote-run parsing and line-comment boundary handling. Scoped acceptance passes: strings valid 23/23, strings invalid 77/77, keys valid 28/28, keys invalid 61/61. Go tests and vet pass.

BLOCKERS:
- Full conformance remains outside this block’s string/key scope and still has unrelated array, scalar, datetime, and table failures.