Encoder emits an empty-object table cell as a valueless key: line, which decode then drops ([{"a":{}}] -> [{}])

[antrixy]

Description

When toon-python encodes an array of objects (a "table") and a cell value is an empty
object {}, it emits the key as a bare "key:" line with no value. Decoding that back drops
the key, so the round-trip loses data. This is an encoder bug: it reproduces whenever
toon-python encodes (python->ts and python->python) but not on ts->python, so the
decoder is fine and the loss is in the representation toon-python emits. The reference
impl @toon-format/toon round-trips [{"a":{}}] correctly.

Reproduction Steps

1. from toon_format import encode, decode
2. toon = encode([{"a":{}}])
3. decode(toon)

Expected Behavior

The round-trip preserves the value: decode(encode([{"a":{}}])) == [{"a":{}}].
(The reference impl @toon-format/toon does this correctly.)

Actual Behavior

encode([{"a":{}}]) produces:

[1]:
  -
    a:

The "a" key is emitted with no value. decode() of that returns:

[{}]

The "a" key has been dropped.

Environment

toon-python (toon_format): 0.9.0b1
reference impl @toon-format/toon: v2.3.0 (round-trips this input correctly)
Python: 3.14

Additional Context

The key name is irrelevant — [{"a":{}}] and [{"n":{}}] both reproduce it.

In a larger table, a {}-valued cell collapses the whole row:
input: [{"a":1,"b":2},{"a":{},"b":4}]
output: [{"a":1,"b":2},{}]

Boundary, reduced with a differential fuzzer + delta-shrinker, to [{"a":{}}]:
the container must be an array of objects, and a cell value must be an empty object {}.
A non-empty object value in the same position round-trips fine.

[antrixy]

Follow-up from further reduction: the trigger is tighter than "a cell value is an empty object" — it's specifically an empty object as the first field of a list-array element. An empty-object field in any later position round-trips fine, as long as an earlier field anchors the list-item dash:

[{"a":{}}]             -> '[1]:\n  -\n    a:'               -> [{}]                    ✗
[{"a":{},"b":1}]       -> '[1]:\n  -\n    a:\n    b: 1'      -> [{}]                    ✗  (b:1 lost too)
[{"a":{},"b":{}}]      -> '[1]:\n  -\n    a:\n    b:'        -> [{}]                    ✗
[{"a":1,"b":{}}]       -> '[1]:\n  - a: 1\n    b:'           -> [{"a":1,"b":{}}]        ✓
[{"a":1,"b":{},"c":2}] -> '[1]:\n  - a: 1\n    b:\n    c: 2' -> [{"a":1,"b":{},"c":2}]  ✓

The pattern is visible in the encode output: when the first field is empty, the encoder emits a bare - and drops the key onto the next line as a valueless a:. Nothing binds the following field lines to that list item, so the element decodes to {}. When a scalar first field anchors the dash (- a: 1), a later empty-object field emits inline and survives — which is why the fix likely belongs at the emit site: give an empty-object first field an inline anchor after the dash.

Two things this adds to the report above:

The collapse takes valid siblings with it. [{"a":{},"b":1}] loses b: 1, not just the empty a — the orphaned dash breaks the whole element. Same effect as the larger-table example in the description, where the empty-first row collapsed and dropped its b.

All-empty-first rows are a hard error, not silent loss. The description's example had one bad row among good ones and collapsed silently. When every row has an empty first field, the miscount becomes fatal:

[{"a":{},"b":1},{"a":{},"b":2}]
  -> '[2]:\n  -\n    a:\n    b: 1\n  -\n    a:\n    b: 2'
  -> ToonDecodeError: Expected 2 items, but got 1

Contrast that pins the diagnosis: an empty array first field renders - a[0]: (inline after the dash) and round-trips fine — [{"a":[]}] -> [{"a":[]}]. So this is specific to how empty objects open a list item, not empty containers in general.

Build: toon_format 0.9.0b1 @ e475c82, Python 3.14.3. Cases reduced/expanded with toon-diff.