Segmented Durable Key-Value Store

Simulate a durable string key-value store over an ordered batch of commands. The durable store is an append-only log split greedily across numbered segments, each with capacity 1024 bytes.
Commands
PUT key value: append a record, set the key to the value using last-write-wins semantics, and return OK. The value is the entire suffix after the second space and may be empty.
GET key: return VALUE:value for a present key, or NOT_FOUND.
RELOAD: discard the in-memory map, rebuild it by replaying every complete record in segment order, and return OK.
SEGMENTS: return SEGMENTS:s1,s2,..., where each number is one segment's used-byte count. With no records, return SEGMENTS:.
Record encoding
Keys and values use printable ASCII, so each character occupies one byte. Encode a record as keyLength:keyvalueLength:value. A record is never split. Before an append that would make the current segment exceed 1024 bytes, start a new segment. Every record fits in one segment.
Return one result string for each command in order.

Function
runSegmentedStore(commands: String[]) → String[]

Examples
Example 1
commands = ["PUT color blue","GET color","PUT color green","RELOAD","GET color","SEGMENTS"]
return = ["OK","VALUE:blue","OK","OK","VALUE:green","SEGMENTS:27"]
The two encoded records use 13 and 14 bytes. Reload replays both records, so the later value green wins.
Example 2
commands = ["GET missing","SEGMENTS","PUT a " ,"RELOAD","GET a","SEGMENTS"]
return = ["NOT_FOUND","SEGMENTS:","OK","OK","VALUE:","SEGMENTS:5"]
An empty value is durable. Its record is 1:a0:: one digit for the key length, two colons, the one-character key, and one digit for the value length, for 5 bytes total.

Constraints
1 <= commands.length <= 2000
Commands are well formed and use one of the four documented operation names.
Keys are non-empty printable-ASCII strings of length at most 100 and contain no spaces.
Values contain printable ASCII characters, may contain spaces, and have length at most 900.
The total length of all command strings is at most 2 * 10^5.
Every encoded record uses at most 1024 bytes.

The trick is that RELOAD is a replay, so you need to store actual records, not only sizes. Keep a list of segments, each a list of (key, value) records plus a used-byte count. On PUT, compute size as len(str(len(key))) + 1 + len(key) + len(str(len(value))) + 1 + len(value). Check example 2: 1:a0:: gives 5, which matches. If used + size exceeds 1024, open a new segment first. The first record in an empty log goes into segment one. Then update the live map. RELOAD clears the map and walks segments in order, last write wins. The common pitfall is parsing PUT with a plain split, which breaks values containing spaces or empty values. Split on the first two spaces only, and keep the trailing suffix intact, even when it's empty. SEGMENTS with no records returns the bare prefix with nothing after the colon. StealthCoder is the hedge if the parsing details slip under the clock.

Memorize the pattern. If you can't, run StealthCoder. The proctor sees the IDE. They don't see what's behind it.