Inspector¶
The Inspector shows one value in full: the one selected in Variables. Ctrl+I opens it.
Rows in the variable tree are one line each, which is right for scanning a scope and wrong for looking at a 40 KB JSON string. The Inspector is where that value becomes readable.
What it shows¶
For the selected row:
- the name, at the top;
- the shape of the value — what kind of thing the debugger judges it to be;
- the value itself, in a monospaced font, wrapped rather than cut off;
- a warning when the adapter truncated the value, stated explicitly so a partial value is never mistaken for a complete one.
If nothing is selected in Variables, the panel says select a variable.
A byte array is the exception to that list: it has no value of its own to show, and gets its own presentation.
Actions¶
| Button | Effect |
|---|---|
| Copy | copies the value to the clipboard |
| Format as JSON | copies a reformatted version, when the value parses as JSON |
Format as JSON appears only for values that actually parse as JSON. Formatting is a view-only operation: nothing is sent to the adapter and the runtime value is not modified — the value stays owned by the debuggee.
Byte arrays¶
A []byte, a Vec<u8>, a char[] — the tree shows these correctly and
unreadably: forty-eight rows of one number each where the value is a line of
text. For these the Inspector shows the bytes themselves rather than the value
the adapter reported, because the parent's own value carries only len and
cap.
At the top is the size — 48 bytes, or 48 of 512 bytes while part of the
value is still on its way. Below it, a switch:
| Mode | What it shows |
|---|---|
| Text | the bytes decoded as UTF-8; invalid sequences become the replacement character |
| Hex | an xxd-style dump: offset, sixteen bytes, ASCII column |
The mode is chosen for you: mostly printable, valid UTF-8 opens as Text; anything else — a gzip header, a protobuf message, an image — opens as Hex, where a screen of replacement characters would have said nothing. The choice is yours to override, and it lasts as long as the selection: a mode inherited from the previous variable would claim something about the new one that nobody checked.
Copy copies what is on screen — the text in Text mode, the dump in Hex.
The Inspector fetches what it needs. A collapsed node has requested nothing, so selecting one asks for its bytes a page at a time, up to 64 KB — or in one go when the adapter never said how many there are, since there is nothing to paginate by. Past that the value is shown cut off and says so: the panel shows text, not a memory image.
When the adapter truncated the value¶
Adapters cap the length of values they return, and they cap how deep into a
structure they will go. Both show up as a truncation notice: a string cut off
with a ...+1024 more counter, a struct dump that stops at ,..., and a nested
value elided as {...} are all values that arrived incomplete. When the
Inspector says a value was truncated, the missing part was never sent, and no
amount of scrolling will reveal it — the Inspector shows everything that
arrived.
For a structure, the way to see the rest is the tree: expanding a node fetches its fields with the adapter's limits applied afresh, one level at a time.
To see more, ask for the part you need directly rather than for the whole value:
an index range, a field, or a length. Evaluate is the tool for
that — buffer[0:200] returns something the adapter is willing to send whole.
Keyboard¶
The Inspector has no rows of its own, so J / K do nothing here. It follows the selection in Variables: move the selection there, then look here.