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

- block type: block
- date: 2026-08-14
- resulting state: closed/verified
- story points (combined assembled cost): 8629
- execution id: 20260814.052011.978Z-ac5a3505

## Stories built
- Parse TOML basic, multiline basic, literal, and multiline literal strings. (lexical-strings) [story]

## Reusable compacts
- stage_test_compact.md

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

## Stacked context
- compass: COMPASS.md (SP 2629)
- implements: FEATURE-Lexical-Strings.md (SP 846)
- context: stage_test.sh (SP 161)
- context: ARCHITECTURE_compact.md (SP 108)
- stack: go.md (SP 3646)
- stack: common_compact.md (SP 1179)

## Build directory changes
- internal/toml/decode.go
- internal/toml/value_test.go
- toml-decoder

## Pre-build acceptance observation
- RED: strings-conformance (FEATURE-Lexical-Strings.md)
  intent: The implementation passes the authoritative TOML 1.0.0 string conformance slice.
  return code: 1
  stdout:
    FAIL valid/string/ends-in-whitespace-escape
         Values for key "beee" don't match:
           Expected:     heeee
         geeee
           Your encoder: heeee
         geeee\
    
         input sent to parser-cmd (PID 758702):
            1 │ beee = """
            2 │ heeee
            3 │ geeee\
            4 │
            5 │
            6 │       """
    
         output from parser-cmd (PID 758702) (stdout):
            1 │ {
            2 │   "beee": {"type": "string", "value": "heeee\ngeeee\\  \n\n\n      "}
            3 │ }
    
         want:
            1 │ {
            2 │     "beee": {"type": "string", "value": "heeee\ngeeee"}
            3 │ }
    
    FAIL valid/string/escape-tricky
         Values for key "lit_multiline_not_unicode" don't match:
           Expected:     \u007f
           Your encoder:
         \u007f
    
         input sent to parser-cmd (PID 758612):
            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 758612) (stdout):
            1 │ {
            2 │   "end_esc":                   {"type": "string", "value": "String does not end here\" but ends here\\"},
            3 │   "lit_end_esc":               {"type": "string", "value": "String ends here\\"},
            4 │   "lit_multiline_end":         {"type": "string", "value": "There is no escape\\"},
            5 │   "lit_multiline_not_unicode": {"type": "string", "value": "\n\\u007f"},
            6 │   "multiline_end_esc":         {"type": "string", "value": "When will it end? \\\"\"\"...\"\"\\\" should be here\\\""},
            7 │   "multiline_not_unicode":     {"type": "string", "value": "\\\\u0041"},
            8 │   "multiline_unicode":         {"type": "string", "value": "\\u00a0"}
            9 │ }
    
         want:
            1 │ {
            2 │     "end_esc":                   {"type": "string", "value": "String does not end here\" but ends here\\"},
            3 │     "lit_end_esc":               {"type": "string", "value": "String ends here\\"},
            4 │     "lit_multiline_end":         {"type": "string", "value": "There is no escape\\"},
            5 │     "lit_multiline_not_unicode": {"type": "string", "value": "\\u007f"},
            6 │     "multiline_end_esc":         {"type": "string", "value": "When will it end? \"\"\"...\"\"\" should be here\""},
            7 │     "multiline_not_unicode":     {"type": "string", "value": "\\u0041"},
            8 │     "multiline_unicode":         {"type": "string", "value": " "}
            9 │ }
    
    FAIL valid/string/multibyte-escape
         Values for key "ml-basic-1" don't match:
           Expected:     ɑ € 𐫱 ɑ€𐫱
           Your encoder: \u0251 \u20ac \U00010AF1 \u0251\u20ac\U00010AF1
    
         input sent to parser-cmd (PID 758592):
            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 758592) (stdout):
            1 │ {
            2 │   "basic-1":    {"type": "string", "value": "ɑ € 𐫱 ɑ€𐫱"},
            3 │   "basic-2":    {"type": "string", "value": "ɑ € 𐫱 ɑ€𐫱"},
            4 │   "ml-basic-1": {"type": "string", "value": "\\u0251 \\u20ac \\U00010AF1 \\u0251\\u20ac\\U00010AF1"},
            5 │   "ml-basic-2": {
            6 │     "type":  "string",
            7 │     "value": "\\U00000251 \\U000020ac \\U00010AF1 \\U00000251\\U000020ac\\U00010AF1"
            8 │   }
            9 │ }
    
         want:
            1 │ {
            2 │     "basic-1":    {"type": "string", "value": "ɑ € 𐫱 ɑ€𐫱"},
            3 │     "ml-basic-1": {"type": "string", "value": "ɑ € 𐫱 ɑ€𐫱"},
            4 │     "basic-2":    {"type": "string", "value": "ɑ € 𐫱 ɑ€𐫱"},
            5 │     "ml-basic-2": {"type": "string", "value": "ɑ € 𐫱 ɑ€𐫱"}
            6 │ }
    
    FAIL valid/string/multiline
         Values for key "equivalent_three" don't match:
           Expected:     The quick brown fox jumps over the lazy dog.
           Your encoder:        The quick brown        fox jumps over        the lazy dog.
    
         input sent to parser-cmd (PID 758569):
            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 758569) (stdout):
            1 │ {
            2 │   "equivalent_one": {"type": "string", "value": "The quick brown fox jumps over the lazy dog."},
            3 │   "equivalent_two": {"type": "string", "value": "The quick brown \n\n  fox jumps over     the lazy dog."},
            4 │   "escape-bs-1":    {"type": "string", "value": "a \\b"},
            5 │   "escape-bs-2":    {"type": "string", "value": "a \\\\b"},
            6 │   "escape-bs-3":    {"type": "string", "value": "a \\\\\\  b"},
            7 │   "keep-ws-before": {"type": "string", "value": "a   \t   b"},
            8 │   "no-space":       {"type": "string", "value": "a    b"},
            9 │   "equivalent_three": {
           10 │     "type":  "string",
           11 │     "value": "       The quick brown        fox jumps over        the lazy dog.       "
           12 │   },
           13 │   "whitespace-after-bs": {
           14 │     "type":  "string",
           15 │     "value": "       The quick brown        fox jumps over \\   \n       the lazy dog.\\\t\n       "
           16 │   }
           17 │ }
    
         want:
            1 │ {
            2 │     "equivalent_one":      {"type": "string", "value": "The quick brown fox jumps over the lazy dog."},
            3 │     "equivalent_three":    {"type": "string", "value": "The quick brown fox jumps over the lazy dog."},
            4 │     "equivalent_two":      {"type": "string", "value": "The quick brown fox jumps over the lazy dog."},
            5 │     "escape-bs-1":         {"type": "string", "value": "a \\\nb"},
            6 │     "escape-bs-2":         {"type": "string", "value": "a \\b"},
            7 │     "escape-bs-3":         {"type": "string", "value": "a \\\\\n  b"},
            8 │     "keep-ws-before":      {"type": "string", "value": "a   \tb"},
            9 │     "no-space":            {"type": "string", "value": "ab"},
           10 │     "whitespace-after-bs": {"type": "string", "value": "The quick brown fox jumps over the lazy dog."}
           11 │ }
    
    FAIL valid/string/multiline-empty
         Values for key "empty-3" don't match:
           Expected:
           Your encoder:
    
         input sent to parser-cmd (PID 758588):
            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 758588) (stdout):
            1 │ {
            2 │   "empty-1": {"type": "string", "value": ""},
            3 │   "empty-2": {"type": "string", "value": ""},
            4 │   "empty-3": {"type": "string", "value": "    "},
            5 │   "empty-4": {"type": "string", "value": "      \\  \n   "}
            6 │ }
    
         want:
            1 │ {
            2 │     "empty-1": {"type": "string", "value": ""},
            3 │     "empty-2": {"type": "string", "value": ""},
            4 │     "empty-3": {"type": "string", "value": ""},
            5 │     "empty-4": {"type": "string", "value": ""}
            6 │ }
    
    FAIL valid/string/multiline-escaped-crlf
         Values for key "0" don't match:
           Expected:
           Your encoder: \
    
         input sent to parser-cmd (PID 758587):
            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 758587) (stdout):
            1 │ {
            2 │   "0": {"type": "string", "value": "\\\r\n"}
            3 │ }
    
         want:
            1 │ {
            2 │     "0": {"type": "string", "value": ""}
            3 │ }
    
    FAIL valid/string/multiline-quotes
         unterminated value
     
         Exit 1
    
         input sent to parser-cmd (PID 758609):
            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 758609) (stderr):
            1 │ unterminated value
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/nl
         Values for key "nl_end" don't match:
           Expected:     value
     
           Your encoder: value\n
    
         input sent to parser-cmd (PID 758590):
            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 758590) (stdout):
            1 │ {
            2 │   "lit_nl_end": {"type": "string", "value": "value\\n"},
            3 │   "lit_nl_mid": {"type": "string", "value": "val\\nue"},
            4 │   "lit_nl_uni": {"type": "string", "value": "val\\ue"},
            5 │   "nl_end":     {"type": "string", "value": "value\\n"},
            6 │   "nl_mid":     {"type": "string", "value": "val\nue"}
            7 │ }
    
         want:
            1 │ {
            2 │     "lit_nl_end": {"type": "string", "value": "value\\n"},
            3 │     "lit_nl_mid": {"type": "string", "value": "val\\nue"},
            4 │     "lit_nl_uni": {"type": "string", "value": "val\\ue"},
            5 │     "nl_end":     {"type": "string", "value": "value\n"},
            6 │     "nl_mid":     {"type": "string", "value": "val\nue"}
            7 │ }
    
    FAIL valid/string/raw-multiline
         unterminated value
     
         Exit 1
    
         input sent to parser-cmd (PID 758608):
            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 758608) (stderr):
            1 │ unterminated value
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/string/start-mb
         Values for key "s6" don't match:
           Expected:     §
           Your encoder:
         §
    
         input sent to parser-cmd (PID 758610):
            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 758610) (stdout):
            1 │ {
            2 │   "s1": {"type": "string", "value": "§"},
            3 │   "s2": {"type": "string", "value": "§"},
            4 │   "s3": {"type": "string", "value": "§"},
            5 │   "s4": {"type": "string", "value": "§"},
            6 │   "s5": {"type": "string", "value": "§"},
            7 │   "s6": {"type": "string", "value": "\n§"},
            8 │   "s7": {"type": "string", "value": "§"}
            9 │ }
    
         want:
            1 │ {
            2 │     "s1": {"type": "string", "value": "§"},
            3 │     "s2": {"type": "string", "value": "§"},
            4 │     "s3": {"type": "string", "value": "§"},
            5 │     "s4": {"type": "string", "value": "§"},
            6 │     "s5": {"type": "string", "value": "§"},
            7 │     "s6": {"type": "string", "value": "§"},
            8 │     "s7": {"type": "string", "value": "§"}
            9 │ }
    
    FAIL valid/string/unicode-escape
         Values for key "ml-a" don't match:
           Expected:     a
           Your encoder: \u0061
    
         input sent to parser-cmd (PID 758586):
            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 758586) (stdout):
            1 │ {
            2 │   "a":          {"type": "string", "value": "a"},
            3 │   "b":          {"type": "string", "value": "b"},
            4 │   "c":          {"type": "string", "value": "c"},
            5 │   "delta-1":    {"type": "string", "value": "δ"},
            6 │   "delta-2":    {"type": "string", "value": "δ"},
            7 │   "ml-a":       {"type": "string", "value": "\\u0061"},
            8 │   "ml-b":       {"type": "string", "value": "\\u0062"},
            9 │   "ml-c":       {"type": "string", "value": "\\U00000063"},
           10 │   "ml-delta-1": {"type": "string", "value": "\\u03B4"},
           11 │   "ml-delta-2": {"type": "string", "value": "\\U000003B4"},
           12 │   "ml-null-1":  {"type": "string", "value": "\\u0000"},
           13 │   "ml-null-2":  {"type": "string", "value": "\\U00000000"},
           14 │   "null-1":     {"type": "string", "value": "\u0000"},
           15 │   "null-2":     {"type": "string", "value": "\u0000"}
           16 │ }
    
         want:
            1 │ {
            2 │     "a":          {"type": "string", "value": "a"},
            3 │     "b":          {"type": "string", "value": "b"},
            4 │     "c":          {"type": "string", "value": "c"},
            5 │     "delta-1":    {"type": "string", "value": "δ"},
            6 │     "delta-2":    {"type": "string", "value": "δ"},
            7 │     "ml-a":       {"type": "string", "value": "a"},
            8 │     "ml-b":       {"type": "string", "value": "b"},
            9 │     "ml-c":       {"type": "string", "value": "c"},
           10 │     "ml-delta-1": {"type": "string", "value": "δ"},
           11 │     "ml-delta-2": {"type": "string", "value": "δ"},
           12 │     "ml-null-1":  {"type": "string", "value": "\u0000"},
           13 │     "ml-null-2":  {"type": "string", "value": "\u0000"},
           14 │     "null-1":     {"type": "string", "value": "\u0000"},
           15 │     "null-2":     {"type": "string", "value": "\u0000"}
           16 │ }
    
    toml-test v2.2.0 [/mnt/c/Users/barlo/projects/drydock/uat/Toml/runs/20260814.050011/build/toml/toml-decoder] [no encoder]
    skipped tests: 861
      valid tests:  12 passed, 11 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:
    Traceback (most recent call last):
      File "strings-conformance.py", line 12, in <module>
        assert result.returncode == 0
               ^^^^^^^^^^^^^^^^^^^^^^
    AssertionError
