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

- block type: block
- date: 2026-08-14
- resulting state: closed/verified
- story points (combined assembled cost): 8690
- execution id: 20260814.054821.850Z-b97cfb83

## Stories built
- Enforce closure of TOML inline tables. (structures-inline-table-closure) [story]
- Parse standard TOML table headers and implicit tables. (tables-standard) [story]

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

## Stacked context
- compass: COMPASS.md (SP 2629)
- implements: FEATURE-Inline-Table-Closure.md (SP 432)
- context: stage_test.sh (SP 161)
- context: ARCHITECTURE_compact.md (SP 108)
- stack: go.md (SP 3646)
- stack: common_compact.md (SP 1179)
- implements: FEATURE-Standard-Tables.md (SP 439)

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

## Pre-build acceptance observation
- GREEN (prepassed): inline-closure-invalid (FEATURE-Inline-Table-Closure.md)
  intent: The implementation rejects authoritative invalid cases that extend or redefine inline tables.
  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: 856
      valid tests:   0 passed,  0 failed
    encoder tests: no encoder command given
    invalid tests:  28 passed,  0 failed
    
    harness: /home/barlo/.local/bin/toml-test toml-test v2.2.0; go1.24.6 linux/amd64; race=false; cgo=true
- GREEN (prepassed): inline-closure-boundary (FEATURE-Inline-Table-Closure.md)
  intent: The implementation passes the authoritative valid inline-table cases while preserving inline-table closure semantics.
  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: 867
      valid tests:  17 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
- RED: standard-tables-valid (FEATURE-Standard-Tables.md)
  intent: The implementation passes the authoritative valid TOML standard-table conformance slice.
  return code: 1
  stdout:
    FAIL valid/table/array-nest
         line 4: table conflict
     
         Exit 1
    
         input sent to parser-cmd (PID 838453):
            1 │ [[albums]]
            2 │ name = "Born to Run"
            3 │
            4 │   [[albums.songs]]
            5 │   name = "Jungleland"
            6 │
            7 │   [[albums.songs]]
            8 │   name = "Meeting Across the River"
            9 │
           10 │ [[albums]]
           11 │ name = "Born in the USA"
           12 │
           13 │   [[albums.songs]]
           14 │   name = "Glory Days"
           15 │
           16 │   [[albums.songs]]
           17 │   name = "Dancing in the Dark"
    
         output from parser-cmd (PID 838453) (stderr):
            1 │ line 4: table conflict
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/table/array-table-array
         line 2: table conflict
     
         Exit 1
    
         input sent to parser-cmd (PID 838488):
            1 │ [[a]]
            2 │     [[a.b]]
            3 │         [a.b.c]
            4 │             d = "val0"
            5 │     [[a.b]]
            6 │         [a.b.c]
            7 │             d = "val1"
    
         output from parser-cmd (PID 838488) (stderr):
            1 │ line 2: table conflict
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/table/names
         line 2: table redefinition
     
         Exit 1
    
         input sent to parser-cmd (PID 838454):
            1 │ [a.b.c]
            2 │ [a."b.c"]
            3 │ [a.'d.e']
            4 │ [a.' x ']
            5 │ [ d.e.f ]
            6 │ [ g . h . i ]
            7 │ [ j . "ʞ" . 'l' ]
            8 │
            9 │ [x.1.2]
    
         output from parser-cmd (PID 838454) (stderr):
            1 │ line 2: table redefinition
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    FAIL valid/table/names-with-values
         line 4: table redefinition
     
         Exit 1
    
         input sent to parser-cmd (PID 838484):
            1 │ [a.b.c]
            2 │ key = 1
            3 │
            4 │ [a."b.c"]
            5 │ key = 2
            6 │
            7 │ [a.'d.e']
            8 │ key = 3
            9 │
           10 │ [a.' x ']
           11 │ key = 4
           12 │
           13 │ [ d.e.f ]
           14 │ key = 5
           15 │
           16 │ [ g . h . i ]
           17 │ key = 6
           18 │
           19 │ [ j . "ʞ" . 'l' ]
           20 │ key = 7
           21 │
           22 │ [x.1.2]
           23 │ key = 8
    
         output from parser-cmd (PID 838484) (stderr):
            1 │ line 4: table redefinition
            2 │
            3 │ Exit 1
    
         want:
              <empty>
    
    toml-test v2.2.0 [/mnt/c/Users/barlo/projects/drydock/uat/Toml/runs/20260814.050011/build/toml/toml-decoder] [no encoder]
    skipped tests: 860
      valid tests:  20 passed,  4 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 "standard-tables-valid.py", line 10, in <module>
        assert result.returncode == 0
               ^^^^^^^^^^^^^^^^^^^^^^
    AssertionError
