This is where your architecture evolves from a simple parser into a true
multiplayer Virtual Machine.
Because your Control Plane is accessible over HTTP/WebSockets, your Builder
Bots act as privileged clients. They don't need to understand the internal
memory structures of the VM; they just send standardized JSON Remote Procedure
Calls (RPCs) that the engine translates into live FSO state and code
mutations.
Here is a sketch of a robust JSON protocol for live room injection.
The INJECT_ROOM Payload
When a roaming Builder Bot decides the jungle needs a treehouse up in the
canopy, it constructs this payload and fires it at http://localhost:8080/api/vm
/mutate:
{
  "protocol": "FSO_RPC_V1",
  "bot_id": "builder_bot_alpha",
  "intent": "INJECT_ROOM",
  
  "mutation": {
    "anchor": {
      "room_id": "a2_room_jungle",
      "append_desc": " A rope ladder leads UP into the canopy.",
      "add_exit": {
        "direction": "UP",
        "target": "bot_room_treehouse"
      }
    },
    
    "new_state": [
      {
        "opcode": "VAR bot_room_treehouse_DESC STR \"A wooden platform high in
the canopy. Exits: DOWN.\""
      },
      {
        "opcode": "VAR bot_room_treehouse ARR '[]'"
      }
    ],
    
    "new_code": [
      "LBL bot_room_treehouse",
      "ENV_FLUSH",
      "DESC \"A wooden platform high in the canopy. Exits: DOWN.\"",
      "EXIT \"DOWN\" a2_room_jungle",
      "AWAIT"
    ]
  },

  "broadcast": {
    "target_room": "a2_room_jungle",
    "message": "[ENV EVENT]: A strange mechanical whirring echoes through the
jungle as a rope ladder drops from the canopy above!"
  }
}

How the VM Processes This Live
When your FSO Engine receives this JSON, it executes a deterministic, 4-step
hot-patch without dropping a single player connection:
 * The Broadcast: It immediately routes the broadcast.message to any player
currently sitting in a2_room_jungle. This makes the procedural generation feel
like a live, in-universe event rather than a server pop-in.
 * State Registration: It parses the new_state strings through your standard
FSO state parser, dynamically allocating memory for the new VAR identifiers in
the heap.
 * Code Appending: It takes the new_code array, joins it with newlines, and
appends the LBL bot_room_treehouse block directly to the VM's active execution
registry.
 * The Anchor Patch (The Critical Step): It locates a2_room_jungle in active
memory. It appends the new text to VAR a2_room_jungle_DESC, and dynamically
inserts EXIT "UP" bot_room_treehouse into the jungle's routing block just
above the AWAIT.
The Beauty of the Architecture
By using this JSON protocol, the AI (the Builder Bot) never actually touches
your core game files or risks corrupting the active FSO syntax. The bot just
fills out a structured form, and your deterministic engine translates that
form into safe, mathematically sound bytecode changes.
If the bot hallucinates a malformed JSON payload, the Node.js control plane
simply rejects the HTTP request with a 400 Bad Request, and the game world
keeps ticking flawlessly.