@nice2dev/game-engine 1.3.14 → 1.3.16

package/dist/cjs/unity-integration/UnityLiveLink.js

@@ -1,1020 +1,973 @@
-'use strict';
-
-/**
- * @file UnityLiveLink.ts
- * @description Unity Live Link system for real-time editor synchronization
- * PRO-1.8.2: Unity Live Link
- *
- * Features:
- * - Unity Editor Plugin (C#) integration
- * - Bidirectional Sync Protocol (WebSocket)
- * - Unity Play Mode Integration
- * - Real-time scene sync
- * - Selection mirroring
- * - Property change streaming
- */
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 class UnityLiveLinkClient {
-    constructor(config = {}) {
-        this.ws = null;
-        this.state = 'disconnected';
-        this.sessionId = '';
-        this.sequence = 0;
-        this.reconnectAttempts = 0;
-        this.heartbeatTimer = null;
-        this.reconnectTimer = null;
-        this.pendingRequests = new Map();
-        this.callbacks = {};
-        // Scene state
-        this.sceneData = new Map();
-        this.selectedIds = [];
-        this.activeId = null;
-        this.versionVector = {};
-        this.pendingChanges = [];
-        this.playModeState = 'stopped';
-        this.config = {
-            serverUrl: 'ws://localhost:9876',
-            autoReconnect: true,
-            reconnectInterval: 3000,
-            maxReconnectAttempts: 10,
-            heartbeatInterval: 5000,
-            connectionTimeout: 10000,
-            syncConfig: {
-                direction: 'bidirectional',
-                conflictResolution: 'lastWriteWins',
-                autoSync: true,
-                syncInterval: 100,
-                componentFilter: [],
-                layerFilter: [],
-                maxPendingChanges: 50,
-            },
-            ...config,
+  constructor(config = {}) {
+    this.ws = null;
+    this.state = "disconnected";
+    this.sessionId = "";
+    this.sequence = 0;
+    this.reconnectAttempts = 0;
+    this.heartbeatTimer = null;
+    this.reconnectTimer = null;
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.callbacks = {};
+    this.sceneData = /* @__PURE__ */ new Map();
+    this.selectedIds = [];
+    this.activeId = null;
+    this.versionVector = {};
+    this.pendingChanges = [];
+    this.playModeState = "stopped";
+    this.config = {
+      serverUrl: "ws://localhost:9876",
+      autoReconnect: true,
+      reconnectInterval: 3e3,
+      maxReconnectAttempts: 10,
+      heartbeatInterval: 5e3,
+      connectionTimeout: 1e4,
+      syncConfig: {
+        direction: "bidirectional",
+        conflictResolution: "lastWriteWins",
+        autoSync: true,
+        syncInterval: 100,
+        componentFilter: [],
+        layerFilter: [],
+        maxPendingChanges: 50
+      },
+      ...config
+    };
+  }
+  // ─── Connection Management ─────────────────────────────
+  async connect() {
+    if (this.state === "connected" || this.state === "connecting") {
+      return;
+    }
+    this.state = "connecting";
+    this.callbacks.onStateChange?.(this.state);
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.ws?.close();
+        reject(new Error("Connection timeout"));
+      }, this.config.connectionTimeout);
+      try {
+        this.ws = new WebSocket(this.config.serverUrl);
+        this.ws.onopen = () => {
+          clearTimeout(timeout);
+          this.state = "authenticating";
+          this.callbacks.onStateChange?.(this.state);
+          this.reconnectAttempts = 0;
+          this.startHeartbeat();
+          this.sendHandshake();
+          resolve();
         };
-    }
-    // ─── Connection Management ─────────────────────────────
-    async connect() {
-        if (this.state === 'connected' || this.state === 'connecting') {
-            return;
-        }
-        this.state = 'connecting';
-        this.callbacks.onStateChange?.(this.state);
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                this.ws?.close();
-                reject(new Error('Connection timeout'));
-            }, this.config.connectionTimeout);
-            try {
-                this.ws = new WebSocket(this.config.serverUrl);
-                this.ws.onopen = () => {
-                    clearTimeout(timeout);
-                    this.state = 'authenticating';
-                    this.callbacks.onStateChange?.(this.state);
-                    this.reconnectAttempts = 0;
-                    this.startHeartbeat();
-                    this.sendHandshake();
-                    resolve();
-                };
-                this.ws.onclose = (event) => {
-                    clearTimeout(timeout);
-                    this.handleDisconnect(event.code, event.reason);
-                };
-                this.ws.onerror = (error) => {
-                    clearTimeout(timeout);
-                    this.state = 'error';
-                    this.callbacks.onStateChange?.(this.state);
-                    this.callbacks.onError?.(new Error('WebSocket error'));
-                    reject(error);
-                };
-                this.ws.onmessage = (event) => {
-                    this.handleMessage(event.data);
-                };
-            }
-            catch (error) {
-                clearTimeout(timeout);
-                this.state = 'error';
-                this.callbacks.onStateChange?.(this.state);
-                reject(error);
-            }
-        });
-    }
-    disconnect() {
-        this.stopHeartbeat();
-        this.stopReconnect();
-        if (this.ws) {
-            this.ws.close(1000, 'Client disconnect');
-            this.ws = null;
-        }
-        this.state = 'disconnected';
-        this.callbacks.onStateChange?.(this.state);
-        this.sessionId = '';
-        this.clearPendingRequests();
-    }
-    handleDisconnect(code, reason) {
-        this.stopHeartbeat();
-        this.state = 'disconnected';
-        this.ws = null;
+        this.ws.onclose = (event) => {
+          clearTimeout(timeout);
+          this.handleDisconnect(event.code, event.reason);
+        };
+        this.ws.onerror = (error) => {
+          clearTimeout(timeout);
+          this.state = "error";
+          this.callbacks.onStateChange?.(this.state);
+          this.callbacks.onError?.(new Error("WebSocket error"));
+          reject(error);
+        };
+        this.ws.onmessage = (event) => {
+          this.handleMessage(event.data);
+        };
+      } catch (error) {
+        clearTimeout(timeout);
+        this.state = "error";
         this.callbacks.onStateChange?.(this.state);
-        this.callbacks.onDisconnected?.(code, reason);
-        if (this.config.autoReconnect && code !== 1000) {
-            this.scheduleReconnect();
-        }
-    }
-    scheduleReconnect() {
-        if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
-            this.callbacks.onError?.(new Error('Max reconnect attempts reached'));
-            return;
-        }
-        this.reconnectAttempts++;
-        this.callbacks.onReconnecting?.(this.reconnectAttempts);
-        this.reconnectTimer = setTimeout(() => {
-            this.connect().catch(() => {
-                // Reconnect will be scheduled again in handleDisconnect
-            });
-        }, this.config.reconnectInterval);
-    }
-    stopReconnect() {
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-        this.reconnectAttempts = 0;
-    }
-    startHeartbeat() {
-        this.heartbeatTimer = setInterval(() => {
-            this.sendPing();
-        }, this.config.heartbeatInterval);
-    }
-    stopHeartbeat() {
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = null;
-        }
-    }
-    // ─── Message Handling ──────────────────────────────────
-    handleMessage(data) {
-        let message;
-        try {
-            message = JSON.parse(data);
-        }
-        catch {
-            this.callbacks.onError?.(new Error('Invalid message format'));
-            return;
-        }
-        // Handle pending request responses
-        if (message.correlationId && this.pendingRequests.has(message.correlationId)) {
-            const pending = this.pendingRequests.get(message.correlationId);
-            clearTimeout(pending.timeout);
-            this.pendingRequests.delete(message.correlationId);
-            pending.resolve(message.payload);
-            return;
-        }
-        // Handle by message type
-        switch (message.type) {
-            case 'handshake_ack':
-                this.handleHandshakeAck(message.payload);
-                break;
-            case 'sync_scene':
-                this.handleSyncScene(message.payload);
-                break;
-            case 'sync_object':
-                this.handleSyncObject(message.payload);
-                break;
-            case 'sync_property':
-                this.handleSyncProperty(message.payload);
-                break;
-            case 'selection_change':
-                this.handleSelectionChange(message.payload);
-                break;
-            case 'create_object':
-                this.handleCreateObject(message.payload);
-                break;
-            case 'delete_object':
-                this.handleDeleteObject(message.payload);
-                break;
-            case 'reparent_object':
-                this.handleReparentObject(message.payload);
-                break;
-            case 'play_mode_start':
-            case 'play_mode_stop':
-            case 'play_mode_pause':
-                this.handlePlayModeChange(message.type, message.payload);
-                break;
-            case 'play_mode_state':
-                this.handlePlayModeState(message.payload);
-                break;
-            case 'hot_reload':
-                this.handleHotReload(message.payload);
-                break;
-            case 'breakpoint_hit':
-                this.handleBreakpoint(message.payload);
-                break;
-            case 'pong':
-                // Heartbeat response, no action needed
-                break;
-            case 'error':
-                this.handleError(message.payload);
-                break;
-        }
+        reject(error);
+      }
+    });
+  }
+  disconnect() {
+    this.stopHeartbeat();
+    this.stopReconnect();
+    if (this.ws) {
+      this.ws.close(1e3, "Client disconnect");
+      this.ws = null;
+    }
+    this.state = "disconnected";
+    this.callbacks.onStateChange?.(this.state);
+    this.sessionId = "";
+    this.clearPendingRequests();
+  }
+  handleDisconnect(code, reason) {
+    this.stopHeartbeat();
+    this.state = "disconnected";
+    this.ws = null;
+    this.callbacks.onStateChange?.(this.state);
+    this.callbacks.onDisconnected?.(code, reason);
+    if (this.config.autoReconnect && code !== 1e3) {
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+      this.callbacks.onError?.(new Error("Max reconnect attempts reached"));
+      return;
+    }
+    this.reconnectAttempts++;
+    this.callbacks.onReconnecting?.(this.reconnectAttempts);
+    this.reconnectTimer = setTimeout(() => {
+      this.connect().catch(() => {
+      });
+    }, this.config.reconnectInterval);
+  }
+  stopReconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.reconnectAttempts = 0;
+  }
+  startHeartbeat() {
+    this.heartbeatTimer = setInterval(() => {
+      this.sendPing();
+    }, this.config.heartbeatInterval);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  // ─── Message Handling ──────────────────────────────────
+  handleMessage(data) {
+    let message;
+    try {
+      message = JSON.parse(data);
+    } catch {
+      this.callbacks.onError?.(new Error("Invalid message format"));
+      return;
+    }
+    if (message.correlationId && this.pendingRequests.has(message.correlationId)) {
+      const pending = this.pendingRequests.get(message.correlationId);
+      clearTimeout(pending.timeout);
+      this.pendingRequests.delete(message.correlationId);
+      pending.resolve(message.payload);
+      return;
+    }
+    switch (message.type) {
+      case "handshake_ack":
+        this.handleHandshakeAck(message.payload);
+        break;
+      case "sync_scene":
+        this.handleSyncScene(message.payload);
+        break;
+      case "sync_object":
+        this.handleSyncObject(message.payload);
+        break;
+      case "sync_property":
+        this.handleSyncProperty(message.payload);
+        break;
+      case "selection_change":
+        this.handleSelectionChange(message.payload);
+        break;
+      case "create_object":
+        this.handleCreateObject(message.payload);
+        break;
+      case "delete_object":
+        this.handleDeleteObject(message.payload);
+        break;
+      case "reparent_object":
+        this.handleReparentObject(message.payload);
+        break;
+      case "play_mode_start":
+      case "play_mode_stop":
+      case "play_mode_pause":
+        this.handlePlayModeChange(message.type, message.payload);
+        break;
+      case "play_mode_state":
+        this.handlePlayModeState(message.payload);
+        break;
+      case "hot_reload":
+        this.handleHotReload(message.payload);
+        break;
+      case "breakpoint_hit":
+        this.handleBreakpoint(message.payload);
+        break;
+      case "pong":
+        break;
+      case "error":
+        this.handleError(message.payload);
+        break;
+    }
+  }
+  handleHandshakeAck(payload) {
+    if (payload.success) {
+      this.sessionId = payload.sessionId;
+      this.config.syncConfig = { ...this.config.syncConfig, ...payload.syncConfig };
+      this.state = "connected";
+      this.callbacks.onStateChange?.(this.state);
+      this.callbacks.onConnected?.(payload.sessionId);
+    } else {
+      this.state = "error";
+      this.callbacks.onStateChange?.(this.state);
+      this.callbacks.onError?.(new Error(payload.error ?? "Handshake failed"));
+      this.disconnect();
+    }
+  }
+  handleSyncScene(payload) {
+    if (payload.isFullSync) {
+      this.sceneData.clear();
+    }
+    const processObject = (obj) => {
+      this.sceneData.set(obj.instanceId, obj);
+    };
+    for (const root of payload.roots) {
+      this.processObjectRecursive(root, processObject);
+    }
+    this.versionVector = { ...this.versionVector, ...payload.versionVector };
+    this.callbacks.onSceneSync?.(payload);
+  }
+  processObjectRecursive(obj, callback) {
+    callback(obj);
+  }
+  handleSyncObject(payload) {
+    const existing = this.sceneData.get(payload.instanceId);
+    if (existing && existing.version >= payload.version) {
+      if (this.config.syncConfig.conflictResolution === "lastWriteWins" || this.config.syncConfig.conflictResolution === "unityWins") ;
+      else if (this.config.syncConfig.conflictResolution === "nice2devWins") {
+        return;
+      } else {
+        this.callbacks.onConflict?.("object", payload.instanceId, existing, payload);
+        return;
+      }
+    }
+    this.sceneData.set(payload.instanceId, payload);
+    this.callbacks.onObjectSync?.(payload);
+  }
+  handleSyncProperty(payload) {
+    const obj = this.sceneData.get(payload.objectInstanceId);
+    if (!obj) {
+      return;
+    }
+    if (payload.componentInstanceId === 0) {
+      this.applyPropertyChange(obj, payload.propertyPath, payload.value);
+    } else {
+      const component = obj.components.find((c) => c.instanceId === payload.componentInstanceId);
+      if (component) {
+        this.applyPropertyChange(component.properties, payload.propertyPath, payload.value);
+      }
+    }
+    this.callbacks.onPropertySync?.(payload);
+  }
+  applyPropertyChange(target, path, value) {
+    const parts = path.split(".");
+    let current = target;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (typeof current[part] !== "object" || current[part] === null) {
+        current[part] = {};
+      }
+      current = current[part];
+    }
+    current[parts[parts.length - 1]] = value;
+  }
+  handleSelectionChange(payload) {
+    if (payload.origin !== "nice2dev") {
+      this.selectedIds = payload.selectedInstanceIds;
+      this.activeId = payload.activeInstanceId;
+      this.callbacks.onSelectionChange?.(payload);
+    }
+  }
+  handleCreateObject(payload) {
+    this.sceneData.set(payload.object.instanceId, payload.object);
+    this.callbacks.onObjectCreated?.(payload);
+  }
+  handleDeleteObject(payload) {
+    for (const id of payload.instanceIds) {
+      if (payload.deleteChildren) {
+        this.deleteObjectAndChildren(id);
+      } else {
+        this.sceneData.delete(id);
+      }
+    }
+    this.callbacks.onObjectDeleted?.(payload);
+  }
+  deleteObjectAndChildren(instanceId) {
+    const obj = this.sceneData.get(instanceId);
+    if (!obj) {
+      return;
+    }
+    for (const childId of obj.children) {
+      this.deleteObjectAndChildren(childId);
+    }
+    this.sceneData.delete(instanceId);
+  }
+  handleReparentObject(payload) {
+    const obj = this.sceneData.get(payload.instanceId);
+    if (!obj) {
+      return;
+    }
+    this.callbacks.onObjectReparented?.(payload);
+  }
+  handlePlayModeChange(type, payload) {
+    this.playModeState = payload.state;
+    switch (type) {
+      case "play_mode_start":
+        this.callbacks.onPlayModeStart?.(payload);
+        break;
+      case "play_mode_stop":
+        this.callbacks.onPlayModeStop?.(payload);
+        break;
+      case "play_mode_pause":
+        this.callbacks.onPlayModePause?.(payload);
+        break;
+    }
+  }
+  handlePlayModeState(payload) {
+    this.playModeState = payload.state;
+    this.callbacks.onPlayModeState?.(payload);
+  }
+  handleHotReload(payload) {
+    this.callbacks.onHotReload?.(payload);
+  }
+  handleBreakpoint(payload) {
+    this.callbacks.onBreakpointHit?.(payload);
+  }
+  handleError(payload) {
+    this.callbacks.onError?.(new Error(`${payload.code}: ${payload.message}`));
+  }
+  // ─── Sending Messages ──────────────────────────────────
+  send(message) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    const fullMessage = {
+      ...message,
+      sequence: this.sequence++,
+      timestamp: Date.now()
+    };
+    this.ws.send(JSON.stringify(fullMessage));
+  }
+  async sendRequest(message, timeout = 1e4) {
+    const correlationId = this.generateCorrelationId();
+    return new Promise((resolve, reject) => {
+      const timeoutHandle = setTimeout(() => {
+        this.pendingRequests.delete(correlationId);
+        reject(new Error("Request timeout"));
+      }, timeout);
+      this.pendingRequests.set(correlationId, {
+        resolve,
+        reject,
+        timeout: timeoutHandle
+      });
+      this.send({ ...message, correlationId });
+    });
+  }
+  clearPendingRequests() {
+    for (const [, pending] of this.pendingRequests) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("Connection closed"));
+    }
+    this.pendingRequests.clear();
+  }
+  generateCorrelationId() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  }
+  sendHandshake() {
+    this.send({
+      type: "handshake",
+      payload: {
+        clientName: "Nice2Dev Game Engine",
+        clientVersion: "1.0.0",
+        protocolVersion: 1,
+        features: ["scene_sync", "selection_mirror", "play_mode", "hot_reload", "breakpoints"]
+      }
+    });
+  }
+  sendPing() {
+    this.send({
+      type: "ping",
+      payload: { timestamp: Date.now() }
+    });
+  }
+  // ─── Public API ────────────────────────────────────────
+  getState() {
+    return this.state;
+  }
+  isConnected() {
+    return this.state === "connected";
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  getPlayModeState() {
+    return this.playModeState;
+  }
+  getSceneData() {
+    return new Map(this.sceneData);
+  }
+  getObject(instanceId) {
+    return this.sceneData.get(instanceId);
+  }
+  getSelectedIds() {
+    return [...this.selectedIds];
+  }
+  getActiveId() {
+    return this.activeId;
+  }
+  // ─── Scene Operations ──────────────────────────────────
+  requestFullSync() {
+    this.send({
+      type: "sync_scene",
+      payload: { requestFullSync: true }
+    });
+  }
+  setSelection(instanceIds, activeId = null) {
+    this.selectedIds = instanceIds;
+    this.activeId = activeId ?? instanceIds[0] ?? null;
+    this.send({
+      type: "selection_change",
+      payload: {
+        selectedInstanceIds: instanceIds,
+        activeInstanceId: this.activeId,
+        origin: "nice2dev"
+      }
+    });
+  }
+  updateProperty(objectInstanceId, componentInstanceId, propertyPath, value) {
+    const payload = {
+      objectInstanceId,
+      componentInstanceId,
+      propertyPath,
+      value,
+      version: Date.now()
+      // Simple version
+    };
+    this.pendingChanges.push(payload);
+    if (this.pendingChanges.length >= this.config.syncConfig.maxPendingChanges) {
+      this.flushPendingChanges();
+    }
+  }
+  flushPendingChanges() {
+    for (const change of this.pendingChanges) {
+      this.send({
+        type: "sync_property",
+        payload: change
+      });
+    }
+    this.pendingChanges = [];
+  }
+  createObject(parentInstanceId, name, position = { x: 0, y: 0, z: 0 }) {
+    const tempInstanceId = -(Date.now() % 1e6);
+    const payload = {
+      parentInstanceId,
+      siblingIndex: -1,
+      // Append
+      object: {
+        instanceId: tempInstanceId,
+        name,
+        isActive: true,
+        layer: 0,
+        tag: "Untagged",
+        transform: {
+          localPosition: position,
+          localRotation: { x: 0, y: 0, z: 0, w: 1 },
+          localScale: { x: 1, y: 1, z: 1 }
+        },
+        components: [],
+        children: [],
+        version: 1
+      }
+    };
+    this.send({
+      type: "create_object",
+      payload
+    });
+  }
+  deleteObjects(instanceIds, deleteChildren = true) {
+    this.send({
+      type: "delete_object",
+      payload: {
+        instanceIds,
+        deleteChildren
+      }
+    });
+  }
+  reparentObject(instanceId, newParentInstanceId, siblingIndex = -1) {
+    this.send({
+      type: "reparent_object",
+      payload: {
+        instanceId,
+        newParentInstanceId,
+        newSiblingIndex: siblingIndex
+      }
+    });
+  }
+  // ─── Play Mode Control ─────────────────────────────────
+  enterPlayMode() {
+    this.send({
+      type: "play_mode_start",
+      payload: {}
+    });
+  }
+  exitPlayMode() {
+    this.send({
+      type: "play_mode_stop",
+      payload: {}
+    });
+  }
+  pausePlayMode() {
+    this.send({
+      type: "play_mode_pause",
+      payload: {}
+    });
+  }
+  togglePlayMode() {
+    if (this.playModeState === "stopped") {
+      this.enterPlayMode();
+    } else if (this.playModeState === "playing") {
+      this.pausePlayMode();
+    } else {
+      this.enterPlayMode();
+    }
+  }
+  // ─── Hot Reload ────────────────────────────────────────
+  triggerHotReload(scriptPaths) {
+    this.send({
+      type: "hot_reload",
+      payload: { scripts: scriptPaths ?? [] }
+    });
+  }
+  // ─── Callbacks ─────────────────────────────────────────
+  setCallbacks(callbacks) {
+    this.callbacks = { ...this.callbacks, ...callbacks };
+  }
+  onStateChange(callback) {
+    this.callbacks.onStateChange = callback;
+    return () => {
+      this.callbacks.onStateChange = void 0;
+    };
+  }
+  onConnected(callback) {
+    this.callbacks.onConnected = callback;
+    return () => {
+      this.callbacks.onConnected = void 0;
+    };
+  }
+  onDisconnected(callback) {
+    this.callbacks.onDisconnected = callback;
+    return () => {
+      this.callbacks.onDisconnected = void 0;
+    };
+  }
+  onSceneSync(callback) {
+    this.callbacks.onSceneSync = callback;
+    return () => {
+      this.callbacks.onSceneSync = void 0;
+    };
+  }
+}
+function generateUnityLiveLinkPlugin(config) {
+  const ns = config?.namespace ?? "Nice2Dev.LiveLink";
+  const className = config?.className ?? "Nice2DevLiveLinkEditor";
+  const port = config?.defaultPort ?? 9876;
+  return `// Auto-generated Unity Editor Plugin for Nice2Dev Live Link
+// Place this in Assets/Editor/Nice2Dev/
+
+using System;
+using System.Collections.Generic;
+using System.Net.WebSockets;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using UnityEditor;
+using UnityEngine;
+
+namespace ${ns}
+{
+    [Serializable]
+    public class LiveLinkMessage
+    {
+        public string type;
+        public int sequence;
+        public long timestamp;
+        public string correlationId;
+        public string payload;
     }
-    handleHandshakeAck(payload) {
-        if (payload.success) {
-            this.sessionId = payload.sessionId;
-            this.config.syncConfig = { ...this.config.syncConfig, ...payload.syncConfig };
-            this.state = 'connected';
-            this.callbacks.onStateChange?.(this.state);
-            this.callbacks.onConnected?.(payload.sessionId);
-        }
-        else {
-            this.state = 'error';
-            this.callbacks.onStateChange?.(this.state);
-            this.callbacks.onError?.(new Error(payload.error ?? 'Handshake failed'));
-            this.disconnect();
+
+    public class ${className} : EditorWindow
+    {
+        private ClientWebSocket _webSocket;
+        private CancellationTokenSource _tokenSource;
+        private string _serverUrl = "ws://localhost:${port}";
+        private string _connectionStatus = "Disconnected";
+        private bool _isConnected = false;
+        private int _sequence = 0;
+        
+        private Vector2 _scrollPos;
+        private List<string> _log = new List<string>();
+
+        [MenuItem("Window/Nice2Dev/Live Link")]
+        public static void ShowWindow()
+        {
+            GetWindow<${className}>("Nice2Dev Live Link");
         }
-    }
-    handleSyncScene(payload) {
-        if (payload.isFullSync) {
-            this.sceneData.clear();
+
+        private void OnEnable()
+        {
+            EditorApplication.update += OnEditorUpdate;
+            Selection.selectionChanged += OnSelectionChanged;
+            EditorApplication.playModeStateChanged += OnPlayModeChanged;
         }
-        // Build scene data map
-        const processObject = (obj) => {
-            this.sceneData.set(obj.instanceId, obj);
-            // Note: children are instance IDs, not full objects in delta sync
-        };
-        for (const root of payload.roots) {
-            this.processObjectRecursive(root, processObject);
+
+        private void OnDisable()
+        {
+            EditorApplication.update -= OnEditorUpdate;
+            Selection.selectionChanged -= OnSelectionChanged;
+            EditorApplication.playModeStateChanged -= OnPlayModeChanged;
+            Disconnect();
         }
-        // Update version vector
-        this.versionVector = { ...this.versionVector, ...payload.versionVector };
-        this.callbacks.onSceneSync?.(payload);
-    }
-    processObjectRecursive(obj, callback) {
-        callback(obj);
-        // Children in full sync would be full objects; in delta sync they're IDs
-        // This simplified version assumes IDs only
-    }
-    handleSyncObject(payload) {
-        const existing = this.sceneData.get(payload.instanceId);
-        // Conflict detection
-        if (existing && existing.version >= payload.version) {
-            if (this.config.syncConfig.conflictResolution === 'lastWriteWins' ||
-                this.config.syncConfig.conflictResolution === 'unityWins') ;
-            else if (this.config.syncConfig.conflictResolution === 'nice2devWins') {
-                // Reject, keep our version
-                return;
+
+        private void OnGUI()
+        {
+            GUILayout.Label("Nice2Dev Live Link", EditorStyles.boldLabel);
+            
+            EditorGUILayout.BeginHorizontal();
+            _serverUrl = EditorGUILayout.TextField("Server URL", _serverUrl);
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.BeginHorizontal();
+            GUI.enabled = !_isConnected;
+            if (GUILayout.Button("Connect"))
+            {
+                Connect();
             }
-            else {
-                // Manual resolution
-                this.callbacks.onConflict?.('object', payload.instanceId, existing, payload);
-                return;
+            GUI.enabled = _isConnected;
+            if (GUILayout.Button("Disconnect"))
+            {
+                Disconnect();
             }
-        }
-        this.sceneData.set(payload.instanceId, payload);
-        this.callbacks.onObjectSync?.(payload);
-    }
-    handleSyncProperty(payload) {
-        const obj = this.sceneData.get(payload.objectInstanceId);
-        if (!obj) {
-            return;
-        }
-        // Apply property change
-        if (payload.componentInstanceId === 0) {
-            // GameObject property
-            this.applyPropertyChange(obj, payload.propertyPath, payload.value);
-        }
-        else {
-            // Component property
-            const component = obj.components.find((c) => c.instanceId === payload.componentInstanceId);
-            if (component) {
-                this.applyPropertyChange(component.properties, payload.propertyPath, payload.value);
+            GUI.enabled = true;
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.LabelField("Status:", _connectionStatus);
+            
+            EditorGUILayout.Space();
+            
+            if (_isConnected)
+            {
+                if (GUILayout.Button("Sync Scene"))
+                {
+                    SendSceneData();
+                }
             }
-        }
-        this.callbacks.onPropertySync?.(payload);
-    }
-    applyPropertyChange(target, path, value) {
-        const parts = path.split('.');
-        let current = target;
-        for (let i = 0; i < parts.length - 1; i++) {
-            const part = parts[i];
-            if (typeof current[part] !== 'object' || current[part] === null) {
-                current[part] = {};
+
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Log:", EditorStyles.boldLabel);
+            
+            _scrollPos = EditorGUILayout.BeginScrollView(_scrollPos, GUILayout.Height(200));
+            foreach (var entry in _log)
+            {
+                EditorGUILayout.LabelField(entry);
+            }
+            EditorGUILayout.EndScrollView();
+
+            if (GUILayout.Button("Clear Log"))
+            {
+                _log.Clear();
             }
-            current = current[part];
-        }
-        current[parts[parts.length - 1]] = value;
-    }
-    handleSelectionChange(payload) {
-        if (payload.origin !== 'nice2dev') {
-            this.selectedIds = payload.selectedInstanceIds;
-            this.activeId = payload.activeInstanceId;
-            this.callbacks.onSelectionChange?.(payload);
         }
-    }
-    handleCreateObject(payload) {
-        this.sceneData.set(payload.object.instanceId, payload.object);
-        this.callbacks.onObjectCreated?.(payload);
-    }
-    handleDeleteObject(payload) {
-        for (const id of payload.instanceIds) {
-            if (payload.deleteChildren) {
-                this.deleteObjectAndChildren(id);
+
+        private async void Connect()
+        {
+            try
+            {
+                _tokenSource = new CancellationTokenSource();
+                _webSocket = new ClientWebSocket();
+                
+                _connectionStatus = "Connecting...";
+                Log("Connecting to " + _serverUrl);
+                
+                await _webSocket.ConnectAsync(new Uri(_serverUrl), _tokenSource.Token);
+                
+                _isConnected = true;
+                _connectionStatus = "Connected";
+                Log("Connected successfully");
+                
+                SendHandshake();
+                _ = ReceiveLoop();
             }
-            else {
-                this.sceneData.delete(id);
+            catch (Exception ex)
+            {
+                _connectionStatus = "Error: " + ex.Message;
+                Log("Connection error: " + ex.Message);
+                _isConnected = false;
             }
         }
-        this.callbacks.onObjectDeleted?.(payload);
-    }
-    deleteObjectAndChildren(instanceId) {
-        const obj = this.sceneData.get(instanceId);
-        if (!obj) {
-            return;
-        }
-        for (const childId of obj.children) {
-            this.deleteObjectAndChildren(childId);
+
+        private void Disconnect()
+        {
+            _tokenSource?.Cancel();
+            _webSocket?.Dispose();
+            _webSocket = null;
+            _isConnected = false;
+            _connectionStatus = "Disconnected";
+            Log("Disconnected");
         }
-        this.sceneData.delete(instanceId);
-    }
-    handleReparentObject(payload) {
-        const obj = this.sceneData.get(payload.instanceId);
-        if (!obj) {
-            return;
+
+        private async Task ReceiveLoop()
+        {
+            var buffer = new byte[65536];
+            
+            while (_isConnected && _webSocket?.State == WebSocketState.Open)
+            {
+                try
+                {
+                    var result = await _webSocket.ReceiveAsync(
+                        new ArraySegment<byte>(buffer), 
+                        _tokenSource.Token
+                    );
+                    
+                    if (result.MessageType == WebSocketMessageType.Close)
+                    {
+                        Disconnect();
+                        break;
+                    }
+                    
+                    var json = Encoding.UTF8.GetString(buffer, 0, result.Count);
+                    HandleMessage(json);
+                }
+                catch (OperationCanceledException)
+                {
+                    break;
+                }
+                catch (Exception ex)
+                {
+                    Log("Receive error: " + ex.Message);
+                    break;
+                }
+            }
         }
-        // Update parent references would need to be implemented
-        // based on how parent relationships are tracked
-        this.callbacks.onObjectReparented?.(payload);
-    }
-    handlePlayModeChange(type, payload) {
-        this.playModeState = payload.state;
-        switch (type) {
-            case 'play_mode_start':
-                this.callbacks.onPlayModeStart?.(payload);
-                break;
-            case 'play_mode_stop':
-                this.callbacks.onPlayModeStop?.(payload);
-                break;
-            case 'play_mode_pause':
-                this.callbacks.onPlayModePause?.(payload);
-                break;
+
+        private void HandleMessage(string json)
+        {
+            try
+            {
+                var message = JsonUtility.FromJson<LiveLinkMessage>(json);
+                Log($"Received: {message.type}");
+                
+                switch (message.type)
+                {
+                    case "handshake_ack":
+                        Log("Handshake acknowledged");
+                        break;
+                    case "sync_property":
+                        // Handle property sync from Nice2Dev
+                        break;
+                    case "selection_change":
+                        // Handle selection change from Nice2Dev
+                        break;
+                    case "play_mode_start":
+                        EditorApplication.isPlaying = true;
+                        break;
+                    case "play_mode_stop":
+                        EditorApplication.isPlaying = false;
+                        break;
+                    case "ping":
+                        SendPong();
+                        break;
+                }
+            }
+            catch (Exception ex)
+            {
+                Log("Message parse error: " + ex.Message);
+            }
         }
-    }
-    handlePlayModeState(payload) {
-        this.playModeState = payload.state;
-        this.callbacks.onPlayModeState?.(payload);
-    }
-    handleHotReload(payload) {
-        this.callbacks.onHotReload?.(payload);
-    }
-    handleBreakpoint(payload) {
-        this.callbacks.onBreakpointHit?.(payload);
-    }
-    handleError(payload) {
-        this.callbacks.onError?.(new Error(`${payload.code}: ${payload.message}`));
-    }
-    // ─── Sending Messages ──────────────────────────────────
-    send(message) {
-        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-            return;
+
+        private void SendMessage(string type, object payload)
+        {
+            if (!_isConnected || _webSocket?.State != WebSocketState.Open)
+                return;
+            
+            var message = new
+            {
+                type = type,
+                sequence = _sequence++,
+                timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+                payload = payload
+            };
+            
+            var json = JsonUtility.ToJson(message);
+            var bytes = Encoding.UTF8.GetBytes(json);
+            
+            _ = _webSocket.SendAsync(
+                new ArraySegment<byte>(bytes),
+                WebSocketMessageType.Text,
+                true,
+                _tokenSource.Token
+            );
         }
-        const fullMessage = {
-            ...message,
-            sequence: this.sequence++,
-            timestamp: Date.now(),
-        };
-        this.ws.send(JSON.stringify(fullMessage));
-    }
-    async sendRequest(message, timeout = 10000) {
-        const correlationId = this.generateCorrelationId();
-        return new Promise((resolve, reject) => {
-            const timeoutHandle = setTimeout(() => {
-                this.pendingRequests.delete(correlationId);
-                reject(new Error('Request timeout'));
-            }, timeout);
-            this.pendingRequests.set(correlationId, {
-                resolve: resolve,
-                reject,
-                timeout: timeoutHandle,
+
+        private void SendHandshake()
+        {
+            SendMessage("handshake", new
+            {
+                clientName = "Unity Editor",
+                clientVersion = Application.unityVersion,
+                protocolVersion = 1,
+                features = new[] { "scene_sync", "selection_mirror", "play_mode", "hot_reload" },
+                projectPath = Application.dataPath,
+                unityVersion = Application.unityVersion
             });
-            this.send({ ...message, correlationId });
-        });
-    }
-    clearPendingRequests() {
-        for (const [, pending] of this.pendingRequests) {
-            clearTimeout(pending.timeout);
-            pending.reject(new Error('Connection closed'));
         }
-        this.pendingRequests.clear();
-    }
-    generateCorrelationId() {
-        return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    }
-    sendHandshake() {
-        this.send({
-            type: 'handshake',
-            payload: {
-                clientName: 'Nice2Dev Game Engine',
-                clientVersion: '1.0.0',
-                protocolVersion: 1,
-                features: ['scene_sync', 'selection_mirror', 'play_mode', 'hot_reload', 'breakpoints'],
-            },
-        });
-    }
-    sendPing() {
-        this.send({
-            type: 'ping',
-            payload: { timestamp: Date.now() },
-        });
-    }
-    // ─── Public API ────────────────────────────────────────
-    getState() {
-        return this.state;
-    }
-    isConnected() {
-        return this.state === 'connected';
-    }
-    getSessionId() {
-        return this.sessionId;
-    }
-    getPlayModeState() {
-        return this.playModeState;
-    }
-    getSceneData() {
-        return new Map(this.sceneData);
-    }
-    getObject(instanceId) {
-        return this.sceneData.get(instanceId);
-    }
-    getSelectedIds() {
-        return [...this.selectedIds];
-    }
-    getActiveId() {
-        return this.activeId;
-    }
-    // ─── Scene Operations ──────────────────────────────────
-    requestFullSync() {
-        this.send({
-            type: 'sync_scene',
-            payload: { requestFullSync: true },
-        });
-    }
-    setSelection(instanceIds, activeId = null) {
-        this.selectedIds = instanceIds;
-        this.activeId = activeId ?? instanceIds[0] ?? null;
-        this.send({
-            type: 'selection_change',
-            payload: {
-                selectedInstanceIds: instanceIds,
-                activeInstanceId: this.activeId,
-                origin: 'nice2dev',
-            },
-        });
-    }
-    updateProperty(objectInstanceId, componentInstanceId, propertyPath, value) {
-        const payload = {
-            objectInstanceId,
-            componentInstanceId,
-            propertyPath,
-            value,
-            version: Date.now(), // Simple version
-        };
-        // Buffer change for batch sending
-        this.pendingChanges.push(payload);
-        // Flush if over threshold
-        if (this.pendingChanges.length >= this.config.syncConfig.maxPendingChanges) {
-            this.flushPendingChanges();
+
+        private void SendPong()
+        {
+            SendMessage("pong", new { timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() });
         }
-    }
-    flushPendingChanges() {
-        for (const change of this.pendingChanges) {
-            this.send({
-                type: 'sync_property',
-                payload: change,
+
+        private void SendSceneData()
+        {
+            var scene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
+            var roots = scene.GetRootGameObjects();
+            var syncRoots = new List<object>();
+            
+            foreach (var root in roots)
+            {
+                syncRoots.Add(SerializeGameObject(root));
+            }
+            
+            SendMessage("sync_scene", new
+            {
+                sceneName = scene.name,
+                scenePath = scene.path,
+                sceneGUID = AssetDatabase.AssetPathToGUID(scene.path),
+                roots = syncRoots,
+                isFullSync = true,
+                versionVector = new Dictionary<string, int>()
             });
+            
+            Log($"Sent scene data: {roots.Length} root objects");
         }
-        this.pendingChanges = [];
-    }
-    createObject(parentInstanceId, name, position = { x: 0, y: 0, z: 0 }) {
-        const tempInstanceId = -(Date.now() % 1000000); // Negative temp ID
-        const payload = {
-            parentInstanceId,
-            siblingIndex: -1, // Append
-            object: {
-                instanceId: tempInstanceId,
-                name,
-                isActive: true,
-                layer: 0,
-                tag: 'Untagged',
-                transform: {
-                    localPosition: position,
-                    localRotation: { x: 0, y: 0, z: 0, w: 1 },
-                    localScale: { x: 1, y: 1, z: 1 },
+
+        private object SerializeGameObject(GameObject go)
+        {
+            var components = new List<object>();
+            foreach (var comp in go.GetComponents<Component>())
+            {
+                if (comp == null) continue;
+                components.Add(new
+                {
+                    instanceId = comp.GetInstanceID(),
+                    typeName = comp.GetType().Name,
+                    enabled = comp is Behaviour b ? b.enabled : true,
+                    properties = new Dictionary<string, object>()
+                });
+            }
+            
+            var children = new List<int>();
+            for (int i = 0; i < go.transform.childCount; i++)
+            {
+                children.Add(go.transform.GetChild(i).gameObject.GetInstanceID());
+            }
+            
+            return new
+            {
+                instanceId = go.GetInstanceID(),
+                name = go.name,
+                isActive = go.activeSelf,
+                layer = go.layer,
+                tag = go.tag,
+                transform = new
+                {
+                    localPosition = new { x = go.transform.localPosition.x, y = go.transform.localPosition.y, z = go.transform.localPosition.z },
+                    localRotation = new { x = go.transform.localRotation.x, y = go.transform.localRotation.y, z = go.transform.localRotation.z, w = go.transform.localRotation.w },
+                    localScale = new { x = go.transform.localScale.x, y = go.transform.localScale.y, z = go.transform.localScale.z }
                 },
-                components: [],
-                children: [],
-                version: 1,
-            },
-        };
-        this.send({
-            type: 'create_object',
-            payload,
-        });
-    }
-    deleteObjects(instanceIds, deleteChildren = true) {
-        this.send({
-            type: 'delete_object',
-            payload: {
-                instanceIds,
-                deleteChildren,
-            },
-        });
-    }
-    reparentObject(instanceId, newParentInstanceId, siblingIndex = -1) {
-        this.send({
-            type: 'reparent_object',
-            payload: {
-                instanceId,
-                newParentInstanceId,
-                newSiblingIndex: siblingIndex,
-            },
-        });
-    }
-    // ─── Play Mode Control ─────────────────────────────────
-    enterPlayMode() {
-        this.send({
-            type: 'play_mode_start',
-            payload: {},
-        });
-    }
-    exitPlayMode() {
-        this.send({
-            type: 'play_mode_stop',
-            payload: {},
-        });
-    }
-    pausePlayMode() {
-        this.send({
-            type: 'play_mode_pause',
-            payload: {},
-        });
-    }
-    togglePlayMode() {
-        if (this.playModeState === 'stopped') {
-            this.enterPlayMode();
+                components = components,
+                children = children,
+                version = 1
+            };
         }
-        else if (this.playModeState === 'playing') {
-            this.pausePlayMode();
+
+        private void OnSelectionChanged()
+        {
+            if (!_isConnected) return;
+            
+            var ids = new List<int>();
+            foreach (var obj in Selection.gameObjects)
+            {
+                ids.Add(obj.GetInstanceID());
+            }
+            
+            SendMessage("selection_change", new
+            {
+                selectedInstanceIds = ids,
+                activeInstanceId = Selection.activeGameObject?.GetInstanceID() ?? 0,
+                origin = "unity"
+            });
         }
-        else {
-            this.enterPlayMode();
+
+        private void OnPlayModeChanged(PlayModeStateChange state)
+        {
+            if (!_isConnected) return;
+            
+            string messageType = state switch
+            {
+                PlayModeStateChange.EnteredPlayMode => "play_mode_start",
+                PlayModeStateChange.ExitingPlayMode => "play_mode_stop",
+                PlayModeStateChange.EnteredEditMode => "play_mode_stop",
+                _ => null
+            };
+            
+            if (messageType != null)
+            {
+                SendMessage(messageType, new
+                {
+                    state = EditorApplication.isPlaying ? "playing" : "stopped",
+                    gameTime = Time.time,
+                    frameCount = Time.frameCount,
+                    targetFrameRate = Application.targetFrameRate,
+                    actualFps = 1.0f / Time.deltaTime
+                });
+            }
+        }
+
+        private void OnEditorUpdate()
+        {
+            // Could implement periodic state sync here
+        }
+
+        private void Log(string message)
+        {
+            _log.Add($"[{DateTime.Now:HH:mm:ss}] {message}");
+            if (_log.Count > 100)
+            {
+                _log.RemoveAt(0);
+            }
+            Repaint();
         }
-    }
-    // ─── Hot Reload ────────────────────────────────────────
-    triggerHotReload(scriptPaths) {
-        this.send({
-            type: 'hot_reload',
-            payload: { scripts: scriptPaths ?? [] },
-        });
-    }
-    // ─── Callbacks ─────────────────────────────────────────
-    setCallbacks(callbacks) {
-        this.callbacks = { ...this.callbacks, ...callbacks };
-    }
-    onStateChange(callback) {
-        this.callbacks.onStateChange = callback;
-        return () => {
-            this.callbacks.onStateChange = undefined;
-        };
-    }
-    onConnected(callback) {
-        this.callbacks.onConnected = callback;
-        return () => {
-            this.callbacks.onConnected = undefined;
-        };
-    }
-    onDisconnected(callback) {
-        this.callbacks.onDisconnected = callback;
-        return () => {
-            this.callbacks.onDisconnected = undefined;
-        };
-    }
-    onSceneSync(callback) {
-        this.callbacks.onSceneSync = callback;
-        return () => {
-            this.callbacks.onSceneSync = undefined;
-        };
     }
 }
-// ============================================================
-// Unity C# Plugin Generator
-// ============================================================
-function generateUnityLiveLinkPlugin(config) {
-    const ns = config?.namespace ?? 'Nice2Dev.LiveLink';
-    const className = config?.className ?? 'Nice2DevLiveLinkEditor';
-    const port = config?.defaultPort ?? 9876;
-    return `// Auto-generated Unity Editor Plugin for Nice2Dev Live Link
-// Place this in Assets/Editor/Nice2Dev/
-
-using System;
-using System.Collections.Generic;
-using System.Net.WebSockets;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using UnityEditor;
-using UnityEngine;
-
-namespace ${ns}
-{
-    [Serializable]
-    public class LiveLinkMessage
-    {
-        public string type;
-        public int sequence;
-        public long timestamp;
-        public string correlationId;
-        public string payload;
-    }
-
-    public class ${className} : EditorWindow
-    {
-        private ClientWebSocket _webSocket;
-        private CancellationTokenSource _tokenSource;
-        private string _serverUrl = "ws://localhost:${port}";
-        private string _connectionStatus = "Disconnected";
-        private bool _isConnected = false;
-        private int _sequence = 0;
-        
-        private Vector2 _scrollPos;
-        private List<string> _log = new List<string>();
-
-        [MenuItem("Window/Nice2Dev/Live Link")]
-        public static void ShowWindow()
-        {
-            GetWindow<${className}>("Nice2Dev Live Link");
-        }
-
-        private void OnEnable()
-        {
-            EditorApplication.update += OnEditorUpdate;
-            Selection.selectionChanged += OnSelectionChanged;
-            EditorApplication.playModeStateChanged += OnPlayModeChanged;
-        }
-
-        private void OnDisable()
-        {
-            EditorApplication.update -= OnEditorUpdate;
-            Selection.selectionChanged -= OnSelectionChanged;
-            EditorApplication.playModeStateChanged -= OnPlayModeChanged;
-            Disconnect();
-        }
-
-        private void OnGUI()
-        {
-            GUILayout.Label("Nice2Dev Live Link", EditorStyles.boldLabel);
-            
-            EditorGUILayout.BeginHorizontal();
-            _serverUrl = EditorGUILayout.TextField("Server URL", _serverUrl);
-            EditorGUILayout.EndHorizontal();
-
-            EditorGUILayout.BeginHorizontal();
-            GUI.enabled = !_isConnected;
-            if (GUILayout.Button("Connect"))
-            {
-                Connect();
-            }
-            GUI.enabled = _isConnected;
-            if (GUILayout.Button("Disconnect"))
-            {
-                Disconnect();
-            }
-            GUI.enabled = true;
-            EditorGUILayout.EndHorizontal();
-
-            EditorGUILayout.LabelField("Status:", _connectionStatus);
-            
-            EditorGUILayout.Space();
-            
-            if (_isConnected)
-            {
-                if (GUILayout.Button("Sync Scene"))
-                {
-                    SendSceneData();
-                }
-            }
-
-            EditorGUILayout.Space();
-            EditorGUILayout.LabelField("Log:", EditorStyles.boldLabel);
-            
-            _scrollPos = EditorGUILayout.BeginScrollView(_scrollPos, GUILayout.Height(200));
-            foreach (var entry in _log)
-            {
-                EditorGUILayout.LabelField(entry);
-            }
-            EditorGUILayout.EndScrollView();
-
-            if (GUILayout.Button("Clear Log"))
-            {
-                _log.Clear();
-            }
-        }
-
-        private async void Connect()
-        {
-            try
-            {
-                _tokenSource = new CancellationTokenSource();
-                _webSocket = new ClientWebSocket();
-                
-                _connectionStatus = "Connecting...";
-                Log("Connecting to " + _serverUrl);
-                
-                await _webSocket.ConnectAsync(new Uri(_serverUrl), _tokenSource.Token);
-                
-                _isConnected = true;
-                _connectionStatus = "Connected";
-                Log("Connected successfully");
-                
-                SendHandshake();
-                _ = ReceiveLoop();
-            }
-            catch (Exception ex)
-            {
-                _connectionStatus = "Error: " + ex.Message;
-                Log("Connection error: " + ex.Message);
-                _isConnected = false;
-            }
-        }
-
-        private void Disconnect()
-        {
-            _tokenSource?.Cancel();
-            _webSocket?.Dispose();
-            _webSocket = null;
-            _isConnected = false;
-            _connectionStatus = "Disconnected";
-            Log("Disconnected");
-        }
-
-        private async Task ReceiveLoop()
-        {
-            var buffer = new byte[65536];
-            
-            while (_isConnected && _webSocket?.State == WebSocketState.Open)
-            {
-                try
-                {
-                    var result = await _webSocket.ReceiveAsync(
-                        new ArraySegment<byte>(buffer), 
-                        _tokenSource.Token
-                    );
-                    
-                    if (result.MessageType == WebSocketMessageType.Close)
-                    {
-                        Disconnect();
-                        break;
-                    }
-                    
-                    var json = Encoding.UTF8.GetString(buffer, 0, result.Count);
-                    HandleMessage(json);
-                }
-                catch (OperationCanceledException)
-                {
-                    break;
-                }
-                catch (Exception ex)
-                {
-                    Log("Receive error: " + ex.Message);
-                    break;
-                }
-            }
-        }
-
-        private void HandleMessage(string json)
-        {
-            try
-            {
-                var message = JsonUtility.FromJson<LiveLinkMessage>(json);
-                Log($"Received: {message.type}");
-                
-                switch (message.type)
-                {
-                    case "handshake_ack":
-                        Log("Handshake acknowledged");
-                        break;
-                    case "sync_property":
-                        // Handle property sync from Nice2Dev
-                        break;
-                    case "selection_change":
-                        // Handle selection change from Nice2Dev
-                        break;
-                    case "play_mode_start":
-                        EditorApplication.isPlaying = true;
-                        break;
-                    case "play_mode_stop":
-                        EditorApplication.isPlaying = false;
-                        break;
-                    case "ping":
-                        SendPong();
-                        break;
-                }
-            }
-            catch (Exception ex)
-            {
-                Log("Message parse error: " + ex.Message);
-            }
-        }
-
-        private void SendMessage(string type, object payload)
-        {
-            if (!_isConnected || _webSocket?.State != WebSocketState.Open)
-                return;
-            
-            var message = new
-            {
-                type = type,
-                sequence = _sequence++,
-                timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
-                payload = payload
-            };
-            
-            var json = JsonUtility.ToJson(message);
-            var bytes = Encoding.UTF8.GetBytes(json);
-            
-            _ = _webSocket.SendAsync(
-                new ArraySegment<byte>(bytes),
-                WebSocketMessageType.Text,
-                true,
-                _tokenSource.Token
-            );
-        }
-
-        private void SendHandshake()
-        {
-            SendMessage("handshake", new
-            {
-                clientName = "Unity Editor",
-                clientVersion = Application.unityVersion,
-                protocolVersion = 1,
-                features = new[] { "scene_sync", "selection_mirror", "play_mode", "hot_reload" },
-                projectPath = Application.dataPath,
-                unityVersion = Application.unityVersion
-            });
-        }
-
-        private void SendPong()
-        {
-            SendMessage("pong", new { timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() });
-        }
-
-        private void SendSceneData()
-        {
-            var scene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
-            var roots = scene.GetRootGameObjects();
-            var syncRoots = new List<object>();
-            
-            foreach (var root in roots)
-            {
-                syncRoots.Add(SerializeGameObject(root));
-            }
-            
-            SendMessage("sync_scene", new
-            {
-                sceneName = scene.name,
-                scenePath = scene.path,
-                sceneGUID = AssetDatabase.AssetPathToGUID(scene.path),
-                roots = syncRoots,
-                isFullSync = true,
-                versionVector = new Dictionary<string, int>()
-            });
-            
-            Log($"Sent scene data: {roots.Length} root objects");
-        }
-
-        private object SerializeGameObject(GameObject go)
-        {
-            var components = new List<object>();
-            foreach (var comp in go.GetComponents<Component>())
-            {
-                if (comp == null) continue;
-                components.Add(new
-                {
-                    instanceId = comp.GetInstanceID(),
-                    typeName = comp.GetType().Name,
-                    enabled = comp is Behaviour b ? b.enabled : true,
-                    properties = new Dictionary<string, object>()
-                });
-            }
-            
-            var children = new List<int>();
-            for (int i = 0; i < go.transform.childCount; i++)
-            {
-                children.Add(go.transform.GetChild(i).gameObject.GetInstanceID());
-            }
-            
-            return new
-            {
-                instanceId = go.GetInstanceID(),
-                name = go.name,
-                isActive = go.activeSelf,
-                layer = go.layer,
-                tag = go.tag,
-                transform = new
-                {
-                    localPosition = new { x = go.transform.localPosition.x, y = go.transform.localPosition.y, z = go.transform.localPosition.z },
-                    localRotation = new { x = go.transform.localRotation.x, y = go.transform.localRotation.y, z = go.transform.localRotation.z, w = go.transform.localRotation.w },
-                    localScale = new { x = go.transform.localScale.x, y = go.transform.localScale.y, z = go.transform.localScale.z }
-                },
-                components = components,
-                children = children,
-                version = 1
-            };
-        }
-
-        private void OnSelectionChanged()
-        {
-            if (!_isConnected) return;
-            
-            var ids = new List<int>();
-            foreach (var obj in Selection.gameObjects)
-            {
-                ids.Add(obj.GetInstanceID());
-            }
-            
-            SendMessage("selection_change", new
-            {
-                selectedInstanceIds = ids,
-                activeInstanceId = Selection.activeGameObject?.GetInstanceID() ?? 0,
-                origin = "unity"
-            });
-        }
-
-        private void OnPlayModeChanged(PlayModeStateChange state)
-        {
-            if (!_isConnected) return;
-            
-            string messageType = state switch
-            {
-                PlayModeStateChange.EnteredPlayMode => "play_mode_start",
-                PlayModeStateChange.ExitingPlayMode => "play_mode_stop",
-                PlayModeStateChange.EnteredEditMode => "play_mode_stop",
-                _ => null
-            };
-            
-            if (messageType != null)
-            {
-                SendMessage(messageType, new
-                {
-                    state = EditorApplication.isPlaying ? "playing" : "stopped",
-                    gameTime = Time.time,
-                    frameCount = Time.frameCount,
-                    targetFrameRate = Application.targetFrameRate,
-                    actualFps = 1.0f / Time.deltaTime
-                });
-            }
-        }
-
-        private void OnEditorUpdate()
-        {
-            // Could implement periodic state sync here
-        }
-
-        private void Log(string message)
-        {
-            _log.Add($"[{DateTime.Now:HH:mm:ss}] {message}");
-            if (_log.Count > 100)
-            {
-                _log.RemoveAt(0);
-            }
-            Repaint();
-        }
-    }
-}
 `;
 }
-// ============================================================
-// Factory Functions
-// ============================================================
 function createUnityLiveLinkClient(config) {
-    return new UnityLiveLinkClient(config);
+  return new UnityLiveLinkClient(config);
 }
 function createDefaultLiveLinkConfig() {
-    return {
-        serverUrl: 'ws://localhost:9876',
-        autoReconnect: true,
-        reconnectInterval: 3000,
-        maxReconnectAttempts: 10,
-        heartbeatInterval: 5000,
-        connectionTimeout: 10000,
-        syncConfig: {
-            direction: 'bidirectional',
-            conflictResolution: 'lastWriteWins',
-            autoSync: true,
-            syncInterval: 100,
-            componentFilter: [],
-            layerFilter: [],
-            maxPendingChanges: 50,
-        },
-    };
+  return {
+    serverUrl: "ws://localhost:9876",
+    autoReconnect: true,
+    reconnectInterval: 3e3,
+    maxReconnectAttempts: 10,
+    heartbeatInterval: 5e3,
+    connectionTimeout: 1e4,
+    syncConfig: {
+      direction: "bidirectional",
+      conflictResolution: "lastWriteWins",
+      autoSync: true,
+      syncInterval: 100,
+      componentFilter: [],
+      layerFilter: [],
+      maxPendingChanges: 50
+    }
+  };
 }
-
 exports.UnityLiveLinkClient = UnityLiveLinkClient;
 exports.createDefaultLiveLinkConfig = createDefaultLiveLinkConfig;
 exports.createUnityLiveLinkClient = createUnityLiveLinkClient;