- RED: standard-tables-invalid (FEATURE-Standard-Tables.md)
  intent: The implementation rejects invalid standard-table header and hierarchy cases in the authoritative suite.
  return code: 1
  stdout:
    FAIL invalid/table/append-with-dotted-keys-01
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 838715):
            1 │ # First a.b.c defines a table: a.b.c = {z=9}
            2 │ #
            3 │ # Then we define a.b.c.t = "str" to add a str to the above table, making it:
            4 │ #
            5 │ #   a.b.c = {z=9, t="..."}
            6 │ #
            7 │ # While this makes sense, logically, it was decided this is not valid TOML as
            8 │ # it's too confusing/convoluted.
            9 │ #
           10 │ # See: https://github.com/toml-lang/toml/issues/846
           11 │ #      https://github.com/toml-lang/toml/pull/859
           12 │
           13 │ [a.b.c]
           14 │   z = 9
           15 │
           16 │ [a]
           17 │   b.c.t = "Using dotted keys to add to [a.b.c] after explicitly defining it above is not allowed"
    
         output from parser-cmd (PID 838715) (stdout):
            1 │ {
            2 │   "a": {
            3 │     "b": {
            4 │       "c": {
            5 │         "z": {"type": "integer", "value": "9"},
            6 │         "t": {
            7 │           "type":  "string",
            8 │           "value": "Using dotted keys to add to [a.b.c] after explicitly defining it above is not allowed"
            9 │         }
           10 │       }
           11 │     }
           12 │   }
           13 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/table/append-with-dotted-keys-02
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 838750):
            1 │ # This is the same issue as in injection-1.toml, except that nests one level
            2 │ # deeper. See that file for a more complete description.
            3 │
            4 │ [a.b.c.d]
            5 │   z = 9
            6 │
            7 │ [a]
            8 │   b.c.d.k.t = "Using dotted keys to add to [a.b.c.d] after explicitly defining it above is not allowed"
    
         output from parser-cmd (PID 838750) (stdout):
            1 │ {
            2 │   "a": {
            3 │     "b": {
            4 │       "c": {
            5 │         "d": {
            6 │           "z": {"type": "integer", "value": "9"},
            7 │           "k": {
            8 │             "t": {
            9 │               "type":  "string",
           10 │               "value": "Using dotted keys to add to [a.b.c.d] after explicitly defining it above is not allowed"
           11 │             }
           12 │           }
           13 │         }
           14 │       }
           15 │     }
           16 │   }
           17 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/table/append-with-dotted-keys-08
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 838849):
            1 │ [a.b.c]
            2 │ z = 9
            3 │
            4 │ [[totally_unrelated]]
            5 │ x = 123
            6 │
            7 │ [a]
            8 │ b.c.t = "this should NOT be allowed"
    
         output from parser-cmd (PID 838849) (stdout):
            1 │ {
            2 │   "totally_unrelated": [{
            3 │     "x": {"type": "integer", "value": "123"}
            4 │   }],
            5 │   "a": {
            6 │     "b": {
            7 │       "c": {
            8 │         "t": {"type": "string", "value": "this should NOT be allowed"},
            9 │         "z": {"type": "integer", "value": "9"}
           10 │       }
           11 │     }
           12 │   }
           13 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/table/array-implicit
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 838789):
            1 │ # This test is a bit tricky. It should fail because the first use of
            2 │ # `[[albums.songs]]` without first declaring `albums` implies that `albums`
            3 │ # must be a table. The alternative would be quite weird. Namely, it wouldn't
            4 │ # comply with the TOML spec: "Each double-bracketed sub-table will belong to
            5 │ # the most *recently* defined table element *above* it."
            6 │ #
            7 │ # This is in contrast to the *valid* test, table-array-implicit where
            8 │ # `[[albums.songs]]` works by itself, so long as `[[albums]]` isn't declared
            9 │ # later. (Although, `[albums]` could be.)
           10 │ [[albums.songs]]
           11 │ name = "Glory Days"
           12 │
           13 │ [[albums]]
           14 │ name = "Born in the USA"
    
         output from parser-cmd (PID 838789) (stdout):
            1 │ {
            2 │   "albums": [{
            3 │     "name": {"type": "string", "value": "Born in the USA"}
            4 │   }]
            5 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/table/duplicate-key-06
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 838719):
            1 │ [tbl]
            2 │ [[tbl]]
    
         output from parser-cmd (PID 838719) (stdout):
            1 │ {
            2 │   "tbl": [{}]
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/table/newline-01
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 838922):
            1 │ [tbl
            2 │ ]
            3 │ k = 1
    
         output from parser-cmd (PID 838922) (stdout):
            1 │ {
            2 │   "tbl": {
            3 │     "k": {"type": "integer", "value": "1"}
            4 │   }
            5 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/table/newline-03
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 838918):
            1 │ ["tbl"
            2 │ ]
            3 │ k = 1
    
         output from parser-cmd (PID 838918) (stdout):
            1 │ {
            2 │   "tbl": {
            3 │     "k": {"type": "integer", "value": "1"}
            4 │   }
            5 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/table/newline-05
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 838919):
            1 │ [tbl
            2 │ .sub]
            3 │ k = 1
    
         output from parser-cmd (PID 838919) (stdout):
            1 │ {
            2 │   "tbl": {
            3 │     "sub": {
            4 │       "k": {"type": "integer", "value": "1"}
            5 │     }
            6 │   }
            7 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/table/overwrite-bool-with-array
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 838988):
            1 │ a=true
            2 │ [[a]]
    
         output from parser-cmd (PID 838988) (stdout):
            1 │ {
            2 │   "a": [{}]
            3 │ }
    
         want:
           Exit code 1
    
    FAIL invalid/table/redefine-02
         Expected an error, but no error was reported.
    
         input sent to parser-cmd (PID 838943):
            1 │ [t1]
            2 │ t2.t3.v = 0
            3 │ [t1.t2]
    
         output from parser-cmd (PID 838943) (stdout):
            1 │ {
            2 │   "t1": {
            3 │     "t2": {
            4 │       "t3": {
            5 │         "v": {"type": "integer", "value": "0"}
            6 │       }
            7 │     }
            8 │   }
            9 │ }
    
         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: 822
      valid tests:   0 passed,  0 failed
    encoder tests: no encoder command given
    invalid tests:  52 passed, 10 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 "standard-tables-invalid.py", line 10, in <module>
        assert result.returncode == 0
               ^^^^^^^^^^^^^^^^^^^^^^
    AssertionError

