@nice2dev/game-engine 1.0.4 → 1.0.10

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

@@ -0,0 +1,1017 @@
+/**
+ * @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
+ */
+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,
+        };
+    }
+    // ─── 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.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;
+        }
+    }
+    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();
+        }
+        // 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);
+        }
+        // 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;
+            }
+            else {
+                // Manual resolution
+                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;
+        }
+        // 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);
+            }
+        }
+        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;
+        }
+        // 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;
+        }
+    }
+    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 = 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,
+            });
+            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();
+        }
+    }
+    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() % 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 },
+                },
+                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 = 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);
+}
+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,
+        },
+    };
+}
+
+export { UnityLiveLinkClient, createDefaultLiveLinkConfig, createUnityLiveLinkClient, generateUnityLiveLinkPlugin };
+//# sourceMappingURL=UnityLiveLink.js.map