@inspecto-dev/plugin 0.3.6 → 0.3.8

package/dist/astro.js

@@ -0,0 +1,2212 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b2) => (typeof require !== "undefined" ? require : a)[b2]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/server/index.ts
+import http from "http";
+import fs5 from "fs";
+import path5 from "path";
+import os2 from "os";
+import crypto2 from "crypto";
+import portfinder from "portfinder";
+import { INSPECTO_API_PATHS } from "@inspecto-dev/types";
+
+// src/server/snippet.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as parser from "@babel/parser";
+import traverse_ from "@babel/traverse";
+var traverse = typeof traverse_ === "function" ? traverse_ : traverse_.default || traverse_;
+var snippetCache = /* @__PURE__ */ new Map();
+var DEFAULT_MAX_LINES = 100;
+var DEFAULT_CONTEXT_LINES_BEFORE = 5;
+async function extractSnippet(req) {
+  const { file, line, column, maxLines = DEFAULT_MAX_LINES } = req;
+  const absolutePath = path.resolve(file);
+  let stat;
+  try {
+    stat = await fs.promises.stat(absolutePath);
+  } catch {
+    throw new Error(`FILE_NOT_FOUND: ${absolutePath}`);
+  }
+  const mtime = stat.mtimeMs;
+  let lines;
+  const cached = snippetCache.get(absolutePath);
+  if (cached && cached.mtime === mtime) {
+    lines = cached.lines;
+  } else {
+    const source = await fs.promises.readFile(absolutePath, "utf-8");
+    lines = source.split("\n");
+    snippetCache.set(absolutePath, { mtime, lines });
+  }
+  let snippetLines;
+  let startLine;
+  let componentName;
+  try {
+    const result = extractComponentBoundary(lines.join("\n"), line, column, maxLines);
+    snippetLines = result.lines;
+    startLine = result.startLine;
+    componentName = result.name;
+  } catch {
+    const before = Math.max(0, line - 1 - DEFAULT_CONTEXT_LINES_BEFORE);
+    const after = Math.min(lines.length, before + maxLines);
+    snippetLines = lines.slice(before, after);
+    startLine = before + 1;
+  }
+  if (snippetLines.length > maxLines) {
+    snippetLines = snippetLines.slice(0, maxLines);
+  }
+  return {
+    snippet: snippetLines.join("\n"),
+    startLine,
+    file: absolutePath,
+    ...componentName ? { name: componentName } : {}
+  };
+}
+function extractComponentBoundary(source, targetLine, _targetColumn, maxLines) {
+  const ast = parser.parse(source, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript", "decorators-legacy", "classProperties"],
+    errorRecovery: true
+  });
+  const allLines = source.split("\n");
+  let bestStart = 0;
+  let bestEnd = allLines.length - 1;
+  let bestName;
+  traverse(ast, {
+    "FunctionDeclaration|FunctionExpression|ArrowFunctionExpression|ClassMethod"(nodePath) {
+      const node = nodePath.node;
+      if (!node.loc) return;
+      const nodeStart = node.loc.start.line;
+      const nodeEnd = node.loc.end.line;
+      if (targetLine < nodeStart || targetLine > nodeEnd) return;
+      if (nodeEnd - nodeStart < bestEnd - bestStart) {
+        bestStart = nodeStart - 1;
+        bestEnd = nodeEnd - 1;
+        bestName = extractFunctionName(nodePath);
+      }
+    }
+  });
+  let sliceStart = bestStart;
+  let sliceEnd = bestEnd + 1;
+  if (sliceEnd - sliceStart > maxLines) {
+    const targetIdx = targetLine - 1;
+    sliceStart = Math.max(bestStart, targetIdx - Math.floor(maxLines / 3));
+    sliceEnd = sliceStart + maxLines;
+    if (sliceEnd > bestEnd + 1) {
+      sliceEnd = bestEnd + 1;
+      sliceStart = Math.max(0, sliceEnd - maxLines);
+    }
+  }
+  return {
+    lines: allLines.slice(sliceStart, sliceEnd),
+    startLine: sliceStart + 1,
+    ...bestName ? { name: bestName } : {}
+  };
+}
+function extractFunctionName(nodePath) {
+  const node = nodePath.node;
+  if (node.type === "FunctionDeclaration" && node.id) {
+    return node.id.name;
+  }
+  const parent = nodePath.parent;
+  if ((node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && parent.type === "VariableDeclarator" && parent.id.type === "Identifier") {
+    return parent.id.name;
+  }
+  if (node.type === "ClassMethod" && node.key.type === "Identifier") {
+    return node.key.name;
+  }
+  return void 0;
+}
+
+// src/config.ts
+import fs2 from "fs";
+import path2 from "path";
+import os from "os";
+import { createDefu } from "defu";
+import {
+  DEFAULT_PROVIDER_MODE,
+  VALID_MODES,
+  DEFAULT_INTENTS
+} from "@inspecto-dev/types";
+
+// src/utils/logger.ts
+var LOG_LEVELS = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3
+};
+function isDebugEnabled(namespace) {
+  if (typeof process === "undefined" || !process.env) return false;
+  const debugEnv = process.env.DEBUG;
+  if (!debugEnv) return false;
+  const namespaces = debugEnv.split(",").map((s2) => s2.trim());
+  for (const ns of namespaces) {
+    if (ns === "*") return true;
+    if (ns.endsWith("*")) {
+      const prefix = ns.slice(0, -1);
+      if (namespace.startsWith(prefix)) return true;
+    } else if (ns === namespace) {
+      return true;
+    }
+  }
+  return false;
+}
+var globalLevel = "warn";
+var registeredLoggers = /* @__PURE__ */ new Set();
+function setLoggerGlobalLevel(level) {
+  globalLevel = level;
+  for (const logger of registeredLoggers) {
+    if (logger.setLevel) {
+      logger.setLevel(level);
+    }
+  }
+}
+function createLogger(namespace, options) {
+  let currentLevel = options?.logLevel ?? globalLevel;
+  let numericLevel = LOG_LEVELS[currentLevel] ?? 2;
+  const debugEnabled = isDebugEnabled(namespace);
+  const logger = {
+    setLevel(level) {
+      currentLevel = level;
+      numericLevel = LOG_LEVELS[level] ?? 2;
+    },
+    info(msg, ...args) {
+      if (numericLevel >= LOG_LEVELS.info) {
+        console.log(`\x1B[36m[inspecto]\x1B[0m ${msg}`, ...args);
+      }
+    },
+    warn(msg, ...args) {
+      if (numericLevel >= LOG_LEVELS.warn) {
+        console.warn(`\x1B[33m[inspecto] WARN:\x1B[0m ${msg}`, ...args);
+      }
+    },
+    error(msg, ...args) {
+      if (numericLevel >= LOG_LEVELS.error) {
+        console.error(`\x1B[31m[inspecto] ERROR:\x1B[0m ${msg}`, ...args);
+      }
+    },
+    debug(msg, ...args) {
+      if (debugEnabled) {
+        console.log(`\x1B[90m[${namespace}]\x1B[0m ${msg}`, ...args);
+      }
+    }
+  };
+  registeredLoggers.add(logger);
+  return logger;
+}
+
+// src/config.ts
+var configLogger = createLogger("inspecto:config");
+var loadedConfig = null;
+var loadedPrompts = null;
+var globalLogLevel = "warn";
+var isWatching = false;
+var arrayReplaceMerge = createDefu((obj, key, val) => {
+  if (Array.isArray(val)) {
+    obj[key] = val;
+    return true;
+  }
+});
+function setGlobalLogLevel(level) {
+  if (level) {
+    globalLogLevel = level;
+    setLoggerGlobalLevel(level);
+  }
+}
+function getGlobalLogLevel() {
+  return globalLogLevel;
+}
+function resolveConfigRoots(cwd, gitRoot) {
+  const roots = [];
+  let current = cwd;
+  const isUnderOrEqual = current === gitRoot || current.startsWith(gitRoot + path2.sep);
+  if (!isUnderOrEqual) {
+    if (fs2.existsSync(path2.join(cwd, ".inspecto"))) roots.push(cwd);
+    return roots;
+  }
+  while (true) {
+    if (fs2.existsSync(path2.join(current, ".inspecto"))) {
+      roots.push(current);
+    }
+    if (current === gitRoot) break;
+    const parent = path2.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return roots;
+}
+function loadUserConfigSync(force = false, cwd = process.cwd(), gitRoot) {
+  if (loadedConfig && !force) return loadedConfig;
+  loadedConfig = null;
+  const layers = [];
+  const roots = resolveConfigRoots(cwd, gitRoot ?? cwd);
+  for (const root of roots) {
+    layers.push(readJsonSafely(path2.join(root, ".inspecto", "settings.local.json")));
+    layers.push(readJsonSafely(path2.join(root, ".inspecto", "settings.json")));
+  }
+  layers.push(readJsonSafely(path2.join(os.homedir(), ".inspecto", "settings.json")));
+  layers.push({});
+  const validLayers = layers.filter((l) => l !== null);
+  loadedConfig = arrayReplaceMerge(...validLayers);
+  return loadedConfig;
+}
+async function loadPromptsConfig(force = false, cwd = process.cwd(), gitRoot) {
+  if (loadedPrompts && !force) return loadedPrompts;
+  const layers = [];
+  const roots = resolveConfigRoots(cwd, gitRoot ?? cwd);
+  for (const root of roots) {
+    const localPath = path2.join(root, ".inspecto", "prompts.local.json");
+    const jsonPath = path2.join(root, ".inspecto", "prompts.json");
+    layers.push(readJsonSafely(localPath));
+    layers.push(readJsonSafely(jsonPath));
+  }
+  layers.push(readJsonSafely(path2.join(os.homedir(), ".inspecto", "prompts.json")));
+  let finalPrompts = [];
+  for (const layer of layers) {
+    if (Array.isArray(layer) && layer.length > 0) {
+      finalPrompts = layer;
+      break;
+    }
+    if (layer && typeof layer === "object" && layer.$replace === true && Array.isArray(layer.items)) {
+      finalPrompts = layer;
+      break;
+    }
+  }
+  loadedPrompts = finalPrompts;
+  return loadedPrompts;
+}
+function readJsonSafely(filePath) {
+  try {
+    if (fs2.existsSync(filePath)) {
+      const content = fs2.readFileSync(filePath, "utf-8").trim();
+      if (!content) return null;
+      const parsed = JSON.parse(content);
+      if (!Array.isArray(parsed) && parsed.prompts && Array.isArray(parsed.prompts)) {
+        return parsed.prompts;
+      }
+      return parsed;
+    }
+  } catch (e) {
+    if (e instanceof SyntaxError) {
+      configLogger.warn(`Failed to parse config at ${filePath}: Invalid JSON`);
+    } else {
+      configLogger.warn(`Failed to read config at ${filePath}:`, e);
+    }
+  }
+  return null;
+}
+function resolveTargetTool(config, _ide = "vscode") {
+  const defaultProvider = config["provider.default"];
+  if (defaultProvider) {
+    const tool = defaultProvider.split(".")[0];
+    return tool;
+  }
+  return "copilot";
+}
+function resolveProviderMode(tool, ide, config) {
+  let requestedType = void 0;
+  const defaultProvider = config["provider.default"];
+  if (defaultProvider && defaultProvider.startsWith(`${tool}.`)) {
+    const mode = defaultProvider.split(".")[1];
+    if (mode === "extension") requestedType = "extension";
+    if (mode === "cli") requestedType = "cli";
+  }
+  requestedType = requestedType ?? DEFAULT_PROVIDER_MODE[tool];
+  const valid = VALID_MODES[tool] || [DEFAULT_PROVIDER_MODE[tool]];
+  return requestedType && valid.includes(requestedType) ? requestedType : valid[0];
+}
+function extractToolOverrides(ide, config) {
+  const result = {};
+  if (!config) return result;
+  for (const [key, value] of Object.entries(config)) {
+    if (!key.startsWith("provider.")) continue;
+    if (key === "provider.default") continue;
+    const toolIndex = 1;
+    const modeIndex = 2;
+    const propIndex = 3;
+    const parts = key.split(".");
+    if (parts.length >= propIndex + 1) {
+      const tool = parts[toolIndex];
+      const mode = parts[modeIndex];
+      const prop = parts[propIndex];
+      if (!result[tool]) {
+        result[tool] = { type: mode };
+      }
+      const overrides = result[tool];
+      if (prop === "bin") overrides.binaryPath = value;
+      if (prop === "args") overrides.args = value;
+      if (prop === "cwd") overrides.cwd = value;
+      if (prop === "coldStartDelay") overrides.coldStartDelay = value;
+    }
+  }
+  return result;
+}
+function resolveIntents(serverPrompts) {
+  const baseMap = /* @__PURE__ */ new Map();
+  for (const intent of DEFAULT_INTENTS) {
+    baseMap.set(intent.id, { ...intent });
+  }
+  const defaults = () => Array.from(baseMap.values());
+  if (!serverPrompts) return defaults();
+  const isReplace = !Array.isArray(serverPrompts) && typeof serverPrompts === "object" && serverPrompts.$replace === true;
+  const promptsArray = Array.isArray(serverPrompts) ? serverPrompts : isReplace ? serverPrompts.items : [];
+  if (!promptsArray || promptsArray.length === 0) return defaults();
+  if (isReplace) {
+    const result = [];
+    for (const item of promptsArray) {
+      if (typeof item === "string") {
+        if (baseMap.has(item)) {
+          result.push(baseMap.get(item));
+        } else {
+          configLogger.warn(
+            `Unknown built-in intent id: "${item}". Available: ${[...baseMap.keys()].join(", ")}`
+          );
+        }
+      } else if (typeof item === "object") {
+        if (!item.id) {
+          configLogger.warn('Intent object missing required "id" field, skipping.');
+          continue;
+        }
+        if (item.enabled === false) {
+          configLogger.warn(
+            `Intent "${item.id}" is listed in $replace but has enabled:false \u2014 it will be excluded.`
+          );
+          continue;
+        }
+        if (!item.aiIntent) {
+          configLogger.warn(`Intent "${item.id}" is missing required "aiIntent".`);
+          continue;
+        }
+        result.push(
+          baseMap.has(item.id) ? { ...baseMap.get(item.id), ...item } : item
+        );
+      }
+    }
+    return result;
+  }
+  const merged = Array.from(baseMap.values());
+  for (const item of promptsArray) {
+    if (typeof item === "string") {
+      if (!baseMap.has(item)) {
+        configLogger.warn(
+          `Unknown built-in intent id: "${item}". In append mode, strings have no effect on ordering \u2014 use $replace to control order.`
+        );
+      }
+      continue;
+    }
+    if (typeof item === "object") {
+      if (!item.id) {
+        configLogger.warn('Intent object missing required "id" field, skipping.');
+        continue;
+      }
+      if (!item.aiIntent) {
+        configLogger.warn(`Intent "${item.id}" is missing required "aiIntent".`);
+        continue;
+      }
+      const existingIdx = merged.findIndex((i2) => i2.id === item.id);
+      if (existingIdx !== -1) {
+        if (item.enabled === false) {
+          merged.splice(existingIdx, 1);
+        } else {
+          merged[existingIdx] = { ...merged[existingIdx], ...item };
+        }
+      } else {
+        if (item.enabled !== false) {
+          merged.push(item);
+        }
+      }
+    }
+  }
+  return merged;
+}
+var watchers = [];
+function watchConfig(onReload, cwd = process.cwd(), gitRoot) {
+  if (isWatching) return;
+  isWatching = true;
+  const watchDirs = [path2.join(os.homedir(), ".inspecto")];
+  const roots = resolveConfigRoots(cwd, gitRoot ?? cwd);
+  for (const root of roots) {
+    watchDirs.push(path2.join(root, ".inspecto"));
+  }
+  const CONFIG_FILES = /* @__PURE__ */ new Set([
+    "settings.json",
+    "settings.local.json",
+    "prompts.json",
+    "prompts.local.json"
+  ]);
+  for (const dir of watchDirs) {
+    if (!fs2.existsSync(dir)) continue;
+    try {
+      const watcher = fs2.watch(dir, async (eventType, filename) => {
+        if (!filename || !CONFIG_FILES.has(filename)) return;
+        loadedConfig = null;
+        loadedPrompts = null;
+        loadUserConfigSync(true, cwd, gitRoot);
+        await loadPromptsConfig(true, cwd, gitRoot);
+        onReload();
+      });
+      watcher.unref();
+      watchers.push(watcher);
+    } catch (_e) {
+    }
+  }
+}
+
+// src/server/dispatch-transport.ts
+import crypto from "crypto";
+import { execFileSync } from "child_process";
+import { launchIDE } from "launch-ide";
+var serverLogger = createLogger("inspecto:server", { logLevel: getGlobalLogLevel() });
+var payloadTickets = /* @__PURE__ */ new Map();
+function createTicket(payload) {
+  const ticketId = crypto.randomUUID();
+  payloadTickets.set(ticketId, JSON.stringify(payload));
+  setTimeout(
+    () => {
+      payloadTickets.delete(ticketId);
+    },
+    5 * 60 * 1e3
+  );
+  return ticketId;
+}
+function readTicket(ticketId) {
+  return payloadTickets.get(ticketId);
+}
+function launchURI(uri) {
+  try {
+    if (process.platform === "darwin") {
+      execFileSync("open", [uri]);
+    } else if (process.platform === "win32") {
+      execFileSync("cmd", ["/c", "start", '""', uri]);
+    } else {
+      execFileSync("xdg-open", [uri]);
+    }
+  } catch (e) {
+    serverLogger.error("Failed to launch URI via execFileSync, falling back to launchIDE:", e);
+    launchIDE({ file: uri });
+  }
+}
+
+// src/server/dispatch-runtime.ts
+function normalizeIdeToken(value) {
+  return (value ?? "").toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function resolvePromptDispatchRuntime(state) {
+  const userConfig = loadUserConfigSync(false, state.cwd, state.projectRoot);
+  const resolvedTarget = resolveTargetTool(userConfig);
+  const finalIde = resolveFinalIde(userConfig.ide, state.ideInfo?.ide, state.ideInfo?.scheme);
+  const mode = resolveProviderMode(resolvedTarget, finalIde, userConfig);
+  const overrides = extractToolOverrides(finalIde, userConfig)[resolvedTarget] || void 0;
+  return {
+    resolvedTarget,
+    finalIde,
+    mode,
+    ...hasOverrides(overrides) ? { overrides } : {},
+    ...userConfig["prompt.autoSend"] !== void 0 ? { autoSend: Boolean(userConfig["prompt.autoSend"]) } : {}
+  };
+}
+function dispatchPromptThroughIde(runtime, payload) {
+  const ticketId = createTicket({
+    ide: runtime.finalIde,
+    target: runtime.resolvedTarget,
+    targetType: runtime.mode,
+    prompt: payload.prompt,
+    filePath: payload.filePath,
+    line: payload.line,
+    column: payload.column,
+    snippet: payload.snippet,
+    ...payload.screenshotContext ? { screenshotContext: payload.screenshotContext } : {},
+    overrides: runtime.overrides,
+    autoSend: runtime.autoSend
+  });
+  const params = new URLSearchParams();
+  params.set("ticket", ticketId);
+  params.set("target", runtime.resolvedTarget);
+  launchURI(`${runtime.finalIde}://inspecto.inspecto/send?${params.toString()}`);
+  return {
+    success: true,
+    fallbackPayload: {
+      prompt: payload.prompt,
+      ...payload.filePath ? { file: payload.filePath } : {}
+    }
+  };
+}
+function resolveFinalIde(configuredIde, activeIde, activeIdeScheme) {
+  const configuredIdeMatchesActiveScheme = Boolean(configuredIde) && Boolean(activeIdeScheme) && normalizeIdeToken(configuredIde) === normalizeIdeToken(activeIdeScheme);
+  if (configuredIdeMatchesActiveScheme) {
+    return activeIdeScheme;
+  }
+  if (configuredIde && activeIdeScheme && normalizeIdeToken(activeIdeScheme).includes(normalizeIdeToken(configuredIde)) === false) {
+    return configuredIde;
+  }
+  return configuredIde || activeIdeScheme || activeIde || "vscode";
+}
+function hasOverrides(overrides) {
+  return Boolean(overrides && Object.keys(overrides).length > 0);
+}
+
+// src/server/path-guards.ts
+import path3 from "path";
+import fs3 from "fs";
+function isWindowsAbsolutePath(file) {
+  return /^[a-zA-Z]:[\\/]/.test(file) || /^\\\\[^\\]+\\[^\\]+/.test(file);
+}
+function resolveWorkspacePath(file, cwd) {
+  if (isWindowsAbsolutePath(file)) {
+    return path3.win32.normalize(file);
+  }
+  return path3.isAbsolute(file) ? path3.resolve(file) : path3.resolve(cwd, file);
+}
+function assertPathWithinProject(file, projectRoot) {
+  let realFile = file;
+  let realProjectRoot = projectRoot;
+  try {
+    if (fs3.existsSync(file)) {
+      realFile = fs3.realpathSync(file);
+    }
+  } catch {
+  }
+  try {
+    if (fs3.existsSync(projectRoot)) {
+      realProjectRoot = fs3.realpathSync(projectRoot);
+    }
+  } catch {
+  }
+  if (isWithinPath(file, projectRoot) || isWithinPath(realFile, realProjectRoot)) {
+    return;
+  }
+  throw new Error(
+    `Access denied: File ${normalizeForComparison(realFile)} is outside of project workspace ${normalizeForComparison(realProjectRoot)}`
+  );
+}
+function tryReadPackageName(packageRoot) {
+  try {
+    const packageJsonPath = path3.join(packageRoot, "package.json");
+    if (!fs3.existsSync(packageJsonPath)) return void 0;
+    const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
+    return typeof packageJson.name === "string" ? packageJson.name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function findNearestPackageRoot(file) {
+  let current = path3.dirname(file);
+  while (true) {
+    if (fs3.existsSync(path3.join(current, "package.json"))) {
+      return current;
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+function normalizeForComparison(file) {
+  return isWindowsAbsolutePath(file) ? path3.win32.normalize(file) : path3.normalize(file);
+}
+function pathSeparatorFor(file) {
+  return isWindowsAbsolutePath(file) ? path3.win32.sep : path3.sep;
+}
+function isWithinPath(file, root) {
+  const normalizedFile = normalizeForComparison(file);
+  const normalizedRoot = normalizeForComparison(root);
+  const separator = pathSeparatorFor(normalizedRoot);
+  const rootWithSep = normalizedRoot.endsWith(separator) ? normalizedRoot : normalizedRoot + separator;
+  return normalizedFile === normalizedRoot || normalizedFile.startsWith(rootWithSep);
+}
+function resolveLinkedDependencyEntry(projectRoot, packageName) {
+  const packageSegments = packageName.split("/");
+  const dependencyPath = path3.join(projectRoot, "node_modules", ...packageSegments);
+  if (!fs3.existsSync(dependencyPath)) return void 0;
+  try {
+    return fs3.realpathSync(dependencyPath);
+  } catch {
+    return dependencyPath;
+  }
+}
+function isLinkedDependencyPath(file, projectRoot, packageName) {
+  const linkedDependencyRoot = resolveLinkedDependencyEntry(projectRoot, packageName);
+  if (!linkedDependencyRoot) return false;
+  return isWithinPath(file, linkedDependencyRoot);
+}
+function isLinkedDependencySourcePath(file, projectRoot) {
+  const packageRoot = findNearestPackageRoot(file);
+  if (!packageRoot) return false;
+  const packageName = tryReadPackageName(packageRoot);
+  if (!packageName) return false;
+  return isLinkedDependencyPath(file, projectRoot, packageName);
+}
+function assertPathWithinIdeOpenScope(file, projectRoot) {
+  try {
+    assertPathWithinProject(file, projectRoot);
+    return;
+  } catch {
+    if (isLinkedDependencySourcePath(file, projectRoot)) {
+      return;
+    }
+    throw new Error(`Access denied: File is outside of project workspace`);
+  }
+}
+
+// src/server/annotation-dispatch.ts
+var AnnotationDispatchError = class extends Error {
+  constructor(message, errorCode) {
+    super(message);
+    this.name = "AnnotationDispatchError";
+    this.errorCode = errorCode;
+  }
+};
+async function dispatchAnnotationsToAi(req, state) {
+  try {
+    validateAnnotationDispatchRequest(req, state);
+    const batch = normalizeAnnotationBatch(req);
+    const prompt = buildAnnotationBatchPrompt(batch);
+    const representativeTarget = batch.annotations[0]?.targets[0];
+    const runtime = resolvePromptDispatchRuntime(state);
+    return dispatchPromptThroughIde(runtime, {
+      prompt,
+      ...representativeTarget?.file ? { filePath: representativeTarget.file } : {},
+      ...representativeTarget?.line ? { line: representativeTarget.line } : {},
+      ...representativeTarget?.column ? { column: representativeTarget.column } : {},
+      ...batch.screenshotContext ? { screenshotContext: batch.screenshotContext } : {}
+    });
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      errorCode: getAnnotationDispatchErrorCode(error)
+    };
+  }
+}
+function validateAnnotationDispatchRequest(req, state) {
+  if (!req.annotations.length) {
+    throw new AnnotationDispatchError("At least one annotation is required.", "INVALID_REQUEST");
+  }
+  for (const annotation of req.annotations) {
+    if (!annotation.targets.length) {
+      throw new AnnotationDispatchError(
+        "Each annotation must include at least one target.",
+        "INVALID_REQUEST"
+      );
+    }
+    for (const target of annotation.targets) {
+      const absolutePath = resolveWorkspacePath(target.location.file, state.cwd);
+      assertPathWithinProject(absolutePath, state.projectRoot);
+    }
+  }
+}
+function normalizeAnnotationBatch(req) {
+  return {
+    instruction: req.instruction?.trim() ?? "",
+    responseMode: req.responseMode ?? "unified",
+    ...req.runtimeContext ? { runtimeContext: req.runtimeContext } : {},
+    ...req.screenshotContext ? { screenshotContext: req.screenshotContext } : {},
+    ...req.cssContextPrompt?.trim() ? { cssContextPrompt: req.cssContextPrompt.trim() } : {},
+    annotations: req.annotations.map((annotation, index) => ({
+      index: index + 1,
+      note: annotation.note.trim(),
+      intent: annotation.intent,
+      targets: annotation.targets.map((target) => ({
+        file: target.location.file,
+        line: target.location.line,
+        column: target.location.column,
+        ...target.label ? { label: target.label } : {},
+        ...target.selector ? { selector: target.selector } : {},
+        ...target.snippet ? { snippet: target.snippet } : {}
+      }))
+    }))
+  };
+}
+function buildAnnotationBatchPrompt(batch) {
+  const body = buildSelectedElementsPrompt(batch.annotations);
+  const prompt = batch.instruction ? `${batch.instruction}
+
+${body}` : body;
+  return appendScreenshotContextSection(
+    appendCssContextSection(
+      appendRuntimeContextSection(prompt, batch.runtimeContext),
+      batch.cssContextPrompt
+    ),
+    batch.screenshotContext
+  );
+}
+function appendCssContextSection(prompt, cssContextPrompt) {
+  if (!cssContextPrompt) return prompt;
+  return `${prompt}
+
+${cssContextPrompt}`;
+}
+function buildSelectedElementsPrompt(annotations) {
+  const lines = ["Selected elements:"];
+  for (const annotation of annotations) {
+    const trimmedNote = annotation.note.trim();
+    for (const target of annotation.targets) {
+      const targetLabel = (target.label || "Unknown target").trim() || "Unknown target";
+      lines.push(`- ${targetLabel}`);
+      lines.push(`file=${target.file}:${target.line}:${target.column}`);
+      if (trimmedNote) {
+        lines.push(`note=${trimmedNote}`);
+      }
+    }
+  }
+  if (lines.length === 1) {
+    lines.push("- None");
+  }
+  return lines.join("\n");
+}
+function appendScreenshotContextSection(prompt, screenshotContext) {
+  if (!screenshotContext || !screenshotContext.imageDataUrl && !screenshotContext.imageAssetId) {
+    return prompt;
+  }
+  const lines = [
+    "Visual screenshot context attached:",
+    `- capturedAt=${screenshotContext.capturedAt}`,
+    `- mimeType=${screenshotContext.mimeType}`,
+    ...screenshotContext.imageAssetId ? [`- imageAssetId=${screenshotContext.imageAssetId}`] : []
+  ];
+  return `${prompt}
+
+${lines.join("\n")}`;
+}
+function appendRuntimeContextSection(prompt, runtimeContext) {
+  if (!runtimeContext?.records.length) {
+    return prompt;
+  }
+  return `${prompt}
+
+${buildRuntimeContextSection(runtimeContext.records)}`;
+}
+function buildRuntimeContextSection(records) {
+  return ["Relevant runtime context:", ...records.map(formatRuntimeRecord)].join("\n");
+}
+function formatRuntimeRecord(record) {
+  const requestSummary = record.kind === "failed-request" ? `request=${record.request?.method ?? "GET"} ${record.request?.pathname ?? record.request?.url ?? "unknown"} status=${record.request?.status ?? "unknown"}` : `occurrences=${record.occurrenceCount}`;
+  const reasonSummary = record.relevanceReasons.length ? record.relevanceReasons.join("; ") : "timing-based";
+  const stackSummary = record.stack ? `
+  stack=${record.stack.split("\n").slice(0, 5).join(" | ")}` : "";
+  return [
+    `- [${record.kind}] ${record.message}`,
+    `  relevance=${record.relevanceLevel} (${reasonSummary})`,
+    `  ${requestSummary}`,
+    stackSummary
+  ].filter(Boolean).join("\n");
+}
+function getAnnotationDispatchErrorCode(error) {
+  if (error instanceof AnnotationDispatchError) return error.errorCode;
+  if (error instanceof Error && error.message.includes("outside of project workspace")) {
+    return "FORBIDDEN_PATH";
+  }
+  return "UNKNOWN";
+}
+
+// src/server/client-config.ts
+async function buildClientConfig(serverState2) {
+  const userConfig = loadUserConfigSync(false, serverState2.cwd, serverState2.configRoot);
+  const promptsConfig = await loadPromptsConfig(false, serverState2.cwd, serverState2.configRoot);
+  const effectiveIde = userConfig.ide ?? "vscode";
+  let info;
+  if (!serverState2.ideInfo) {
+    info = { ide: effectiveIde };
+  } else {
+    const { scheme: _scheme, ...rest } = serverState2.ideInfo;
+    info = rest;
+  }
+  return {
+    ...info,
+    prompts: resolveIntents(promptsConfig),
+    hotKeys: userConfig["inspector.hotKey"] ?? "alt",
+    theme: userConfig["inspector.theme"] ?? "auto",
+    includeSnippet: userConfig["prompt.includeSnippet"] ?? false,
+    runtimeContext: {
+      enabled: true,
+      preview: true,
+      maxRuntimeErrors: 3,
+      maxFailedRequests: 2
+    },
+    screenshotContext: {
+      enabled: false
+    },
+    annotationResponseMode: userConfig["prompt.annotationResponseMode"] ?? "unified",
+    autoSend: userConfig["prompt.autoSend"] ?? false
+  };
+}
+
+// src/server/open-file.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { launchIDE as launchIDE2 } from "launch-ide";
+var serverLogger2 = createLogger("inspecto:server", { logLevel: getGlobalLogLevel() });
+var VSCODE_FAMILY_SCHEMES = [
+  "vscode",
+  "vscode-insiders",
+  "cursor",
+  "windsurf",
+  "trae",
+  "trae-cn",
+  "vscodium",
+  "codebuddy",
+  "codebuddy-cn",
+  "codebuddycn",
+  "antigravity"
+];
+function normalizeIdeToken2(value) {
+  return (value ?? "").toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function handleOpenFileRequest(body, serverState2) {
+  const absolutePath = resolveWorkspacePath(body.file, serverState2.cwd);
+  assertPathWithinIdeOpenScope(absolutePath, serverState2.projectRoot);
+  const userConfig = loadUserConfigSync(false, serverState2.cwd, serverState2.configRoot);
+  const configuredIde = userConfig.ide;
+  const activeIde = serverState2.ideInfo?.ide;
+  const activeIdeScheme = serverState2.ideInfo?.scheme;
+  const configuredIdeMatchesActiveScheme = Boolean(configuredIde) && Boolean(activeIdeScheme) && normalizeIdeToken2(configuredIde) === normalizeIdeToken2(activeIdeScheme);
+  const rawEditorHint = configuredIdeMatchesActiveScheme ? activeIdeScheme : configuredIde || activeIde || activeIdeScheme || "code";
+  if (configuredIde && activeIdeScheme && normalizeIdeToken2(activeIdeScheme).includes(normalizeIdeToken2(configuredIde)) === false) {
+    serverLogger2.warn(
+      `Active IDE is ${activeIdeScheme}, but config forces ${configuredIde}. Using configured IDE.`
+    );
+  }
+  let editorHint = rawEditorHint;
+  if (rawEditorHint === "vscode") editorHint = "code";
+  else if (rawEditorHint === "vscode-insiders") editorHint = "code-insiders";
+  else if (rawEditorHint === "vscodium") editorHint = "codium";
+  else if (rawEditorHint === "trae-cn" || rawEditorHint === "trae") editorHint = "trae";
+  serverLogger2.debug(
+    `IDE_OPEN: activeIde=${activeIde}, activeIdeScheme=${activeIdeScheme}, configuredIde=${configuredIde} -> rawEditorHint=${rawEditorHint}, finalEditorHint=${editorHint}`
+  );
+  if (VSCODE_FAMILY_SCHEMES.includes(rawEditorHint)) {
+    let normalizedPath = absolutePath.replace(/\\/g, "/");
+    if (!normalizedPath.startsWith("/")) {
+      normalizedPath = "/" + normalizedPath;
+    }
+    const encodedPath = encodeURI(normalizedPath);
+    const uri = `${rawEditorHint}://file${encodedPath}:${body.line}:${body.column}`;
+    serverLogger2.debug(`IDE_OPEN: Bypassing launchIDE, using URI scheme directly: ${uri}`);
+    try {
+      if (process.platform === "darwin") {
+        execFileSync2("open", [uri]);
+      } else if (process.platform === "win32") {
+        execFileSync2("cmd", ["/c", "start", '""', uri]);
+      } else {
+        execFileSync2("xdg-open", [uri]);
+      }
+    } catch (e) {
+      serverLogger2.error(`Failed to launch URI for IDE_OPEN (${uri}):`, e);
+      launchIDE2({
+        file: absolutePath,
+        line: body.line,
+        column: body.column,
+        editor: editorHint,
+        type: process.platform === "darwin" ? "open" : "exec"
+      });
+    }
+  } else {
+    launchIDE2({
+      file: absolutePath,
+      line: body.line,
+      column: body.column,
+      editor: editorHint,
+      type: process.platform === "darwin" ? "open" : "exec"
+    });
+  }
+  return { success: true };
+}
+
+// src/server/project-root.ts
+import fs4 from "fs";
+import path4 from "path";
+import { execSync } from "child_process";
+var serverLogger3 = createLogger("inspecto:server", { logLevel: getGlobalLogLevel() });
+function resolveProjectRoot() {
+  const cwd = process.cwd();
+  let gitRoot;
+  try {
+    gitRoot = execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
+  } catch (e) {
+    serverLogger3.warn("Failed to resolve git root via git rev-parse:", e);
+    gitRoot = cwd;
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const search = (start, stop) => {
+    let current = start;
+    while (!visited.has(current)) {
+      visited.add(current);
+      if (fs4.existsSync(path4.join(current, ".inspecto"))) return current;
+      if (current === stop) break;
+      const parent = path4.dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+    return null;
+  };
+  const cwdMatch = search(cwd, path4.parse(cwd).root);
+  if (cwdMatch) return cwdMatch;
+  const repoMatch = search(gitRoot, path4.parse(gitRoot).root);
+  if (repoMatch) return repoMatch;
+  return gitRoot;
+}
+
+// src/server/index.ts
+var serverLogger4 = createLogger("inspecto:server", { logLevel: getGlobalLogLevel() });
+var serverState = {
+  port: null,
+  running: false,
+  projectRoot: "",
+  configRoot: "",
+  cwd: process.cwd()
+};
+var serverInstance = null;
+async function startServer() {
+  if (serverState.running && serverState.port !== null) {
+    return serverState.port;
+  }
+  serverState.projectRoot = resolveProjectRoot();
+  serverState.configRoot = serverState.projectRoot;
+  serverState.cwd = process.cwd();
+  portfinder.basePort = 5678;
+  const port = await portfinder.getPortPromise();
+  watchConfig(
+    () => {
+      serverLogger4.info("user config reloaded.");
+    },
+    serverState.cwd,
+    serverState.configRoot
+  );
+  serverInstance = http.createServer((req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+    handleRequest(url, req, res).catch((err) => {
+      serverLogger4.error("server error:", err);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: String(err) }));
+    });
+  });
+  await new Promise((resolve2, reject) => {
+    serverInstance.listen(port, "127.0.0.1", () => {
+      serverInstance.unref();
+      resolve2();
+    });
+    serverInstance.once("error", reject);
+  });
+  serverInstance.on("error", (err) => {
+    serverLogger4.error("persistent server error:", err);
+  });
+  serverState.port = port;
+  serverState.running = true;
+  const portFile = path5.join(os2.tmpdir(), "inspecto.port.json");
+  try {
+    let portData = {};
+    if (fs5.existsSync(portFile)) {
+      try {
+        portData = JSON.parse(fs5.readFileSync(portFile, "utf-8"));
+      } catch (_e) {
+      }
+    }
+    const rootHash = crypto2.createHash("md5").update(serverState.projectRoot).digest("hex");
+    portData[rootHash] = port;
+    fs5.writeFileSync(portFile, JSON.stringify(portData, null, 2), "utf-8");
+  } catch (_e) {
+    serverLogger4.warn("Failed to write port file:", _e);
+  }
+  process.once("exit", () => {
+    try {
+      if (fs5.existsSync(portFile)) {
+        const portData = JSON.parse(fs5.readFileSync(portFile, "utf-8"));
+        const rootHash = crypto2.createHash("md5").update(serverState.projectRoot).digest("hex");
+        delete portData[rootHash];
+        if (Object.keys(portData).length === 0) {
+          fs5.unlinkSync(portFile);
+        } else {
+          fs5.writeFileSync(portFile, JSON.stringify(portData, null, 2), "utf-8");
+        }
+      }
+    } catch {
+    }
+  });
+  serverLogger4.info(`server running at http://127.0.0.1:${port}`);
+  return port;
+}
+async function readBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+async function handleRequest(url, req, res) {
+  const pathname = url.pathname;
+  if ((pathname === "/health" || pathname === INSPECTO_API_PATHS.HEALTH) && req.method === "GET") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true, port: serverState.port }));
+    return;
+  }
+  if (pathname === INSPECTO_API_PATHS.CLIENT_CONFIG && req.method === "GET") {
+    const config = await buildClientConfig(serverState);
+    delete config.providers;
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(config));
+    return;
+  }
+  if (pathname === INSPECTO_API_PATHS.IDE_INFO && req.method === "POST") {
+    try {
+      const body = JSON.parse(await readBody(req));
+      const ideWorkspace = body.workspaceRoot || "";
+      const serverProjectRoot = serverState.projectRoot || "";
+      const normalizedIdeRoot = ideWorkspace ? path5.resolve(ideWorkspace) : "";
+      const normalizedServerRoot = serverProjectRoot ? path5.resolve(serverProjectRoot) : "";
+      const isSameProject = !normalizedIdeRoot || !normalizedServerRoot || normalizedIdeRoot === normalizedServerRoot || normalizedServerRoot.startsWith(normalizedIdeRoot + path5.sep) || normalizedIdeRoot.startsWith(normalizedServerRoot + path5.sep);
+      if (isSameProject) {
+        serverState.ideInfo = body;
+        serverLogger4.debug(
+          `Accepted IDE info from matched workspace (ide-${body.ide} / schema-${body.scheme})`
+        );
+      } else {
+        serverLogger4.debug(
+          `Ignored IDE info from unrelated workspace (IDE Workspace: ${ideWorkspace}, Server: ${serverProjectRoot}, Scheme: ${body.scheme}, IDE: ${body.ide})`
+        );
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true }));
+    } catch (e) {
+      serverLogger4.error(`Error parsing ${INSPECTO_API_PATHS.IDE_INFO} POST request:`, e);
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Invalid JSON body" }));
+    }
+    return;
+  }
+  if (pathname === INSPECTO_API_PATHS.IDE_OPEN && req.method === "POST") {
+    let body;
+    try {
+      body = JSON.parse(await readBody(req));
+    } catch (_e) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Invalid JSON body" }));
+      return;
+    }
+    try {
+      handleOpenFileRequest(body, serverState);
+    } catch (err) {
+      serverLogger4.warn(
+        `Security: Blocked path traversal attempt in IDE_OPEN: ${body.file}. Reason: ${err.message}`
+      );
+      res.writeHead(403, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Access denied: File is outside of project workspace" }));
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ success: true }));
+    return;
+  }
+  if (pathname === INSPECTO_API_PATHS.PROJECT_SNIPPET && req.method === "GET") {
+    const file = url.searchParams.get("file") ?? "";
+    const line = parseInt(url.searchParams.get("line") ?? "1", 10);
+    const column = parseInt(url.searchParams.get("column") ?? "1", 10);
+    const maxLines = parseInt(url.searchParams.get("maxLines") ?? "100", 10);
+    try {
+      const absolutePath = resolveWorkspacePath(file, serverState.cwd);
+      try {
+        assertPathWithinProject(absolutePath, serverState.projectRoot);
+      } catch (err) {
+        serverLogger4.warn(
+          `Security: Blocked path traversal attempt in PROJECT_SNIPPET: ${file}. Reason: ${err.message}`
+        );
+        res.writeHead(403, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            success: false,
+            error: "Access denied: File is outside of project workspace",
+            errorCode: "FORBIDDEN"
+          })
+        );
+        return;
+      }
+      const result = await extractSnippet({ file: absolutePath, line, column, maxLines });
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(result));
+    } catch (err) {
+      const message = String(err.message || err);
+      const errorCode = message.startsWith("FILE_NOT_FOUND") ? "FILE_NOT_FOUND" : "UNKNOWN";
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: message, errorCode }));
+    }
+    return;
+  }
+  if (pathname === INSPECTO_API_PATHS.AI_DISPATCH && req.method === "POST") {
+    try {
+      const rawBody = await readBody(req);
+      const body = JSON.parse(rawBody);
+      const result = await dispatchToAi(body);
+      res.writeHead(result.success ? 200 : 500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(result));
+    } catch (e) {
+      serverLogger4.error(`Error parsing ${INSPECTO_API_PATHS.AI_DISPATCH} request:`, e);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: String(e), errorCode: "INTERNAL_ERROR" }));
+    }
+    return;
+  }
+  if (pathname === INSPECTO_API_PATHS.AI_BATCH_DISPATCH && req.method === "POST") {
+    try {
+      const rawBody = await readBody(req);
+      const body = JSON.parse(rawBody);
+      const result = await dispatchAnnotationsToAi(body, serverState);
+      res.writeHead(getBatchDispatchStatusCode(result.errorCode, result.success), {
+        "Content-Type": "application/json"
+      });
+      res.end(JSON.stringify(result));
+    } catch (e) {
+      serverLogger4.error(`Error parsing ${INSPECTO_API_PATHS.AI_BATCH_DISPATCH} request:`, e);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: String(e), errorCode: "INTERNAL_ERROR" }));
+    }
+    return;
+  }
+  if (pathname.startsWith(`${INSPECTO_API_PATHS.AI_TICKET}/`) && req.method === "GET") {
+    const ticketId = pathname.substring(INSPECTO_API_PATHS.AI_TICKET.length + 1);
+    const payloadStr = readTicket(ticketId);
+    if (!payloadStr) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: "Ticket not found or expired" }));
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(payloadStr);
+    return;
+  }
+  res.writeHead(404, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ error: "not found" }));
+}
+async function dispatchToAi(req) {
+  const { location, snippet, prompt, screenshotContext } = req;
+  const formattedPrompt = prompt ?? `Please help me with this code from \`${location.file}\` (line ${location.line}):
+
+\`\`\`
+${snippet}
+\`\`\`
+`;
+  const runtime = resolvePromptDispatchRuntime(serverState);
+  return dispatchPromptThroughIde(runtime, {
+    prompt: formattedPrompt,
+    filePath: location.file,
+    line: location.line,
+    column: location.column,
+    snippet,
+    ...screenshotContext ? { screenshotContext } : {}
+  });
+}
+function getBatchDispatchStatusCode(errorCode, success) {
+  if (success) return 200;
+  if (errorCode === "INVALID_REQUEST") return 400;
+  if (errorCode === "FORBIDDEN_PATH") return 403;
+  return 500;
+}
+
+// src/index.ts
+import { createUnplugin } from "unplugin";
+
+// src/transform/utils.ts
+var DEFAULT_ESCAPE_TAGS = /* @__PURE__ */ new Set([
+  "template",
+  "script",
+  "style",
+  // React special elements
+  "Fragment",
+  "React.Fragment",
+  "StrictMode",
+  "React.StrictMode",
+  "Suspense",
+  "React.Suspense",
+  "Profiler",
+  "React.Profiler",
+  // React transitions
+  "Transition",
+  "TransitionGroup",
+  // Vue built-in components
+  "KeepAlive",
+  "Teleport",
+  "Suspense",
+  // Vue router built-ins
+  "RouterView",
+  "RouterLink",
+  "NuxtPage",
+  "NuxtLink"
+]);
+var JSX_EXTENSIONS = /* @__PURE__ */ new Set([".jsx", ".tsx", ".js", ".ts", ".mjs", ".mts"]);
+function normalizeWebpackModuleRequest(id) {
+  return id.replace(/!+$/, "").replace(/^\((?:app-pages-browser|rsc|ssr)\)\/\.\//, "");
+}
+function extractNextModuleRequest(id) {
+  if (!id.includes("next-flight-client-entry-loader.js?")) {
+    return void 0;
+  }
+  const queryIndex = id.indexOf("?");
+  if (queryIndex === -1) {
+    return void 0;
+  }
+  const params = new URLSearchParams(id.slice(queryIndex + 1).replace(/!+$/, ""));
+  for (const entry of params.getAll("modules")) {
+    try {
+      const parsed = JSON.parse(entry);
+      if (typeof parsed.request === "string" && parsed.request.length > 0) {
+        return parsed.request;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
+function extractTransformFilePath(requestId) {
+  const normalizedRequestId = normalizeWebpackModuleRequest(requestId);
+  const nextModuleRequest = extractNextModuleRequest(normalizedRequestId);
+  if (nextModuleRequest) {
+    return {
+      requestId,
+      filePath: nextModuleRequest,
+      wrapped: true
+    };
+  }
+  const lastLoaderSeparator = normalizedRequestId.lastIndexOf("!");
+  const resourceRequest = lastLoaderSeparator >= 0 ? normalizedRequestId.slice(lastLoaderSeparator + 1) : normalizedRequestId;
+  const queryIndex = resourceRequest.indexOf("?");
+  const filePath = queryIndex >= 0 ? resourceRequest.slice(0, queryIndex) : resourceRequest;
+  return {
+    requestId,
+    filePath,
+    wrapped: filePath !== requestId
+  };
+}
+function shouldTransform(filePath, _options) {
+  const resolvedFilePath = extractTransformFilePath(filePath).filePath;
+  if (process.env["NODE_ENV"] === "production") return false;
+  if (resolvedFilePath.includes("node_modules")) return false;
+  if (resolvedFilePath.startsWith("\0")) return false;
+  if (/[/\\](dist|build|\.next|\.nuxt)[/\\]/.test(resolvedFilePath)) return false;
+  const ext = resolvedFilePath.split(".").pop()?.toLowerCase();
+  if (ext && !["js", "jsx", "ts", "tsx", "mjs", "mts", "vue", "svelte", "astro"].includes(ext)) {
+    return false;
+  }
+  return true;
+}
+function buildEscapeTagsSet(escapeTags) {
+  const merged = new Set(DEFAULT_ESCAPE_TAGS);
+  if (escapeTags) {
+    for (const tag of escapeTags) {
+      merged.add(tag);
+    }
+  }
+  return merged;
+}
+function formatAttrValue(file, line, column) {
+  return `${file}:${line}:${column}`;
+}
+
+// src/transform/index.ts
+import path8 from "path";
+
+// src/transform/transform-jsx.ts
+import * as parser2 from "@babel/parser";
+import traverse_2 from "@babel/traverse";
+import MagicString from "magic-string";
+import path6 from "path";
+var traverse2 = typeof traverse_2 === "function" ? traverse_2 : traverse_2.default || traverse_2;
+function transformJsx(options) {
+  const {
+    filePath,
+    source,
+    projectRoot,
+    escapeTags,
+    pathType = "absolute",
+    attributeName = "data-inspecto"
+  } = options;
+  const escapeTagsSet = buildEscapeTagsSet(escapeTags);
+  const resolvedPath = pathType === "absolute" ? path6.resolve(filePath) : path6.relative(projectRoot, path6.resolve(filePath));
+  const normalizedPath = resolvedPath.replace(/\\/g, "/");
+  let ast;
+  try {
+    ast = parser2.parse(source, {
+      sourceType: "module",
+      plugins: [
+        "jsx",
+        "typescript",
+        "decorators-legacy",
+        "classProperties",
+        "optionalChaining",
+        "nullishCoalescingOperator",
+        "importMeta"
+      ],
+      errorRecovery: true
+    });
+  } catch {
+    return { code: source, map: null, changed: false };
+  }
+  const ms = new MagicString(source);
+  let changed = false;
+  traverse2(ast, {
+    JSXOpeningElement(nodePath) {
+      const node = nodePath.node;
+      const alreadyHasAttr = node.attributes.some(
+        (attr) => attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name === attributeName
+      );
+      if (alreadyHasAttr) return;
+      const nameNode = node.name;
+      let tagName;
+      if (nameNode.type === "JSXIdentifier") {
+        tagName = nameNode.name;
+      } else if (nameNode.type === "JSXMemberExpression") {
+        const objName = nameNode.object.type === "JSXIdentifier" ? nameNode.object.name : "";
+        const propName = nameNode.property.type === "JSXIdentifier" ? nameNode.property.name : "";
+        tagName = objName && propName ? `${objName}.${propName}` : objName;
+      } else {
+        tagName = "";
+      }
+      if (escapeTagsSet.has(tagName)) return;
+      const loc = node.loc;
+      if (!loc) return;
+      const { line, column } = loc.start;
+      const attrValue = formatAttrValue(normalizedPath, line, column + 1);
+      let insertPos = null;
+      if (node.attributes && node.attributes.length > 0) {
+        const firstAttr = node.attributes[0];
+        if (firstAttr && firstAttr.start != null) {
+          insertPos = firstAttr.start;
+        }
+      }
+      if (insertPos == null) {
+        if (node.typeParameters && node.typeParameters.end != null) {
+          insertPos = node.typeParameters.end;
+        } else if (node.name.end != null) {
+          insertPos = node.name.end;
+        }
+      }
+      if (insertPos == null) return;
+      ms.appendLeft(
+        insertPos,
+        ` ${attributeName}="${attrValue}"${node.attributes && node.attributes.length > 0 ? "" : " "}`
+      );
+      changed = true;
+    }
+  });
+  if (!changed) {
+    return { code: source, map: null, changed: false };
+  }
+  return {
+    code: ms.toString(),
+    map: ms.generateMap({ hires: true, source: filePath }),
+    changed: true
+  };
+}
+
+// src/transform/transform-vue.ts
+import * as vueCompiler from "@vue/compiler-dom";
+import { parse as parseSFC } from "@vue/compiler-sfc";
+import { NodeTypes } from "@vue/compiler-core";
+import MagicString2 from "magic-string";
+import path7 from "path";
+function transformVue(options) {
+  const {
+    filePath,
+    source,
+    projectRoot,
+    escapeTags,
+    pathType = "absolute",
+    attributeName = "data-inspecto"
+  } = options;
+  const escapeTagsSet = buildEscapeTagsSet(escapeTags);
+  const resolvedPath = pathType === "absolute" ? path7.resolve(filePath) : path7.relative(projectRoot, path7.resolve(filePath));
+  const normalizedPath = resolvedPath.replace(/\\/g, "/");
+  const { descriptor, errors } = parseSFC(source, {
+    filename: filePath,
+    sourceMap: false,
+    ignoreEmpty: true
+  });
+  if (errors.length > 0 || !descriptor.template) {
+    return { code: source, map: null, changed: false };
+  }
+  const templateContent = descriptor.template.content;
+  const templateBlockStart = descriptor.template.loc.start.offset;
+  let ast;
+  try {
+    ast = vueCompiler.parse(templateContent, {
+      parseMode: "html",
+      // Preserve source locations relative to templateContent
+      onError: () => {
+      }
+    });
+  } catch {
+    return { code: source, map: null, changed: false };
+  }
+  const ms = new MagicString2(source);
+  let changed = false;
+  walkElement(ast, (node) => {
+    if (node.type !== NodeTypes.ELEMENT) return;
+    const tagName = node.tag;
+    if (escapeTagsSet.has(tagName)) return;
+    if (tagName === "template" && node === ast.children[0]) return;
+    const alreadyHasAttr = node.props.some(
+      (p2) => p2.type === NodeTypes.ATTRIBUTE && p2.name === attributeName
+    );
+    if (alreadyHasAttr) return;
+    const loc = node.loc;
+    if (!loc) return;
+    const { line, column } = loc.start;
+    const templateStartLoc = descriptor.template.loc.start;
+    const absoluteLine = templateStartLoc.line + line - 1;
+    const absoluteColumn = line === 1 ? templateStartLoc.column + column - 1 : column;
+    const attrValue = formatAttrValue(normalizedPath, absoluteLine, absoluteColumn);
+    const tagNameEnd = loc.start.offset + tagName.length + 1;
+    const absoluteOffset = templateBlockStart + tagNameEnd;
+    ms.appendLeft(absoluteOffset, ` ${attributeName}="${attrValue}"`);
+    changed = true;
+  });
+  if (!changed) {
+    return { code: source, map: null, changed: false };
+  }
+  return {
+    code: ms.toString(),
+    map: ms.generateMap({ hires: true, source: filePath }),
+    changed: true
+  };
+}
+function walkElement(node, visitor) {
+  if (node.type === NodeTypes.ELEMENT) {
+    visitor(node);
+    for (const child of node.children) {
+      walkElement(child, visitor);
+    }
+  } else if ("children" in node && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      walkElement(child, visitor);
+    }
+  }
+}
+
+// src/transform/transform-svelte.ts
+import MagicString3 from "magic-string";
+import { parse as parseSvelte } from "svelte/compiler";
+function walk(node, visitor) {
+  if (!node || typeof node !== "object") return;
+  visitor.enter(node);
+  for (const key in node) {
+    if (key === "parent" || key === "prev" || key === "next") continue;
+    const value = node[key];
+    if (Array.isArray(value)) {
+      value.forEach((child) => {
+        if (child && typeof child === "object") walk(child, visitor);
+      });
+    } else if (value && typeof value === "object") {
+      walk(value, visitor);
+    }
+  }
+}
+function transformSvelte(options) {
+  const { filePath, source, escapeTags, attributeName = "data-inspecto" } = options;
+  const escapeTagsSet = buildEscapeTagsSet(escapeTags);
+  let replacedContent = source;
+  const scriptRegex = /<script(?:\s+[a-zA-Z-]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^>\s]*))?)?>[\s\S]*?<\/script>/gi;
+  const styleRegex = /<style(?:\s+[a-zA-Z-]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^>\s]*))?)?>[\s\S]*?<\/style>/gi;
+  const scriptMatches = source.match(scriptRegex) || [];
+  const styleMatches = source.match(styleRegex) || [];
+  [...scriptMatches, ...styleMatches].forEach((match) => {
+    replacedContent = replacedContent.replace(match, " ".repeat(match.length));
+  });
+  let ast;
+  try {
+    ast = parseSvelte(replacedContent);
+  } catch {
+    return { code: source, map: null, changed: false };
+  }
+  const s2 = new MagicString3(source);
+  let changed = false;
+  function countLines(text, position) {
+    let lines = 0;
+    for (let i2 = 0; i2 < position; i2++) {
+      if (text[i2] === "\n") lines++;
+    }
+    return lines;
+  }
+  const root = ast.html || ast.fragment || ast;
+  walk(root, {
+    enter(node) {
+      if (node.type === "Element" || node.type === "RegularElement" || node.type === "InlineComponent" || node.type === "Component") {
+        const tagName = node.name || "";
+        if (tagName && !escapeTagsSet.has(tagName.toLowerCase()) && !node.attributes?.some((attr) => attr.name === attributeName)) {
+          const insertPosition = node.start + tagName.length + 1;
+          const line = countLines(source, node.start) + 1;
+          const lastNewLine = source.lastIndexOf("\n", node.start - 1);
+          const column = lastNewLine === -1 ? node.start + 1 : node.start - lastNewLine;
+          const attrValue = formatAttrValue(filePath, line, column);
+          const addition = ` ${attributeName}="${attrValue}"`;
+          s2.appendLeft(insertPosition, addition);
+          changed = true;
+        }
+      }
+    }
+  });
+  return {
+    code: s2.toString(),
+    map: changed ? s2.generateMap({ source: filePath, includeContent: true }) : null,
+    changed
+  };
+}
+
+// src/transform/transform-astro.ts
+import MagicString4 from "magic-string";
+
+// ../../node_modules/.pnpm/@astrojs+compiler@3.0.1/node_modules/@astrojs/compiler/dist/chunk-W5DTLHV4.js
+import g from "crypto";
+import _ from "fs";
+import { TextDecoder as b, TextEncoder as v } from "util";
+globalThis.fs || Object.defineProperty(globalThis, "fs", { value: _ });
+globalThis.process || Object.defineProperties(globalThis, "process", { value: process });
+globalThis.crypto || Object.defineProperty(globalThis, "crypto", { value: g.webcrypto ? g.webcrypto : { getRandomValues(m2) {
+  return g.randomFillSync(m2);
+} } });
+globalThis.performance || Object.defineProperty(globalThis, "performance", { value: { now() {
+  let [m2, o] = process.hrtime();
+  return m2 * 1e3 + o / 1e6;
+} } });
+var y = new v("utf-8");
+var w = new b("utf-8");
+var d = class {
+  constructor() {
+    this.argv = ["js"], this.env = {}, this.exit = (t) => {
+      t !== 0 && console.warn("exit code:", t);
+    }, this._exitPromise = new Promise((t) => {
+      this._resolveExitPromise = t;
+    }), this._pendingEvent = null, this._scheduledTimeouts = /* @__PURE__ */ new Map(), this._nextCallbackTimeoutID = 1;
+    let o = (t, e) => {
+      this.mem.setUint32(t + 0, e, true), this.mem.setUint32(t + 4, Math.floor(e / 4294967296), true);
+    }, n = (t) => {
+      let e = this.mem.getUint32(t + 0, true), s2 = this.mem.getInt32(t + 4, true);
+      return e + s2 * 4294967296;
+    }, r = (t) => {
+      let e = this.mem.getFloat64(t, true);
+      if (e === 0) return;
+      if (!isNaN(e)) return e;
+      let s2 = this.mem.getUint32(t, true);
+      return this._values[s2];
+    }, l = (t, e) => {
+      if (typeof e == "number" && e !== 0) {
+        if (isNaN(e)) {
+          this.mem.setUint32(t + 4, 2146959360, true), this.mem.setUint32(t, 0, true);
+          return;
+        }
+        this.mem.setFloat64(t, e, true);
+        return;
+      }
+      if (e === void 0) {
+        this.mem.setFloat64(t, 0, true);
+        return;
+      }
+      let i2 = this._ids.get(e);
+      i2 === void 0 && (i2 = this._idPool.pop(), i2 === void 0 && (i2 = this._values.length), this._values[i2] = e, this._goRefCounts[i2] = 0, this._ids.set(e, i2)), this._goRefCounts[i2]++;
+      let a = 0;
+      switch (typeof e) {
+        case "object":
+          e !== null && (a = 1);
+          break;
+        case "string":
+          a = 2;
+          break;
+        case "symbol":
+          a = 3;
+          break;
+        case "function":
+          a = 4;
+          break;
+      }
+      this.mem.setUint32(t + 4, 2146959360 | a, true), this.mem.setUint32(t, i2, true);
+    }, c = (t) => {
+      let e = n(t + 0), s2 = n(t + 8);
+      return new Uint8Array(this._inst.exports.mem.buffer, e, s2);
+    }, f2 = (t) => {
+      let e = n(t + 0), s2 = n(t + 8), i2 = new Array(s2);
+      for (let a = 0; a < s2; a++) i2[a] = r(e + a * 8);
+      return i2;
+    }, u = (t) => {
+      let e = n(t + 0), s2 = n(t + 8);
+      return w.decode(new DataView(this._inst.exports.mem.buffer, e, s2));
+    }, h = Date.now() - performance.now();
+    this.importObject = { gojs: { "runtime.wasmExit": (t) => {
+      t >>>= 0;
+      let e = this.mem.getInt32(t + 8, true);
+      this.exited = true, delete this._inst, delete this._values, delete this._goRefCounts, delete this._ids, delete this._idPool, this.exit(e);
+    }, "runtime.wasmWrite": (t) => {
+      t >>>= 0;
+      let e = n(t + 8), s2 = n(t + 16), i2 = this.mem.getInt32(t + 24, true);
+      _.writeSync(e, new Uint8Array(this._inst.exports.mem.buffer, s2, i2));
+    }, "runtime.resetMemoryDataView": (t) => {
+      t >>>= 0, this.mem = new DataView(this._inst.exports.mem.buffer);
+    }, "runtime.nanotime1": (t) => {
+      t >>>= 0, o(t + 8, (h + performance.now()) * 1e6);
+    }, "runtime.walltime": (t) => {
+      t >>>= 0;
+      let e = (/* @__PURE__ */ new Date()).getTime();
+      o(t + 8, e / 1e3), this.mem.setInt32(t + 16, e % 1e3 * 1e6, true);
+    }, "runtime.scheduleTimeoutEvent": (t) => {
+      t >>>= 0;
+      let e = this._nextCallbackTimeoutID;
+      this._nextCallbackTimeoutID++, this._scheduledTimeouts.set(e, setTimeout(() => {
+        for (this._resume(); this._scheduledTimeouts.has(e); ) console.warn("scheduleTimeoutEvent: missed timeout event"), this._resume();
+      }, n(t + 8) + 1)), this.mem.setInt32(t + 16, e, true);
+    }, "runtime.clearTimeoutEvent": (t) => {
+      t >>>= 0;
+      let e = this.mem.getInt32(t + 8, true);
+      clearTimeout(this._scheduledTimeouts.get(e)), this._scheduledTimeouts.delete(e);
+    }, "runtime.getRandomData": (t) => {
+      t >>>= 0, globalThis.crypto.getRandomValues(c(t + 8));
+    }, "syscall/js.finalizeRef": (t) => {
+      t >>>= 0;
+      let e = this.mem.getUint32(t + 8, true);
+      if (this._goRefCounts[e]--, this._goRefCounts[e] === 0) {
+        let s2 = this._values[e];
+        this._values[e] = null, this._ids.delete(s2), this._idPool.push(e);
+      }
+    }, "syscall/js.stringVal": (t) => {
+      t >>>= 0, l(t + 24, u(t + 8));
+    }, "syscall/js.valueGet": (t) => {
+      t >>>= 0;
+      let e = Reflect.get(r(t + 8), u(t + 16));
+      t = this._inst.exports.getsp() >>> 0, l(t + 32, e);
+    }, "syscall/js.valueSet": (t) => {
+      t >>>= 0, Reflect.set(r(t + 8), u(t + 16), r(t + 32));
+    }, "syscall/js.valueDelete": (t) => {
+      t >>>= 0, Reflect.deleteProperty(r(t + 8), u(t + 16));
+    }, "syscall/js.valueIndex": (t) => {
+      t >>>= 0, l(t + 24, Reflect.get(r(t + 8), n(t + 16)));
+    }, "syscall/js.valueSetIndex": (t) => {
+      t >>>= 0, Reflect.set(r(t + 8), n(t + 16), r(t + 24));
+    }, "syscall/js.valueCall": (t) => {
+      t >>>= 0;
+      try {
+        let e = r(t + 8), s2 = Reflect.get(e, u(t + 16)), i2 = f2(t + 32), a = Reflect.apply(s2, e, i2);
+        t = this._inst.exports.getsp() >>> 0, l(t + 56, a), this.mem.setUint8(t + 64, 1);
+      } catch (e) {
+        t = this._inst.exports.getsp() >>> 0, l(t + 56, e), this.mem.setUint8(t + 64, 0);
+      }
+    }, "syscall/js.valueInvoke": (t) => {
+      t >>>= 0;
+      try {
+        let e = r(t + 8), s2 = f2(t + 16), i2 = Reflect.apply(e, void 0, s2);
+        t = this._inst.exports.getsp() >>> 0, l(t + 40, i2), this.mem.setUint8(t + 48, 1);
+      } catch (e) {
+        t = this._inst.exports.getsp() >>> 0, l(t + 40, e), this.mem.setUint8(t + 48, 0);
+      }
+    }, "syscall/js.valueNew": (t) => {
+      t >>>= 0;
+      try {
+        let e = r(t + 8), s2 = f2(t + 16), i2 = Reflect.construct(e, s2);
+        t = this._inst.exports.getsp() >>> 0, l(t + 40, i2), this.mem.setUint8(t + 48, 1);
+      } catch (e) {
+        t = this._inst.exports.getsp() >>> 0, l(t + 40, e), this.mem.setUint8(t + 48, 0);
+      }
+    }, "syscall/js.valueLength": (t) => {
+      t >>>= 0, o(t + 16, Number.parseInt(r(t + 8).length));
+    }, "syscall/js.valuePrepareString": (t) => {
+      t >>>= 0;
+      let e = y.encode(String(r(t + 8)));
+      l(t + 16, e), o(t + 24, e.length);
+    }, "syscall/js.valueLoadString": (t) => {
+      t >>>= 0;
+      let e = r(t + 8);
+      c(t + 16).set(e);
+    }, "syscall/js.valueInstanceOf": (t) => {
+      t >>>= 0, this.mem.setUint8(t + 24, r(t + 8) instanceof r(t + 16) ? 1 : 0);
+    }, "syscall/js.copyBytesToGo": (t) => {
+      t >>>= 0;
+      let e = c(t + 8), s2 = r(t + 32);
+      if (!(s2 instanceof Uint8Array || s2 instanceof Uint8ClampedArray)) {
+        this.mem.setUint8(t + 48, 0);
+        return;
+      }
+      let i2 = s2.subarray(0, e.length);
+      e.set(i2), o(t + 40, i2.length), this.mem.setUint8(t + 48, 1);
+    }, "syscall/js.copyBytesToJS": (t) => {
+      t >>>= 0;
+      let e = r(t + 8), s2 = c(t + 16);
+      if (!(e instanceof Uint8Array || e instanceof Uint8ClampedArray)) {
+        this.mem.setUint8(t + 48, 0);
+        return;
+      }
+      let i2 = s2.subarray(0, e.length);
+      e.set(i2), o(t + 40, i2.length), this.mem.setUint8(t + 48, 1);
+    }, debug: (t) => {
+      console.log(t);
+    } } };
+  }
+  async run(o) {
+    if (!(o instanceof WebAssembly.Instance)) throw new Error("Go.run: WebAssembly.Instance expected");
+    this._inst = o, this.mem = new DataView(this._inst.exports.mem.buffer), this._values = [Number.NaN, 0, null, true, false, globalThis, this], this._goRefCounts = new Array(this._values.length).fill(Number.POSITIVE_INFINITY), this._ids = /* @__PURE__ */ new Map([[0, 1], [null, 2], [true, 3], [false, 4], [globalThis, 5], [this, 6]]), this._idPool = [], this.exited = false;
+    let n = 4096, r = (h) => {
+      let t = n, e = y.encode(`${h}\0`);
+      return new Uint8Array(this.mem.buffer, n, e.length).set(e), n += e.length, n % 8 !== 0 && (n += 8 - n % 8), t;
+    }, l = this.argv.length, c = [];
+    this.argv.forEach((h) => {
+      c.push(r(h));
+    }), c.push(0), Object.keys(this.env).sort().forEach((h) => {
+      c.push(r(`${h}=${this.env[h]}`));
+    }), c.push(0);
+    let u = n;
+    c.forEach((h) => {
+      this.mem.setUint32(n, h, true), this.mem.setUint32(n + 4, 0, true), n += 8;
+    }), this._inst.exports.run(l, u), this.exited && this._resolveExitPromise(), await this._exitPromise;
+  }
+  _resume() {
+    if (this.exited) throw new Error("Go program has already exited");
+    this._inst.exports.resume(), this.exited && this._resolveExitPromise();
+  }
+  _makeFuncWrapper(o) {
+    let n = this;
+    return function() {
+      let r = { id: o, this: this, args: arguments };
+      return n._pendingEvent = r, n._resume(), r.result;
+    };
+  }
+};
+
+// ../../node_modules/.pnpm/@astrojs+compiler@3.0.1/node_modules/@astrojs/compiler/dist/node/sync.js
+import { readFileSync as p } from "fs";
+import { fileURLToPath as m } from "url";
+function i() {
+  return s || (s = f()), s;
+}
+var s;
+var w2 = (e, t) => i().parse(e, t);
+function f() {
+  let e = new d(), t = v2(m(new URL("../astro.wasm", import.meta.url)), e.importObject);
+  e.run(t);
+  let o = globalThis["@astrojs/compiler"];
+  return { transform: (n, a) => {
+    try {
+      return o.transform(n, a || {});
+    } catch (r) {
+      throw s = void 0, r;
+    }
+  }, parse: (n, a) => {
+    try {
+      let r = o.parse(n, a || {});
+      return { ...r, ast: JSON.parse(r.ast) };
+    } catch (r) {
+      throw s = void 0, r;
+    }
+  }, convertToTSX: (n, a) => {
+    try {
+      let r = o.convertToTSX(n, a || {});
+      return { ...r, map: JSON.parse(r.map) };
+    } catch (r) {
+      throw s = void 0, r;
+    }
+  } };
+}
+function v2(e, t) {
+  let o = p(e);
+  return new WebAssembly.Instance(new WebAssembly.Module(o), t);
+}
+
+// src/transform/transform-astro.ts
+function walk2(node, visitor) {
+  if (!node || typeof node !== "object") return;
+  visitor.enter(node);
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) {
+      walk2(child, visitor);
+    }
+  }
+}
+function transformAstro(options) {
+  const { filePath, source, escapeTags, attributeName = "data-inspecto" } = options;
+  const escapeTagsSet = buildEscapeTagsSet(escapeTags);
+  let ast;
+  try {
+    ast = w2(source, { position: true }).ast;
+  } catch (_err) {
+    return { code: source, map: null, changed: false };
+  }
+  const s2 = new MagicString4(source);
+  let changed = false;
+  walk2(ast, {
+    enter(node) {
+      if (node.type === "element" || node.type === "component") {
+        const tagName = node.name;
+        if (tagName && !escapeTagsSet.has(tagName) && !node.attributes?.some((attr) => attr.name === attributeName)) {
+          const startOffset = node.position?.start?.offset ?? -1;
+          if (startOffset === -1) return;
+          let tagStartIndex = startOffset;
+          while (tagStartIndex >= 0 && source[tagStartIndex] !== "<") {
+            tagStartIndex--;
+          }
+          if (tagStartIndex >= 0) {
+            const substringAfterTag = source.substring(tagStartIndex);
+            const escapedTagName = tagName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            const strictRegex = new RegExp(`^<\\s*${escapedTagName}(?=\\s|/|>)`, "i");
+            const strictMatch = substringAfterTag.match(strictRegex);
+            if (strictMatch) {
+              const insertPosition = tagStartIndex + strictMatch[0].length;
+              const line = node.position.start.line;
+              const column = node.position.start.column;
+              const attrValue = formatAttrValue(filePath, line, column);
+              const addition = ` ${attributeName}="${attrValue}"`;
+              s2.appendLeft(insertPosition, addition);
+              changed = true;
+            }
+          }
+        }
+      }
+    }
+  });
+  return {
+    code: s2.toString(),
+    map: changed ? s2.generateMap({ source: filePath, includeContent: true }) : null,
+    changed
+  };
+}
+
+// src/transform/index.ts
+function transformRouter(options) {
+  const { filePath, source, projectRoot, pluginOptions } = options;
+  const ext = path8.extname(filePath).toLowerCase();
+  if (JSX_EXTENSIONS.has(ext)) {
+    return transformJsx({
+      filePath,
+      source,
+      projectRoot,
+      escapeTags: pluginOptions.escapeTags,
+      pathType: pluginOptions.pathType,
+      attributeName: pluginOptions.attributeName
+    });
+  }
+  if (ext === ".vue") {
+    return transformVue({
+      filePath,
+      source,
+      projectRoot,
+      escapeTags: pluginOptions.escapeTags,
+      pathType: pluginOptions.pathType,
+      attributeName: pluginOptions.attributeName
+    });
+  }
+  if (ext === ".svelte") {
+    return transformSvelte({
+      filePath,
+      source,
+      escapeTags: pluginOptions.escapeTags,
+      attributeName: pluginOptions.attributeName
+    });
+  }
+  if (ext === ".astro") {
+    return transformAstro({
+      filePath,
+      source,
+      escapeTags: pluginOptions.escapeTags,
+      attributeName: pluginOptions.attributeName
+    });
+  }
+  return null;
+}
+
+// src/injectors/utils.ts
+import { createRequire } from "module";
+var resolveClientModule = () => {
+  try {
+    return createRequire(import.meta.url).resolve("@inspecto-dev/core");
+  } catch {
+    try {
+      return __require.resolve("@inspecto-dev/core");
+    } catch {
+      console.warn(
+        "[inspecto] Could not resolve @inspecto-dev/core \u2014 falling back to bare specifier"
+      );
+      return "@inspecto-dev/core";
+    }
+  }
+};
+
+// src/injectors/webpack.ts
+function getWebpackHtmlScript(serverPort) {
+  return `
+window.__AI_INSPECTOR_PORT__ = ${serverPort};
+window.addEventListener('load', () => {
+  if (window.InspectoClient) {
+    window.InspectoClient.mountInspector({
+      serverUrl: 'http://127.0.0.1:' + window.__AI_INSPECTOR_PORT__,
+    });
+  }
+});
+`;
+}
+function getWebpackAssetScript(serverPort) {
+  return `
+if (typeof window !== 'undefined') {
+  window.__AI_INSPECTOR_PORT__ = ${serverPort};
+  const _initInspecto = () => {
+    if (window.InspectoClient) {
+      window.InspectoClient.mountInspector({
+        serverUrl: 'http://127.0.0.1:' + window.__AI_INSPECTOR_PORT__,
+      });
+    } else {
+      setTimeout(_initInspecto, 100);
+    }
+  };
+  if (document.readyState === 'complete') {
+    _initInspecto();
+  } else {
+    window.addEventListener('load', _initInspecto);
+  }
+}
+`;
+}
+function injectWebpack(compiler, serverPortFn, resolveClientModule2) {
+  const inspectoClientPath = resolveClientModule2();
+  if (compiler.webpack && compiler.webpack.EntryPlugin) {
+    new compiler.webpack.EntryPlugin(compiler.context, inspectoClientPath, {
+      name: void 0
+    }).apply(compiler);
+  }
+  compiler.hooks.compilation.tap("inspecto-overlay", (compilation) => {
+    const HtmlWebpackPlugin = compiler.options.plugins.find(
+      (p2) => p2 && p2.constructor && p2.constructor.name === "HtmlWebpackPlugin"
+    );
+    if (HtmlWebpackPlugin) {
+      const hooks = HtmlWebpackPlugin.constructor.getHooks(compilation);
+      hooks.alterAssetTagGroups.tapPromise("inspecto-overlay", async (data) => {
+        const port = await serverPortFn();
+        data.headTags.unshift({
+          tagName: "script",
+          voidTag: false,
+          meta: { plugin: "inspecto-overlay" },
+          innerHTML: getWebpackHtmlScript(port)
+        });
+        return data;
+      });
+    } else {
+      if (compilation.hooks.processAssets) {
+        compilation.hooks.processAssets.tapPromise(
+          {
+            name: "inspecto-overlay",
+            stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+          },
+          async (assets) => {
+            const port = await serverPortFn();
+            const mainAssetKey = Object.keys(assets).find(
+              (key) => key.endsWith(".js") && (key.includes("main") || key.includes("app") || key.includes("umi"))
+            );
+            if (!mainAssetKey) return;
+            const originalSource = assets[mainAssetKey].source();
+            assets[mainAssetKey] = new compiler.webpack.sources.RawSource(
+              getWebpackAssetScript(port) + "\n" + originalSource
+            );
+          }
+        );
+      }
+    }
+  });
+}
+
+// src/injectors/rspack.ts
+function injectRspack(compiler, serverPortFn, resolveClientModule2) {
+  const inspectoClientPath = resolveClientModule2();
+  new compiler.webpack.EntryPlugin(compiler.context, inspectoClientPath, {}).apply(compiler);
+  compiler.hooks.compilation.tap("inspecto-overlay", (compilation) => {
+    const HtmlRspackPlugin = compiler.options.plugins.find(
+      (p2) => p2 && p2.constructor && p2.constructor.name === "HtmlRspackPlugin"
+    );
+    if (HtmlRspackPlugin) {
+      const hooks = HtmlRspackPlugin.constructor.getHooks(compilation);
+      hooks.alterAssetTagGroups.tapPromise("inspecto-overlay", async (data) => {
+        const port = await serverPortFn();
+        data.headTags.unshift({
+          tagName: "script",
+          voidTag: false,
+          meta: { plugin: "inspecto-overlay" },
+          innerHTML: getWebpackHtmlScript(port)
+        });
+        return data;
+      });
+    }
+  });
+}
+
+// src/injectors/vite.ts
+function getViteVirtualModuleScript(serverPort) {
+  return `
+import { mountInspector } from '@inspecto-dev/core';
+window.__AI_INSPECTOR_PORT__ = ${serverPort};
+mountInspector({
+  serverUrl: 'http://127.0.0.1:' + window.__AI_INSPECTOR_PORT__,
+});
+`;
+}
+var VITE_VIRTUAL_MODULE_ID = "\0virtual:inspecto-client";
+var VITE_VIRTUAL_IMPORT_ID = "/@id/__x00__virtual:inspecto-client";
+
+// src/index.ts
+var DEFAULT_OPTIONS = {
+  include: [],
+  exclude: [],
+  escapeTags: [],
+  pathType: "absolute",
+  attributeName: "data-inspecto",
+  logLevel: "warn"
+};
+var DEFAULT_PORT = 5678;
+var InspectoPlugin = createUnplugin((userOptions = {}) => {
+  const options = {
+    ...DEFAULT_OPTIONS,
+    ...userOptions
+  };
+  setGlobalLogLevel(options.logLevel);
+  const pluginLogger = createLogger("inspecto:plugin", { logLevel: options.logLevel });
+  const isProduction = process.env["NODE_ENV"] === "production";
+  let projectRoot = process.cwd();
+  let serverPort = null;
+  const ensureServer = async () => {
+    if (serverPort === null) {
+      serverPort = await startServer();
+    }
+    return serverPort;
+  };
+  return {
+    name: "inspecto-overlay",
+    enforce: "pre",
+    buildStart() {
+      if (isProduction) return;
+      projectRoot = serverState.cwd || process.cwd();
+      ensureServer().catch((err) => pluginLogger.error("Failed to start server:", err));
+    },
+    buildEnd() {
+    },
+    webpack: (compiler) => {
+      if (isProduction) return;
+      injectWebpack(compiler, ensureServer, resolveClientModule);
+    },
+    rspack: (compiler) => {
+      if (isProduction) return;
+      injectRspack(compiler, ensureServer, resolveClientModule);
+    },
+    vite: {
+      config(config) {
+        if (isProduction) return config;
+        return {
+          ...config,
+          define: {
+            ...config.define,
+            __AI_INSPECTOR_PORT__: JSON.stringify(DEFAULT_PORT)
+            // Placeholder, rewritten in configureServer
+          }
+        };
+      },
+      resolveId(id) {
+        if (id === "virtual:inspecto-client") {
+          return VITE_VIRTUAL_MODULE_ID;
+        }
+        return null;
+      },
+      load(id) {
+        if (id === VITE_VIRTUAL_MODULE_ID) {
+          return getViteVirtualModuleScript(serverPort ?? DEFAULT_PORT);
+        }
+        return null;
+      },
+      async configureServer(server) {
+        if (isProduction) return;
+        const port = await ensureServer();
+        if (!server.config.define) {
+          ;
+          server.config.define = {};
+        }
+        ;
+        server.config.define["__AI_INSPECTOR_PORT__"] = JSON.stringify(port);
+        const mod = server.moduleGraph.getModuleById(VITE_VIRTUAL_MODULE_ID);
+        if (mod) server.moduleGraph.invalidateModule(mod);
+      },
+      transformIndexHtml(html) {
+        if (isProduction || !serverPort) return html;
+        return {
+          html,
+          tags: [
+            {
+              tag: "script",
+              attrs: { type: "module" },
+              children: `import '${VITE_VIRTUAL_IMPORT_ID}';`
+            }
+          ]
+        };
+      }
+    },
+    transformInclude(id) {
+      if (isProduction || !id) return false;
+      return shouldTransform(id, options);
+    },
+    transform(code, id) {
+      if (isProduction || !id) return null;
+      const { filePath } = extractTransformFilePath(id);
+      const result = transformRouter({
+        filePath,
+        source: code,
+        projectRoot,
+        pluginOptions: options
+      });
+      if (!result || !result.changed) return null;
+      return {
+        code: result.code,
+        map: result.map
+      };
+    }
+  };
+});
+var vitePlugin = InspectoPlugin.vite;
+var webpackPlugin = InspectoPlugin.webpack;
+var rspackPlugin = InspectoPlugin.rspack;
+var rollupPlugin = InspectoPlugin.rollup;
+var esbuildPlugin = InspectoPlugin.esbuild;
+
+// src/astro.ts
+function getAstroInjectedScript(serverPort) {
+  return `
+import { mountInspector } from '@inspecto-dev/core';
+window.__AI_INSPECTOR_SERVER_URL__ = 'http://127.0.0.1:${serverPort}';
+mountInspector({
+  serverUrl: window.__AI_INSPECTOR_SERVER_URL__,
+});
+`;
+}
+function astroIntegration(options) {
+  return {
+    name: "inspecto-astro",
+    hooks: {
+      async "astro:config:setup"({ command, injectScript, updateConfig }) {
+        updateConfig({
+          vite: {
+            plugins: [vitePlugin(options)]
+          }
+        });
+        if (command !== "dev") {
+          return;
+        }
+        const serverPort = await startServer();
+        injectScript("page", getAstroInjectedScript(serverPort));
+      }
+    }
+  };
+}
+var astro_default = astroIntegration;
+export {
+  astroIntegration,
+  astro_default as default,
+  getAstroInjectedScript
+};
+//# sourceMappingURL=astro.js.map