The directory tree is perfectly structured, and `10_mesh.js` contains exactly
the right architectural foundation for this. No additional files need to be
refreshed into the context right now.

The genius of `10_mesh.js` is that you've already implemented a Javascript
`Proxy` to trap object mutations. Whenever a property is changed that matches
your regex, it safely queues a `CRDT_MUTATION` payload into an `__OUTBOX`
array and provides a `RAW_TARGET` symbol to bypass infinite feedback loops.

To bridge this into your live DMZ, the HTML frontend just needs to act as the
mail carrier: sweeping the outbox to send messages to the WebSocket, and
catching incoming WebSocket messages to apply them directly to the
`RAW_TARGET` of the local objects.

Here is the exact prompt and attachment list to spin up this new microservice
chat.

### The CRDT Object Sync Chat (Arena D)

* **Attachments to include:**
* `template.html` (The updated version containing your `dmzSocket` logic)
* `10_mesh.js`



* **Copy-paste this prompt into a new chat:**

> **Act as an Expert Distributed Systems and Frontend Engineer.**
> **The Context:** I am building a Decentralized Virtual Machine in the
browser. I have a DMZ WebSocket relay running at `ws://localhost:1777`. My
local VM objects are wrapped in JavaScript Proxies via my `10_mesh.js` module.
When these objects mutate, the Proxy intercepts the change and drops a
`CRDT_MUTATION` payload into an array located at `window.__rt.__OUTBOX`.
> **The Goal:** I need to write the frontend bridge in my HTML file that
connects this `__OUTBOX` to the network, and safely applies incoming network
mutations to local objects.
> **Technical Requirements for `template.html`:**
> 1. **The Outbox Sweeper:** Write a lightweight JavaScript interval (or
observer) that checks `window.__rt.__OUTBOX` every 50ms. If there are pending
payloads, pop them off the array, `JSON.stringify` them, and send them via my
existing `dmzSocket`.
> 2. **The Inbox Receiver:** Update my `dmzSocket.addEventListener('message',
...)` block to handle incoming `CRDT_MUTATION` types.
> 3. **The Infinite-Loop Bypass:** When a `CRDT_MUTATION` arrives, the script
must look up the object using `window.__rt.master_objects[payload.object_id]`.
Crucially, to prevent the local Proxy from re-broadcasting the incoming
network change, the script MUST apply the value using the `RAW_TARGET` symbol
exported by `10_mesh.js` (e.g., `target[Symbol.for("RAW_TARGET")][payload.prope
rty] = payload.value`).
> 4. Do not rewrite `10_mesh.js`; assume it functions exactly as provided.
Provide only the JavaScript additions needed for the `<script>` block in my
HTML template.
> 
> 

Once this chat provides the HTML bridge, your engine will officially support
distributed, real-time object state synchronization across the entire mesh
network. Do you have a specific test object in mind to clone and test this
with once it's wired up?