This is the defining moment where your project transcends from a single game
into a generic Server-Driven Multiplayer Engine.

By saving these two files into an omega-mesh-core directory, you will have a
pristine, reusable foundation. Any future gamewhether a cyberpunk hacking sim,
a fantasy RPG, or a supply-chain managerwill just require writing new state
schemas and pure functions, leaving this core engine completely untouched.

Here is your packaged engine template.

1. The Isomorphic Network Layer (comm-link.js)

This class runs identically in the browser (Canvas UI) and in Node.js
(Autonomous Bots, Chaos Director). It abstracts the WebSocket connection into
a simple event emitter.

/ omega-mesh-core/comm-link.js export class MeshCommLink { /** * @param
{string} url - The WebSocket URL (e.g., 'wss://gm.omega-mesh.fi') * @param
{Object} [wsPolyfill] - Pass the 'ws' package in Node.js, omit in browsers. */
constructor(url, wsPolyfill = null) { this.url = url; this.listeners = new
Map(); // Isomorphic WebSocket instantiation if (wsPolyfill) { this.ws = new
wsPolyfill(url); } else if (typeof window !== 'undefined' && window.WebSocket)
{ this.ws = new WebSocket(url); } else { throw new Error("No WebSocket
implementation available."); } this.ws.onopen = () => console.log(`[CommLink]
Securely Connected to GM at ${this.url}`); this.ws.onerror = (e) =>
console.error(`[CommLink] Connection Error.`, e); this.ws.onclose = () =>
console.log(`[CommLink] Disconnected from GM.`); this.ws.onmessage = (event)
=> { try { const msg = JSON.parse(event.data); if (this.listeners.has(msg.type)
) { this.listeners.get(msg.type).forEach(cb => cb(msg.payload)); } } catch
(err) { console.error("[CommLink] Parse error:", err); } }; } on(type,
callback) { if (!this.listeners.has(type)) this.listeners.set(type, []);
this.listeners.get(type).push(callback); } _send(type, payload) { if
(this.ws.readyState === 1) { this.ws.send(JSON.stringify({ type, payload }));
} } joinChannel(channelId) { this._send('JOIN', { channel: channelId }); }
sendIntent(channelId, actionName, intentPayload) { this._send('INTENT', {
channel: channelId, actionName, intent: intentPayload }); } } 

2. The Authoritative Core (gm-server.js)

This is the heart of the engine. It maintains reality, routes requests to your
pure-logic edge registry, dynamically regenerates the Server-Driven UI (SDUI),
and provides the God-Mode backdoor for the Chaos Director.

/ omega-mesh-core/gm-server.js import { WebSocketServer } from 'ws'; // Note:
Import or setup your Edge Registry connector here (e.g., fetch to your harness
API) import { registry } from './registry-connector.js'; const PORT = 28080;
const wss = new WebSocketServer({ port: PORT }); // The Master State Tree &
Channel Subscriptions const channels = new Map(); const authoritativeState =
{}; console.log(`[OMEGA Mesh Engine] Game Master Authority running on port
${PORT}`); wss.on('connection', (ws) => { ws.on('message', async (message) =>
{ try { const { type, payload } = JSON.parse(message); // 1. CLIENT CONNECTION
if (type === 'JOIN') { if (!channels.has(payload.channel)) channels.set(payload
.channel, new Set()); channels.get(payload.channel).add(ws); // Immediately
sync current reality to the new client ws.send(JSON.stringify({ type:
'STATE_SYNC', payload: { mutatedState: authoritativeState, events:
['CLIENT_CONNECTED'] } })); } // 2. STANDARD GAME INTENT (Routed through Pure
Functions) if (type === 'INTENT') { await processIntent(payload.channel,
payload.actionName, payload.intent); } // 3. GOD-MODE / CHAOS DIRECTOR
BACKDOOR if (type === 'ADMIN_PATCH') { const { channel, statePatch, eventName
} = payload; console.log(`[GM-ADMIN] Intervention on ${channel}:`, eventName);
// Forcibly overwrite reality for (const [key, val] of Object.entries(statePatc
h)) { authoritativeState[key] = val; } // Re-run the SDUI pipeline to update
the frontend for the new reality await rebuildUI(channel); broadcast(channel,
statePatch, [eventName || 'ADMIN_INTERVENTION']); } } catch (e) {
console.error('[GM] Message Error:', e.message); } }); ws.on('close', () => {
channels.forEach(clients => clients.delete(ws)); }); }); // --- CORE PIPELINES
--- async function processIntent(channel, actionName, intent) {
console.log(`[GM] Routing intent '${actionName}'...`); try { // 1. Run Pure
Logic Sandbox const result = await registry.run(actionName, { state:
authoritativeState, intent }); // 2. Apply Permitted Mutations if
(result.mutatedState) { fo
r (const [key, val] of Object.entries(result.mutatedState)) {
authoritativeState[key] = val; } } // 3. Post-Process Server-Driven UI await
rebuildUI(channel, intent); // 4. Synchronize Network broadcast(channel,
result.mutatedState, result.events); console.log(`[GM] Broadcasted events
[${result.events.join(', ')}]`); } catch (e) { console.error(`[GM] Intent
execution failed:`, e.message); } } async function rebuildUI(channel,
triggerIntent = {}) { if (!authoritativeState['world.status']) return; // Game
hasn't started try { // 'update_ui' is the engine standard for generating
'world.ui_manifest' const uiResult = await registry.run('update_ui', { state:
authoritativeState, intent: triggerIntent }); if (uiResult.mutatedState['world.
ui_manifest']) { authoritativeState['world.ui_manifest'] = uiResult.mutatedStat
e['world.ui_manifest']; } } catch (uiErr) { console.error('[GM] UI Pipeline
Error:', uiErr.message); } } function broadcast(channel, mutatedState, events)
{ const clients = channels.get(channel) || new Set(); const syncMessage =
JSON.stringify({ type: 'STATE_SYNC', payload: { mutatedState, events } });
clients.forEach(client => { if (client.readyState === 1) client.send(syncMessag
e); }); } // --- ENGINE HEARTBEAT (Auto-Tick) --- setInterval(async () => { if
(authoritativeState['world.status']?.active) { // Identify all active actors
on the board generically const activePlayers = Object.keys(authoritativeState)
.filter(key => key.startsWith('players.') && key.endsWith('.core')) .map(key
=> key.split('.')[1]); if (activePlayers.length > 0) { // 'resolve_round' is
the engine standard for time advancement await processIntent('match_01',
'resolve_round', { players: activePlayers }); } } }, 10000); // 10 Second
global tick 

Next Steps for the OMEGA Mesh

You now hold the keys to an incredibly powerful, generic platform. The rules
of the game exist strictly in your edge routines; the server merely
orchestrates time and truth.