@react-spot/core 0.0.1

package/dist/index.js

@@ -0,0 +1,1713 @@
+import { n as __reExport, t as __exportAll } from "./chunk-zc3tnsvq.js";
+import { n as MOD_KEY, t as IS_MAC } from "./platform-BdNumz2Y.js";
+import { Component, Fragment, useCallback, useEffect, useEffectEvent, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { atomWithStorage, createJSONStorage } from "jotai/utils";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { Button, ChevronLeftIcon, ChevronRightIcon, IconButton, Logo, PanelHeader, Popover, Select, Separator, SettingsIcon, ToolbarButton, Tooltip, XIcon } from "@react-spot/ui-components";
+
+//#region ../../node_modules/.pnpm/jotai@2.18.0_@babel+core@7.29.0_@babel+template@7.28.6_@types+react@19.2.14_react@19.2.4/node_modules/jotai/esm/index.mjs
+var esm_exports = /* @__PURE__ */ __exportAll({});
+import * as import_jotai_vanilla from "jotai/vanilla";
+__reExport(esm_exports, import_jotai_vanilla);
+import * as import_jotai_react from "jotai/react";
+__reExport(esm_exports, import_jotai_react);
+
+//#endregion
+//#region ../../node_modules/.pnpm/jotai-family@1.0.1_jotai@2.18.0_@babel+core@7.29.0_@babel+template@7.28.6_@types+react@19.2.14_react@19.2.4_/node_modules/jotai-family/dist/atomFamily.js
+function atomFamily(initializeAtom, areEqual) {
+	let shouldRemove = null;
+	const atoms = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	function createAtom(param) {
+		let item;
+		if (areEqual === void 0) item = atoms.get(param);
+		else for (const [key, value] of atoms) if (areEqual(key, param)) {
+			item = value;
+			break;
+		}
+		if (item !== void 0) if (shouldRemove?.(item[1], param)) createAtom.remove(param);
+		else return item[0];
+		const newAtom = initializeAtom(param);
+		atoms.set(param, [newAtom, Date.now()]);
+		notifyListeners("CREATE", param, newAtom);
+		return newAtom;
+	}
+	function notifyListeners(type, param, atom) {
+		for (const listener of listeners) listener({
+			type,
+			param,
+			atom
+		});
+	}
+	createAtom.unstable_listen = (callback) => {
+		listeners.add(callback);
+		return () => {
+			listeners.delete(callback);
+		};
+	};
+	createAtom.getParams = () => atoms.keys();
+	createAtom.remove = (param) => {
+		if (areEqual === void 0) {
+			if (!atoms.has(param)) return;
+			const [atom] = atoms.get(param);
+			atoms.delete(param);
+			notifyListeners("REMOVE", param, atom);
+		} else for (const [key, [atom]] of atoms) if (areEqual(key, param)) {
+			atoms.delete(key);
+			notifyListeners("REMOVE", key, atom);
+			break;
+		}
+	};
+	createAtom.setShouldRemove = (fn) => {
+		shouldRemove = fn;
+		if (!shouldRemove) return;
+		for (const [key, [atom, createdAt]] of atoms) if (shouldRemove(createdAt, key)) {
+			atoms.delete(key);
+			notifyListeners("REMOVE", key, atom);
+		}
+	};
+	return createAtom;
+}
+
+//#endregion
+//#region src/store.ts
+/**
+* The scoped Jotai store used by the Trace widget.
+* Created once per `<Trace />` mount via the Provider in Trace.tsx.
+* Plugins import atoms from this module and read them through the hooks in
+* `./hooks.ts`, which are scoped to the nearest Provider.
+*/
+/**
+* Absolute path to the project root.
+*/
+const projectRootAtom = (0, esm_exports.atom)("");
+/**
+* Settings atom per project root, persisted in localStorage.
+*/
+const settingsAtom = atomFamily((root) => atomWithStorage(`react-trace:settings:${root}`, { core: {
+	position: "bottom-right",
+	minimized: false
+} }, createJSONStorage(() => localStorage), { getOnInit: typeof window !== "undefined" }));
+const currentSettingsAtom = (0, esm_exports.atom)((get) => get(settingsAtom(get(projectRootAtom))), (get, set, value) => {
+	set(settingsAtom(get(projectRootAtom)), value);
+});
+const settingsPluginFamily = atomFamily((pluginKey) => (0, esm_exports.atom)((get) => get(currentSettingsAtom)[pluginKey], (get, set, value) => {
+	set(currentSettingsAtom, {
+		...get(currentSettingsAtom),
+		[pluginKey]: value
+	});
+}));
+/**
+* Atom family for plugin-specific settings.
+* @param pluginKey
+* @returns
+*/
+function settingsPluginAtom(pluginKey) {
+	return settingsPluginFamily(pluginKey);
+}
+const coreSettingsAtom = settingsPluginFamily("core");
+/**
+* The portal container element that the widget renders into. Plugins can read
+* this to mount their own portals inside the same container.
+*/
+const portalContainerAtom = (0, esm_exports.atom)(() => {
+	const existing = document.querySelector("[data-react-trace]");
+	if (existing) return existing;
+	const container = document.createElement("div");
+	container.setAttribute("data-react-trace", "");
+	container.style.cssText = "position:fixed;inset:0;pointer-events:none;z-index:999997;";
+	document.body.appendChild(container);
+	return container;
+});
+/**
+* Inspector active state.
+*/
+const inspectorActiveAtom = (0, esm_exports.atom)(false);
+/**
+* Editor to open files in when clicking a component.
+*/
+const editorAtom = (0, esm_exports.atom)("vscode");
+/**
+* The component context that is currently selected in the inspector.
+*/
+const selectedContextAtom = (0, esm_exports.atom)(null);
+/**
+* The source of the currently selected file.
+*/
+const selectedSourceAtom = (0, esm_exports.atom)(null);
+/**
+* Creates a new Jotai store instance for Trace widget.
+*/
+const createWidgetStore = () => (0, esm_exports.createStore)();
+
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+	const c = chars.charCodeAt(i);
+	intToChar[i] = c;
+	charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+	let value = 0;
+	let shift = 0;
+	let integer = 0;
+	do {
+		integer = charToInt[reader.next()];
+		value |= (integer & 31) << shift;
+		shift += 5;
+	} while (integer & 32);
+	const shouldNegate = value & 1;
+	value >>>= 1;
+	if (shouldNegate) value = -2147483648 | -value;
+	return relative + value;
+}
+function hasMoreVlq(reader, max) {
+	if (reader.pos >= max) return false;
+	return reader.peek() !== comma;
+}
+var bufLength = 1024 * 16;
+var StringReader = class {
+	constructor(buffer) {
+		this.pos = 0;
+		this.buffer = buffer;
+	}
+	next() {
+		return this.buffer.charCodeAt(this.pos++);
+	}
+	peek() {
+		return this.buffer.charCodeAt(this.pos);
+	}
+	indexOf(char) {
+		const { buffer, pos } = this;
+		const idx = buffer.indexOf(char, pos);
+		return idx === -1 ? buffer.length : idx;
+	}
+};
+function decode(mappings) {
+	const { length } = mappings;
+	const reader = new StringReader(mappings);
+	const decoded = [];
+	let genColumn = 0;
+	let sourcesIndex = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	let namesIndex = 0;
+	do {
+		const semi = reader.indexOf(";");
+		const line = [];
+		let sorted = true;
+		let lastCol = 0;
+		genColumn = 0;
+		while (reader.pos < semi) {
+			let seg;
+			genColumn = decodeInteger(reader, genColumn);
+			if (genColumn < lastCol) sorted = false;
+			lastCol = genColumn;
+			if (hasMoreVlq(reader, semi)) {
+				sourcesIndex = decodeInteger(reader, sourcesIndex);
+				sourceLine = decodeInteger(reader, sourceLine);
+				sourceColumn = decodeInteger(reader, sourceColumn);
+				if (hasMoreVlq(reader, semi)) {
+					namesIndex = decodeInteger(reader, namesIndex);
+					seg = [
+						genColumn,
+						sourcesIndex,
+						sourceLine,
+						sourceColumn,
+						namesIndex
+					];
+				} else seg = [
+					genColumn,
+					sourcesIndex,
+					sourceLine,
+					sourceColumn
+				];
+			} else seg = [genColumn];
+			line.push(seg);
+			reader.pos++;
+		}
+		if (!sorted) sort(line);
+		decoded.push(line);
+		reader.pos = semi + 1;
+	} while (reader.pos <= length);
+	return decoded;
+}
+function sort(line) {
+	line.sort(sortComparator$1);
+}
+function sortComparator$1(a, b) {
+	return a[0] - b[0];
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
+const schemeRegex = /^[\w+.-]+:\/\//;
+/**
+* Matches the parts of a URL:
+* 1. Scheme, including ":", guaranteed.
+* 2. User/password, including "@", optional.
+* 3. Host, guaranteed.
+* 4. Port, including ":", optional.
+* 5. Path, including "/", optional.
+* 6. Query, including "?", optional.
+* 7. Hash, including "#", optional.
+*/
+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+/**
+* File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
+* with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
+*
+* 1. Host, optional.
+* 2. Path, which may include "/", guaranteed.
+* 3. Query, including "?", optional.
+* 4. Hash, including "#", optional.
+*/
+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+function isAbsoluteUrl(input) {
+	return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+	return input.startsWith("//");
+}
+function isAbsolutePath(input) {
+	return input.startsWith("/");
+}
+function isFileUrl(input) {
+	return input.startsWith("file:");
+}
+function isRelative(input) {
+	return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+	const match = urlRegex.exec(input);
+	return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+}
+function parseFileUrl(input) {
+	const match = fileRegex.exec(input);
+	const path = match[2];
+	return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+	return {
+		scheme,
+		user,
+		host,
+		port,
+		path,
+		query,
+		hash,
+		type: 7
+	};
+}
+function parseUrl(input) {
+	if (isSchemeRelativeUrl(input)) {
+		const url = parseAbsoluteUrl("http:" + input);
+		url.scheme = "";
+		url.type = 6;
+		return url;
+	}
+	if (isAbsolutePath(input)) {
+		const url = parseAbsoluteUrl("http://foo.com" + input);
+		url.scheme = "";
+		url.host = "";
+		url.type = 5;
+		return url;
+	}
+	if (isFileUrl(input)) return parseFileUrl(input);
+	if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);
+	const url = parseAbsoluteUrl("http://foo.com/" + input);
+	url.scheme = "";
+	url.host = "";
+	url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
+	return url;
+}
+function stripPathFilename(path) {
+	if (path.endsWith("/..")) return path;
+	const index = path.lastIndexOf("/");
+	return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+	normalizePath$1(base, base.type);
+	if (url.path === "/") url.path = base.path;
+	else url.path = stripPathFilename(base.path) + url.path;
+}
+/**
+* The path can have empty directories "//", unneeded parents "foo/..", or current directory
+* "foo/.". We need to normalize to a standard representation.
+*/
+function normalizePath$1(url, type) {
+	const rel = type <= 4;
+	const pieces = url.path.split("/");
+	let pointer = 1;
+	let positive = 0;
+	let addTrailingSlash = false;
+	for (let i = 1; i < pieces.length; i++) {
+		const piece = pieces[i];
+		if (!piece) {
+			addTrailingSlash = true;
+			continue;
+		}
+		addTrailingSlash = false;
+		if (piece === ".") continue;
+		if (piece === "..") {
+			if (positive) {
+				addTrailingSlash = true;
+				positive--;
+				pointer--;
+			} else if (rel) pieces[pointer++] = piece;
+			continue;
+		}
+		pieces[pointer++] = piece;
+		positive++;
+	}
+	let path = "";
+	for (let i = 1; i < pointer; i++) path += "/" + pieces[i];
+	if (!path || addTrailingSlash && !path.endsWith("/..")) path += "/";
+	url.path = path;
+}
+/**
+* Attempts to resolve `input` URL/path relative to `base`.
+*/
+function resolve(input, base) {
+	if (!input && !base) return "";
+	const url = parseUrl(input);
+	let inputType = url.type;
+	if (base && inputType !== 7) {
+		const baseUrl = parseUrl(base);
+		const baseType = baseUrl.type;
+		switch (inputType) {
+			case 1: url.hash = baseUrl.hash;
+			case 2: url.query = baseUrl.query;
+			case 3:
+			case 4: mergePaths(url, baseUrl);
+			case 5:
+				url.user = baseUrl.user;
+				url.host = baseUrl.host;
+				url.port = baseUrl.port;
+			case 6: url.scheme = baseUrl.scheme;
+		}
+		if (baseType > inputType) inputType = baseType;
+	}
+	normalizePath$1(url, inputType);
+	const queryHash = url.query + url.hash;
+	switch (inputType) {
+		case 2:
+		case 3: return queryHash;
+		case 4: {
+			const path = url.path.slice(1);
+			if (!path) return queryHash || ".";
+			if (isRelative(base || input) && !isRelative(path)) return "./" + path + queryHash;
+			return path + queryHash;
+		}
+		case 5: return url.path + queryHash;
+		default: return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+function stripFilename(path) {
+	if (!path) return "";
+	const index = path.lastIndexOf("/");
+	return path.slice(0, index + 1);
+}
+function resolver(mapUrl, sourceRoot) {
+	const from = stripFilename(mapUrl);
+	const prefix = sourceRoot ? sourceRoot + "/" : "";
+	return (source) => resolve(prefix + (source || ""), from);
+}
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+function maybeSort(mappings, owned) {
+	const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+	if (unsortedIndex === mappings.length) return mappings;
+	if (!owned) mappings = mappings.slice();
+	for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) mappings[i] = sortSegments(mappings[i], owned);
+	return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+	for (let i = start; i < mappings.length; i++) if (!isSorted(mappings[i])) return i;
+	return mappings.length;
+}
+function isSorted(line) {
+	for (let j = 1; j < line.length; j++) if (line[j][COLUMN] < line[j - 1][COLUMN]) return false;
+	return true;
+}
+function sortSegments(line, owned) {
+	if (!owned) line = line.slice();
+	return line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+	return a[COLUMN] - b[COLUMN];
+}
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+	while (low <= high) {
+		const mid = low + (high - low >> 1);
+		const cmp = haystack[mid][COLUMN] - needle;
+		if (cmp === 0) {
+			found = true;
+			return mid;
+		}
+		if (cmp < 0) low = mid + 1;
+		else high = mid - 1;
+	}
+	found = false;
+	return low - 1;
+}
+function upperBound(haystack, needle, index) {
+	for (let i = index + 1; i < haystack.length; index = i++) if (haystack[i][COLUMN] !== needle) break;
+	return index;
+}
+function lowerBound(haystack, needle, index) {
+	for (let i = index - 1; i >= 0; index = i--) if (haystack[i][COLUMN] !== needle) break;
+	return index;
+}
+function memoizedState() {
+	return {
+		lastKey: -1,
+		lastNeedle: -1,
+		lastIndex: -1
+	};
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+	const { lastKey, lastNeedle, lastIndex } = state;
+	let low = 0;
+	let high = haystack.length - 1;
+	if (key === lastKey) {
+		if (needle === lastNeedle) {
+			found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+			return lastIndex;
+		}
+		if (needle >= lastNeedle) low = lastIndex === -1 ? 0 : lastIndex;
+		else high = lastIndex;
+	}
+	state.lastKey = key;
+	state.lastNeedle = needle;
+	return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+function parse(map) {
+	return typeof map === "string" ? JSON.parse(map) : map;
+}
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+var TraceMap = class {
+	constructor(map, mapUrl) {
+		const isString = typeof map === "string";
+		if (!isString && map._decodedMemo) return map;
+		const parsed = parse(map);
+		const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+		this.version = version;
+		this.file = file;
+		this.names = names || [];
+		this.sourceRoot = sourceRoot;
+		this.sources = sources;
+		this.sourcesContent = sourcesContent;
+		this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+		const resolve = resolver(mapUrl, sourceRoot);
+		this.resolvedSources = sources.map(resolve);
+		const { mappings } = parsed;
+		if (typeof mappings === "string") {
+			this._encoded = mappings;
+			this._decoded = void 0;
+		} else if (Array.isArray(mappings)) {
+			this._encoded = void 0;
+			this._decoded = maybeSort(mappings, isString);
+		} else if (parsed.sections) throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+		else throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+		this._decodedMemo = memoizedState();
+		this._bySources = void 0;
+		this._bySourceMemos = void 0;
+	}
+};
+function cast(map) {
+	return map;
+}
+function decodedMappings(map) {
+	var _a;
+	return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+	let { line, column, bias } = needle;
+	line--;
+	if (line < 0) throw new Error(LINE_GTR_ZERO);
+	if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+	const decoded = decodedMappings(map);
+	if (line >= decoded.length) return OMapping(null, null, null, null);
+	const segments = decoded[line];
+	const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+	if (index === -1) return OMapping(null, null, null, null);
+	const segment = segments[index];
+	if (segment.length === 1) return OMapping(null, null, null, null);
+	const { names, resolvedSources } = map;
+	return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+}
+function OMapping(source, line, column, name) {
+	return {
+		source,
+		line,
+		column,
+		name
+	};
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+	let index = memoizedBinarySearch(segments, column, memo, line);
+	if (found) index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+	else if (bias === LEAST_UPPER_BOUND) index++;
+	if (index === -1 || index === segments.length) return -1;
+	return index;
+}
+
+//#endregion
+//#region src/utils/path.ts
+/**
+* Shared path utilities for converting development source identifiers and
+* absolute filesystem paths into relative or absolute forms needed by plugins.
+*
+* Handles the fileName conventions react-trace encounters:
+*   - Vite dev URL          http://localhost:5173/src/App.tsx
+*   - Vite /@fs/ URL        http://localhost:5173/@fs/abs/path/src/App.tsx
+*   - Next webpack URL      webpack-internal:///(app-pages-browser)/./app/page.tsx
+*   - Turbopack URL         turbopack:///[project]/app/page.tsx
+*   - Absolute path / URL   /Users/you/project/src/App.tsx
+*/
+const NEXT_SOURCE_GROUP_RE = /^\((?:app|pages)-[^/]+\)\//;
+const TURBOPACK_PROJECT_PREFIX_RE = /^\[project\]\//;
+function stripQueryAndHash(fileName) {
+	return fileName.split(/[?#]/)[0] ?? fileName;
+}
+function normalizeRoot(root) {
+	if (!root) return null;
+	return root.replace(/\\/g, "/").replace(/\/$/, "");
+}
+function normalizePath(path) {
+	return decodeURIComponent(path).replace(/\\/g, "/");
+}
+function stripRoot(path, root) {
+	const normalizedRoot = normalizeRoot(root);
+	if (normalizedRoot && path.startsWith(normalizedRoot + "/")) return path.slice(normalizedRoot.length + 1);
+	return path;
+}
+function stripWebpackRelativePrefix(path) {
+	return path.replace(/^\/+/, "").replace(/^\.\/+/, "");
+}
+function stripVirtualProjectPrefix(path) {
+	const relativePath = stripWebpackRelativePrefix(path);
+	if (TURBOPACK_PROJECT_PREFIX_RE.test(relativePath)) return relativePath.replace(TURBOPACK_PROJECT_PREFIX_RE, "");
+	return path;
+}
+function stripRootSuffixPrefix(relativePath, root) {
+	const normalizedRoot = normalizeRoot(root);
+	if (!normalizedRoot) return relativePath;
+	const rootParts = normalizedRoot.split("/").filter(Boolean);
+	const pathParts = relativePath.split("/").filter(Boolean);
+	const maxParts = Math.min(rootParts.length, pathParts.length);
+	for (let count = maxParts; count > 0; count--) if (rootParts.slice(-count).join("/") === pathParts.slice(0, count).join("/")) return pathParts.slice(count).join("/");
+	return relativePath;
+}
+/**
+* Normalizes virtual module identifiers emitted by webpack/Turbopack source
+* maps and React component stacks back to project-relative paths.
+*/
+function toVirtualProjectPath(url) {
+	if (url.protocol === "webpack:" || url.protocol === "webpack-internal:") return stripWebpackRelativePrefix(normalizePath(url.pathname)).replace(NEXT_SOURCE_GROUP_RE, "");
+	if (url.protocol === "turbopack:") return stripVirtualProjectPrefix(normalizePath(url.pathname));
+	return null;
+}
+function joinRoot(root, relativePath) {
+	const normalizedRoot = normalizeRoot(root);
+	if (!normalizedRoot) return null;
+	return `${normalizedRoot}/${relativePath.replace(/^\/+/, "")}`;
+}
+/**
+* Converts a source fileName to a path relative to the project root.
+*
+*   Vite URL    http://localhost:5173/src/App.tsx         → src/App.tsx
+*   /@fs/ URL   http://localhost:5173/@fs/abs/root/src/…  → src/App.tsx  (root required)
+*   Abs URL     http://localhost:5173//abs/root/src/…     → src/App.tsx  (root required)
+*   Abs path    /Users/you/project/src/App.tsx            → src/App.tsx  (root required)
+*/
+function toRelativePath(fileName, root) {
+	const clean = stripQueryAndHash(fileName).trim();
+	try {
+		const url = new URL(clean);
+		const virtualPath = toVirtualProjectPath(url);
+		if (virtualPath) return stripRootSuffixPrefix(virtualPath, root);
+		const pathname = normalizePath(url.pathname);
+		if (url.protocol === "file:") return stripRoot(pathname, root);
+		if (pathname.startsWith("/@fs/") || pathname.startsWith("/Users/")) return stripRoot(pathname.startsWith("/@fs/") ? pathname.slice(4) : pathname, root);
+		const rootRelativePath = stripRoot(pathname, root);
+		if (rootRelativePath !== pathname) return rootRelativePath;
+		return pathname.replace(/^\//, "");
+	} catch {
+		const normalizedPath = normalizePath(clean);
+		const virtualPath = stripVirtualProjectPrefix(normalizedPath);
+		if (virtualPath !== normalizedPath) return stripRootSuffixPrefix(virtualPath, root);
+		return stripRoot(normalizedPath, root);
+	}
+}
+/**
+* Converts a source fileName to an absolute filesystem path.
+* Used by plugins that build editor URL schemes (vscode://, cursor://, etc.)
+*
+*   Vite /@fs/ URL   → strip /@fs prefix → /abs/path/src/App.tsx
+*   Vite URL         → prepend root if provided → /project/src/App.tsx
+*   Abs URL          → strip host → /abs/root/src/App.tsx
+*   Abs path         → used as-is
+*
+* Returns null if the path is empty or cannot be resolved.
+*/
+function toAbsolutePath(fileName, root) {
+	const clean = stripQueryAndHash(fileName).trim();
+	if (!clean) return null;
+	try {
+		const url = new URL(clean);
+		const virtualPath = toVirtualProjectPath(url);
+		if (virtualPath) {
+			const rootRelativePath = stripRootSuffixPrefix(virtualPath, root);
+			return joinRoot(root, rootRelativePath) ?? rootRelativePath;
+		}
+		const pathname = normalizePath(url.pathname);
+		if (url.protocol === "file:") return pathname;
+		if (pathname.startsWith("/Users/")) return pathname;
+		if (stripRoot(pathname, root) !== pathname) return pathname;
+		if (pathname.startsWith("/@fs/")) return pathname.slice(4);
+		return joinRoot(root, pathname) ?? pathname;
+	} catch {
+		const normalizedPath = normalizePath(clean);
+		const virtualPath = stripVirtualProjectPrefix(normalizedPath);
+		if (virtualPath !== normalizedPath) {
+			const rootRelativePath = stripRootSuffixPrefix(virtualPath, root);
+			return joinRoot(root, rootRelativePath) ?? rootRelativePath;
+		}
+		return normalizedPath;
+	}
+}
+
+//#endregion
+//#region src/utils/fiber.ts
+/**
+* Per-URL cache of TraceMap promises.
+* Each file is fetched at most once per page load — subsequent calls are instant
+* cache hits. The cache is intentionally not invalidated on HMR because the
+* compiled line numbers in the new _debugStack will also change, so the next
+* hover naturally uses fresh positions against the new source map.
+*/
+const traceMapCache = /* @__PURE__ */ new Map();
+function loadTraceMap(fileUrl) {
+	const cached = traceMapCache.get(fileUrl);
+	if (cached !== void 0) return cached;
+	const promise = (async () => {
+		try {
+			const res = await fetch(fileUrl);
+			if (!res.ok) return null;
+			const sourceMapHeader = res.headers.get("SourceMap") ?? res.headers.get("X-SourceMap");
+			if (sourceMapHeader) {
+				const mapUrl = new URL(sourceMapHeader, fileUrl).href;
+				const mapRes = await fetch(mapUrl);
+				if (mapRes.ok) return new TraceMap(await mapRes.json(), mapUrl);
+			}
+			const code = await res.text();
+			const inlineMatch = code.match(/\/\/# sourceMappingURL=data:application\/json;(?:charset=[^;]+;)?base64,([A-Za-z0-9+/=]+)/);
+			if (inlineMatch) return new TraceMap(JSON.parse(atob(inlineMatch[1])), fileUrl);
+			const externalMatch = code.match(/\/\/# sourceMappingURL=([^\s]+)/);
+			if (externalMatch && !externalMatch[1].startsWith("data:")) {
+				const mapUrl = new URL(externalMatch[1], fileUrl).href;
+				const mapRes = await fetch(mapUrl);
+				if (!mapRes.ok) return null;
+				return new TraceMap(await mapRes.json(), mapUrl);
+			}
+			return null;
+		} catch {
+			return null;
+		}
+	})();
+	traceMapCache.set(fileUrl, promise);
+	return promise;
+}
+/**
+* Detects Turbopack chunk file paths that can't be shown to the user as-is.
+* These are generated files like `[project]/.next/static/chunks/_1rlvw7y._.js`
+* or URL-form equivalents that still point at `/_next/static/chunks/`.
+*/
+function isChunkPath(fileName) {
+	return fileName.includes(".next/static/chunks/") || fileName.includes("_next/static/chunks/");
+}
+/**
+* For Turbopack virtual paths like `[project]/.next/static/chunks/foo.js`,
+* constructs the full dev-server URL so we can fetch the source map.
+* Returns null if the path doesn't look like a servable chunk.
+*/
+function tryConstructChunkUrl(fileName) {
+	if (typeof globalThis.location === "undefined") return null;
+	const stripped = fileName.replace(/^\[project\]\//, "");
+	if (!stripped.includes(".next/static/chunks/")) return null;
+	const urlPath = stripped.replace(/^\.next\//, "_next/");
+	return `${globalThis.location.origin}/${urlPath}`;
+}
+/**
+* Resolves compiled positions (post-Babel/esbuild) back to original TypeScript
+* source positions by fetching and applying the inline source map.
+*
+* - Only runs for URL-form fileNames (Vite dev mode serves files as URLs)
+* - For Turbopack chunk paths, constructs the dev-server URL to fetch source maps
+* - Results are cached per file URL — each file is fetched at most once
+* - Returns the original source unchanged on any error
+*
+* Designed to be called *after* the synchronous context is already rendered,
+* so the UI updates the line number once the source map resolves (usually <50ms
+* after the first hover on a given file, instant on subsequent hovers).
+*/
+async function resolveSource(source) {
+	let fileUrl = null;
+	try {
+		fileUrl = new URL(source.fileName).href;
+	} catch {
+		const chunkUrl = tryConstructChunkUrl(source.fileName);
+		if (chunkUrl) fileUrl = chunkUrl;
+		else if (isChunkPath(source.fileName)) return null;
+		else return source;
+	}
+	const traceMap = await loadTraceMap(fileUrl);
+	if (!traceMap) {
+		if (isChunkPath(source.fileName) || isChunkPath(fileUrl)) return null;
+		return source;
+	}
+	const original = originalPositionFor(traceMap, {
+		line: source.lineNumber,
+		column: source.columnNumber - 1
+	});
+	if (original.source == null || original.line == null) return null;
+	return {
+		fileName: original.source,
+		lineNumber: original.line,
+		columnNumber: original.column != null ? original.column + 1 : 1
+	};
+}
+const FiberTags = {
+	FunctionComponent: 0,
+	ClassComponent: 1,
+	IndeterminateComponent: 2,
+	HostRoot: 3,
+	HostPortal: 4,
+	HostComponent: 5,
+	HostText: 6,
+	Fragment: 7,
+	Mode: 8,
+	ContextConsumer: 9,
+	ContextProvider: 10,
+	ForwardRef: 11,
+	Profiler: 12,
+	SuspenseComponent: 13,
+	MemoComponent: 14,
+	SimpleMemoComponent: 15,
+	LazyComponent: 16,
+	IncompleteClassComponent: 17,
+	DehydratedFragment: 18,
+	SuspenseListComponent: 19,
+	ScopeComponent: 21,
+	OffscreenComponent: 22,
+	LegacyHiddenComponent: 23,
+	CacheComponent: 24,
+	TracingMarkerComponent: 25
+};
+const COMPONENT_TAGS = [
+	FiberTags.FunctionComponent,
+	FiberTags.ClassComponent,
+	FiberTags.IndeterminateComponent,
+	FiberTags.SuspenseComponent,
+	FiberTags.ForwardRef,
+	FiberTags.MemoComponent,
+	FiberTags.SimpleMemoComponent,
+	FiberTags.LazyComponent
+];
+/**
+* Finds the React fiber attached to a DOM element.
+* React attaches it as __reactFiber$<randomKey> in development mode.
+*/
+function findFiber(element) {
+	const key = Object.keys(element).find((k) => k.startsWith("__reactFiber$"));
+	return key ? element[key] : null;
+}
+function getDisplayName(type) {
+	if (!type || typeof type === "string") return "Unknown";
+	return type.displayName ?? type.name ?? type.render?.name ?? "Anonymous";
+}
+function parseStackFrameLocation(frame) {
+	const parenMatch = frame.match(/\((.+):(\d+):(\d+)\)$/);
+	const bareMatch = frame.match(/^at\s+(.+):(\d+):(\d+)$/);
+	const match = parenMatch ?? bareMatch;
+	if (!match) return null;
+	return {
+		fileName: match[1],
+		lineNumber: parseInt(match[2], 10),
+		columnNumber: parseInt(match[3], 10)
+	};
+}
+function parseSourceLocation(value) {
+	const match = value?.match(/^(.+):(\d+):(\d+)$/);
+	if (!match) return null;
+	return {
+		fileName: match[1],
+		lineNumber: parseInt(match[2], 10),
+		columnNumber: parseInt(match[3], 10)
+	};
+}
+function getElementSource(element) {
+	return parseSourceLocation(element.getAttribute("data-locatorjs"));
+}
+/**
+* Parses the component definition source location from a React fiber's _debugStack.
+*
+* In React 19, _debugStack is an Error object captured at JSX creation time.
+* For a DOM fiber (e.g. <button> inside Button.tsx), the stack contains
+* Button.tsx as the first non-React frame — which is the component's definition file.
+*
+* The fileName may be a full URL in Vite dev mode (e.g. "http://localhost:5173/src/Button.tsx").
+* URL → absolute path normalization is deferred to the FileSystemService.
+*
+* When the stack only contains Turbopack chunk frames (common for RSC-rendered
+* parent fibers), returns the first chunk frame so resolveSource can attempt
+* source-map resolution on it.
+*/
+function parseComponentSource(debugStack) {
+	if (!debugStack?.stack) return null;
+	let stack = debugStack.stack;
+	if (stack.startsWith("Error: react-stack-top-frame\n")) stack = stack.slice(stack.indexOf("\n") + 1);
+	else if (stack.startsWith("Error\n")) stack = stack.slice(6);
+	let firstChunkSource = null;
+	for (const line of stack.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed || !trimmed.startsWith("at ")) continue;
+		if (trimmed.includes("node_modules") || trimmed.includes("react-jsx") || trimmed.includes("react-dom") || trimmed.includes("react-stack-bottom-frame") || trimmed.includes("(@fs")) continue;
+		const source = parseStackFrameLocation(trimmed);
+		if (!source) continue;
+		if (isChunkPath(source.fileName)) {
+			firstChunkSource ??= source;
+			continue;
+		}
+		return source;
+	}
+	return firstChunkSource;
+}
+/**
+* Extracts source location from a fiber, supporting both React versions and
+* bundler source strategies.
+*
+* Prefer _debugSource when available because it is the structured JSX source
+* object. In Turbopack builds, _debugStack often points at generated chunk
+* files, while _debugSource still carries the original [project]/... module
+* path emitted by jsxDEV.
+*
+* React 18 paths are absolute filesystem paths (/abs/path/to/File.tsx) so
+* resolveSource() will no-op on them — they're already at original positions.
+*/
+function getSource(fiber) {
+	if (!fiber) return null;
+	if (fiber._debugSource) return fiber._debugSource;
+	if (fiber._debugStack) return parseComponentSource(fiber._debugStack);
+	return null;
+}
+/**
+* Given a DOM element, returns the ComponentContext describing the nearest
+* React component that rendered it — including display name, breadcrumb path,
+* source location (definition file), and current props.
+*
+* Pass `point` (mouse coordinates) to enable text-node detection: when the
+* cursor is over a bare text node, `caretPositionFromPoint` gives its direct
+* parent element, which is more specific than the DOM event target that bubbles
+* up to the nearest element ancestor.
+*
+* Note on text source accuracy: React's HostText fibers (tag=6) have
+* _debugStack = null — source location is only stored on element fibers.
+* So the location shown is always where the *containing element* was written
+* (e.g. Card.tsx:11 for `<h3>{title}</h3>`), not where the text value was
+* defined. Resolving the value's origin (prop, const, literal) requires
+* AST-level analysis and is handled by the inline-editing plugin, not here.
+*
+* Returns null if:
+* - React is not present / not in dev mode
+* - The element is not part of a React tree
+* - No component fiber is found in the ancestor chain
+*/
+async function getComponentContext(element, root) {
+	const domFiber = findFiber(element);
+	if (!domFiber) return null;
+	let fiber = domFiber;
+	const parts = [{
+		source: getElementSource(element) ?? getSource(fiber),
+		names: []
+	}];
+	let i = 0;
+	while (fiber) {
+		if (fiber.tag === 5 && typeof fiber.type === "string") parts[i].names.push(fiber.type);
+		else if (COMPONENT_TAGS.includes(fiber.tag)) {
+			const name = getDisplayName(fiber.type);
+			if (name !== "Unknown" && name !== "Anonymous") parts[i].names.push(name);
+			parts[++i] = {
+				source: getSource(fiber),
+				names: [name]
+			};
+		}
+		fiber = fiber.return;
+	}
+	const sources = await Promise.all(parts.map((part) => part.source ? resolveSource(part.source) : null));
+	/** Enrich a raw source with computed relative and absolute paths. */
+	function enrichSource(raw) {
+		return {
+			...raw,
+			relativePath: toRelativePath(raw.fileName, root),
+			absolutePath: toAbsolutePath(raw.fileName, root) ?? raw.fileName
+		};
+	}
+	const files = parts.map((part, idx) => {
+		const resolved = sources[idx];
+		return {
+			source: resolved ? enrichSource(resolved) : null,
+			names: part.names.reverse()
+		};
+	}).reduce((acc, part) => {
+		if (!part.source) return acc;
+		const file = part.source.fileName;
+		if (!acc.some((p) => p.source?.fileName === file)) acc.push(part);
+		return acc;
+	}, []);
+	const breadcrumb = parts[0].names;
+	return {
+		element,
+		displayName: breadcrumb[0] ?? "Unknown",
+		breadcrumb,
+		all: files,
+		props: domFiber.memoizedProps ?? {}
+	};
+}
+
+//#endregion
+//#region src/hooks/useEffectEvent.ts
+const useEffectEvent$1 = useEffectEvent ?? function useEffectEventShim(fn) {
+	const ref = useRef(fn);
+	ref.current = fn;
+	return useCallback(((...args) => ref.current(...args)), []);
+};
+
+//#endregion
+//#region src/hooks/useInspectorBehavior.ts
+function isTraceUiTarget(target, portalContainer) {
+	if (!(target instanceof Node)) return false;
+	return portalContainer.contains(target);
+}
+function buildEditorUrl(editor, path, line, col) {
+	if (editor === "webstorm") return `webstorm://open?file=${encodeURIComponent(path)}&line=${line}`;
+	if (editor === "intellij") return `idea://open?file=${encodeURIComponent(path)}&line=${line}`;
+	return `${editor}://file/${path}:${line}:${col}`;
+}
+function findFirstProjectSource(all, root) {
+	for (const entry of all) if (entry.source && entry.source.absolutePath.startsWith(root) && !entry.source.relativePath.startsWith("node_modules/")) return entry.source;
+	return null;
+}
+/**
+* LocatorJS-style inspector behavior:
+*
+* - Tracks hovered component context via mousemove + fiber tree walking
+* - Click to open the nearest project source file directly in the editor
+* - Escape to deactivate inspector
+*/
+function useInspectorBehavior() {
+	const portalContainer = (0, esm_exports.useAtomValue)(portalContainerAtom);
+	const inspectorActive = (0, esm_exports.useAtomValue)(inspectorActiveAtom);
+	const root = (0, esm_exports.useAtomValue)(projectRootAtom);
+	const editor = (0, esm_exports.useAtomValue)(editorAtom);
+	const setInspectorActive = (0, esm_exports.useSetAtom)(inspectorActiveAtom);
+	const [hoveredContext, setHoveredContext] = useState(null);
+	const hoveredContextRef = useRef(hoveredContext);
+	hoveredContextRef.current = hoveredContext;
+	const openSourceInEditor = useEffectEvent$1((ctx) => {
+		const source = findFirstProjectSource(ctx.all, root);
+		if (!source) return;
+		const url = buildEditorUrl(editor, source.absolutePath, source.lineNumber, source.columnNumber);
+		window.open(url);
+		setInspectorActive(false);
+	});
+	const onEscapeKeyDown = useEffectEvent$1((e) => {
+		if (e.key !== "Escape") return;
+		setInspectorActive(false);
+		setHoveredContext(null);
+	});
+	useEffect(() => {
+		if (!inspectorActive) return;
+		let lastHoveredElement = null;
+		async function onMouseMove(e) {
+			const target = e.target;
+			if (!target || target === lastHoveredElement) return;
+			if (isTraceUiTarget(target, portalContainer)) return;
+			lastHoveredElement = target;
+			try {
+				const ctx = await getComponentContext(target, root);
+				if (lastHoveredElement !== target) return;
+				setHoveredContext(ctx);
+			} catch {}
+		}
+		function onClick(e) {
+			const target = e.target;
+			if (isTraceUiTarget(target, portalContainer)) return;
+			e.stopPropagation();
+			e.preventDefault();
+			const ctx = hoveredContextRef.current;
+			if (ctx) openSourceInEditor(ctx);
+		}
+		document.addEventListener("mousemove", onMouseMove, { passive: true });
+		document.addEventListener("click", onClick, true);
+		document.addEventListener("keydown", onEscapeKeyDown);
+		return () => {
+			document.removeEventListener("mousemove", onMouseMove);
+			document.removeEventListener("click", onClick, true);
+			document.removeEventListener("keydown", onEscapeKeyDown);
+		};
+	}, [
+		inspectorActive,
+		portalContainer,
+		root
+	]);
+	useEffect(() => {
+		if (!inspectorActive) setHoveredContext(null);
+	}, [inspectorActive]);
+	return { hoveredContext };
+}
+
+//#endregion
+//#region src/hooks/useLongPressHotkey.ts
+const MODIFIER_INSPECT_DELAY_MS = 250;
+const LEGACY_SHORTCUT_DELAY_MS = 600;
+/**
+* Activates inspect mode when the user holds Option/Alt. Releasing before the
+* timer fires cancels activation; releasing after activation exits inspect mode.
+*
+* Also keeps the legacy Cmd+X (Mac) / Ctrl+X shortcut working.
+*/
+function useLongPressHotkey() {
+	const inspectorActive = (0, esm_exports.useAtomValue)(inspectorActiveAtom);
+	const setInspectorActive = (0, esm_exports.useSetAtom)(inspectorActiveAtom);
+	const [coreSettings, setCoreSettings] = (0, esm_exports.useAtom)(coreSettingsAtom);
+	const settingsRef = useRef(coreSettings);
+	const inspectorActiveRef = useRef(inspectorActive);
+	settingsRef.current = coreSettings;
+	inspectorActiveRef.current = inspectorActive;
+	useEffect(() => {
+		let modifierTimer = null;
+		let legacyTimer = null;
+		let modifierActivated = false;
+		let modifierStartedWithInspector = false;
+		function activateInspector() {
+			setInspectorActive(true);
+			if (settingsRef.current.minimized) setCoreSettings({
+				...settingsRef.current,
+				minimized: false
+			});
+		}
+		function clearModifierTimer() {
+			if (modifierTimer !== null) {
+				clearTimeout(modifierTimer);
+				modifierTimer = null;
+			}
+		}
+		function clearLegacyTimer() {
+			if (legacyTimer !== null) {
+				clearTimeout(legacyTimer);
+				legacyTimer = null;
+			}
+		}
+		function onKeyDown(e) {
+			if (e.key === "Alt" && !e.repeat && modifierTimer === null && !modifierActivated) {
+				modifierStartedWithInspector = inspectorActiveRef.current;
+				modifierTimer = setTimeout(() => {
+					modifierTimer = null;
+					modifierActivated = !modifierStartedWithInspector;
+					activateInspector();
+				}, MODIFIER_INSPECT_DELAY_MS);
+			}
+			const modifierHeld = IS_MAC ? e.metaKey : e.ctrlKey;
+			if (e.key === "x" && modifierHeld && !e.repeat && legacyTimer === null) {
+				e.preventDefault();
+				legacyTimer = setTimeout(() => {
+					legacyTimer = null;
+					activateInspector();
+				}, LEGACY_SHORTCUT_DELAY_MS);
+			}
+		}
+		function onKeyUp(e) {
+			if (e.key === "Alt") {
+				clearModifierTimer();
+				if (modifierActivated) {
+					modifierActivated = false;
+					setInspectorActive(false);
+				}
+			}
+			if (e.key === "x" || e.key === "Meta" || e.key === "Control") clearLegacyTimer();
+		}
+		function onWindowBlur() {
+			clearModifierTimer();
+			clearLegacyTimer();
+			if (modifierActivated) {
+				modifierActivated = false;
+				setInspectorActive(false);
+			}
+		}
+		document.addEventListener("keydown", onKeyDown);
+		document.addEventListener("keyup", onKeyUp);
+		window.addEventListener("blur", onWindowBlur);
+		return () => {
+			document.removeEventListener("keydown", onKeyDown);
+			document.removeEventListener("keyup", onKeyUp);
+			window.removeEventListener("blur", onWindowBlur);
+			clearModifierTimer();
+			clearLegacyTimer();
+		};
+	}, []);
+}
+
+//#endregion
+//#region src/components/Overlay.tsx
+function toRect(el) {
+	const r = el.getBoundingClientRect();
+	return {
+		top: r.top,
+		left: r.left,
+		width: r.width,
+		height: r.height
+	};
+}
+function HighlightRect({ rect, label }) {
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("div", { style: {
+		position: "fixed",
+		top: rect.top,
+		left: rect.left,
+		width: rect.width,
+		height: rect.height,
+		background: "rgba(59,130,246,0.07)",
+		border: "2px dashed rgba(59,130,246,0.7)",
+		borderRadius: 2,
+		pointerEvents: "none",
+		boxSizing: "border-box"
+	} }), /* @__PURE__ */ jsx("div", {
+		style: {
+			position: "fixed",
+			top: Math.max(0, rect.top - 24),
+			left: rect.left,
+			background: "rgba(59,130,246,0.85)",
+			color: "#fff",
+			fontSize: 11,
+			fontFamily: "ui-monospace, monospace",
+			fontWeight: 600,
+			padding: "2px 6px",
+			borderRadius: 4,
+			whiteSpace: "nowrap",
+			pointerEvents: "none",
+			lineHeight: "18px"
+		},
+		children: label
+	})] });
+}
+function Overlay({ hoveredContext }) {
+	const [mouse, setMouse] = useState(null);
+	useEffect(() => {
+		function onMove(e) {
+			setMouse({
+				x: e.clientX,
+				y: e.clientY
+			});
+		}
+		document.addEventListener("mousemove", onMove, { passive: true });
+		return () => {
+			document.removeEventListener("mousemove", onMove);
+		};
+	}, []);
+	const [hoveredRect, setHoveredRect] = useState(null);
+	useEffect(() => {
+		setHoveredRect(hoveredContext ? toRect(hoveredContext.element) : null);
+	}, [hoveredContext]);
+	useEffect(() => {
+		document.body.style.cursor = "crosshair";
+		return () => {
+			document.body.style.cursor = "";
+		};
+	}, []);
+	useEffect(() => {
+		if (!hoveredContext) return;
+		function update() {
+			if (hoveredContext) setHoveredRect(toRect(hoveredContext.element));
+		}
+		window.addEventListener("scroll", update, {
+			passive: true,
+			capture: true
+		});
+		window.addEventListener("resize", update, { passive: true });
+		return () => {
+			window.removeEventListener("scroll", update, { capture: true });
+			window.removeEventListener("resize", update);
+		};
+	}, [hoveredContext]);
+	return /* @__PURE__ */ jsxs("div", {
+		style: {
+			position: "fixed",
+			inset: 0,
+			pointerEvents: "none",
+			zIndex: 999998
+		},
+		children: [mouse && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("div", { style: {
+			position: "fixed",
+			top: 0,
+			left: mouse.x,
+			width: 1,
+			height: "100dvh",
+			background: "rgba(59,130,246,0.5)",
+			pointerEvents: "none"
+		} }), /* @__PURE__ */ jsx("div", { style: {
+			position: "fixed",
+			left: 0,
+			top: mouse.y,
+			height: 1,
+			width: "100dvw",
+			background: "rgba(59,130,246,0.5)",
+			pointerEvents: "none"
+		} })] }), hoveredRect && hoveredContext && /* @__PURE__ */ jsx(HighlightRect, {
+			rect: hoveredRect,
+			label: hoveredContext.breadcrumb.join(" › ")
+		})]
+	});
+}
+
+//#endregion
+//#region src/components/ErrorBoundary.tsx
+var ErrorBoundary = class extends Component {
+	constructor(props) {
+		super(props);
+		this.state = { hasError: false };
+	}
+	static getDerivedStateFromError(error) {
+		return {
+			hasError: true,
+			error
+		};
+	}
+	componentDidCatch(error, errorInfo) {
+		console.error(error, errorInfo);
+	}
+	render() {
+		if (this.state.hasError) return /* @__PURE__ */ jsxs("h1", { children: [
+			"Something went wrong.",
+			" ",
+			/* @__PURE__ */ jsx(Button, {
+				variant: "primary",
+				onClick: () => this.setState({ hasError: false }),
+				children: "Try Again"
+			})
+		] });
+		return this.props.children;
+	}
+};
+
+//#endregion
+//#region src/hooks.ts
+function useProjectRoot() {
+	return (0, esm_exports.useAtomValue)(projectRootAtom);
+}
+function useInspectorActive() {
+	return (0, esm_exports.useAtomValue)(inspectorActiveAtom);
+}
+function useDeactivateInspector() {
+	const setInspectorActive = (0, esm_exports.useSetAtom)(inspectorActiveAtom);
+	return useCallback(() => setInspectorActive(false), [setInspectorActive]);
+}
+function useSelectedContext() {
+	return (0, esm_exports.useAtomValue)(selectedContextAtom);
+}
+function useClearSelectedContext() {
+	const setSelectedContext = (0, esm_exports.useSetAtom)(selectedContextAtom);
+	return useCallback(() => setSelectedContext(null), [setSelectedContext]);
+}
+function useSelectedSource() {
+	return (0, esm_exports.useAtomValue)(selectedSourceAtom);
+}
+function useWidgetPortalContainer() {
+	return (0, esm_exports.useAtomValue)(portalContainerAtom);
+}
+
+//#endregion
+//#region src/components/SettingsMenu.tsx
+const SECTION_TITLE_STYLE = {
+	fontSize: 11,
+	fontWeight: 600,
+	color: "#71717a",
+	fontFamily: "system-ui, sans-serif",
+	letterSpacing: "0.04em",
+	textTransform: "uppercase"
+};
+const LABEL_STYLE = {
+	fontSize: 12,
+	color: "#d4d4d8",
+	fontFamily: "system-ui, sans-serif"
+};
+const INPUT_STYLE = {
+	width: "100%",
+	minWidth: 0,
+	background: "#0f0f11",
+	border: "1px solid #3f3f46",
+	borderRadius: 5,
+	color: "#fafafa",
+	fontSize: 12,
+	fontFamily: "system-ui, sans-serif",
+	padding: "6px 8px",
+	boxSizing: "border-box"
+};
+const POSITION_OPTIONS = [
+	{
+		value: "bottom-right",
+		label: "Bottom right"
+	},
+	{
+		value: "bottom-left",
+		label: "Bottom left"
+	},
+	{
+		value: "top-right",
+		label: "Top right"
+	},
+	{
+		value: "top-left",
+		label: "Top left"
+	}
+];
+function CoreSettingsSection() {
+	const portalContainer = useWidgetPortalContainer();
+	const [root, setRoot] = (0, esm_exports.useAtom)(projectRootAtom);
+	const [coreSettings, setCoreSettings] = (0, esm_exports.useAtom)(coreSettingsAtom);
+	const [draftRoot, setDraftRoot] = useState(root);
+	const trimmedRoot = draftRoot.trim();
+	const canApplyRoot = trimmedRoot.length > 0 && trimmedRoot !== root;
+	return /* @__PURE__ */ jsxs("div", {
+		style: {
+			display: "flex",
+			flexDirection: "column",
+			gap: 12
+		},
+		children: [/* @__PURE__ */ jsxs("div", {
+			style: {
+				display: "flex",
+				flexDirection: "column",
+				gap: 6
+			},
+			children: [/* @__PURE__ */ jsx("label", {
+				style: LABEL_STYLE,
+				children: "Project root"
+			}), /* @__PURE__ */ jsxs("div", {
+				style: {
+					display: "flex",
+					gap: 8
+				},
+				children: [/* @__PURE__ */ jsx("input", {
+					value: draftRoot,
+					onChange: (e) => setDraftRoot(e.target.value),
+					onKeyDown: (e) => {
+						e.stopPropagation();
+						if (e.key === "Enter" && canApplyRoot) {
+							e.preventDefault();
+							setRoot(trimmedRoot);
+						}
+					},
+					style: INPUT_STYLE
+				}), /* @__PURE__ */ jsx(Button, {
+					variant: "secondary",
+					disabled: !canApplyRoot,
+					onClick: () => setRoot(trimmedRoot),
+					children: "Apply"
+				})]
+			})]
+		}), /* @__PURE__ */ jsxs("div", {
+			style: {
+				display: "flex",
+				flexDirection: "column",
+				gap: 6
+			},
+			children: [/* @__PURE__ */ jsx("label", {
+				style: LABEL_STYLE,
+				children: "Toolbar position"
+			}), /* @__PURE__ */ jsxs(Select.Root, {
+				value: coreSettings.position,
+				items: POSITION_OPTIONS,
+				onValueChange: (value) => {
+					if (value) setCoreSettings({
+						...coreSettings,
+						position: value
+					});
+				},
+				children: [/* @__PURE__ */ jsx(Select.Trigger, {
+					onClick: (e) => e.stopPropagation(),
+					children: /* @__PURE__ */ jsx(Select.Value, {})
+				}), /* @__PURE__ */ jsx(Select.Portal, {
+					container: portalContainer,
+					children: /* @__PURE__ */ jsx(Select.Positioner, {
+						style: {
+							zIndex: 1e8,
+							pointerEvents: "auto"
+						},
+						children: /* @__PURE__ */ jsx(Select.Popup, { children: /* @__PURE__ */ jsx(Select.List, { children: POSITION_OPTIONS.map((option) => /* @__PURE__ */ jsx(Select.Item, {
+							value: option.value,
+							onClick: (e) => e.stopPropagation(),
+							children: /* @__PURE__ */ jsx(Select.ItemText, { children: option.label })
+						}, option.value)) }) })
+					})
+				})]
+			})]
+		})]
+	});
+}
+function SettingsMenu({ plugins }) {
+	const portalContainer = useWidgetPortalContainer();
+	const deactivateInspector = useDeactivateInspector();
+	const [isOpen, setIsOpen] = useState(false);
+	const buttonRef = useRef(null);
+	const settingsPlugins = plugins.filter((plugin) => Boolean(plugin.settings));
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Tooltip, {
+		label: "Settings",
+		container: portalContainer,
+		render: /* @__PURE__ */ jsx(ToolbarButton, { ref: buttonRef }),
+		"aria-label": "Settings",
+		onClick: () => {
+			deactivateInspector();
+			setIsOpen((open) => !open);
+		},
+		children: /* @__PURE__ */ jsx(SettingsIcon, {})
+	}), /* @__PURE__ */ jsx(Popover.Root, {
+		open: isOpen,
+		onOpenChange: setIsOpen,
+		children: /* @__PURE__ */ jsx(Popover.Portal, {
+			container: portalContainer,
+			children: /* @__PURE__ */ jsx(Popover.Positioner, {
+				anchor: buttonRef.current,
+				side: "top",
+				align: "end",
+				sideOffset: 8,
+				collisionPadding: 8,
+				positionMethod: "fixed",
+				style: {
+					zIndex: 99999999,
+					pointerEvents: "auto"
+				},
+				children: /* @__PURE__ */ jsxs(Popover.Popup, {
+					style: { width: 320 },
+					children: [/* @__PURE__ */ jsx(PanelHeader, {
+						title: "Settings",
+						actionsRender: /* @__PURE__ */ jsx(IconButton, {
+							onClick: () => setIsOpen(false),
+							title: "Close",
+							children: /* @__PURE__ */ jsx(XIcon, {})
+						})
+					}), /* @__PURE__ */ jsxs("div", {
+						style: {
+							display: "flex",
+							flexDirection: "column",
+							gap: 12,
+							padding: 12
+						},
+						children: [/* @__PURE__ */ jsxs("div", {
+							style: {
+								display: "flex",
+								flexDirection: "column",
+								gap: 10
+							},
+							children: [/* @__PURE__ */ jsx("div", {
+								style: SECTION_TITLE_STYLE,
+								children: "Core"
+							}), /* @__PURE__ */ jsx(CoreSettingsSection, {})]
+						}), settingsPlugins.map((plugin) => {
+							const SettingsContent = plugin.settings;
+							return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Separator, {}), /* @__PURE__ */ jsxs("div", {
+								style: {
+									display: "flex",
+									flexDirection: "column",
+									gap: 10
+								},
+								children: [/* @__PURE__ */ jsx("div", {
+									style: SECTION_TITLE_STYLE,
+									children: plugin.name
+								}), /* @__PURE__ */ jsx(SettingsContent, {})]
+							})] }, `settings:${plugin.name}`);
+						})]
+					})]
+				})
+			})
+		})
+	})] });
+}
+
+//#endregion
+//#region src/components/Toolbar.tsx
+const DEFAULT_SPACING = 32;
+const POSITION_STYLES = {
+	"bottom-right": {
+		bottom: DEFAULT_SPACING,
+		right: DEFAULT_SPACING
+	},
+	"bottom-left": {
+		bottom: DEFAULT_SPACING,
+		left: DEFAULT_SPACING
+	},
+	"top-right": {
+		top: DEFAULT_SPACING,
+		right: DEFAULT_SPACING
+	},
+	"top-left": {
+		top: DEFAULT_SPACING,
+		left: DEFAULT_SPACING
+	}
+};
+const MINIMIZED_POSITION_STYLES = {
+	"bottom-right": {
+		bottom: DEFAULT_SPACING,
+		right: 0
+	},
+	"bottom-left": {
+		bottom: DEFAULT_SPACING,
+		left: 0
+	},
+	"top-right": {
+		top: DEFAULT_SPACING,
+		right: 0
+	},
+	"top-left": {
+		top: DEFAULT_SPACING,
+		left: 0
+	}
+};
+const TOGGLE_SHORTCUT = IS_MAC ? "Hold Option" : "Hold Alt";
+const contentGridStyle = {
+	display: "grid",
+	transition: "grid-template-columns 0.3s ease"
+};
+const contentInnerStyle = {
+	overflow: "hidden",
+	minWidth: 0,
+	display: "flex",
+	alignItems: "center"
+};
+function Toolbar({ plugins }) {
+	const [isInspectorActive, setInspectorActive] = (0, esm_exports.useAtom)(inspectorActiveAtom);
+	const portalContainer = (0, esm_exports.useAtomValue)(portalContainerAtom);
+	const [coreSettings, setCoreSettings] = (0, esm_exports.useAtom)(coreSettingsAtom);
+	const minimized = coreSettings.minimized ?? false;
+	const isRightAligned = coreSettings.position.includes("right");
+	const toggleMinimized = () => {
+		setCoreSettings({
+			...coreSettings,
+			minimized: !minimized
+		});
+	};
+	const CollapseArrow = isRightAligned ? ChevronRightIcon : ChevronLeftIcon;
+	const ExpandArrow = isRightAligned ? ChevronLeftIcon : ChevronRightIcon;
+	const toggleButton = /* @__PURE__ */ jsx(Tooltip, {
+		label: minimized ? "Expand toolbar" : "Collapse toolbar",
+		container: portalContainer,
+		render: /* @__PURE__ */ jsx(ToolbarButton, { style: {
+			width: 16,
+			color: "#71717a"
+		} }),
+		"aria-label": minimized ? "Expand toolbar" : "Collapse toolbar",
+		onClick: toggleMinimized,
+		children: minimized ? /* @__PURE__ */ jsx(ExpandArrow, {}) : /* @__PURE__ */ jsx(CollapseArrow, {})
+	});
+	const toolbarContent = /* @__PURE__ */ jsx("div", {
+		style: {
+			...contentGridStyle,
+			gridTemplateColumns: minimized ? "0fr" : "1fr"
+		},
+		children: /* @__PURE__ */ jsxs("div", {
+			style: contentInnerStyle,
+			children: [
+				/* @__PURE__ */ jsx(Tooltip, {
+					label: "Inspector",
+					shortcut: isInspectorActive ? "Esc to exit" : TOGGLE_SHORTCUT,
+					container: portalContainer,
+					render: /* @__PURE__ */ jsx(ToolbarButton, {}),
+					"aria-label": "Inspector",
+					onClick: () => setInspectorActive((prev) => !prev),
+					children: /* @__PURE__ */ jsx(Logo, {})
+				}),
+				plugins.filter((plugin) => plugin.toolbar).map((plugin) => {
+					const ToolbarContent = plugin.toolbar;
+					return /* @__PURE__ */ jsx(ErrorBoundary, { children: /* @__PURE__ */ jsx(ToolbarContent, {}) }, plugin.name);
+				}),
+				/* @__PURE__ */ jsx(SettingsMenu, { plugins })
+			]
+		})
+	});
+	return /* @__PURE__ */ jsx(Tooltip.Provider, {
+		delay: 300,
+		children: /* @__PURE__ */ jsxs("div", {
+			style: {
+				position: "fixed",
+				...minimized ? MINIMIZED_POSITION_STYLES[coreSettings.position] : POSITION_STYLES[coreSettings.position],
+				display: "flex",
+				alignItems: "center",
+				overflow: "hidden",
+				background: "#18181b",
+				borderRadius: minimized ? isRightAligned ? "10px 0 0 10px" : "0 10px 10px 0" : 10,
+				boxShadow: "0 4px 16px rgba(0,0,0,0.5)",
+				outline: isInspectorActive ? "2px solid #3b82f6" : "2px solid transparent",
+				transition: "right 0.3s ease, left 0.3s ease, border-radius 0.3s ease",
+				userSelect: "none",
+				height: 32,
+				boxSizing: "border-box",
+				zIndex: 999999
+			},
+			children: [
+				!isRightAligned && toggleButton,
+				toolbarContent,
+				isRightAligned && toggleButton
+			]
+		})
+	});
+}
+
+//#endregion
+//#region src/components/Trace.tsx
+function Trace({ root, editor = "vscode", plugins = [], position = "bottom-right", minimized = false }) {
+	const [jotaiStore] = useState(() => {
+		const store = createWidgetStore();
+		store.set(projectRootAtom, root);
+		store.set(editorAtom, editor);
+		if (!store.get(coreSettingsAtom)) store.set(coreSettingsAtom, {
+			position,
+			minimized
+		});
+		return store;
+	});
+	return /* @__PURE__ */ jsx(esm_exports.Provider, {
+		store: jotaiStore,
+		children: /* @__PURE__ */ jsx(TraceRoot, { plugins })
+	});
+}
+function TraceRoot({ plugins }) {
+	const portalContainer = (0, esm_exports.useAtomValue)(portalContainerAtom);
+	const inspectorActive = (0, esm_exports.useAtomValue)(inspectorActiveAtom);
+	const { hoveredContext } = useInspectorBehavior();
+	useLongPressHotkey();
+	return createPortal(/* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("div", {
+		style: { pointerEvents: "auto" },
+		children: /* @__PURE__ */ jsx(Toolbar, { plugins })
+	}), inspectorActive && /* @__PURE__ */ jsx(Overlay, { hoveredContext })] }), portalContainer);
+}
+
+//#endregion
+export { IS_MAC, MOD_KEY, Trace, settingsPluginAtom, useClearSelectedContext, useDeactivateInspector, useInspectorActive, useProjectRoot, useSelectedContext, useSelectedSource, useWidgetPortalContainer };
+//# sourceMappingURL=index.js.map