@visulima/error 4.4.18 → 4.5.0

package/dist/packem_shared/aiFinder-Bk1vt0_x.mjs

@@ -0,0 +1,261 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { generateText } from 'ai';
+import aiPrompt from '../solution/ai/ai-prompt.mjs';
+import aiSolutionResponse from './aiSolutionResponse-bDi4ad8f.mjs';
+
+var __defProp$1 = Object.defineProperty;
+var __name$1 = (target, value) => __defProp$1(target, "name", { value, configurable: true });
+var __defProp$1$1 = Object.defineProperty;
+var __name$1$1 = /* @__PURE__ */ __name$1((target, value) => __defProp$1$1(target, "name", { value, configurable: true }), "__name$1");
+const DRIVE_LETTER_START_RE = /^[A-Z]:\//i;
+const normalizeWindowsPath = /* @__PURE__ */ __name$1$1((input = "") => {
+  if (!input) {
+    return input;
+  }
+  return input.replaceAll("\\", "/").replace(DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}, "normalizeWindowsPath");
+var __defProp2 = Object.defineProperty;
+var __name2 = /* @__PURE__ */ __name$1((target, value) => __defProp2(target, "name", { value, configurable: true }), "__name");
+const UNC_REGEX = /^[/\\]{2}/;
+const IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Z]:[/\\]/i;
+const DRIVE_LETTER_RE = /^[A-Z]:$/i;
+const normalizeString = /* @__PURE__ */ __name2((path2, allowAboveRoot) => {
+  let result = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path2.length; ++index) {
+    if (index < path2.length) {
+      char = path2[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ;
+      else if (dots === 2) {
+        if (result.length < 2 || lastSegmentLength !== 2 || !result.endsWith(".") || result.at(-2) !== ".") {
+          if (result.length > 2) {
+            const lastSlashIndex = result.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              result = "";
+              lastSegmentLength = 0;
+            } else {
+              result = result.slice(0, lastSlashIndex);
+              lastSegmentLength = result.length - 1 - result.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (result.length > 0) {
+            result = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          result += result.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (result.length > 0) {
+          result += `/${path2.slice(lastSlash + 1, index)}`;
+        } else {
+          result = path2.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return result;
+}, "normalizeString");
+const isAbsolute = /* @__PURE__ */ __name2((path2) => IS_ABSOLUTE_RE.test(path2), "isAbsolute");
+const normalize = /* @__PURE__ */ __name2(function(path2) {
+  if (path2.length === 0) {
+    return ".";
+  }
+  path2 = normalizeWindowsPath(path2);
+  const isUNCPath = UNC_REGEX.exec(path2);
+  const isPathAbsolute = isAbsolute(path2);
+  const trailingSeparator = path2.at(-1) === "/";
+  path2 = normalizeString(path2, !isPathAbsolute);
+  if (path2.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path2 += "/";
+  }
+  if (DRIVE_LETTER_RE.test(path2)) {
+    path2 += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path2}`;
+    }
+    return `//${path2}`;
+  }
+  return isPathAbsolute && !isAbsolute(path2) ? `/${path2}` : path2;
+}, "normalize");
+const join = /* @__PURE__ */ __name2((...segments) => {
+  let path2 = "";
+  for (const seg of segments) {
+    if (!seg) {
+      continue;
+    }
+    if (path2.length > 0) {
+      const pathTrailing = path2[path2.length - 1] === "/";
+      const segLeading = seg[0] === "/";
+      const both = pathTrailing && segLeading;
+      if (both) {
+        path2 += seg.slice(1);
+      } else {
+        path2 += pathTrailing || segLeading ? seg : `/${seg}`;
+      }
+    } else {
+      path2 += seg;
+    }
+  }
+  return normalize(path2);
+}, "join");
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const DEFAULT_HEADER = "## Ai Generated Solution";
+const DEFAULT_ERROR_MESSAGE = "Creation of a AI solution failed.";
+const generateCacheKey = /* @__PURE__ */ __name((error, file, temperature) => {
+  const keyData = {
+    error: {
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    },
+    file: {
+      file: file.file,
+      language: file.language,
+      line: file.line,
+      snippet: file.snippet
+    },
+    temperature
+  };
+  return createHash("sha256").update(JSON.stringify(keyData)).digest("hex");
+}, "generateCacheKey");
+const getCacheDirectory = /* @__PURE__ */ __name((directory) => {
+  if (directory) {
+    return directory;
+  }
+  return join(tmpdir(), "visulima-error-cache");
+}, "getCacheDirectory");
+const ensureCacheDirectory = /* @__PURE__ */ __name((cacheDir) => {
+  if (!existsSync(cacheDir)) {
+    mkdirSync(cacheDir, { recursive: true });
+  }
+}, "ensureCacheDirectory");
+const getCacheFilePath = /* @__PURE__ */ __name((cacheDir, key) => {
+  return join(cacheDir, `${key}.json`);
+}, "getCacheFilePath");
+const readFromCache = /* @__PURE__ */ __name((cacheFilePath, ttl) => {
+  try {
+    if (!existsSync(cacheFilePath)) {
+      return null;
+    }
+    const cacheContent = readFileSync(cacheFilePath, "utf-8");
+    const cacheEntry = JSON.parse(cacheContent);
+    const now = Date.now();
+    if (now - cacheEntry.timestamp > ttl) {
+      return null;
+    }
+    return cacheEntry.solution;
+  } catch {
+    return null;
+  }
+}, "readFromCache");
+const writeToCache = /* @__PURE__ */ __name((cacheFilePath, solution, ttl) => {
+  try {
+    const cacheEntry = {
+      solution,
+      timestamp: Date.now(),
+      ttl
+    };
+    writeFileSync(cacheFilePath, JSON.stringify(cacheEntry, null, 2), "utf-8");
+  } catch {
+  }
+}, "writeToCache");
+const aiFinder = /* @__PURE__ */ __name((model, options) => {
+  return {
+    handle: /* @__PURE__ */ __name(async (error, file) => {
+      const cacheOptions = options?.cache;
+      const temperature = options?.temperature ?? 0;
+      const ttl = cacheOptions?.ttl ?? 24 * 60 * 60 * 1e3;
+      if (cacheOptions?.enabled !== false) {
+        const cacheKey = generateCacheKey(error, file, temperature);
+        const cacheDir = getCacheDirectory(cacheOptions?.directory);
+        const cacheFilePath = getCacheFilePath(cacheDir, cacheKey);
+        const cachedSolution = readFromCache(cacheFilePath, ttl);
+        if (cachedSolution) {
+          return cachedSolution;
+        }
+        ensureCacheDirectory(cacheDir);
+      }
+      const content = aiPrompt({ applicationType: void 0, error, file });
+      try {
+        const result = await generateText({
+          model,
+          prompt: content,
+          temperature
+        });
+        const messageContent = result.text;
+        let solution;
+        if (!messageContent) {
+          solution = {
+            body: aiSolutionResponse(DEFAULT_ERROR_MESSAGE),
+            header: DEFAULT_HEADER
+          };
+        } else {
+          solution = {
+            body: aiSolutionResponse(messageContent),
+            header: DEFAULT_HEADER
+          };
+        }
+        if (cacheOptions?.enabled !== false) {
+          const cacheKey = generateCacheKey(error, file, temperature);
+          const cacheDir = getCacheDirectory(cacheOptions?.directory);
+          const cacheFilePath = getCacheFilePath(cacheDir, cacheKey);
+          writeToCache(cacheFilePath, solution, ttl);
+        }
+        return solution;
+      } catch (error_) {
+        console.error(error_);
+        const solution = {
+          body: aiSolutionResponse(DEFAULT_ERROR_MESSAGE),
+          header: DEFAULT_HEADER
+        };
+        if (cacheOptions?.enabled !== false) {
+          const cacheKey = generateCacheKey(error, file, temperature);
+          const cacheDir = getCacheDirectory(cacheOptions?.directory);
+          const cacheFilePath = getCacheFilePath(cacheDir, cacheKey);
+          writeToCache(cacheFilePath, solution, ttl);
+        }
+        return solution;
+      }
+    }, "handle"),
+    name: "AI SDK",
+    priority: 99
+  };
+}, "aiFinder");
+
+export { aiFinder as default };

package/dist/packem_shared/aiSolutionResponse-BPckbL56.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const between = /* @__PURE__ */ __name((start, end, text) => {
+  const startPosition = text.indexOf(start);
+  if (startPosition === -1) {
+    return "";
+  }
+  const adjustedStartPosition = startPosition + start.length;
+  const endPosition = text.indexOf(end, adjustedStartPosition);
+  if (endPosition === -1) {
+    return "";
+  }
+  return text.substring(adjustedStartPosition, endPosition).trim();
+}, "between");
+const aiSolutionResponse = /* @__PURE__ */ __name((rawText) => {
+  const description = between("FIX", "ENDFIX", rawText);
+  if (!description) {
+    return [
+      "No solution found.",
+      'Provide this response to the Maintainer of <a href="https://github.com/visulima/visulima/issues/new?assignees=&labels=s%3A+pending+triage%2Cc%3A+bug&projects=&template=bug_report.yml" target="_blank" rel="noopener noreferrer" class="text-blue-500 hover:underline inline-flex items-center text-sm">@visulima/error</a>.',
+      `"${rawText}"`
+    ].join("</br></br>");
+  }
+  const links = between("LINKS", "ENDLINKS", rawText).split("\n").map((link) => JSON.parse(link));
+  return `${description.replaceAll(/"([^"]*)"(\s|\.)/g, "<code>$1</code> ")}
+
+## Links
+
+${links.map((link) => `- <a href="${link.url}" target="_blank" rel="noopener noreferrer">${link.title}</a>`).join("\n")}
+
+--------------------
+This solution was generated with the <a href="https://sdk.vercel.ai/" target="_blank" rel="noopener noreferrer">AI SDK</a> and may not be 100% accurate.`;
+}, "aiSolutionResponse");
+
+module.exports = aiSolutionResponse;

package/dist/packem_shared/aiSolutionResponse-bDi4ad8f.mjs

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const between = /* @__PURE__ */ __name((start, end, text) => {
+  const startPosition = text.indexOf(start);
+  if (startPosition === -1) {
+    return "";
+  }
+  const adjustedStartPosition = startPosition + start.length;
+  const endPosition = text.indexOf(end, adjustedStartPosition);
+  if (endPosition === -1) {
+    return "";
+  }
+  return text.substring(adjustedStartPosition, endPosition).trim();
+}, "between");
+const aiSolutionResponse = /* @__PURE__ */ __name((rawText) => {
+  const description = between("FIX", "ENDFIX", rawText);
+  if (!description) {
+    return [
+      "No solution found.",
+      'Provide this response to the Maintainer of <a href="https://github.com/visulima/visulima/issues/new?assignees=&labels=s%3A+pending+triage%2Cc%3A+bug&projects=&template=bug_report.yml" target="_blank" rel="noopener noreferrer" class="text-blue-500 hover:underline inline-flex items-center text-sm">@visulima/error</a>.',
+      `"${rawText}"`
+    ].join("</br></br>");
+  }
+  const links = between("LINKS", "ENDLINKS", rawText).split("\n").map((link) => JSON.parse(link));
+  return `${description.replaceAll(/"([^"]*)"(\s|\.)/g, "<code>$1</code> ")}
+
+## Links
+
+${links.map((link) => `- <a href="${link.url}" target="_blank" rel="noopener noreferrer">${link.title}</a>`).join("\n")}
+
+--------------------
+This solution was generated with the <a href="https://sdk.vercel.ai/" target="_blank" rel="noopener noreferrer">AI SDK</a> and may not be 100% accurate.`;
+}, "aiSolutionResponse");
+
+export { aiSolutionResponse as default };

package/dist/packem_shared/errorHintFinder-CQy_qIK3.mjs

@@ -0,0 +1,23 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const errorHintFinder = {
+  handle: /* @__PURE__ */ __name(async (error) => {
+    if (error.hint === void 0) {
+      return void 0;
+    }
+    if (typeof error.hint === "string") {
+      return { body: error.hint };
+    }
+    if (typeof error.hint === "object" && typeof error.hint.body === "string") {
+      return error.hint;
+    }
+    if (Array.isArray(error.hint)) {
+      return { body: error.hint.join("\n") };
+    }
+    return void 0;
+  }, "handle"),
+  name: "errorHint",
+  priority: 1
+};
+
+export { errorHintFinder as default };

package/dist/packem_shared/errorHintFinder-DZugFHq0.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const errorHintFinder = {
+  handle: /* @__PURE__ */ __name(async (error) => {
+    if (error.hint === void 0) {
+      return void 0;
+    }
+    if (typeof error.hint === "string") {
+      return { body: error.hint };
+    }
+    if (typeof error.hint === "object" && typeof error.hint.body === "string") {
+      return error.hint;
+    }
+    if (Array.isArray(error.hint)) {
+      return { body: error.hint.join("\n") };
+    }
+    return void 0;
+  }, "handle"),
+  name: "errorHint",
+  priority: 1
+};
+
+module.exports = errorHintFinder;

package/dist/packem_shared/formatStackFrameLine-DcXSX--m.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const formatStackFrameLine = /* @__PURE__ */ __name((frame) => {
+  const method = frame.methodName && frame.methodName !== "<unknown>" ? `${frame.methodName} ` : "";
+  const file = frame.file ?? "<unknown>";
+  const line = frame.line ?? 0;
+  const column = frame.column ?? 0;
+  if (method.trim()) {
+    return `    at ${method}(${file}:${line}:${column})`;
+  }
+  return `    at ${file}:${line}:${column}`;
+}, "formatStackFrameLine");
+const formatStacktrace = /* @__PURE__ */ __name((frames, options) => {
+  const lines = [];
+  if (options?.header && (options.header.name || options.header.message)) {
+    const headerName = String(options.header.name || "Error");
+    const headerMessage = String(options.header.message || "");
+    lines.push(`${headerName}${headerMessage ? ": " : ""}${headerMessage}`);
+  }
+  for (const frame of frames) {
+    lines.push(formatStackFrameLine(frame));
+  }
+  return lines.join("\n");
+}, "formatStacktrace");
+
+exports.formatStackFrameLine = formatStackFrameLine;
+exports.formatStacktrace = formatStacktrace;

package/dist/packem_shared/formatStackFrameLine-DqkmKWH3.mjs

@@ -0,0 +1,26 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const formatStackFrameLine = /* @__PURE__ */ __name((frame) => {
+  const method = frame.methodName && frame.methodName !== "<unknown>" ? `${frame.methodName} ` : "";
+  const file = frame.file ?? "<unknown>";
+  const line = frame.line ?? 0;
+  const column = frame.column ?? 0;
+  if (method.trim()) {
+    return `    at ${method}(${file}:${line}:${column})`;
+  }
+  return `    at ${file}:${line}:${column}`;
+}, "formatStackFrameLine");
+const formatStacktrace = /* @__PURE__ */ __name((frames, options) => {
+  const lines = [];
+  if (options?.header && (options.header.name || options.header.message)) {
+    const headerName = String(options.header.name || "Error");
+    const headerMessage = String(options.header.message || "");
+    lines.push(`${headerName}${headerMessage ? ": " : ""}${headerMessage}`);
+  }
+  for (const frame of frames) {
+    lines.push(formatStackFrameLine(frame));
+  }
+  return lines.join("\n");
+}, "formatStacktrace");
+
+export { formatStackFrameLine, formatStacktrace };

package/dist/packem_shared/ruleBasedFinder-BYrndubA.mjs

@@ -0,0 +1,227 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const code = /* @__PURE__ */ __name((s) => `\`\`\`
+${s.trim()}
+\`\`\``, "code");
+const bash = /* @__PURE__ */ __name((s) => `\`\`\`bash
+${s.trim()}
+\`\`\``, "bash");
+const ts = /* @__PURE__ */ __name((s) => `\`\`\`ts
+${s.trim()}
+\`\`\``, "ts");
+const js = /* @__PURE__ */ __name((s) => `\`\`\`js
+${s.trim()}
+\`\`\``, "js");
+const has = /* @__PURE__ */ __name((message, ...needles) => {
+  const lower = message.toLowerCase();
+  return needles.some((n) => lower.includes(n.toLowerCase()));
+}, "has");
+const rules = [
+  {
+    name: "esm-cjs-interop",
+    test: /* @__PURE__ */ __name((error) => {
+      const message = (error?.message || String(error || "")).toString();
+      if (has(
+        message,
+        "err_require_esm",
+        "cannot use import statement outside a module",
+        "must use import to load es module",
+        "require() of es module",
+        "does not provide an export named"
+      )) {
+        return {
+          md: [
+            "Your project or a dependency may be mixing CommonJS and ES Modules.",
+            "",
+            "Try:",
+            "- Ensure package.json has the correct `type` (either `module` or `commonjs`).",
+            "- Use dynamic `import()` when requiring ESM from CJS.",
+            "- Prefer ESM-compatible entrypoints from dependencies.",
+            "- In Node, align `module` resolution with your bundler config.",
+            "",
+            "Check Node resolution:",
+            bash("node -v\ncat package.json | jq .type"),
+            "",
+            "Example dynamic import in CJS:",
+            js("(async () => { const mod = await import('some-esm'); mod.default(); })();")
+          ].join("\n"),
+          title: "ESM/CJS interop"
+        };
+      }
+      return void 0;
+    }, "test")
+  },
+  {
+    name: "missing-default-export",
+    test: /* @__PURE__ */ __name((error) => {
+      const message = (error?.message || String(error || "")).toString();
+      if (has(message, "default export not found", "has no default export", "does not provide an export named 'default'", "is not exported from")) {
+        return {
+          md: [
+            "Verify your import/export shapes.",
+            "",
+            "Default export example:",
+            ts("export default function Component() {}\n// import Component from './file'"),
+            "",
+            "Named export example:",
+            ts("export function Component() {}\n// import { Component } from './file'")
+          ].join("\n"),
+          title: "Export mismatch (default vs named)"
+        };
+      }
+      return void 0;
+    }, "test")
+  },
+  {
+    name: "port-in-use",
+    test: /* @__PURE__ */ __name((error) => {
+      const message = (error?.message || String(error || "")).toString();
+      if (has(message, "eaddrinuse", "address already in use", "listen eaddrinuse")) {
+        return {
+          md: [
+            "Another process is using the port.",
+            "",
+            "Change the port or stop the other process.",
+            "",
+            "On macOS/Linux:",
+            bash("lsof -i :3000\nkill -9 <PID>"),
+            "",
+            "On Windows (PowerShell):",
+            bash("netstat -ano | findstr :3000\ntaskkill /PID <PID> /F")
+          ].join("\n"),
+          title: "Port already in use"
+        };
+      }
+      return void 0;
+    }, "test")
+  },
+  {
+    name: "file-not-found-or-case",
+    test: /* @__PURE__ */ __name((error, file) => {
+      const message = (error?.message || String(error || "")).toString();
+      if (has(message, "enoent", "module not found", "cannot find module")) {
+        return {
+          md: [
+            "Check the import path and filename case (Linux/macOS are case-sensitive).",
+            "If using TS path aliases, verify `tsconfig.paths` and bundler aliases.",
+            "",
+            "Current file:",
+            code(`${file.file}:${file.line}`)
+          ].join("\n"),
+          title: "Missing file or path case mismatch"
+        };
+      }
+      return void 0;
+    }, "test")
+  },
+  {
+    name: "ts-path-mapping",
+    test: /* @__PURE__ */ __name((error) => {
+      const message = (error?.message || String(error || "")).toString();
+      if (has(message, "ts2307", "cannot find module") || message.includes("TS2307")) {
+        return {
+          md: [
+            "If you use path aliases, align TS `paths` with Vite/Webpack resolve aliases.",
+            "Ensure file extensions are correct and included in resolver.",
+            "",
+            "tsconfig.json excerpt:",
+            ts(`{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": { "@/*": ["src/*"] }
+  }
+}`)
+          ].join("\n"),
+          title: "TypeScript path mapping / resolution"
+        };
+      }
+      return void 0;
+    }, "test")
+  },
+  {
+    name: "network-dns-enotfound",
+    test: /* @__PURE__ */ __name((error) => {
+      const message = (error?.message || String(error || "")).toString();
+      if (has(message, "enotfound", "getaddrinfo enotfound", "dns", "fetch failed", "ecconnrefused", "econnrefused")) {
+        return {
+          md: [
+            "The host may be unreachable or misconfigured.",
+            "",
+            "Try:",
+            "- Verify the hostname and protocol (http/https).",
+            "- Check VPN/proxy and firewall.",
+            "- Confirm the service is running and listening on the expected port.",
+            "",
+            bash("ping <host>\nnslookup <host>\ncurl -v http://<host>:<port>")
+          ].join("\n"),
+          title: "Network/DNS connection issue"
+        };
+      }
+      return void 0;
+    }, "test")
+  },
+  {
+    name: "react-hydration-mismatch",
+    test: /* @__PURE__ */ __name((error) => {
+      const message = (error?.message || String(error || "")).toString();
+      if (has(message, "hydration failed", "did not match", "expected server html", "text content does not match")) {
+        return {
+          md: [
+            "Client and server rendered markup differ.",
+            "",
+            "Checklist:",
+            "- Avoid non-deterministic rendering during SSR (dates, random, locale).",
+            "- Ensure feature flags / env checks are consistent between server and client.",
+            "- Wrap browser-only code with guards (e.g., check `typeof window !== 'undefined'`).",
+            "- Ensure data used on server matches client rehydration data."
+          ].join("\n"),
+          title: "React hydration mismatch"
+        };
+      }
+      return void 0;
+    }, "test")
+  },
+  {
+    name: "undefined-property",
+    test: /* @__PURE__ */ __name((error) => {
+      const message = (error?.message || String(error || "")).toString();
+      if (has(message, "cannot read properties of undefined", "reading '")) {
+        return {
+          md: [
+            "A variable or function returned `undefined`.",
+            "",
+            "Mitigations:",
+            "- Add nullish checks before property access.",
+            "- Validate function return values and input props/state.",
+            "",
+            ts("const value = maybe?.prop; // or: if (maybe) { use(maybe.prop) }")
+          ].join("\n"),
+          title: "Accessing property of undefined"
+        };
+      }
+      return void 0;
+    }, "test")
+  }
+];
+const ruleBasedFinder = {
+  handle: /* @__PURE__ */ __name(async (error, file) => {
+    try {
+      const matches = rules.map((r) => {
+        return { match: r.test(error, file), rule: r };
+      }).filter((x) => Boolean(x.match));
+      if (matches.length === 0) {
+        return void 0;
+      }
+      const sections = matches.sort((a, b) => (a.match.priority || 0) - (b.match.priority || 0)).map((m) => `#### ${m.match.title}
+
+${m.match.md}`).join("\n\n---\n\n");
+      return { body: sections, header: "### Potential fixes detected" };
+    } catch {
+      return void 0;
+    }
+  }, "handle"),
+  name: "ruleBasedHints",
+  priority: 0
+};
+
+export { ruleBasedFinder as default };