fixdog 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1606 @@
+// src/instrument.ts
+import {
+  instrument,
+  secure,
+  isCompositeFiber,
+  isHostFiber,
+  traverseFiber,
+  getDisplayName,
+  getFiberFromHostInstance
+} from "bippy";
+import { getSource } from "bippy/source";
+var isInstrumented = false;
+function setupBippyInstrumentation() {
+  if (isInstrumented)
+    return;
+  if (typeof window === "undefined")
+    return;
+  isInstrumented = true;
+  instrument(
+    secure({
+      onCommitFiberRoot: (_rendererID, _fiberRoot) => {
+      }
+    })
+  );
+}
+async function getSourceFromElement(element) {
+  try {
+    const fiber = getFiberFromHostInstance(element);
+    if (!fiber) {
+      return null;
+    }
+    const source = await getSource(fiber);
+    if (source && source.fileName) {
+      if (source.fileName.includes("node_modules") || source.fileName.includes("react-dom") || source.fileName.includes("react/")) {
+        return await findUserSourceFromFiber(fiber);
+      }
+      return {
+        fileName: source.fileName,
+        lineNumber: source.lineNumber ?? 1,
+        columnNumber: source.columnNumber ?? 1,
+        functionName: source.functionName ?? void 0
+      };
+    }
+    return await findUserSourceFromFiber(fiber);
+  } catch (error) {
+    console.warn("[UiDog Next] Error getting source from element:", error);
+    return null;
+  }
+}
+async function findUserSourceFromFiber(startFiber) {
+  let result = null;
+  traverseFiber(
+    startFiber,
+    async (fiber) => {
+      if (isCompositeFiber(fiber)) {
+        try {
+          const source = await getSource(fiber);
+          if (source && source.fileName) {
+            if (!source.fileName.includes("node_modules") && !source.fileName.includes("react-dom") && !source.fileName.includes("react/")) {
+              result = {
+                fileName: source.fileName,
+                lineNumber: source.lineNumber ?? 1,
+                columnNumber: source.columnNumber ?? 1,
+                functionName: source.functionName ?? getDisplayName(fiber) ?? void 0
+              };
+              return true;
+            }
+          }
+        } catch {
+        }
+      }
+      return false;
+    },
+    true
+    // Traverse upward (toward root)
+  );
+  return result;
+}
+function getComponentNameFromFiber(fiber) {
+  if (!fiber)
+    return "Unknown";
+  const displayName = getDisplayName(fiber);
+  if (displayName && displayName !== "Unknown") {
+    return displayName;
+  }
+  let componentName = "Unknown";
+  traverseFiber(
+    fiber,
+    (f) => {
+      if (isCompositeFiber(f)) {
+        const name = getDisplayName(f);
+        if (name && name !== "Unknown") {
+          componentName = name;
+          return true;
+        }
+      }
+      return false;
+    },
+    true
+    // Traverse upward
+  );
+  return componentName;
+}
+
+// src/source-resolver.ts
+var EDITOR_SCHEMES = {
+  vscode: "vscode://file/{path}:{line}:{column}",
+  "vscode-insiders": "vscode-insiders://file/{path}:{line}:{column}",
+  cursor: "cursor://file/{path}:{line}:{column}",
+  webstorm: "webstorm://open?file={path}&line={line}&column={column}",
+  atom: "atom://core/open/file?filename={path}&line={line}&column={column}",
+  sublime: "subl://open?url=file://{path}&line={line}&column={column}"
+};
+function buildEditorUrl(source, editor = "cursor", projectPath = "") {
+  const template = EDITOR_SCHEMES[editor] || EDITOR_SCHEMES.cursor;
+  let fullPath = normalizeFileName(source.fileName);
+  if (projectPath && !fullPath.startsWith("/")) {
+    const normalizedProjectPath = projectPath.endsWith("/") ? projectPath.slice(0, -1) : projectPath;
+    fullPath = `${normalizedProjectPath}/${fullPath}`;
+  }
+  return template.replace("{path}", fullPath).replace("{line}", String(source.lineNumber || 1)).replace("{column}", String(source.columnNumber || 1));
+}
+function normalizeFileName(fileName) {
+  if (!fileName)
+    return "";
+  let normalized = fileName;
+  const prefixPatterns = [
+    /^webpack:\/\/[^/]*\//,
+    /^webpack-internal:\/\/\//,
+    /^file:\/\//,
+    /^about:react/,
+    /^\.\//,
+    /^https?:\/\/localhost:\d+\//,
+    /^https?:\/\/[^/]+\/@fs\//,
+    /^https?:\/\/[^/]+\//,
+    /^\/@fs\//,
+    /^@fs\//
+  ];
+  for (const pattern of prefixPatterns) {
+    normalized = normalized.replace(pattern, "");
+  }
+  normalized = normalized.split("?")[0].split("#")[0];
+  normalized = normalized.replace(/^\/+/, "/");
+  return normalized;
+}
+function isSourceFile(fileName) {
+  if (!fileName)
+    return false;
+  const normalized = normalizeFileName(fileName);
+  const excludePatterns = [
+    /node_modules/,
+    /react-dom/,
+    /^react\//,
+    /\.next\//,
+    /_next\//,
+    /webpack/,
+    /@vite\//,
+    /vite\/client/,
+    /\[eval\]/,
+    /<anonymous>/
+  ];
+  for (const pattern of excludePatterns) {
+    if (pattern.test(normalized)) {
+      return false;
+    }
+  }
+  const includeExtensions = [".tsx", ".ts", ".jsx", ".js", ".mjs", ".cjs"];
+  return includeExtensions.some(
+    (ext) => normalized.toLowerCase().endsWith(ext)
+  );
+}
+function getShortFileName(filePath) {
+  const normalized = normalizeFileName(filePath);
+  const parts = normalized.split("/");
+  return parts[parts.length - 1] || normalized;
+}
+
+// src/element-detector.ts
+var detectorCleanup = null;
+var isSetup = false;
+function setupElementDetector(options) {
+  const { onElementSelected, modifier = "alt" } = options;
+  if (detectorCleanup) {
+    detectorCleanup();
+  }
+  isSetup = true;
+  const handleClick = async (event) => {
+    const modifierPressed = modifier === "alt" && event.altKey || modifier === "ctrl" && event.ctrlKey || modifier === "meta" && event.metaKey || modifier === "shift" && event.shiftKey;
+    if (!modifierPressed)
+      return;
+    event.preventDefault();
+    event.stopPropagation();
+    const target = event.target;
+    try {
+      const source = await getSourceFromElement(target);
+      if (source && source.fileName && isSourceFile(source.fileName)) {
+        const fiber = getFiberFromHostInstance(target);
+        const componentName = fiber ? getComponentNameFromFiber(fiber) : "Unknown";
+        const enrichedSource = {
+          ...source,
+          functionName: source.functionName || componentName
+        };
+        onElementSelected(enrichedSource, target);
+      } else {
+        console.info(
+          "[UiDog Next] Could not find source for element. Falling back to DOM snapshot (likely server component or library code)."
+        );
+        onElementSelected(null, target);
+      }
+    } catch (error) {
+      console.warn("[UiDog Next] Error detecting element source:", error);
+    }
+  };
+  const handleMouseMove = (event) => {
+    const modifierPressed = modifier === "alt" && event.altKey || modifier === "ctrl" && event.ctrlKey || modifier === "meta" && event.metaKey || modifier === "shift" && event.shiftKey;
+    if (!modifierPressed) {
+      removeHighlight();
+      return;
+    }
+    const target = event.target;
+    highlightElement(target);
+  };
+  const handleKeyUp = (event) => {
+    const relevantKey = modifier === "alt" && event.key === "Alt" || modifier === "ctrl" && event.key === "Control" || modifier === "meta" && event.key === "Meta" || modifier === "shift" && event.key === "Shift";
+    if (relevantKey) {
+      removeHighlight();
+    }
+  };
+  document.addEventListener("click", handleClick, true);
+  document.addEventListener("mousemove", handleMouseMove, true);
+  document.addEventListener("keyup", handleKeyUp, true);
+  detectorCleanup = () => {
+    document.removeEventListener("click", handleClick, true);
+    document.removeEventListener("mousemove", handleMouseMove, true);
+    document.removeEventListener("keyup", handleKeyUp, true);
+    removeHighlight();
+    isSetup = false;
+  };
+  return detectorCleanup;
+}
+var currentHighlight = null;
+var highlightOverlay = null;
+function highlightElement(element) {
+  if (element === highlightOverlay || highlightOverlay?.contains(element)) {
+    return;
+  }
+  if (!highlightOverlay) {
+    highlightOverlay = document.createElement("div");
+    highlightOverlay.id = "uidog-highlight-overlay";
+    highlightOverlay.style.cssText = `
+      position: fixed;
+      pointer-events: none;
+      background: rgba(59, 130, 246, 0.2);
+      border: 2px solid rgba(59, 130, 246, 0.8);
+      border-radius: 4px;
+      z-index: 999998;
+      transition: all 0.1s ease-out;
+    `;
+    document.body.appendChild(highlightOverlay);
+  }
+  const rect = element.getBoundingClientRect();
+  highlightOverlay.style.top = `${rect.top}px`;
+  highlightOverlay.style.left = `${rect.left}px`;
+  highlightOverlay.style.width = `${rect.width}px`;
+  highlightOverlay.style.height = `${rect.height}px`;
+  highlightOverlay.style.display = "block";
+  currentHighlight = element;
+}
+function removeHighlight() {
+  if (highlightOverlay) {
+    highlightOverlay.style.display = "none";
+  }
+  currentHighlight = null;
+}
+function cleanupElementDetector() {
+  if (detectorCleanup) {
+    detectorCleanup();
+    detectorCleanup = null;
+  }
+}
+
+// src/sidebar-initializer.ts
+import { createRoot } from "react-dom/client";
+import { createElement } from "react";
+
+// src/components/UiDogSidebarReact.tsx
+import { useEffect as useEffect2 } from "react";
+
+// src/components/ElementInfoDisplayReact.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function ElementInfoDisplayReact(props) {
+  const isDomSnapshot = props.elementInfo.kind === "dom";
+  if (isDomSnapshot) {
+    const dom = props.elementInfo.domSnapshot;
+    const outerHTML = dom?.outerHTML || "No HTML available";
+    const text = dom?.text || "";
+    const attributes = dom?.attributes || {};
+    return /* @__PURE__ */ jsxs("div", { className: "uidog-element-info", children: [
+      /* @__PURE__ */ jsxs("div", { className: "uidog-element-info-content", children: [
+        /* @__PURE__ */ jsx("div", { className: "uidog-file-location", children: "Server-rendered DOM (no source available)" }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            className: "uidog-close-btn",
+            onClick: props.onClose,
+            title: "Close sidebar (ESC)",
+            "aria-label": "Close sidebar",
+            children: "\xD7"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "uidog-dom-snapshot", children: [
+        /* @__PURE__ */ jsx("div", { className: "uidog-dom-label", children: "outerHTML (trimmed):" }),
+        /* @__PURE__ */ jsx("pre", { className: "uidog-dom-snippet", children: outerHTML }),
+        text && /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx("div", { className: "uidog-dom-label", children: "textContent (trimmed):" }),
+          /* @__PURE__ */ jsx("pre", { className: "uidog-dom-snippet", children: text })
+        ] }),
+        Object.keys(attributes).length > 0 && /* @__PURE__ */ jsxs("div", { className: "uidog-dom-attributes", children: [
+          /* @__PURE__ */ jsx("div", { className: "uidog-dom-label", children: "attributes:" }),
+          /* @__PURE__ */ jsx("ul", { children: Object.entries(attributes).map(([key, value]) => /* @__PURE__ */ jsxs("li", { children: [
+            /* @__PURE__ */ jsx("code", { children: key }),
+            "=",
+            /* @__PURE__ */ jsx("code", { children: value })
+          ] }, key)) })
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "uidog-dom-hint", children: "To see file/line info, render this DOM through a small client boundary." })
+      ] })
+    ] });
+  }
+  const fileName = props.elementInfo.filePath?.split("/").pop() || "";
+  const fileLocation = `Selected element at ${fileName}`;
+  return /* @__PURE__ */ jsx("div", { className: "uidog-element-info", children: /* @__PURE__ */ jsxs("div", { className: "uidog-element-info-content", children: [
+    /* @__PURE__ */ jsx("span", { className: "uidog-file-location", children: fileLocation }),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        className: "uidog-close-btn",
+        onClick: props.onClose,
+        title: "Close sidebar (ESC)",
+        "aria-label": "Close sidebar",
+        children: "\xD7"
+      }
+    )
+  ] }) });
+}
+
+// src/components/ConversationalInputReact.tsx
+import { useState, useEffect, useRef } from "react";
+
+// src/api/client.ts
+async function sendChatPrompt(request, apiEndpoint = "http://localhost:3000") {
+  try {
+    const response = await fetch(`${apiEndpoint}/chat`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(request)
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({ error: response.statusText }));
+      return {
+        ok: false,
+        message: "",
+        error: errorData.error || `API error (${response.status})`
+      };
+    }
+    return await response.json();
+  } catch (error) {
+    if (error instanceof Error) {
+      return {
+        ok: false,
+        message: "",
+        error: error.message
+      };
+    }
+    return {
+      ok: false,
+      message: "",
+      error: "Unknown error occurred"
+    };
+  }
+}
+async function sendToDeveloper(request, apiEndpoint = "http://localhost:3000") {
+  try {
+    const response = await fetch(`${apiEndpoint}/send-to-dev`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(request)
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({ error: response.statusText }));
+      return {
+        ok: false,
+        error: errorData.error || `API error (${response.status})`
+      };
+    }
+    return await response.json();
+  } catch (error) {
+    if (error instanceof Error) {
+      return {
+        ok: false,
+        error: error.message
+      };
+    }
+    return {
+      ok: false,
+      error: "Unknown error occurred"
+    };
+  }
+}
+
+// src/components/ConversationalInputReact.tsx
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function ConversationalInputReact(props) {
+  const [userInput, setUserInput] = useState("");
+  const [messages, setMessages] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [sessionId, setSessionId] = useState(void 0);
+  const [isCreatingPR, setIsCreatingPR] = useState(false);
+  const [prUrl, setPrUrl] = useState(null);
+  const textareaRef = useRef(null);
+  const messagesEndRef = useRef(null);
+  useEffect(() => {
+    textareaRef.current?.focus();
+  }, []);
+  useEffect(() => {
+    const textarea = textareaRef.current;
+    if (textarea) {
+      textarea.style.height = "auto";
+      textarea.style.height = `${Math.min(textarea.scrollHeight, 200)}px`;
+    }
+  }, [userInput]);
+  useEffect(() => {
+    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [messages]);
+  const handleSubmit = async () => {
+    const input = userInput.trim();
+    if (!input || isLoading)
+      return;
+    const userMessage = {
+      id: `user-${Date.now()}`,
+      role: "user",
+      content: input,
+      timestamp: Date.now()
+    };
+    setMessages((prev) => [...prev, userMessage]);
+    setUserInput("");
+    setIsLoading(true);
+    const loadingMessageId = `loading-${Date.now()}`;
+    const loadingMessage = {
+      id: loadingMessageId,
+      role: "assistant",
+      content: "",
+      timestamp: Date.now(),
+      isLoading: true
+    };
+    setMessages((prev) => [...prev, loadingMessage]);
+    const request = {
+      prompt: `The component selected by the user: ${props.editorUrl}
+User request: ${input}
+Update multiple files (if necessary) to achieve the user's request.`,
+      sessionId
+    };
+    try {
+      const result = await sendChatPrompt(
+        request,
+        props.apiEndpoint
+      );
+      if (result.sessionId && !sessionId) {
+        setSessionId(result.sessionId);
+      }
+      setMessages((prev) => {
+        const filtered = prev.filter((msg) => msg.id !== loadingMessageId);
+        const assistantMessage = {
+          id: `assistant-${Date.now()}`,
+          role: "assistant",
+          content: result.ok ? result.message : result.error || "Request failed",
+          timestamp: Date.now(),
+          error: !result.ok ? result.error : void 0
+        };
+        return [...filtered, assistantMessage];
+      });
+    } catch (err) {
+      setMessages((prev) => {
+        const filtered = prev.filter((msg) => msg.id !== loadingMessageId);
+        const errorMessage = {
+          id: `error-${Date.now()}`,
+          role: "assistant",
+          content: err instanceof Error ? err.message : "Unknown error occurred",
+          timestamp: Date.now(),
+          error: err instanceof Error ? err.message : "Unknown error occurred"
+        };
+        return [...filtered, errorMessage];
+      });
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const handleKeyDown = (e) => {
+    if ((e.metaKey || e.ctrlKey) && e.key === "Enter") {
+      e.preventDefault();
+      handleSubmit();
+    }
+  };
+  const handleSendToDeveloper = async () => {
+    if (!sessionId || isCreatingPR)
+      return;
+    setIsCreatingPR(true);
+    setPrUrl(null);
+    try {
+      const result = await sendToDeveloper(
+        { sessionId },
+        props.apiEndpoint
+      );
+      if (result.ok && result.prUrl) {
+        setPrUrl(result.prUrl);
+        const successMessage = {
+          id: `pr-success-${Date.now()}`,
+          role: "assistant",
+          content: `Pull request created successfully!`,
+          timestamp: Date.now()
+        };
+        setMessages((prev) => [...prev, successMessage]);
+      } else {
+        const errorMessage = {
+          id: `pr-error-${Date.now()}`,
+          role: "assistant",
+          content: result.error || "Failed to create pull request",
+          timestamp: Date.now(),
+          error: result.error || "Failed to create pull request"
+        };
+        setMessages((prev) => [...prev, errorMessage]);
+      }
+    } catch (err) {
+      const errorMessage = {
+        id: `pr-error-${Date.now()}`,
+        role: "assistant",
+        content: err instanceof Error ? err.message : "Unknown error occurred",
+        timestamp: Date.now(),
+        error: err instanceof Error ? err.message : "Unknown error occurred"
+      };
+      setMessages((prev) => [...prev, errorMessage]);
+    } finally {
+      setIsCreatingPR(false);
+    }
+  };
+  const handleRetry = async (messageId) => {
+    const errorIndex = messages.findIndex((msg) => msg.id === messageId);
+    if (errorIndex === -1)
+      return;
+    let userMessageIndex = -1;
+    for (let i = errorIndex - 1; i >= 0; i--) {
+      if (messages[i].role === "user") {
+        userMessageIndex = i;
+        break;
+      }
+    }
+    if (userMessageIndex === -1)
+      return;
+    const userMessage = messages[userMessageIndex];
+    const input = userMessage.content;
+    setMessages((prev) => prev.filter((msg) => msg.id !== messageId));
+    setIsLoading(true);
+    const loadingMessageId = `loading-${Date.now()}`;
+    const loadingMessage = {
+      id: loadingMessageId,
+      role: "assistant",
+      content: "",
+      timestamp: Date.now(),
+      isLoading: true
+    };
+    setMessages((prev) => [...prev, loadingMessage]);
+    const request = {
+      prompt: `The component selected by the user: ${props.editorUrl}
+User request: ${input}
+Update multiple files (if necessary) to achieve the user's request.`,
+      sessionId
+    };
+    try {
+      const result = await sendChatPrompt(
+        request,
+        props.apiEndpoint
+      );
+      if (result.sessionId && !sessionId) {
+        setSessionId(result.sessionId);
+      }
+      setMessages((prev) => {
+        const filtered = prev.filter((msg) => msg.id !== loadingMessageId);
+        const assistantMessage = {
+          id: `assistant-${Date.now()}`,
+          role: "assistant",
+          content: result.ok ? result.message : result.error || "Request failed",
+          timestamp: Date.now(),
+          error: !result.ok ? result.error : void 0
+        };
+        return [...filtered, assistantMessage];
+      });
+    } catch (err) {
+      setMessages((prev) => {
+        const filtered = prev.filter((msg) => msg.id !== loadingMessageId);
+        const errorMessage = {
+          id: `error-${Date.now()}`,
+          role: "assistant",
+          content: err instanceof Error ? err.message : "Unknown error occurred",
+          timestamp: Date.now(),
+          error: err instanceof Error ? err.message : "Unknown error occurred"
+        };
+        return [...filtered, errorMessage];
+      });
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  return /* @__PURE__ */ jsxs2(Fragment2, { children: [
+    /* @__PURE__ */ jsxs2("div", { className: "uidog-messages-container", children: [
+      messages.length === 0 && /* @__PURE__ */ jsx2("div", { className: "uidog-empty-state", children: /* @__PURE__ */ jsx2("div", { className: "uidog-empty-state-text", children: "What changes would you like to make?" }) }),
+      messages.map((message) => /* @__PURE__ */ jsx2(
+        "div",
+        {
+          className: `uidog-message uidog-message-${message.role}`,
+          children: /* @__PURE__ */ jsx2("div", { className: "uidog-message-bubble", children: message.isLoading ? /* @__PURE__ */ jsxs2("div", { className: "uidog-message-loading", children: [
+            /* @__PURE__ */ jsx2("div", { className: "uidog-spinner" }),
+            /* @__PURE__ */ jsx2("span", { children: "Processing your request..." })
+          ] }) : message.error ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+            /* @__PURE__ */ jsx2("div", { className: "uidog-message-content uidog-message-error", children: message.content }),
+            /* @__PURE__ */ jsx2(
+              "button",
+              {
+                className: "uidog-retry-btn",
+                onClick: () => handleRetry(message.id),
+                children: "Retry"
+              }
+            )
+          ] }) : /* @__PURE__ */ jsx2("div", { className: "uidog-message-content", children: message.content }) })
+        },
+        message.id
+      )),
+      /* @__PURE__ */ jsx2("div", { ref: messagesEndRef })
+    ] }),
+    /* @__PURE__ */ jsxs2("div", { className: "uidog-input-footer-fixed", children: [
+      /* @__PURE__ */ jsxs2("div", { className: "uidog-input-wrapper", children: [
+        /* @__PURE__ */ jsx2(
+          "textarea",
+          {
+            id: "uidog-textarea",
+            ref: textareaRef,
+            className: "uidog-textarea",
+            placeholder: "Describe the changes you want...",
+            value: userInput,
+            onChange: (e) => setUserInput(e.target.value),
+            onKeyDown: handleKeyDown,
+            disabled: isLoading
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          "button",
+          {
+            className: "uidog-submit-btn",
+            onClick: handleSubmit,
+            disabled: !userInput.trim() || isLoading,
+            title: "Send message (Cmd/Ctrl + Enter)",
+            children: isLoading ? /* @__PURE__ */ jsx2("div", { className: "uidog-spinner-small" }) : /* @__PURE__ */ jsx2(
+              "svg",
+              {
+                width: "16",
+                height: "16",
+                viewBox: "0 0 16 16",
+                fill: "none",
+                xmlns: "http://www.w3.org/2000/svg",
+                children: /* @__PURE__ */ jsx2(
+                  "path",
+                  {
+                    d: "M8 2L8 14M8 2L2 8M8 2L14 8",
+                    stroke: "currentColor",
+                    strokeWidth: "2",
+                    strokeLinecap: "round",
+                    strokeLinejoin: "round"
+                  }
+                )
+              }
+            )
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx2("div", { className: "uidog-input-hint", children: "Cmd/Ctrl + Enter to submit" }),
+      sessionId && /* @__PURE__ */ jsxs2("div", { className: "uidog-send-to-dev-section", children: [
+        /* @__PURE__ */ jsx2(
+          "button",
+          {
+            className: "uidog-send-to-dev-btn",
+            onClick: handleSendToDeveloper,
+            disabled: isCreatingPR || isLoading,
+            title: "Create PR with changes",
+            children: isCreatingPR ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+              /* @__PURE__ */ jsx2("div", { className: "uidog-spinner-small" }),
+              /* @__PURE__ */ jsx2("span", { children: "Creating PR..." })
+            ] }) : /* @__PURE__ */ jsxs2(Fragment2, { children: [
+              /* @__PURE__ */ jsx2(
+                "svg",
+                {
+                  width: "16",
+                  height: "16",
+                  viewBox: "0 0 16 16",
+                  fill: "none",
+                  xmlns: "http://www.w3.org/2000/svg",
+                  children: /* @__PURE__ */ jsx2(
+                    "path",
+                    {
+                      d: "M8 1L8 15M8 1L1 8M8 1L15 8",
+                      stroke: "currentColor",
+                      strokeWidth: "2",
+                      strokeLinecap: "round",
+                      strokeLinejoin: "round"
+                    }
+                  )
+                }
+              ),
+              /* @__PURE__ */ jsx2("span", { children: "Submit to Developer" })
+            ] })
+          }
+        ),
+        prUrl && /* @__PURE__ */ jsx2(
+          "a",
+          {
+            href: prUrl,
+            target: "_blank",
+            rel: "noopener noreferrer",
+            className: "uidog-pr-link",
+            children: "View PR \u2192"
+          }
+        )
+      ] })
+    ] })
+  ] });
+}
+
+// src/components/UiDogSidebarReact.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function UiDogSidebarReact(props) {
+  useEffect2(() => {
+    const handleEscapeKey = (e) => {
+      if (e.key === "Escape") {
+        props.onClose();
+      }
+    };
+    document.addEventListener("keydown", handleEscapeKey);
+    return () => {
+      document.removeEventListener("keydown", handleEscapeKey);
+    };
+  }, [props]);
+  return /* @__PURE__ */ jsx3("div", { className: "uidog-sidebar-overlay", children: /* @__PURE__ */ jsxs3("div", { className: "uidog-sidebar", children: [
+    /* @__PURE__ */ jsx3("div", { className: "uidog-element-info-section", children: /* @__PURE__ */ jsx3(
+      ElementInfoDisplayReact,
+      {
+        elementInfo: props.elementInfo,
+        onClose: props.onClose
+      }
+    ) }),
+    /* @__PURE__ */ jsx3("div", { className: "uidog-chat-container", children: /* @__PURE__ */ jsx3(
+      ConversationalInputReact,
+      {
+        elementInfo: props.elementInfo,
+        editorUrl: props.editorUrl,
+        apiEndpoint: props.apiEndpoint
+      }
+    ) })
+  ] }) });
+}
+
+// src/styles/sidebarStyles.ts
+var sidebarStyles = `/* UiDog Sidebar Styles */
+
+/* Overlay */
+.uidog-sidebar-overlay {
+  position: fixed;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  z-index: 999999;
+  pointer-events: none;
+}
+
+/* Main Sidebar Container */
+.uidog-sidebar {
+  position: fixed;
+  right: 0;
+  top: 0;
+  width: 420px;
+  max-width: 100vw;
+  height: 100vh;
+  background: #13140a;
+  box-shadow: -4px 0 24px rgba(0, 0, 0, 0.5);
+  display: flex;
+  flex-direction: column;
+  font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+  font-size: 14px;
+  color: #ffffff;
+  pointer-events: auto;
+  animation: uidog-slide-in 0.3s ease-out;
+  overflow: hidden;
+  border-left: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+@keyframes uidog-slide-in {
+  from {
+    transform: translateX(100%);
+  }
+  to {
+    transform: translateX(0);
+  }
+}
+
+/* Header */
+.uidog-sidebar-header {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  padding: 20px 24px;
+  border-bottom: 1px solid rgba(255, 255, 255, 0.15);
+  background: rgba(0, 0, 0, 0.3);
+  flex-shrink: 0;
+}
+
+.uidog-sidebar-title {
+  margin: 0;
+  font-size: 18px;
+  font-weight: 600;
+  color: #ffffff;
+  letter-spacing: -0.01em;
+}
+
+.uidog-close-btn {
+  width: 32px;
+  height: 32px;
+  border: none;
+  background: transparent;
+  font-size: 28px;
+  line-height: 1;
+  color: rgba(255, 255, 255, 0.7);
+  cursor: pointer;
+  border-radius: 4px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  transition: all 0.2s;
+  flex-shrink: 0;
+  margin-left: 12px;
+}
+
+.uidog-close-btn:hover {
+  background: rgba(255, 255, 255, 0.1);
+  color: #ffffff;
+}
+
+/* Content Area */
+.uidog-sidebar-content {
+  flex: 1;
+  overflow-y: auto;
+  overflow-x: hidden;
+  padding: 24px;
+  scrollbar-width: thin;
+  scrollbar-color: rgba(255, 255, 255, 0.2) transparent;
+}
+
+.uidog-sidebar-content::-webkit-scrollbar {
+  width: 8px;
+}
+
+.uidog-sidebar-content::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.uidog-sidebar-content::-webkit-scrollbar-thumb {
+  background: rgba(255, 255, 255, 0.2);
+  border-radius: 4px;
+}
+
+.uidog-sidebar-content::-webkit-scrollbar-thumb:hover {
+  background: rgba(255, 255, 255, 0.3);
+}
+
+/* Element Info Section */
+.uidog-element-info-section {
+  padding: 20px 24px;
+  border-bottom: 1px solid rgba(255, 255, 255, 0.15);
+  flex-shrink: 0;
+  background: rgba(0, 0, 0, 0.2);
+  margin-top: 0;
+  padding-top: 20px;
+}
+
+/* Element Info Section */
+.uidog-element-info {
+  margin-bottom: 0;
+}
+
+.uidog-element-info-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  margin-bottom: 12px;
+}
+
+.uidog-element-info-title {
+  margin: 0;
+  font-size: 14px;
+  font-weight: 600;
+  color: rgba(255, 255, 255, 0.9);
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+
+.uidog-toggle-view-btn {
+  padding: 6px 14px;
+  font-size: 12px;
+  border: 1px solid rgba(255, 255, 255, 0.2);
+  background: rgba(255, 255, 255, 0.1);
+  color: #ffffff;
+  border-radius: 6px;
+  cursor: pointer;
+  transition: all 0.2s;
+  font-weight: 500;
+}
+
+.uidog-toggle-view-btn:hover {
+  background: rgba(255, 255, 255, 0.2);
+  border-color: rgba(255, 255, 255, 0.3);
+}
+
+.uidog-element-info-content {
+  background: rgba(0, 0, 0, 0.3);
+  border: 1px solid rgba(255, 255, 255, 0.15);
+  border-radius: 8px;
+  padding: 16px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  position: relative;
+}
+
+.uidog-file-location {
+  font-family: "SF Mono", Monaco, Menlo, Consolas, monospace;
+  font-size: 13px;
+  color: #ffffff;
+  word-break: break-word;
+}
+
+.uidog-info-row {
+  display: flex;
+  margin-bottom: 12px;
+  line-height: 1.6;
+}
+
+.uidog-info-row:last-of-type {
+  margin-bottom: 0;
+}
+
+.uidog-info-row:last-child {
+  margin-bottom: 0;
+}
+
+.uidog-info-label {
+  flex-shrink: 0;
+  width: 100px;
+  font-weight: 500;
+  color: rgba(255, 255, 255, 0.75);
+  font-size: 13px;
+}
+
+.uidog-info-value {
+  flex: 1;
+  color: #ffffff;
+  word-break: break-word;
+  font-size: 13px;
+}
+
+.uidog-component-name {
+  font-weight: 600;
+  color: #60a5fa;
+}
+
+.uidog-file-path {
+  font-family: "SF Mono", Monaco, Menlo, Consolas, monospace;
+  font-size: 12px;
+}
+
+.uidog-dom-snapshot {
+  margin-top: 16px;
+  background: rgba(255, 255, 255, 0.03);
+  border: 1px solid rgba(255, 255, 255, 0.08);
+  border-radius: 8px;
+  padding: 12px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.uidog-dom-label {
+  color: rgba(255, 255, 255, 0.7);
+  font-size: 12px;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+
+.uidog-dom-snippet {
+  margin: 0;
+  background: rgba(0, 0, 0, 0.4);
+  border: 1px solid rgba(255, 255, 255, 0.08);
+  border-radius: 6px;
+  padding: 10px;
+  color: rgba(255, 255, 255, 0.85);
+  font-family: "SF Mono", Monaco, Menlo, Consolas, monospace;
+  font-size: 12px;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+.uidog-dom-attributes ul {
+  margin: 6px 0 0 0;
+  padding-left: 16px;
+  color: rgba(255, 255, 255, 0.85);
+  font-family: "SF Mono", Monaco, Menlo, Consolas, monospace;
+  font-size: 12px;
+  word-break: break-word;
+}
+
+.uidog-dom-attributes code {
+  background: rgba(255, 255, 255, 0.08);
+  padding: 2px 4px;
+  border-radius: 4px;
+}
+
+.uidog-dom-hint {
+  color: rgba(255, 255, 255, 0.6);
+  font-size: 12px;
+  line-height: 1.5;
+}
+
+.uidog-mono {
+  font-family: "SF Mono", Monaco, Menlo, Consolas, monospace;
+  font-size: 12px;
+}
+
+.uidog-detailed-section {
+  margin-top: 12px;
+  padding-top: 12px;
+  border-top: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.uidog-code-preview {
+  flex-direction: column;
+}
+
+.uidog-code-placeholder {
+  margin-top: 6px;
+  padding: 8px;
+  background: rgba(0, 0, 0, 0.3);
+  color: rgba(255, 255, 255, 0.8);
+  border-radius: 4px;
+  font-family: "SF Mono", Monaco, Menlo, Consolas, monospace;
+  font-size: 12px;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+/* Chat Container */
+.uidog-chat-container {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  min-height: 0;
+}
+
+/* Messages Container */
+.uidog-messages-container {
+  flex: 1;
+  overflow-y: auto;
+  overflow-x: hidden;
+  padding: 20px 24px;
+  scrollbar-width: thin;
+  scrollbar-color: rgba(255, 255, 255, 0.2) transparent;
+}
+
+.uidog-dom-banner {
+  margin-bottom: 12px;
+  padding: 12px 14px;
+  background: rgba(255, 255, 255, 0.08);
+  border: 1px solid rgba(255, 255, 255, 0.15);
+  border-radius: 8px;
+  color: rgba(255, 255, 255, 0.85);
+  font-size: 13px;
+  line-height: 1.5;
+}
+
+.uidog-messages-container::-webkit-scrollbar {
+  width: 8px;
+}
+
+.uidog-messages-container::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.uidog-messages-container::-webkit-scrollbar-thumb {
+  background: rgba(255, 255, 255, 0.2);
+  border-radius: 4px;
+}
+
+.uidog-messages-container::-webkit-scrollbar-thumb:hover {
+  background: rgba(255, 255, 255, 0.3);
+}
+
+/* Empty State */
+.uidog-empty-state {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  height: 100%;
+  min-height: 200px;
+}
+
+.uidog-empty-state-text {
+  color: rgba(255, 255, 255, 0.6);
+  font-size: 14px;
+  text-align: center;
+}
+
+/* Messages */
+.uidog-message {
+  margin-bottom: 16px;
+  display: flex;
+  animation: uidog-message-fade-in 0.2s ease-out;
+}
+
+@keyframes uidog-message-fade-in {
+  from {
+    opacity: 0;
+    transform: translateY(4px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.uidog-message-user {
+  justify-content: flex-end;
+}
+
+.uidog-message-assistant {
+  justify-content: flex-start;
+}
+
+/* Message Bubbles */
+.uidog-message-bubble {
+  max-width: 80%;
+  padding: 12px 16px;
+  border-radius: 12px;
+  word-wrap: break-word;
+  overflow-wrap: break-word;
+}
+
+.uidog-message-user .uidog-message-bubble {
+  background: rgba(59, 130, 246, 0.2);
+  border: 1px solid rgba(59, 130, 246, 0.3);
+  color: #93c5fd;
+}
+
+.uidog-message-assistant .uidog-message-bubble {
+  background: rgba(255, 255, 255, 0.08);
+  border: 1px solid rgba(255, 255, 255, 0.15);
+  color: rgba(255, 255, 255, 0.9);
+}
+
+.uidog-message-content {
+  line-height: 1.6;
+  white-space: pre-wrap;
+  word-break: break-word;
+  font-size: 14px;
+}
+
+.uidog-message-content.uidog-message-error {
+  color: #fca5a5;
+}
+
+/* Loading Message */
+.uidog-message-loading {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  color: rgba(255, 255, 255, 0.7);
+  font-size: 14px;
+}
+
+.uidog-spinner {
+  width: 16px;
+  height: 16px;
+  border: 2px solid rgba(255, 255, 255, 0.2);
+  border-top-color: rgba(255, 255, 255, 0.8);
+  border-radius: 50%;
+  animation: uidog-spin 0.8s linear infinite;
+}
+
+.uidog-spinner-small {
+  width: 14px;
+  height: 14px;
+  border: 2px solid rgba(255, 255, 255, 0.3);
+  border-top-color: #ffffff;
+  border-radius: 50%;
+  animation: uidog-spin 0.8s linear infinite;
+}
+
+@keyframes uidog-spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+/* Fixed Input Footer */
+.uidog-input-footer-fixed {
+  flex-shrink: 0;
+  padding: 16px 24px;
+  border-top: 1px solid rgba(255, 255, 255, 0.15);
+  background: rgba(0, 0, 0, 0.3);
+}
+
+.uidog-input-wrapper {
+  position: relative;
+  margin-bottom: 8px;
+}
+
+.uidog-textarea {
+  width: 100%;
+  padding: 10px 60px 10px 14px;
+  border: 1px solid rgba(255, 255, 255, 0.2);
+  border-radius: 8px;
+  font-family: inherit;
+  font-size: 14px;
+  line-height: 1.5;
+  resize: none;
+  min-height: 44px;
+  max-height: 200px;
+  background: rgba(0, 0, 0, 0.4);
+  color: #ffffff;
+  transition: border-color 0.2s, box-shadow 0.2s, background 0.2s;
+  box-sizing: border-box;
+  overflow-wrap: break-word;
+  word-wrap: break-word;
+  overflow-y: auto;
+}
+
+.uidog-textarea::placeholder {
+  color: rgba(255, 255, 255, 0.5);
+}
+
+.uidog-textarea:focus {
+  outline: none;
+  border-color: #60a5fa;
+  background: rgba(0, 0, 0, 0.5);
+  box-shadow: 0 0 0 3px rgba(96, 165, 250, 0.15);
+}
+
+.uidog-textarea:disabled {
+  background: rgba(0, 0, 0, 0.2);
+  color: rgba(255, 255, 255, 0.5);
+  cursor: not-allowed;
+}
+
+.uidog-submit-btn {
+  position: absolute;
+  bottom: 10px;
+  right: 6px;
+  width: 32px;
+  height: 32px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0;
+  font-size: 14px;
+  font-weight: 500;
+  color: #ffffff;
+  background: #3b82f6;
+  border: none;
+  border-radius: 6px;
+  cursor: pointer;
+  transition: all 0.2s;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
+}
+
+.uidog-submit-btn:active {
+  transform: translateY(1px);
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.2);
+}
+
+.uidog-submit-btn:hover:not(:disabled) {
+  background: #2563eb;
+}
+
+.uidog-submit-btn:disabled {
+  background: rgba(255, 255, 255, 0.1);
+  color: rgba(255, 255, 255, 0.3);
+  cursor: not-allowed;
+}
+
+.uidog-submit-btn svg {
+  stroke: currentColor;
+}
+
+.uidog-input-hint {
+  font-size: 11px;
+  color: rgba(255, 255, 255, 0.5);
+  text-align: center;
+  margin-top: 4px;
+}
+
+.uidog-retry-btn {
+  margin-top: 8px;
+  padding: 6px 12px;
+  font-size: 12px;
+  font-weight: 500;
+  color: #ffffff;
+  background: #ef4444;
+  border: none;
+  border-radius: 6px;
+  cursor: pointer;
+  transition: background 0.2s;
+}
+
+.uidog-retry-btn:hover {
+  background: #dc2626;
+}
+
+/* Footer */
+.uidog-sidebar-footer {
+  padding: 16px 24px;
+  border-top: 1px solid rgba(255, 255, 255, 0.15);
+  background: rgba(0, 0, 0, 0.3);
+  text-align: center;
+  flex-shrink: 0;
+}
+
+.uidog-footer-text {
+  font-size: 12px;
+  color: rgba(255, 255, 255, 0.7);
+}
+
+.uidog-footer-link {
+  color: #60a5fa;
+  text-decoration: none;
+  font-weight: 500;
+}
+
+.uidog-footer-link:hover {
+  text-decoration: underline;
+  color: #93c5fd;
+}
+
+/* Mobile Responsive */
+@media (max-width: 768px) {
+  .uidog-sidebar {
+    width: 100vw;
+  }
+}`;
+var sidebarStyles_default = sidebarStyles;
+
+// src/sidebar-initializer.ts
+var sidebarRoot = null;
+var sidebarContainer = null;
+var shadowRoot = null;
+var config = { apiEndpoint: "https://api.ui.dog" };
+var currentState = {
+  isOpen: false,
+  elementInfo: null,
+  editorUrl: ""
+};
+function initializeSidebar(sidebarConfig) {
+  if (typeof window === "undefined")
+    return;
+  config = sidebarConfig;
+  if (document.getElementById("uidog-next-sidebar-root")) {
+    return;
+  }
+  sidebarContainer = document.createElement("div");
+  sidebarContainer.id = "uidog-next-sidebar-root";
+  document.body.appendChild(sidebarContainer);
+  shadowRoot = sidebarContainer.attachShadow({ mode: "open" });
+  const styleElement = document.createElement("style");
+  styleElement.textContent = sidebarStyles_default;
+  shadowRoot.appendChild(styleElement);
+  const mountPoint = document.createElement("div");
+  mountPoint.id = "uidog-sidebar-mount";
+  shadowRoot.appendChild(mountPoint);
+  sidebarRoot = createRoot(mountPoint);
+  render();
+}
+function render() {
+  if (!sidebarRoot)
+    return;
+  const { isOpen, elementInfo, editorUrl } = currentState;
+  if (!isOpen || !elementInfo) {
+    sidebarRoot.render(null);
+    return;
+  }
+  sidebarRoot.render(
+    createElement(UiDogSidebarReact, {
+      elementInfo,
+      editorUrl,
+      onClose: closeSidebar,
+      apiEndpoint: config.apiEndpoint
+    })
+  );
+}
+function openSidebar(elementInfo, editorUrl) {
+  currentState = {
+    isOpen: true,
+    elementInfo,
+    editorUrl
+  };
+  if (typeof window !== "undefined") {
+    window.__UIDOG_SIDEBAR__ = {
+      isOpen: true,
+      elementInfo,
+      editorUrl
+    };
+  }
+  render();
+}
+function closeSidebar() {
+  currentState = {
+    isOpen: false,
+    elementInfo: null,
+    editorUrl: ""
+  };
+  if (typeof window !== "undefined") {
+    window.__UIDOG_SIDEBAR__ = {
+      isOpen: false,
+      elementInfo: null,
+      editorUrl: null
+    };
+  }
+  render();
+}
+function cleanupSidebar() {
+  if (sidebarRoot) {
+    sidebarRoot.unmount();
+    sidebarRoot = null;
+  }
+  if (sidebarContainer && sidebarContainer.parentNode) {
+    sidebarContainer.parentNode.removeChild(sidebarContainer);
+    sidebarContainer = null;
+  }
+  shadowRoot = null;
+  currentState = {
+    isOpen: false,
+    elementInfo: null,
+    editorUrl: ""
+  };
+  if (typeof window !== "undefined") {
+    delete window.__UIDOG_SIDEBAR__;
+  }
+}
+
+// src/index.ts
+var isInitialized = false;
+function initializeUiDogNext(options = {}) {
+  if (typeof window === "undefined")
+    return;
+  if (isInitialized) {
+    console.warn("[UiDog Next] Already initialized");
+    return;
+  }
+  if (process.env.NODE_ENV === "production") {
+    console.warn(
+      "[UiDog Next] Running in production mode. Element source detection may not work as _debugSource is stripped in production builds."
+    );
+  }
+  const {
+    editor = "cursor",
+    projectPath = "",
+    modifier = "alt",
+    enableSidebar = true,
+    apiEndpoint = "https://api.ui.dog"
+  } = options;
+  isInitialized = true;
+  window.__UIDOG_NEXT_INITIALIZED__ = true;
+  setupBippyInstrumentation();
+  if (enableSidebar) {
+    initializeSidebar({ apiEndpoint });
+  }
+  setupElementDetector({
+    modifier,
+    onElementSelected: (source, element) => {
+      const rect = element.getBoundingClientRect ? element.getBoundingClientRect() : null;
+      const buildDomSnapshot = () => {
+        const outerHTML = element.outerHTML || "";
+        const text = (element.textContent || "").trim();
+        const attributes = {};
+        Array.from(element.attributes || []).forEach((attr) => {
+          attributes[attr.name] = attr.value;
+        });
+        return {
+          outerHTML: outerHTML.length > 4e3 ? `${outerHTML.slice(0, 4e3)}\u2026` : outerHTML,
+          text: text.length > 1e3 ? `${text.slice(0, 1e3)}\u2026` : text,
+          attributes
+        };
+      };
+      if (source) {
+        const editorUrl = buildEditorUrl(source, editor, projectPath);
+        console.info(
+          "[UiDog Next] Source detected:",
+          normalizeFileName(source.fileName),
+          "line",
+          source.lineNumber,
+          "column",
+          source.columnNumber
+        );
+        if (enableSidebar) {
+          const elementInfo = {
+            kind: "source",
+            componentName: source.functionName || "Unknown",
+            filePath: normalizeFileName(source.fileName),
+            line: source.lineNumber,
+            column: source.columnNumber,
+            box: rect ? {
+              x: rect.x,
+              y: rect.y,
+              width: rect.width,
+              height: rect.height
+            } : void 0
+          };
+          openSidebar(elementInfo, editorUrl);
+        } else {
+          console.log("[UiDog Next] Element selected:");
+          console.log("  Component:", source.functionName || "Unknown");
+          console.log("  File:", source.fileName);
+          console.log("  Line:", source.lineNumber);
+          console.log("  Column:", source.columnNumber);
+          console.log("  Editor URL:", editorUrl);
+        }
+      } else {
+        const domSnapshot = buildDomSnapshot();
+        console.info("[UiDog Next] DOM snapshot (no source):", {
+          outerHTML: domSnapshot.outerHTML,
+          text: domSnapshot.text,
+          attributes: domSnapshot.attributes,
+          box: rect ? {
+            x: rect.x,
+            y: rect.y,
+            width: rect.width,
+            height: rect.height
+          } : void 0
+        });
+        const elementInfo = {
+          kind: "dom",
+          componentName: "Server-rendered element",
+          domSnapshot,
+          box: rect ? {
+            x: rect.x,
+            y: rect.y,
+            width: rect.width,
+            height: rect.height
+          } : void 0
+        };
+        if (enableSidebar) {
+          openSidebar(elementInfo, "");
+        } else {
+          console.log("[UiDog Next] Element selected (DOM snapshot):");
+          console.log("  outerHTML:", domSnapshot.outerHTML);
+          console.log("  text:", domSnapshot.text);
+        }
+      }
+    }
+  });
+  console.log(
+    `[UiDog Next] Initialized (${modifier}+click to select elements)`
+  );
+}
+function cleanupUiDogNext() {
+  cleanupElementDetector();
+  cleanupSidebar();
+  isInitialized = false;
+  if (typeof window !== "undefined") {
+    window.__UIDOG_NEXT_INITIALIZED__ = false;
+  }
+}
+function isUiDogNextInitialized() {
+  return isInitialized;
+}
+export {
+  buildEditorUrl,
+  cleanupUiDogNext,
+  closeSidebar,
+  getComponentNameFromFiber,
+  getShortFileName,
+  getSourceFromElement,
+  initializeUiDogNext,
+  isUiDogNextInitialized,
+  normalizeFileName,
+  openSidebar,
+  setupBippyInstrumentation
+};