## Post-build programmatic acceptance
- PASS: inline-closure-invalid (FEATURE-Inline-Table-Closure.md)
  intent: The implementation rejects authoritative invalid cases that extend or redefine inline tables.
  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: 856
      valid tests:   0 passed,  0 failed
    encoder tests: no encoder command given
    invalid tests:  28 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: inline-closure-boundary (FEATURE-Inline-Table-Closure.md)
  intent: The implementation passes the authoritative valid inline-table cases while preserving inline-table closure semantics.
  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: 867
      valid tests:  17 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: standard-tables-valid (FEATURE-Standard-Tables.md)
  intent: The implementation passes the authoritative valid TOML standard-table 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: 860
      valid tests:  24 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: standard-tables-invalid (FEATURE-Standard-Tables.md)
  intent: The implementation rejects invalid standard-table header and hierarchy cases in the authoritative suite.
  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: 822
      valid tests:   0 passed,  0 failed
    encoder tests: no encoder command given
    invalid tests:  62 passed,  0 failed
    
    harness: /home/barlo/.local/bin/toml-test toml-test v2.2.0; go1.24.6 linux/amd64; race=false; cgo=true

## Build summary
RESULT: SUCCESS

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

SUMMARY:
Implemented standard tables, implicit/nested table resolution, array-of-table contexts, dotted-key provenance, and inline-table closure enforcement. Added focused tests.

Scoped suites passed:
- Tables: 24 valid, 62 invalid
- Inline tables: 17 valid, 28 invalid
- Go tests passed

BLOCKERS:
- Full suite retains unrelated pre-existing failures in multiline strings, numeric validation, and integer-sign handling.