- RED: strings-invalid-conformance (FEATURE-Lexical-Strings.md)
  intent: The implementation rejects the authoritative invalid string cases.
  return code: 1
  stdout:
    FAIL invalid/string/bad-escape-01
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 758967):
            1 │ invalid-escape = "This string has a bad \a escape character."
    
         output from parser-cmd (PID 758967) (stdout):
            1 │ {
            2 │   "invalid-escape": {"type": "string", "value": "This string has a bad \u0007 escape character."}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/bad-uni-esc-ml-01
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 758956):
            1 │ bad-uni-esc-ml-01 = """val\ue"""
    
         output from parser-cmd (PID 758956) (stdout):
            1 │ {
            2 │   "bad-uni-esc-ml-01": {"type": "string", "value": "val\\ue"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/bad-uni-esc-ml-02
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 758924):
            1 │ bad-uni-esc-ml-02 = """val\Ux"""
    
         output from parser-cmd (PID 758924) (stdout):
            1 │ {
            2 │   "bad-uni-esc-ml-02": {"type": "string", "value": "val\\Ux"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/bad-uni-esc-ml-03
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 759105):
            1 │ bad-uni-esc-ml-03 = """val\U0000000"""
    
         output from parser-cmd (PID 759105) (stdout):
            1 │ {
            2 │   "bad-uni-esc-ml-03": {"type": "string", "value": "val\\U0000000"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/bad-uni-esc-ml-04
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 758892):
            1 │ bad-uni-esc-ml-04 = """val\U0000"""
    
         output from parser-cmd (PID 758892) (stdout):
            1 │ {
            2 │   "bad-uni-esc-ml-04": {"type": "string", "value": "val\\U0000"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/bad-uni-esc-ml-05
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 758958):
            1 │ bad-uni-esc-ml-05 = """val\Ugggggggg"""
    
         output from parser-cmd (PID 758958) (stdout):
            1 │ {
            2 │   "bad-uni-esc-ml-05": {"type": "string", "value": "val\\Ugggggggg"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/bad-uni-esc-ml-06
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 758957):
            1 │ bad-uni-esc-ml-06 = """This string contains a non scalar unicode codepoint \uD801"""
    
         output from parser-cmd (PID 758957) (stdout):
            1 │ {
            2 │   "bad-uni-esc-ml-06": {"type": "string", "value": "This string contains a non scalar unicode codepoint \\uD801"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/bad-uni-esc-ml-07
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 758893):
            1 │ bad-uni-esc-ml-07 = """\uabag"""
    
         output from parser-cmd (PID 758893) (stdout):
            1 │ {
            2 │   "bad-uni-esc-ml-07": {"type": "string", "value": "\\uabag"}
            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 759046):
            1 │ answer = "\x33"
    
         output from parser-cmd (PID 759046) (stdout):
            1 │ {
            2 │   "answer": {"type": "string", "value": "3"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/basic-multiline-out-of-range-unicode-escape-01
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 758962):
            1 │ a = """\UFFFFFFFF"""
    
         output from parser-cmd (PID 758962) (stdout):
            1 │ {
            2 │   "a": {"type": "string", "value": "\\UFFFFFFFF"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/basic-multiline-out-of-range-unicode-escape-02
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 758959):
            1 │ a = """\U00D80000"""
    
         output from parser-cmd (PID 758959) (stdout):
            1 │ {
            2 │   "a": {"type": "string", "value": "\\U00D80000"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/basic-multiline-unknown-escape
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 758969):
            1 │ a = """\@"""
    
         output from parser-cmd (PID 758969) (stdout):
            1 │ {
            2 │   "a": {"type": "string", "value": "\\@"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/multiline-bad-escape-01
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 759257):
            1 │ k = """t\a"""
    
         output from parser-cmd (PID 759257) (stdout):
            1 │ {
            2 │   "k": {"type": "string", "value": "t\\a"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/multiline-bad-escape-02
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 759090):
            1 │ # \<Space> is not a valid escape.
            2 │ k = """t\ t"""
    
         output from parser-cmd (PID 759090) (stdout):
            1 │ {
            2 │   "k": {"type": "string", "value": "t\\ t"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/multiline-bad-escape-03
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 759153):
            1 │ # \<Space> is not a valid escape.
            2 │ k = """t\ """
    
         output from parser-cmd (PID 759153) (stdout):
            1 │ {
            2 │   "k": {"type": "string", "value": "t\\ "}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/multiline-escape-space-01
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 759106):
            1 │ a = """
            2 │   foo \ \n
            3 │   bar"""
    
         output from parser-cmd (PID 759106) (stdout):
            1 │ {
            2 │   "a": {"type": "string", "value": "  foo \\ \\n\n  bar"}
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/string/multiline-escape-space-02
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 759107):
            1 │ bee = """
            2 │ hee \
            3 │
            4 │ gee \   """
    
         output from parser-cmd (PID 759107) (stdout):
            1 │ {
            2 │   "bee": {"type": "string", "value": "hee \ngee \\   "}
            3 │ }
    
         want:
           Exit code 1
    
    toml-test v2.2.0 [/mnt/c/Users/barlo/projects/drydock/uat/Toml/runs/20260814.050011/build/toml/toml-decoder] [no encoder]
    skipped tests: 807
      valid tests:   0 passed,  0 failed
    encoder tests: no encoder command given
    invalid tests:  60 passed, 17 failed
    
    harness: /home/barlo/.local/bin/toml-test toml-test v2.2.0; go1.24.6 linux/amd64; race=false; cgo=true
  stderr:
    Traceback (most recent call last):
      File "strings-invalid-conformance.py", line 12, in <module>
        assert result.returncode == 0
               ^^^^^^^^^^^^^^^^^^^^^^
    AssertionError
- GREEN (prepassed): strings-process (FEATURE-Lexical-Strings.md)
  intent: A basic string is accepted through the decoder process boundary.
  return code: 0
- GREEN (prepassed): strings-literal (FEATURE-Lexical-Strings.md)
  intent: A literal string preserves its backslashes as supplied input.
  return code: 0

## Post-build programmatic acceptance
- PASS: strings-conformance (FEATURE-Lexical-Strings.md)
  intent: The implementation passes the authoritative TOML 1.0.0 string conformance slice.
  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/20260814.050011/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-conformance (FEATURE-Lexical-Strings.md)
  intent: The implementation rejects the authoritative invalid string cases.
  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/20260814.050011/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-process (FEATURE-Lexical-Strings.md)
  intent: A basic string is accepted through the decoder process boundary.
  target interpreter: /mnt/c/Users/barlo/projects/drydock/.venv/bin/python3
  provisioning: not required
  return code: 0
- PASS: strings-literal (FEATURE-Lexical-Strings.md)
  intent: A literal string preserves its backslashes as supplied input.
  target interpreter: /mnt/c/Users/barlo/projects/drydock/.venv/bin/python3
  provisioning: not required
  return code: 0

## Build summary
<reusable-compact filename="stage_test.sh">
Runs `go build -o toml-decoder ./cmd/toml-decoder`, then executes `sources/run_conformance.sh -run "$1"` against TOML_TEST_VERSION v2.2.0. Requires exactly one test-pattern argument and uses the command exit status as the verdict.
</reusable-compact>

RESULT: SUCCESS

FILES CHANGED:
- internal/toml/decode.go
- internal/toml/value_test.go

SUMMARY:
Implemented TOML basic, multiline basic, literal, and multiline literal strings. Valid slice: 23/23; invalid slice: 77/77. Go tests, race tests, vet, build, and formatting pass.

BLOCKERS:
- None