@concavejs/devtools 0.0.1-alpha.10

package/dist/vite-plugin.js

@@ -0,0 +1,668 @@
+function c(o = {}) {
+  const { enabled: s = !0, position: a = "bottom-right" } = o;
+  let t = !1;
+  return {
+    name: "concave-devtools",
+    configResolved(e) {
+      t = e.mode === "development";
+    },
+    transformIndexHtml: {
+      order: "pre",
+      handler(e) {
+        if (!t || !s)
+          return e;
+        const i = `
+<script>
+  // Initialize event store immediately
+  (function() {
+    if (window.__concaveDevTools) return;
+    
+    console.log('[DevTools] Installing WebSocket interceptor...');
+    
+    // Minimal event store for capturing events
+    window.__concaveDevToolsEvents = [];
+    window.__concaveDevToolsPendingQueries = new Map();
+    window.__concaveDevToolsPendingMutations = new Map();
+    window.__concaveDevToolsPendingActions = new Map();
+    window.__concaveDevToolsPendingAuthTokenType = null;
+
+    // Latency simulation config (mutated by devtools settings panel)
+    if (!window.__concaveDevToolsLatencyConfig) {
+      window.__concaveDevToolsLatencyConfig = { latencyMs: 0, jitterMs: 0 };
+    }
+
+    var __concaveSanitizeLatency = function(value) {
+      var parsed = Number(value);
+      if (!Number.isFinite(parsed) || parsed <= 0) return 0;
+      return Math.min(parsed, 5000);
+    };
+
+    var __concaveGetLatencyDelay = function() {
+      var cfg = window.__concaveDevToolsLatencyConfig;
+      if (!cfg) return 0;
+      var base = __concaveSanitizeLatency(cfg.latencyMs);
+      var jitter = __concaveSanitizeLatency(cfg.jitterMs);
+      if (base <= 0 && jitter <= 0) return 0;
+      if (base > 0 && jitter > base) jitter = base;
+      return Math.max(0, base + (jitter > 0 ? (Math.random() * 2 - 1) * jitter : 0));
+    };
+
+    var __concaveInternalMessageListener = Symbol.for('__concaveDevToolsInternalWsListener');
+    var __concaveLatencyDelaySymbol = Symbol.for('__concaveDevToolsWsDelayMs');
+    var __concaveGetDelayForEvent = function(event) {
+      if (!event || typeof event !== 'object') return __concaveGetLatencyDelay();
+      var existing = event[__concaveLatencyDelaySymbol];
+      if (typeof existing === 'number' && isFinite(existing) && existing >= 0) {
+        return existing;
+      }
+      var sampled = __concaveGetLatencyDelay();
+      try {
+        Object.defineProperty(event, __concaveLatencyDelaySymbol, {
+          value: sampled,
+          configurable: true
+        });
+      } catch (e) {
+        event[__concaveLatencyDelaySymbol] = sampled;
+      }
+      return sampled;
+    };
+    var __concaveInvokeWithLatency = function(listener, target, event) {
+      if (typeof listener !== 'function') return;
+      if (listener[__concaveInternalMessageListener]) {
+        listener.call(target, event);
+        return;
+      }
+      var delay = 0;
+      try {
+        delay = __concaveGetDelayForEvent(event);
+      } catch (e) {
+        delay = 0;
+      }
+      if (delay > 0) {
+        setTimeout(function() {
+          listener.call(target, event);
+        }, delay);
+        return;
+      }
+      listener.call(target, event);
+    };
+
+    const OriginalWebSocket = window.WebSocket;
+
+    const emitAuthEvent = (direction, messageType, status, details, error, tokenType) => {
+      const now = Date.now();
+      window.__concaveDevToolsEvents.push({
+        id: 'auth-' + direction + '-' + messageType + '-' + now + '-' + Math.random().toString(36).slice(2, 8),
+        timestamp: now,
+        type: 'auth',
+        direction,
+        messageType,
+        status,
+        tokenType,
+        error,
+        details,
+      });
+    };
+
+    const decodeJwtClaims = (token) => {
+      const parts = token.split('.');
+      if (parts.length < 2) return null;
+      try {
+        const normalized = parts[1].replace(/-/g, '+').replace(/_/g, '/');
+        const padded = normalized + '='.repeat((4 - (normalized.length % 4)) % 4);
+        const payload = JSON.parse(atob(padded));
+        const keys = ['iss', 'sub', 'aud', 'exp', 'iat', 'nbf'];
+        const claims = {};
+        keys.forEach((key) => {
+          if (payload[key] !== undefined) claims[key] = payload[key];
+        });
+        if (typeof claims.exp === 'number') claims.expIso = new Date(claims.exp * 1000).toISOString();
+        if (typeof claims.iat === 'number') claims.iatIso = new Date(claims.iat * 1000).toISOString();
+        return Object.keys(claims).length > 0 ? claims : null;
+      } catch (e) {
+        return null;
+      }
+    };
+    
+    // Create intercepted WebSocket constructor
+    window.WebSocket = function(url, protocols) {
+      const ws = new OriginalWebSocket(url, protocols);
+
+      // Intercept send
+      const originalSend = ws.send.bind(ws);
+      ws.send = function(data) {
+        if (typeof data === 'string') {
+          try {
+            const msg = JSON.parse(data);
+            const now = Date.now();
+
+            if (msg.type === 'Connect') {
+              const connectDetails = {};
+              if (typeof msg.connectionCount === 'number') connectDetails.connectionCount = msg.connectionCount;
+              if (typeof msg.lastCloseReason === 'string') connectDetails.lastCloseReason = msg.lastCloseReason;
+              if (typeof msg.clientTs === 'number') connectDetails.clientTs = msg.clientTs;
+              if (typeof msg.sessionId === 'string') connectDetails.sessionId = msg.sessionId;
+              emitAuthEvent('client', 'Connect', 'success', connectDetails, undefined, undefined);
+            }
+
+            if (msg.type === 'Authenticate') {
+              const authDetails = {};
+              if (typeof msg.baseVersion === 'number') authDetails.baseVersion = msg.baseVersion;
+              if (typeof msg.tokenType === 'string') authDetails.tokenType = msg.tokenType;
+              if (typeof msg.value === 'string' && msg.value.length > 0) {
+                authDetails.tokenLength = msg.value.length;
+                authDetails.tokenPreview = msg.value.length > 24
+                  ? msg.value.slice(0, 12) + '…' + msg.value.slice(-10)
+                  : msg.value;
+                const claims = decodeJwtClaims(msg.value);
+                if (claims) authDetails.jwtClaims = claims;
+              }
+              window.__concaveDevToolsPendingAuthTokenType = msg.tokenType || 'Unknown';
+              emitAuthEvent('client', 'Authenticate', 'success', authDetails, undefined, msg.tokenType);
+            }
+            
+            // Track queries
+            if (msg.type === 'ModifyQuerySet' && msg.modifications) {
+              msg.modifications.forEach(mod => {
+                if (mod.type === 'Add') {
+                  window.__concaveDevToolsPendingQueries.set(mod.queryId, {
+                    queryId: mod.queryId,
+                    udfPath: mod.udfPath,
+                    args: mod.args,
+                    componentPath: mod.componentPath,
+                    startTime: now
+                  });
+                  
+                  window.__concaveDevToolsEvents.push({
+                    id: 'sub-' + mod.queryId + '-' + now,
+                    timestamp: now,
+                    type: 'subscription',
+                    queryId: mod.queryId,
+                    udfPath: mod.udfPath,
+                    args: mod.args,
+                    componentPath: mod.componentPath,
+                    status: 'added'
+                  });
+
+                  window.__concaveDevToolsEvents.push({
+                    id: 'query-pending-' + mod.queryId + '-' + now,
+                    timestamp: now,
+                    type: 'query',
+                    queryId: mod.queryId,
+                    udfPath: mod.udfPath,
+                    args: mod.args,
+                    componentPath: mod.componentPath,
+                    status: 'pending'
+                  });
+                } else if (mod.type === 'Remove') {
+                  const pending = window.__concaveDevToolsPendingQueries.get(mod.queryId);
+                  window.__concaveDevToolsPendingQueries.delete(mod.queryId);
+                  // Emit removed subscription if we have context
+                  window.__concaveDevToolsEvents.push({
+                    id: 'sub-' + mod.queryId + '-' + now,
+                    timestamp: now,
+                    type: 'subscription',
+                    queryId: mod.queryId,
+                    udfPath: pending ? pending.udfPath : 'unknown',
+                    args: pending ? pending.args : [],
+                    componentPath: pending ? pending.componentPath : undefined,
+                    status: 'removed'
+                  });
+                }
+              });
+            }
+            
+            // Track mutations
+            if (msg.type === 'Mutation') {
+              window.__concaveDevToolsPendingMutations.set(msg.requestId, {
+                requestId: msg.requestId,
+                udfPath: msg.udfPath,
+                args: msg.args,
+                componentPath: msg.componentPath,
+                startTime: now
+              });
+
+              window.__concaveDevToolsEvents.push({
+                id: 'mutation-pending-' + msg.requestId + '-' + now,
+                timestamp: now,
+                type: 'mutation',
+                requestId: msg.requestId,
+                udfPath: msg.udfPath,
+                args: msg.args,
+                componentPath: msg.componentPath,
+                status: 'pending'
+              });
+            }
+            
+            // Track actions
+            if (msg.type === 'Action') {
+              window.__concaveDevToolsPendingActions.set(msg.requestId, {
+                requestId: msg.requestId,
+                udfPath: msg.udfPath,
+                args: msg.args,
+                componentPath: msg.componentPath,
+                startTime: now
+              });
+
+              window.__concaveDevToolsEvents.push({
+                id: 'action-pending-' + msg.requestId + '-' + now,
+                timestamp: now,
+                type: 'action',
+                requestId: msg.requestId,
+                udfPath: msg.udfPath,
+                args: msg.args,
+                componentPath: msg.componentPath,
+                status: 'pending'
+              });
+            }
+          } catch (e) {
+            console.warn('[DevTools] Error parsing client message:', e);
+          }
+        }
+        return originalSend(data);
+      };
+      
+      // Intercept message handlers and keep listener identity stable so removeEventListener works.
+      const originalAddEventListener = ws.addEventListener.bind(ws);
+      const originalRemoveEventListener = ws.removeEventListener.bind(ws);
+      const messageListenerWrappers = new WeakMap();
+      ws.addEventListener = function(type, listener, options) {
+        if (type === 'message' && typeof listener === 'function') {
+          let wrappedListener = messageListenerWrappers.get(listener);
+          if (!wrappedListener) {
+            wrappedListener = function(event) {
+              try {
+                const msg = JSON.parse(event.data);
+                const now = Date.now();
+                const delayMs = __concaveGetDelayForEvent(event);
+
+                if (msg.type === 'AuthError') {
+                  const errorDetails = {};
+                  if (typeof msg.baseVersion === 'number') errorDetails.baseVersion = msg.baseVersion;
+                  if (typeof msg.authUpdateAttempted === 'boolean') errorDetails.authUpdateAttempted = msg.authUpdateAttempted;
+                  emitAuthEvent('server', 'AuthError', 'error', errorDetails, msg.error || 'Authentication failed', window.__concaveDevToolsPendingAuthTokenType || undefined);
+                  window.__concaveDevToolsPendingAuthTokenType = null;
+                }
+                
+                // Handle transitions (query updates)
+                if (msg.type === 'Transition' && msg.modifications) {
+                  if (window.__concaveDevToolsPendingAuthTokenType) {
+                    emitAuthEvent(
+                      'server',
+                      'Authenticated',
+                      'success',
+                      { modificationCount: msg.modifications.length },
+                      undefined,
+                      window.__concaveDevToolsPendingAuthTokenType
+                    );
+                    window.__concaveDevToolsPendingAuthTokenType = null;
+                  }
+                  msg.modifications.forEach(mod => {
+                    if (mod.type === 'QueryUpdated' || mod.type === 'QueryFailed') {
+                      const pending = window.__concaveDevToolsPendingQueries.get(mod.queryId);
+                      if (pending) {
+                        const duration = now - pending.startTime;
+                        window.__concaveDevToolsEvents.push({
+                          id: 'query-' + mod.queryId + '-' + now,
+                          timestamp: now,
+                          type: 'query',
+                          queryId: mod.queryId,
+                          udfPath: pending.udfPath,
+                          args: pending.args,
+                          componentPath: pending.componentPath,
+                          status: mod.type === 'QueryUpdated' ? 'success' : 'error',
+                          result: mod.type === 'QueryUpdated' ? mod.value : undefined,
+                          error: mod.type === 'QueryFailed' ? mod.errorMessage : undefined,
+                          trace: mod.type === 'QueryUpdated' ? mod.trace : undefined,
+                          logLines: mod.logLines,
+                          duration: duration,
+                          simulatedDelayMs: delayMs,
+                          endToEndDurationMs: duration + delayMs
+                        });
+                        
+                        // Extract log events
+                        if (mod.logLines && mod.logLines.length > 0) {
+                          mod.logLines.forEach(logLine => {
+                            const match = logLine.match(/^\\[(log|info|warn|error)\\]\\s+(.+)$/i);
+                            const level = match ? match[1].toLowerCase() : 'log';
+                            const message = match ? match[2] : logLine;
+                            window.__concaveDevToolsEvents.push({
+                              id: 'log-' + now + '-' + Math.random(),
+                              timestamp: now,
+                              type: 'log',
+                              level: level,
+                              message: message,
+                              relatedEventId: 'query-' + mod.queryId + '-' + now
+                            });
+                          });
+                        }
+                      }
+                    }
+                  });
+                }
+                
+                // Handle mutation responses
+                if (msg.type === 'MutationResponse') {
+                  const pending = window.__concaveDevToolsPendingMutations.get(msg.requestId);
+                  if (pending) {
+                    const duration = now - pending.startTime;
+                    window.__concaveDevToolsEvents.push({
+                      id: 'mutation-' + msg.requestId + '-' + now,
+                      timestamp: now,
+                      type: 'mutation',
+                      requestId: msg.requestId,
+                      udfPath: pending.udfPath,
+                      args: pending.args,
+                      componentPath: pending.componentPath,
+                      status: msg.success ? 'success' : 'error',
+                      result: msg.success ? msg.result : undefined,
+                      error: !msg.success ? msg.result : undefined,
+                      trace: msg.trace,
+                      logLines: msg.logLines,
+                      duration: duration,
+                      simulatedDelayMs: delayMs,
+                      endToEndDurationMs: duration + delayMs
+                    });
+                    
+                    // Extract log events
+                    if (msg.logLines && msg.logLines.length > 0) {
+                      msg.logLines.forEach(logLine => {
+                        const match = logLine.match(/^\\[(log|info|warn|error)\\]\\s+(.+)$/i);
+                        const level = match ? match[1].toLowerCase() : 'log';
+                        const message = match ? match[2] : logLine;
+                        window.__concaveDevToolsEvents.push({
+                          id: 'log-' + now + '-' + Math.random(),
+                          timestamp: now,
+                          type: 'log',
+                          level: level,
+                          message: message,
+                          relatedEventId: 'mutation-' + msg.requestId + '-' + now
+                        });
+                      });
+                    }
+                    
+                    window.__concaveDevToolsPendingMutations.delete(msg.requestId);
+                  }
+                }
+                
+                // Handle action responses
+                if (msg.type === 'ActionResponse') {
+                  const pending = window.__concaveDevToolsPendingActions.get(msg.requestId);
+                  if (pending) {
+                    const duration = now - pending.startTime;
+                    window.__concaveDevToolsEvents.push({
+                      id: 'action-' + msg.requestId + '-' + now,
+                      timestamp: now,
+                      type: 'action',
+                      requestId: msg.requestId,
+                      udfPath: pending.udfPath,
+                      args: pending.args,
+                      componentPath: pending.componentPath,
+                      status: msg.success ? 'success' : 'error',
+                      result: msg.success ? msg.result : undefined,
+                      error: !msg.success ? msg.result : undefined,
+                      trace: msg.trace,
+                      logLines: msg.logLines,
+                      duration: duration,
+                      simulatedDelayMs: delayMs,
+                      endToEndDurationMs: duration + delayMs
+                    });
+                    
+                    // Extract log events
+                    if (msg.logLines && msg.logLines.length > 0) {
+                      msg.logLines.forEach(logLine => {
+                        const match = logLine.match(/^\\[(log|info|warn|error)\\]\\s+(.+)$/i);
+                        const level = match ? match[1].toLowerCase() : 'log';
+                        const message = match ? match[2] : logLine;
+                        window.__concaveDevToolsEvents.push({
+                          id: 'log-' + now + '-' + Math.random(),
+                          timestamp: now,
+                          type: 'log',
+                          level: level,
+                          message: message,
+                          relatedEventId: 'action-' + msg.requestId + '-' + now
+                        });
+                      });
+                    }
+                    
+                    window.__concaveDevToolsPendingActions.delete(msg.requestId);
+                  }
+                }
+              } catch (e) {
+                console.warn('[DevTools] Error parsing server message:', e);
+              }
+              __concaveInvokeWithLatency(listener, ws, event);
+            };
+            wrappedListener[__concaveInternalMessageListener] = true;
+            messageListenerWrappers.set(listener, wrappedListener);
+          }
+          return originalAddEventListener('message', wrappedListener, options);
+        }
+        return originalAddEventListener(type, listener, options);
+      };
+
+      ws.removeEventListener = function(type, listener, options) {
+        if (type === 'message' && typeof listener === 'function') {
+          const wrappedListener = messageListenerWrappers.get(listener);
+          return originalRemoveEventListener('message', wrappedListener || listener, options);
+        }
+        return originalRemoveEventListener(type, listener, options);
+      };
+
+      // Intercept onmessage assignment as well
+      (function(){
+        let currentHandler = null;
+        let currentOnMessageWrapper = null;
+        Object.defineProperty(ws, 'onmessage', {
+          configurable: true,
+          enumerable: true,
+          get() {
+            return currentHandler;
+          },
+          set(handler) {
+            // Remove previous wrapper if present
+            if (currentOnMessageWrapper) {
+              originalRemoveEventListener('message', currentOnMessageWrapper);
+              currentOnMessageWrapper = null;
+            }
+            currentHandler = handler;
+            if (typeof handler === 'function') {
+              const wrapper = function(event) {
+                try {
+                  const msg = JSON.parse(event.data);
+                  const now = Date.now();
+                  const delayMs = __concaveGetDelayForEvent(event);
+
+                  if (msg.type === 'AuthError') {
+                    const errorDetails = {};
+                    if (typeof msg.baseVersion === 'number') errorDetails.baseVersion = msg.baseVersion;
+                    if (typeof msg.authUpdateAttempted === 'boolean') errorDetails.authUpdateAttempted = msg.authUpdateAttempted;
+                    emitAuthEvent('server', 'AuthError', 'error', errorDetails, msg.error || 'Authentication failed', window.__concaveDevToolsPendingAuthTokenType || undefined);
+                    window.__concaveDevToolsPendingAuthTokenType = null;
+                  }
+
+                  // Mirror the same processing as in addEventListener wrapper
+                  if (msg.type === 'Transition' && msg.modifications) {
+                    if (window.__concaveDevToolsPendingAuthTokenType) {
+                      emitAuthEvent(
+                        'server',
+                        'Authenticated',
+                        'success',
+                        { modificationCount: msg.modifications.length },
+                        undefined,
+                        window.__concaveDevToolsPendingAuthTokenType
+                      );
+                      window.__concaveDevToolsPendingAuthTokenType = null;
+                    }
+                    msg.modifications.forEach(mod => {
+                      if (mod.type === 'QueryUpdated' || mod.type === 'QueryFailed') {
+                        const pending = window.__concaveDevToolsPendingQueries.get(mod.queryId);
+                        if (pending) {
+                          const duration = now - pending.startTime;
+                          window.__concaveDevToolsEvents.push({
+                            id: 'query-' + mod.queryId + '-' + now,
+                            timestamp: now,
+                            type: 'query',
+                            queryId: mod.queryId,
+                            udfPath: pending.udfPath,
+                            args: pending.args,
+                            componentPath: pending.componentPath,
+                            status: mod.type === 'QueryUpdated' ? 'success' : 'error',
+                            result: mod.type === 'QueryUpdated' ? mod.value : undefined,
+                            error: mod.type === 'QueryFailed' ? mod.errorMessage : undefined,
+                            trace: mod.type === 'QueryUpdated' ? mod.trace : undefined,
+                            logLines: mod.logLines,
+                            duration: duration,
+                            simulatedDelayMs: delayMs,
+                            endToEndDurationMs: duration + delayMs
+                          });
+                          if (mod.logLines && mod.logLines.length > 0) {
+                            mod.logLines.forEach(logLine => {
+                              const match = logLine.match(/^\\[(log|info|warn|error)\\]\\s+(.+)$/i);
+                              const level = match ? match[1].toLowerCase() : 'log';
+                              const message = match ? match[2] : logLine;
+                              window.__concaveDevToolsEvents.push({
+                                id: 'log-' + now + '-' + Math.random(),
+                                timestamp: now,
+                                type: 'log',
+                                level: level,
+                                message: message,
+                                relatedEventId: 'query-' + mod.queryId + '-' + now
+                              });
+                            });
+                          }
+                        }
+                      }
+                    });
+                  }
+                  if (msg.type === 'MutationResponse') {
+                    const pending = window.__concaveDevToolsPendingMutations.get(msg.requestId);
+                    if (pending) {
+                      const duration = now - pending.startTime;
+                      window.__concaveDevToolsEvents.push({
+                        id: 'mutation-' + msg.requestId + '-' + now,
+                        timestamp: now,
+                        type: 'mutation',
+                        requestId: msg.requestId,
+                        udfPath: pending.udfPath,
+                        args: pending.args,
+                        componentPath: pending.componentPath,
+                        status: msg.success ? 'success' : 'error',
+                        result: msg.success ? msg.result : undefined,
+                        error: !msg.success ? msg.result : undefined,
+                        trace: msg.trace,
+                        logLines: msg.logLines,
+                        duration: duration,
+                        simulatedDelayMs: delayMs,
+                        endToEndDurationMs: duration + delayMs
+                      });
+                      if (msg.logLines && msg.logLines.length > 0) {
+                        msg.logLines.forEach(logLine => {
+                          const match = logLine.match(/^\\[(log|info|warn|error)\\]\\s+(.+)$/i);
+                          const level = match ? match[1].toLowerCase() : 'log';
+                          const message = match ? match[2] : logLine;
+                          window.__concaveDevToolsEvents.push({
+                            id: 'log-' + now + '-' + Math.random(),
+                            timestamp: now,
+                            type: 'log',
+                            level: level,
+                            message: message,
+                            relatedEventId: 'mutation-' + msg.requestId + '-' + now
+                          });
+                        });
+                      }
+                      window.__concaveDevToolsPendingMutations.delete(msg.requestId);
+                    }
+                  }
+                  if (msg.type === 'ActionResponse') {
+                    const pending = window.__concaveDevToolsPendingActions.get(msg.requestId);
+                    if (pending) {
+                      const duration = now - pending.startTime;
+                      window.__concaveDevToolsEvents.push({
+                        id: 'action-' + msg.requestId + '-' + now,
+                        timestamp: now,
+                        type: 'action',
+                        requestId: msg.requestId,
+                        udfPath: pending.udfPath,
+                        args: pending.args,
+                        componentPath: pending.componentPath,
+                        status: msg.success ? 'success' : 'error',
+                        result: msg.success ? msg.result : undefined,
+                        error: !msg.success ? msg.result : undefined,
+                        trace: msg.trace,
+                        logLines: msg.logLines,
+                        duration: duration,
+                        simulatedDelayMs: delayMs,
+                        endToEndDurationMs: duration + delayMs
+                      });
+                      if (msg.logLines && msg.logLines.length > 0) {
+                        msg.logLines.forEach(logLine => {
+                          const match = logLine.match(/^\\[(log|info|warn|error)\\]\\s+(.+)$/i);
+                          const level = match ? match[1].toLowerCase() : 'log';
+                          const message = match ? match[2] : logLine;
+                          window.__concaveDevToolsEvents.push({
+                            id: 'log-' + now + '-' + Math.random(),
+                            timestamp: now,
+                            type: 'log',
+                            level: level,
+                            message: message,
+                            relatedEventId: 'action-' + msg.requestId + '-' + now
+                          });
+                        });
+                      }
+                      window.__concaveDevToolsPendingActions.delete(msg.requestId);
+                    }
+                  }
+                } catch (e) {
+                  console.warn('[DevTools] Error parsing server message (onmessage):', e);
+                }
+                __concaveInvokeWithLatency(handler, ws, event);
+              };
+              wrapper[__concaveInternalMessageListener] = true;
+              currentOnMessageWrapper = wrapper;
+              originalAddEventListener('message', wrapper);
+            }
+          }
+        });
+      })();
+      
+      return ws;
+    };
+
+    // Preserve prototype chain
+    Object.setPrototypeOf(window.WebSocket, OriginalWebSocket);
+    Object.defineProperty(window.WebSocket, 'prototype', {
+      value: OriginalWebSocket.prototype,
+      writable: false,
+      configurable: false
+    });
+
+    console.log('[DevTools] WebSocket interceptor installed');
+  })();
+<\/script>
+`, r = `
+<script>
+  window.__concaveDevToolsConfig = ${JSON.stringify({ position: a, autoInit: !0 })};
+<\/script>
+`, n = i + r + `
+<script type="module">
+  import { initDevTools } from '@concavejs/devtools/client';
+<\/script>
+`;
+        return e.includes("</head>") ? e.replace("</head>", `${n}</head>`) : e.includes("</body>") ? e.replace("</body>", `${n}</body>`) : e + n;
+      }
+    },
+    // Ensure devtools dependencies are optimized
+    config(e) {
+      return {
+        optimizeDeps: {
+          include: [...e.optimizeDeps?.include || [], "react", "react-dom"]
+        }
+      };
+    }
+  };
+}
+export {
+  c as concaveDevTools,
+  c as default
+};