This is a brilliant evolutionary step. What you are describing is the
industry-standard pattern for scaling complex applications: Server-Driven UI
(SDUI) combined with an Event-Driven Game Master (GM).
By separating the communication layer and the authoritative game loop from the
client, you solve three massive problems at once:
 * Zero UI Rewrites: If the backend dictates what buttons exist and where
entities are, the frontend simply becomes a "dumb renderer" that loops over
JSON arrays and draws what it is told.
 * True Multiplayer: You move from a single-player local filesystem loop to a
real-time synchronized mesh.
 * Headless AI: A Game Master process can easily inject AI players (like an
automated Sushi Bot) that trigger intents exactly like a human player.
Developing an isomorphic communications sidecar is the perfect way to achieve
this.
Here is the architectural blueprint for how we can build this next phase.
1. The Server-Driven UI Pattern (How to avoid rewriting the frontend)
Currently, your frontend hardcodes things like "Draw a Taco Truck here" and
"Show a Buy Sauce button."
To make it modular, we need to introduce a new state file: /world/ui_manifest.j
son. The routine registry will start updating this file based on the game
phase.
For example, when init_match runs, it returns a UI manifest like this:
{
  "buttons": [
    { "id": "btn_buy_sauce", "label": "Buy Secret Sauce (2$)", "intent": {
"actionName": "market_purchase", "payload": {"item": "secret_sauce"} } }
  ],
  "entities": [
    { "id": "taco_bot", "type": "TRUCK", "sprite": "van", "x": 100, "y": 200 }
  ]
}

Your Canvas UI simply loops over state['world.ui_manifest'].entities to draw
them, and loops over .buttons to render HTML buttons. When a button is
clicked, it blindly sends the attached intent back to the backend. You never
have to write UI code for a new action againyou just update the routine to
output the new button.
2. The Isomorphic Comm-Link (The Sidecar)
We need a lightweight, zero-dependency Pub/Sub class that runs in both the
Browser and Node.js. It will connect to a central WebSocket server via your
Cloudflare tunnel.
It should have a beautifully simple API, something like MeshCommLink:
/ Works in Browser or Node.js GM
const comms = new MeshCommLink('wss://gm.omega-mesh.fi');

/ 1. Join a specific game instance
await comms.joinChannel('match_001');

/ 2. Listen for state updates and events broadcasted by the GM
comms.on('STATE_SYNC', (data) => {
    // UI simply overwrites local state and redraws
    storage.writeBatch(data.mutatedState);
    renderer.triggerAnimations(data.events);
});

/ 3. Send Intents blindly
document.getElementById('btn_buy').onclick = () => {
    comms.sendIntent('match_001', 'market_purchase', { item: 'van' });
};

3. The Game Master (Node.js Middleware)
The Game Master (GM) is an ephemeral Node.js process running on your Alpine
server.
It replaces the browser as the "conductor."
The GM's Job:
 * Hold the File Locks: The GM is the sole authority writing to the
filesystem, eliminating race conditions entirely.
 * Receive Intents: It listens to the MeshCommLink for intents from Player A,
Player B, and AIs.
 * Execute: It calls your routine-service (just like the browser did in our
tests).
 * Broadcast: It immediately broadcasts the mutatedState and events back down
the Comm-Link to all connected browsers so their Canvases update
simultaneously.
The Migration Path
To build this without breaking your working setup, we should do it in two
phases:
Phase 1: Build the Comm-Link & GM Prototype
We write a tiny Node.js WebSocket server (the GM) and the comm-link.js
sidecar. We can test it by having two browser windows send intents and
watching them both receive the synchronized state updates.
Phase 2: Introduce SDUI to the Registry
We update omega_ftr_init_match to generate a world.ui_manifest slice. Then you
tell your frontend chat to wipe the hardcoded buttons and render them
dynamically from that JSON slice.
Would you like me to write the comm-link.js and the basic Node.js Game Master
server so we can test the real-time channel?