uilint-react 0.1.38 → 0.1.40

package/dist/{chunk-PU6XPNPN.js → chunk-LAL3JTAA.js}

@@ -70,6 +70,7 @@ function shouldSkipElement(element) {
 function scanDOMForSources(root = document.body, hideNodeModules = true) {
   const elements = [];
   elementCounter = 0;
+  const occurrenceByDataLoc = /* @__PURE__ */ new Map();
   cleanupDataAttributes();
   const locElements = root.querySelectorAll("[data-loc]");
   for (const el of locElements) {
@@ -80,7 +81,9 @@ function scanDOMForSources(root = document.body, hideNodeModules = true) {
       continue;
     }
     const dataLoc = el.getAttribute("data-loc");
-    const id = `loc:${dataLoc}`;
+    const occurrence = (occurrenceByDataLoc.get(dataLoc) ?? 0) + 1;
+    occurrenceByDataLoc.set(dataLoc, occurrence);
+    const id = `loc:${dataLoc}#${occurrence}`;
     el.setAttribute(DATA_ATTR, id);
     elements.push({
       id,
@@ -130,16 +133,21 @@ function updateElementRects(elements) {
     rect: el.element.getBoundingClientRect()
   }));
 }
-function buildEditorUrl(source, editor = "cursor") {
+function buildEditorUrl(source, editor = "cursor", workspaceRoot) {
   const { fileName, lineNumber, columnNumber } = source;
   const column = columnNumber ?? 1;
+  let absolutePath = fileName;
+  if (workspaceRoot && !fileName.startsWith("/")) {
+    const root = workspaceRoot.endsWith("/") ? workspaceRoot.slice(0, -1) : workspaceRoot;
+    absolutePath = `${root}/${fileName}`;
+  }
   if (editor === "cursor") {
     return `cursor://file/${encodeURIComponent(
-      fileName
+      absolutePath
     )}:${lineNumber}:${column}`;
   }
   return `vscode://file/${encodeURIComponent(
-    fileName
+    absolutePath
   )}:${lineNumber}:${column}`;
 }
 
@@ -186,7 +194,8 @@ var DATA_UILINT_ID = "data-ui-lint-id";
 import { create } from "zustand";
 function getDataLocFromId(id) {
   if (id.startsWith("loc:")) {
-    return id.slice(4);
+    const raw = id.slice(4);
+    return raw.split("#")[0] || null;
   }
   return null;
 }
@@ -211,21 +220,25 @@ async function scanFileForIssues(sourceFile, store) {
   return { issues };
 }
 function distributeIssuesToElements(issues, elements, updateElementIssue, hasError) {
-  const dataLocToElementId = /* @__PURE__ */ new Map();
+  const dataLocToElementIds = /* @__PURE__ */ new Map();
   for (const el of elements) {
     const dataLoc = getDataLocFromId(el.id);
     if (dataLoc) {
-      dataLocToElementId.set(dataLoc, el.id);
+      const existing = dataLocToElementIds.get(dataLoc);
+      if (existing) existing.push(el.id);
+      else dataLocToElementIds.set(dataLoc, [el.id]);
     }
   }
   const issuesByElement = /* @__PURE__ */ new Map();
   for (const issue of issues) {
     if (issue.dataLoc) {
-      const elementId = dataLocToElementId.get(issue.dataLoc);
-      if (elementId) {
-        const existing = issuesByElement.get(elementId) || [];
-        existing.push(issue);
-        issuesByElement.set(elementId, existing);
+      const elementIds = dataLocToElementIds.get(issue.dataLoc);
+      if (elementIds) {
+        for (const elementId of elementIds) {
+          const existing = issuesByElement.get(elementId) || [];
+          existing.push(issue);
+          issuesByElement.set(elementId, existing);
+        }
       }
     }
   }
@@ -265,12 +278,11 @@ var useUILintStore = create()((set, get) => ({
   // ============ Inspection ============
   inspectedElement: null,
   setInspectedElement: (el) => set({ inspectedElement: el }),
-  // ============ Auto-Scan ============
+  // ============ Live Scanning ============
+  liveScanEnabled: false,
   autoScanState: DEFAULT_AUTO_SCAN_STATE,
   elementIssuesCache: /* @__PURE__ */ new Map(),
   scanLock: false,
-  scanPaused: false,
-  scanAborted: false,
   _setScanState: (partial) => set((state) => ({
     autoScanState: { ...state.autoScanState, ...partial }
   })),
@@ -279,17 +291,15 @@ var useUILintStore = create()((set, get) => ({
     newCache.set(id, issue);
     return { elementIssuesCache: newCache };
   }),
-  startAutoScan: async (hideNodeModules) => {
+  enableLiveScan: async (hideNodeModules) => {
     const state = get();
     if (state.scanLock) {
       console.warn("UILint: Scan already in progress");
       return;
     }
     set({
-      scanLock: true,
-      scanPaused: false,
-      scanAborted: false,
-      pendingNewElements: 0
+      liveScanEnabled: true,
+      scanLock: true
     });
     const elements = scanDOMForSources(document.body, hideNodeModules);
     const initialCache = /* @__PURE__ */ new Map();
@@ -309,60 +319,72 @@ var useUILintStore = create()((set, get) => ({
         elements
       }
     });
-    await get()._runScanLoop(elements, 0);
-  },
-  pauseAutoScan: () => {
-    set({ scanPaused: true });
-    get()._setScanState({ status: "paused" });
+    await get()._runScanLoop(elements);
   },
-  resumeAutoScan: () => {
-    const state = get();
-    if (state.autoScanState.status !== "paused") return;
-    set({ scanPaused: false });
-    get()._setScanState({ status: "scanning" });
-    get()._runScanLoop(
-      state.autoScanState.elements,
-      state.autoScanState.currentIndex
-    );
-  },
-  stopAutoScan: () => {
+  disableLiveScan: () => {
     set({
-      scanAborted: true,
-      scanPaused: false,
+      liveScanEnabled: false,
       scanLock: false,
       autoScanState: DEFAULT_AUTO_SCAN_STATE,
-      elementIssuesCache: /* @__PURE__ */ new Map(),
-      pendingNewElements: 0
+      elementIssuesCache: /* @__PURE__ */ new Map()
     });
   },
-  _runScanLoop: async (elements, startIndex) => {
+  scanNewElements: async (newElements) => {
+    const state = get();
+    if (!state.liveScanEnabled) return;
+    if (newElements.length === 0) return;
+    set((s) => {
+      const newCache = new Map(s.elementIssuesCache);
+      for (const el of newElements) {
+        newCache.set(el.id, {
+          elementId: el.id,
+          issues: [],
+          status: "pending"
+        });
+      }
+      return {
+        elementIssuesCache: newCache,
+        autoScanState: {
+          ...s.autoScanState,
+          elements: [...s.autoScanState.elements, ...newElements],
+          totalElements: s.autoScanState.totalElements + newElements.length
+        }
+      };
+    });
+    const sourceFiles = groupBySourceFile(newElements);
+    for (const sourceFile of sourceFiles) {
+      for (const el of sourceFile.elements) {
+        get().updateElementIssue(el.id, {
+          elementId: el.id,
+          issues: [],
+          status: "scanning"
+        });
+      }
+      await new Promise((resolve) => requestAnimationFrame(resolve));
+      const { issues, error } = await scanFileForIssues(sourceFile, get());
+      distributeIssuesToElements(
+        issues,
+        sourceFile.elements,
+        get().updateElementIssue,
+        error ?? false
+      );
+      if (get().wsConnected && get().wsConnection) {
+        get().subscribeToFile(sourceFile.path);
+      }
+      await new Promise((resolve) => requestAnimationFrame(resolve));
+    }
+  },
+  _runScanLoop: async (elements) => {
     const sourceFiles = groupBySourceFile(elements);
     let processedElements = 0;
-    let skipElements = startIndex;
     for (const sourceFile of sourceFiles) {
-      if (skipElements >= sourceFile.elements.length) {
-        skipElements -= sourceFile.elements.length;
-        processedElements += sourceFile.elements.length;
-        continue;
-      }
-      skipElements = 0;
-      if (get().scanAborted) {
+      if (!get().liveScanEnabled) {
         set({
           scanLock: false,
-          autoScanState: { ...get().autoScanState, status: "idle" }
+          autoScanState: DEFAULT_AUTO_SCAN_STATE
         });
         return;
       }
-      while (get().scanPaused) {
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        if (get().scanAborted) {
-          set({
-            scanLock: false,
-            autoScanState: { ...get().autoScanState, status: "idle" }
-          });
-          return;
-        }
-      }
       get()._setScanState({ currentIndex: processedElements });
       for (const el of sourceFile.elements) {
         get().updateElementIssue(el.id, {
@@ -394,10 +416,7 @@ var useUILintStore = create()((set, get) => ({
       }
     });
   },
-  // ============ Navigation Detection ============
-  pendingNewElements: 0,
-  setPendingNewElements: (count) => set({ pendingNewElements: count }),
-  clearPendingNewElements: () => set({ pendingNewElements: 0 }),
+  // ============ DOM Observer ============
   removeStaleResults: (elementIds) => set((state) => {
     const newCache = new Map(state.elementIssuesCache);
     const newElements = state.autoScanState.elements.filter(
@@ -415,6 +434,15 @@ var useUILintStore = create()((set, get) => ({
       }
     };
   }),
+  // ============ File/Element Selection ============
+  hoveredFilePath: null,
+  selectedFilePath: null,
+  selectedElementId: null,
+  hoveredElementId: null,
+  setHoveredFilePath: (path) => set({ hoveredFilePath: path }),
+  setSelectedFilePath: (path) => set({ selectedFilePath: path }),
+  setSelectedElementId: (id) => set({ selectedElementId: id }),
+  setHoveredElementId: (id) => set({ hoveredElementId: id }),
   // ============ WebSocket ============
   wsConnection: null,
   wsConnected: false,
@@ -424,6 +452,9 @@ var useUILintStore = create()((set, get) => ({
   wsProgressPhase: /* @__PURE__ */ new Map(),
   wsLastActivity: null,
   wsRecentResults: [],
+  workspaceRoot: null,
+  appRoot: null,
+  serverCwd: null,
   connectWebSocket: (url) => {
     const targetUrl = url || get().wsUrl;
     const existing = get().wsConnection;
@@ -573,7 +604,7 @@ var useUILintStore = create()((set, get) => ({
           return { eslintIssuesCache: next };
         });
         const state = get();
-        if (state.autoScanState.status !== "idle") {
+        if (state.liveScanEnabled) {
           const sourceFiles = groupBySourceFile(state.autoScanState.elements);
           const sf = sourceFiles.find((s) => s.path === filePath);
           if (sf) {
@@ -633,7 +664,7 @@ var useUILintStore = create()((set, get) => ({
           return { eslintIssuesCache: next };
         });
         const state = get();
-        if (state.autoScanState.status !== "idle") {
+        if (state.liveScanEnabled) {
           const sourceFiles = groupBySourceFile(state.autoScanState.elements);
           const sf = sourceFiles.find((s) => s.path === filePath);
           if (sf) {
@@ -659,6 +690,16 @@ var useUILintStore = create()((set, get) => ({
         }
         break;
       }
+      case "workspace:info": {
+        const { appRoot, workspaceRoot, serverCwd } = data;
+        console.log("[UILint] Received workspace info:", {
+          appRoot,
+          workspaceRoot,
+          serverCwd
+        });
+        set({ appRoot, workspaceRoot, serverCwd });
+        break;
+      }
     }
   },
   _reconnectWebSocket: () => {
@@ -685,50 +726,53 @@ function useDOMObserver(enabled = true) {
   const reconcileTimeoutRef = useRef(
     null
   );
-  const lastScanElementIdsRef = useRef(/* @__PURE__ */ new Set());
-  const setPendingNewElements = useUILintStore(
-    (s) => s.setPendingNewElements
-  );
+  const knownElementIdsRef = useRef(/* @__PURE__ */ new Set());
+  const liveScanEnabled = useUILintStore((s) => s.liveScanEnabled);
+  const settings = useUILintStore((s) => s.settings);
+  const autoScanState = useUILintStore((s) => s.autoScanState);
   const removeStaleResults = useUILintStore(
     (s) => s.removeStaleResults
   );
-  const autoScanState = useUILintStore((s) => s.autoScanState);
+  const scanNewElements = useUILintStore((s) => s.scanNewElements);
   useEffect(() => {
-    if (autoScanState.status === "complete") {
+    if (autoScanState.elements.length > 0) {
       const ids = new Set(autoScanState.elements.map((el) => el.id));
-      lastScanElementIdsRef.current = ids;
+      knownElementIdsRef.current = ids;
     }
-  }, [autoScanState.status, autoScanState.elements]);
+  }, [autoScanState.elements]);
   const reconcileElements = useCallback(() => {
-    const currentElements = document.querySelectorAll("[data-loc]");
-    const currentIds = /* @__PURE__ */ new Set();
+    if (!liveScanEnabled) return;
+    const currentElements = scanDOMForSources(
+      document.body,
+      settings.hideNodeModules
+    );
+    const currentIds = new Set(currentElements.map((el) => el.id));
+    const knownIds = knownElementIdsRef.current;
+    const newElements = [];
     for (const el of currentElements) {
-      const dataLoc = el.getAttribute("data-loc");
-      if (dataLoc) {
-        currentIds.add(`loc:${dataLoc}`);
-      }
-    }
-    const lastScanIds = lastScanElementIdsRef.current;
-    if (lastScanIds.size === 0) return;
-    const newElementIds = [];
-    for (const id of currentIds) {
-      if (!lastScanIds.has(id)) {
-        newElementIds.push(id);
+      if (!knownIds.has(el.id)) {
+        newElements.push(el);
       }
     }
     const removedElementIds = [];
-    for (const id of lastScanIds) {
+    for (const id of knownIds) {
       if (!currentIds.has(id)) {
         removedElementIds.push(id);
       }
     }
-    if (newElementIds.length > 0) {
-      setPendingNewElements(newElementIds.length);
+    knownElementIdsRef.current = currentIds;
+    if (newElements.length > 0) {
+      scanNewElements(newElements);
     }
     if (removedElementIds.length > 0) {
       removeStaleResults(removedElementIds);
     }
-  }, [setPendingNewElements, removeStaleResults]);
+  }, [
+    liveScanEnabled,
+    settings.hideNodeModules,
+    scanNewElements,
+    removeStaleResults
+  ]);
   const debouncedReconcile = useCallback(() => {
     if (reconcileTimeoutRef.current) {
       clearTimeout(reconcileTimeoutRef.current);
@@ -819,14 +863,15 @@ function UILintProvider({
   const setInspectedElement = useUILintStore(
     (s) => s.setInspectedElement
   );
+  const liveScanEnabled = useUILintStore((s) => s.liveScanEnabled);
   const autoScanState = useUILintStore((s) => s.autoScanState);
   const elementIssuesCache = useUILintStore(
     (s) => s.elementIssuesCache
   );
-  const startAutoScan = useUILintStore((s) => s.startAutoScan);
-  const pauseAutoScan = useUILintStore((s) => s.pauseAutoScan);
-  const resumeAutoScan = useUILintStore((s) => s.resumeAutoScan);
-  const stopAutoScan = useUILintStore((s) => s.stopAutoScan);
+  const storeEnableLiveScan = useUILintStore(
+    (s) => s.enableLiveScan
+  );
+  const disableLiveScan = useUILintStore((s) => s.disableLiveScan);
   const connectWebSocket = useUILintStore(
     (s) => s.connectWebSocket
   );
@@ -852,7 +897,7 @@ function UILintProvider({
   );
   const handleMouseMove = useCallback2(
     (e) => {
-      if (!altKeyHeld && !inspectedElement) return;
+      if (!altKeyHeld) return;
       const elementAtPoint = document.elementFromPoint(e.clientX, e.clientY);
       if (!elementAtPoint) {
         setLocatorTarget(null);
@@ -869,16 +914,11 @@ function UILintProvider({
       }
       setLocatorTarget(null);
     },
-    [
-      altKeyHeld,
-      inspectedElement,
-      getLocatorTargetFromElement,
-      setLocatorTarget
-    ]
+    [altKeyHeld, getLocatorTargetFromElement, setLocatorTarget]
   );
   const handleLocatorClick = useCallback2(
     (e) => {
-      if (!altKeyHeld && !inspectedElement || !locatorTarget) return;
+      if (!altKeyHeld || !locatorTarget) return;
       const targetEl = e.target;
       if (targetEl?.closest?.("[data-ui-lint]")) return;
       e.preventDefault();
@@ -890,13 +930,7 @@ function UILintProvider({
       });
       setLocatorTarget(null);
     },
-    [
-      altKeyHeld,
-      locatorTarget,
-      inspectedElement,
-      setInspectedElement,
-      setLocatorTarget
-    ]
+    [altKeyHeld, locatorTarget, setInspectedElement, setLocatorTarget]
   );
   useEffect2(() => {
     if (!isBrowser() || !enabled) return;
@@ -926,20 +960,14 @@ function UILintProvider({
   }, [enabled, setAltKeyHeld, setLocatorTarget]);
   useEffect2(() => {
     if (!isBrowser() || !enabled) return;
-    if (!altKeyHeld && !inspectedElement) return;
+    if (!altKeyHeld) return;
     window.addEventListener("mousemove", handleMouseMove);
     window.addEventListener("click", handleLocatorClick, true);
     return () => {
       window.removeEventListener("mousemove", handleMouseMove);
       window.removeEventListener("click", handleLocatorClick, true);
     };
-  }, [
-    enabled,
-    altKeyHeld,
-    inspectedElement,
-    handleMouseMove,
-    handleLocatorClick
-  ]);
+  }, [enabled, altKeyHeld, handleMouseMove, handleLocatorClick]);
   useEffect2(() => {
     if (!isBrowser() || !enabled) return;
     const handleKeyDown = (e) => {
@@ -961,9 +989,9 @@ function UILintProvider({
       disconnectWebSocket();
     };
   }, [enabled, isMounted, connectWebSocket, disconnectWebSocket]);
-  const wrappedStartAutoScan = useCallback2(() => {
-    startAutoScan(settings.hideNodeModules);
-  }, [startAutoScan, settings.hideNodeModules]);
+  const enableLiveScan = useCallback2(() => {
+    storeEnableLiveScan(settings.hideNodeModules);
+  }, [storeEnableLiveScan, settings.hideNodeModules]);
   const contextValue = useMemo(
     () => ({
       settings,
@@ -972,12 +1000,11 @@ function UILintProvider({
       locatorTarget,
       inspectedElement,
       setInspectedElement,
+      liveScanEnabled,
       autoScanState,
       elementIssuesCache,
-      startAutoScan: wrappedStartAutoScan,
-      pauseAutoScan,
-      resumeAutoScan,
-      stopAutoScan
+      enableLiveScan,
+      disableLiveScan
     }),
     [
       settings,
@@ -986,12 +1013,11 @@ function UILintProvider({
       locatorTarget,
       inspectedElement,
       setInspectedElement,
+      liveScanEnabled,
       autoScanState,
       elementIssuesCache,
-      wrappedStartAutoScan,
-      pauseAutoScan,
-      resumeAutoScan,
-      stopAutoScan
+      enableLiveScan,
+      disableLiveScan
     ]
   );
   const shouldRenderUI = enabled && isMounted;
@@ -1001,14 +1027,14 @@ function UILintProvider({
   ] });
 }
 function UILintUI() {
-  const { altKeyHeld, inspectedElement, autoScanState } = useUILintContext();
+  const { altKeyHeld, inspectedElement, liveScanEnabled } = useUILintContext();
   const [components, setComponents] = useState(null);
   useEffect2(() => {
     Promise.all([
-      import("./UILintToolbar-OQY2V7Q7.js"),
-      import("./InspectionPanel-7N56XBWA.js"),
-      import("./LocatorOverlay-RDDLASGB.js"),
-      import("./ElementBadges-J2ELN2PU.js")
+      import("./UILintToolbar-MJH7RUZK.js"),
+      import("./InspectionPanel-4LOWGHW7.js"),
+      import("./LocatorOverlay-ERRFPXKK.js"),
+      import("./ElementBadges-2I25HN6W.js")
     ]).then(([toolbar, panel, locator, badges]) => {
       setComponents({
         Toolbar: toolbar.UILintToolbar,
@@ -1021,11 +1047,10 @@ function UILintUI() {
   }, []);
   if (!components) return null;
   const { Toolbar, Panel, LocatorOverlay, InspectedHighlight, ElementBadges } = components;
-  const showBadges = autoScanState.status !== "idle";
   return /* @__PURE__ */ jsxs(Fragment, { children: [
     /* @__PURE__ */ jsx(Toolbar, {}),
     (altKeyHeld || inspectedElement) && /* @__PURE__ */ jsx(LocatorOverlay, {}),
-    showBadges && /* @__PURE__ */ jsx(ElementBadges, {}),
+    liveScanEnabled && /* @__PURE__ */ jsx(ElementBadges, {}),
     inspectedElement && /* @__PURE__ */ jsxs(Fragment, { children: [
       /* @__PURE__ */ jsx(InspectedHighlight, {}),
       /* @__PURE__ */ jsx(Panel, {})

package/dist/{chunk-V4273T5B.js → chunk-UD6HPLEZ.js}

@@ -1,7 +1,7 @@
 "use client";
 import {
   useUILintContext
-} from "./chunk-PU6XPNPN.js";
+} from "./chunk-LAL3JTAA.js";
 
 // src/components/ui-lint/LocatorOverlay.tsx
 import { useState, useEffect, useMemo } from "react";

package/dist/index.d.ts

@@ -19,7 +19,10 @@ interface SourceLocation {
  * Source is always present from data-loc attribute
  */
 interface ScannedElement {
-    /** Unique ID from data-loc value (format: "loc:path:line:column") */
+    /**
+     * Unique per-instance ID derived from data-loc.
+     * Format: "loc:path:line:column#occurrence"
+     */
     id: string;
     element: Element;
     tagName: string;
@@ -109,18 +112,16 @@ interface UILintContextValue {
     inspectedElement: InspectedElement | null;
     /** Set the element to inspect (opens sidebar) */
     setInspectedElement: (element: InspectedElement | null) => void;
-    /** Auto-scan state */
+    /** Whether live scanning is enabled */
+    liveScanEnabled: boolean;
+    /** Auto-scan state (for progress tracking) */
     autoScanState: AutoScanState;
-    /** Cache of element issues from auto-scan */
+    /** Cache of element issues from scanning */
     elementIssuesCache: Map<string, ElementIssue>;
-    /** Start auto-scanning all page elements */
-    startAutoScan: () => void;
-    /** Pause the auto-scan */
-    pauseAutoScan: () => void;
-    /** Resume the auto-scan */
-    resumeAutoScan: () => void;
-    /** Stop and reset the auto-scan */
-    stopAutoScan: () => void;
+    /** Enable live scanning */
+    enableLiveScan: () => void;
+    /** Disable live scanning */
+    disableLiveScan: () => void;
 }
 /**
  * Props for the UILintProvider component
@@ -168,27 +169,31 @@ declare function useUILintContext(): UILintContextValue;
 declare function UILintProvider({ children, enabled, }: UILintProviderProps): react_jsx_runtime.JSX.Element;
 
 /**
- * UILint Toolbar - Segmented pill with Scan button and settings
+ * UILint Toolbar - Improved UX Version
  *
- * Design:
- * ┌─────────────────────────────────────┐
- * │  [🔍 Scan]  │  [...]               │
- * └─────────────────────────────────────┘
- *        ⌥+Click to inspect
+ * Key improvements:
+ * - Clear visual hierarchy: Primary (toggle) → Secondary (issues) → Tertiary (settings)
+ * - Contextual hints that only show when relevant
+ * - CSS-based hover/focus states (no inline handlers)
+ * - Full keyboard navigation with visible focus rings
+ * - Smooth animations for all state changes
+ * - Better disabled state communication
+ * - Expanded panel that doesn't conflict with settings
+ * - Touch-friendly targets (min 44px)
+ * - ARIA labels and semantic markup
  */
 
-/**
- * Main Toolbar Component - Segmented pill with Scan + Settings
- */
 declare function UILintToolbar(): React$1.ReactPortal | null;
 
 /**
- * Inspection Panel - Slide-out sidebar showing element details, source preview,
- * and LLM analysis with clipboard-ready fix prompts
+ * Inspection Panel - Lightweight floating popover showing element issues
+ * with inline code previews and "Open in Cursor" actions
+ *
+ * Positions near the clicked badge, avoiding overlap with the element itself.
  */
 
 /**
- * Main Inspection Panel Component
+ * Main Inspection Panel Component - Floating Popover
  */
 declare function InspectionPanel(): React$1.ReactPortal | null;
 
@@ -247,8 +252,11 @@ declare function getElementById(id: string): Element | null;
 declare function updateElementRects(elements: ScannedElement[]): ScannedElement[];
 /**
  * Build an "Open in Editor" URL
+ * @param source - The source location (fileName may be relative or absolute)
+ * @param editor - The editor to open in (cursor or vscode)
+ * @param workspaceRoot - Optional workspace root to prepend for relative paths
  */
-declare function buildEditorUrl(source: SourceLocation, editor?: "cursor" | "vscode"): string;
+declare function buildEditorUrl(source: SourceLocation, editor?: "cursor" | "vscode", workspaceRoot?: string | null): string;
 
 /**
  * Client for fetching source code from the dev API

package/dist/index.js

@@ -1,7 +1,7 @@
 "use client";
 import {
   UILintToolbar
-} from "./chunk-WEBVLQL5.js";
+} from "./chunk-C6NUU5MF.js";
 import {
   InspectionPanel,
   clearSourceCache,
@@ -9,10 +9,10 @@ import {
   fetchSourceWithContext,
   getCachedSource,
   prefetchSources
-} from "./chunk-GZOQ6QWC.js";
+} from "./chunk-2VRWAMW7.js";
 import {
   LocatorOverlay
-} from "./chunk-V4273T5B.js";
+} from "./chunk-UD6HPLEZ.js";
 import {
   DATA_UILINT_ID,
   DEFAULT_SETTINGS,
@@ -28,7 +28,7 @@ import {
   scanDOMForSources,
   updateElementRects,
   useUILintContext
-} from "./chunk-PU6XPNPN.js";
+} from "./chunk-LAL3JTAA.js";
 
 // src/consistency/snapshot.ts
 var DATA_ELEMENTS_ATTR = "data-elements";