@visulima/error 5.0.3 → 5.0.5

package/dist/packem_shared/parseStacktrace-oQvk7wYp.js

@@ -0,0 +1,273 @@
+const debugLog = (message, ...arguments_) => {
+  if (process.env.DEBUG && String(process.env.DEBUG) === "true") {
+    console.debug(`error:parse-stacktrace: ${message}`, ...arguments_);
+  }
+};
+const UNKNOWN_FUNCTION = "<unknown>";
+const CHROMIUM_REGEX = /^.*?\s*at\s(?:(.+?\)(?:\s\[.+\])?|\(?.*?)\s?\((?:address\sat\s)?)?(?:async\s)?((?:<anonymous>|[-a-z]+:|.*bundle|\/)?.*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
+const CHROMIUM_EVAL_REGEX = /\((\S+)\),\s(<[^>]+>)?:(\d+)?:(\d+)?\)?/;
+const CHROMIUM_MAPPED = /(.*?):(\d+):(\d+)(\s<-\s(.+):(\d+):(\d+))?/;
+const WINDOWS_EVAL_REGEX = /(eval)\sat\s(<anonymous>)\s\((.*)\)?:(\d+)?:(\d+)\),\s*(<anonymous>)?:(\d+)?:(\d+)/;
+const NODE_REGEX = /^\s*in\s(?:([^\\/]+(?:\s\[as\s\S+\])?)\s\(?)?\(at?\s?(.*?):(\d+)(?::(\d+))?\)?\s*$/;
+const NODE_NESTED_REGEX = /in\s(.*)\s\(at\s(.+)\)\sat/;
+const REACT_ANDROID_NATIVE_REGEX = /^(?:.*@)?(.*):(\d+):(\d+)$/;
+const GECKO_REGEX = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)?((?:[-a-z]+)?:\/.*?|\[native code\]|[^@]*(?:bundle|\d+\.js)|\/[\w\-. \/=]+)(?::(\d+))?(?::(\d+))?\s*$/i;
+const GECKO_EVAL_REGEX = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
+const FIREFOX_REGEX = /(\S[^\s[]*\[.*\]|.*?)@(.*):(\d+):(\d+)/;
+const WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
+const extractSafariExtensionDetails = (methodName, url) => {
+  const isSafariExtension = methodName.includes("safari-extension");
+  const isSafariWebExtension = methodName.includes("safari-web-extension");
+  return isSafariExtension || isSafariWebExtension ? [
+    methodName.includes("@") ? methodName.split("@")[0] : UNKNOWN_FUNCTION,
+    isSafariExtension ? `safari-extension:${url}` : `safari-web-extension:${url}`
+  ] : [methodName, url];
+};
+const parseMapped = (trace, maybeMapped) => {
+  const match = CHROMIUM_MAPPED.exec(maybeMapped);
+  if (match) {
+    trace.file = match[1];
+    trace.line = +match[2];
+    trace.column = +match[3];
+  }
+};
+const parseNode = (line) => {
+  const nestedNode = NODE_NESTED_REGEX.exec(line);
+  if (nestedNode) {
+    debugLog(`parse nested node error stack line: "${line}"`, `found: ${JSON.stringify(nestedNode)}`);
+    const split = nestedNode[2].split(":");
+    return {
+      column: split[2] ? +split[2] : void 0,
+      file: split[0],
+      line: split[1] ? +split[1] : void 0,
+      methodName: nestedNode[1] || UNKNOWN_FUNCTION,
+      raw: line,
+      type: void 0
+    };
+  }
+  const node = NODE_REGEX.exec(line);
+  if (node) {
+    debugLog(`parse node error stack line: "${line}"`, `found: ${JSON.stringify(node)}`);
+    const trace = {
+      column: node[4] ? +node[4] : void 0,
+      file: node[2] ? node[2].replace(/at\s/, "") : void 0,
+      line: node[3] ? +node[3] : void 0,
+      methodName: node[1] || UNKNOWN_FUNCTION,
+      raw: line,
+      type: line.startsWith("internal") ? "internal" : void 0
+    };
+    parseMapped(trace, `${node[2]}:${node[3]}:${node[4]}`);
+    return trace;
+  }
+  return void 0;
+};
+const parseChromium = (line) => {
+  const parts = CHROMIUM_REGEX.exec(line);
+  if (parts) {
+    debugLog(`parse chrome error stack line: "${line}"`, `found: ${JSON.stringify(parts)}`);
+    const isNative = parts[2]?.startsWith("native");
+    const isEval = parts[2]?.startsWith("eval") || parts[1]?.startsWith("eval");
+    let evalOrigin;
+    let windowsParts;
+    if (isEval) {
+      const subMatch = CHROMIUM_EVAL_REGEX.exec(line);
+      if (subMatch) {
+        const split = /^(\S+):(\d+):(\d+)$|^(\S+):(\d+)$/.exec(subMatch[1]);
+        if (split) {
+          parts[2] = split[4] ?? split[1];
+          parts[3] = split[5] ?? split[2];
+          parts[4] = split[3];
+        } else if (subMatch[2]) {
+          parts[2] = subMatch[1];
+        }
+        if (subMatch[2]) {
+          evalOrigin = {
+            column: subMatch[4] ? +subMatch[4] : void 0,
+            file: subMatch[2],
+            line: subMatch[3] ? +subMatch[3] : void 0,
+            methodName: "eval",
+            raw: line,
+            type: "eval"
+          };
+        }
+      } else {
+        const windowsSubMatch = WINDOWS_EVAL_REGEX.exec(line);
+        if (windowsSubMatch) {
+          windowsParts = {
+            column: windowsSubMatch[5] ? +windowsSubMatch[5] : void 0,
+            file: windowsSubMatch[3],
+            line: windowsSubMatch[4] ? +windowsSubMatch[4] : void 0
+          };
+          evalOrigin = {
+            column: windowsSubMatch[8] ? +windowsSubMatch[8] : void 0,
+            file: windowsSubMatch[2],
+            line: windowsSubMatch[7] ? +windowsSubMatch[7] : void 0,
+            methodName: "eval",
+            raw: windowsSubMatch[0],
+            type: "eval"
+          };
+        }
+      }
+    }
+    const [methodName, file] = extractSafariExtensionDetails(
+      // Normalize IE's 'Anonymous function'
+      parts[1] ? parts[1].replace(/^Anonymous function$/, "<anonymous>") : UNKNOWN_FUNCTION,
+      parts[2]
+    );
+    const trace = {
+      column: parts[4] ? +parts[4] : void 0,
+      evalOrigin,
+      file,
+      line: parts[3] ? +parts[3] : void 0,
+      methodName,
+      raw: line,
+      // eslint-disable-next-line sonarjs/no-nested-conditional
+      type: isEval ? "eval" : isNative ? "native" : void 0
+    };
+    if (windowsParts) {
+      trace.column = windowsParts.column;
+      trace.file = windowsParts.file;
+      trace.line = windowsParts.line;
+    } else {
+      parseMapped(trace, `${file}:${parts[3]}:${parts[4]}`);
+    }
+    return trace;
+  }
+  return void 0;
+};
+const parseGecko = (line, topFrameMeta) => {
+  const parts = GECKO_REGEX.exec(line);
+  if (parts) {
+    debugLog(`parse gecko error stack line: "${line}"`, `found: ${JSON.stringify(parts)}`);
+    const isEval = parts[3]?.includes(" > eval");
+    const subMatch = isEval && parts[3] && GECKO_EVAL_REGEX.exec(parts[3]);
+    let evalOrigin;
+    if (isEval && subMatch) {
+      parts[3] = subMatch[1];
+      evalOrigin = {
+        column: parts[5] ? +parts[5] : void 0,
+        file: parts[3],
+        line: parts[4] ? +parts[4] : void 0,
+        methodName: "eval",
+        raw: line,
+        type: "eval"
+      };
+      parts[4] = subMatch[2];
+    }
+    const [methodName, file] = extractSafariExtensionDetails(
+      // Normalize IE's 'Anonymous function'
+      parts[1] ? parts[1].replace(/^Anonymous function$/, "<anonymous>") : UNKNOWN_FUNCTION,
+      parts[3]
+    );
+    let column;
+    if ((topFrameMeta?.type === "safari" || !isEval && topFrameMeta?.type === "firefox") && topFrameMeta.column) {
+      column = topFrameMeta.column;
+    } else if (!isEval && parts[5]) {
+      column = +parts[5];
+    }
+    let lineNumber;
+    if ((topFrameMeta?.type === "safari" || !isEval && topFrameMeta?.type === "firefox") && topFrameMeta.line) {
+      lineNumber = topFrameMeta.line;
+    } else if (parts[4]) {
+      lineNumber = +parts[4];
+    }
+    return {
+      column,
+      evalOrigin,
+      file,
+      line: lineNumber,
+      methodName,
+      raw: line,
+      // eslint-disable-next-line sonarjs/no-nested-conditional
+      type: isEval ? "eval" : file.includes("[native code]") ? "native" : void 0
+    };
+  }
+  return void 0;
+};
+const parseFirefox = (line, topFrameMeta) => {
+  const parts = FIREFOX_REGEX.exec(line);
+  const isEval = parts ? parts[2].includes(" > eval") : false;
+  if (!isEval && parts) {
+    debugLog(`parse firefox error stack line: "${line}"`, `found: ${JSON.stringify(parts)}`);
+    return {
+      column: parts[4] ? +parts[4] : topFrameMeta?.column ?? void 0,
+      file: parts[2],
+      line: parts[3] ? +parts[3] : topFrameMeta?.line ?? void 0,
+      methodName: parts[1] || UNKNOWN_FUNCTION,
+      raw: line,
+      type: void 0
+    };
+  }
+  return void 0;
+};
+const parseReactAndroidNative = (line) => {
+  const parts = REACT_ANDROID_NATIVE_REGEX.exec(line);
+  if (parts) {
+    debugLog(`parse react android native error stack line: "${line}"`, `found: ${JSON.stringify(parts)}`);
+    return {
+      column: parts[3] ? +parts[3] : void 0,
+      file: parts[1],
+      line: parts[2] ? +parts[2] : void 0,
+      methodName: UNKNOWN_FUNCTION,
+      raw: line,
+      type: void 0
+    };
+  }
+  return void 0;
+};
+const parseStacktrace = (error, { filter, frameLimit = 50 } = {}) => {
+  let lines = (error.stacktrace ?? error.stack ?? "").split("\n").map((line) => {
+    const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, "$1") : line;
+    return cleanedLine.replace(/^\s+|\s+$/g, "");
+  }).filter((line) => !/\S*(?:Error: |AggregateError:)/.test(line) && line !== "eval code");
+  if (filter) {
+    lines = lines.filter((element) => filter(element));
+  }
+  lines = lines.slice(0, frameLimit);
+  return lines.reduce((stack, line, currentIndex) => {
+    if (!line) {
+      return stack;
+    }
+    if (line.length > 1024) {
+      return stack;
+    }
+    let parseResult;
+    if (/^\s*in\s.*/.test(line)) {
+      parseResult = parseNode(line);
+    } else if (/^.*?\s*at\s.*/.test(line)) {
+      parseResult = parseChromium(line);
+    } else if (/^.*?\s*@.*|\[native code\]/.test(line)) {
+      let topFrameMeta;
+      if (currentIndex === 0) {
+        if (error.columnNumber || error.lineNumber) {
+          topFrameMeta = {
+            // @ts-expect-error columnNumber and columnNumber property only exists on Firefox
+            column: error.columnNumber,
+            // @ts-expect-error columnNumber and lineNumber property only exists on Firefox
+            line: error.lineNumber,
+            type: "firefox"
+          };
+        } else if (error.line || error.column) {
+          topFrameMeta = {
+            // @ts-expect-error column property only exists on safari
+            column: error.column,
+            // @ts-expect-error line property only exists on safari
+            line: error.line,
+            type: "safari"
+          };
+        }
+      }
+      parseResult = parseFirefox(line, topFrameMeta) || parseGecko(line, topFrameMeta);
+    } else {
+      parseResult = parseReactAndroidNative(line);
+    }
+    if (parseResult) {
+      stack.push(parseResult);
+    } else {
+      debugLog(`parse error stack line: "${line}"`, "not parser found");
+    }
+    return stack;
+  }, []);
+};
+
+export { parseStacktrace as default };

package/dist/packem_shared/renderError-C30PRFtU.js

@@ -0,0 +1,206 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  existsSync,
+  readFileSync
+} = __cjs_getBuiltinModule("node:fs");
+const {
+  relative
+} = __cjs_getBuiltinModule("node:path");
+const {
+  cwd
+} = __cjs_getProcess;
+const {
+  fileURLToPath
+} = __cjs_getBuiltinModule("node:url");
+import { codeFrame } from '../code-frame/index.js';
+import parseStacktrace from './parseStacktrace-oQvk7wYp.js';
+
+const getPrefix = (prefix, indentation, deep) => {
+  if (deep === 0) {
+    return prefix.toString();
+  }
+  if (indentation === "	") {
+    return prefix + "	".repeat(deep);
+  }
+  return prefix + " ".repeat(indentation * deep);
+};
+const getRelativePath = (filePath, cwdPath) => {
+  const path = filePath.replace("async file:", "file:");
+  return relative(cwdPath, path.startsWith("file:") ? fileURLToPath(path) : path);
+};
+const getTitleText = (error, hideErrorTitle, color) => {
+  if (hideErrorTitle) {
+    return color.title(error.message);
+  }
+  const messagePart = error.message ? `: ${error.message}` : "";
+  return color.title(error.name + messagePart);
+};
+const getMessage = (error, { color, hideErrorTitle, indentation, prefix }, deep) => `${getPrefix(prefix, indentation, deep)}${getTitleText(error, hideErrorTitle, color)}
+`;
+const getHint = (error, { color, indentation, prefix }, deep) => {
+  if (error.hint === void 0) {
+    return void 0;
+  }
+  const spaces = getPrefix(prefix, indentation, deep);
+  let message = "";
+  if (Array.isArray(error.hint)) {
+    for (const line of error.hint) {
+      message += `${(spaces + line).toString()}
+`;
+    }
+  } else {
+    message += spaces + error.hint;
+  }
+  return color.hint(message);
+};
+const getMainFrame = (trace, { color, cwd: cwdPath, displayShortPath, indentation, prefix }, deep = 0) => {
+  const filePath = displayShortPath ? getRelativePath(trace.file, cwdPath) : trace.file;
+  const { fileLine, method } = color;
+  return `${getPrefix(prefix, indentation, deep)}at ${trace.methodName ? `${method(trace.methodName)} ` : ""}${fileLine(filePath)}:${fileLine(
+    trace.line?.toString() ?? ""
+  )}`.toString();
+};
+const getCode = (trace, { color, indentation, linesAbove, linesBelow, prefix, showGutter, showLineNumbers, tabWidth }, deep) => {
+  if (trace.file === void 0) {
+    return void 0;
+  }
+  const filePath = trace.file.replace("file://", "");
+  if (!existsSync(filePath)) {
+    return void 0;
+  }
+  const fileContent = readFileSync(filePath, "utf8");
+  return codeFrame(
+    fileContent,
+    {
+      start: { column: trace.column, line: trace.line }
+    },
+    { color, linesAbove, linesBelow, prefix: getPrefix(prefix, indentation, deep), showGutter, showLineNumbers, tabWidth }
+  );
+};
+const getErrors = (error, options, deep) => {
+  if (error.errors.length === 0) {
+    return void 0;
+  }
+  let message = `${getPrefix(options.prefix, options.indentation, deep)}Errors:
+
+`;
+  let first = true;
+  for (const error_ of error.errors) {
+    if (first) {
+      first = false;
+    } else {
+      message += "\n\n";
+    }
+    message += internalRenderError(error_, { ...options, framesMaxLimit: 1, hideErrorCodeView: options.hideErrorErrorsCodeView }, deep + 1);
+  }
+  return `
+${message}`;
+};
+const getCause = (error, options, deep) => {
+  let message = `${getPrefix(options.prefix, options.indentation, deep)}Caused by:
+
+`;
+  const cause = error.cause;
+  message += getMessage(cause, options, deep);
+  const stacktrace = parseStacktrace(cause);
+  const mainFrame = stacktrace.shift();
+  const hint = getHint(cause, options, deep);
+  if (hint) {
+    message += `${hint}
+`;
+  }
+  if (mainFrame) {
+    message += getMainFrame(mainFrame, options, deep);
+    if (!options.hideErrorCauseCodeView) {
+      const code = getCode(mainFrame, options, deep);
+      if (code !== void 0) {
+        message += `
+${code}`;
+      }
+    }
+  }
+  if (cause.cause) {
+    message += `
+${getCause(cause, options, deep + 1)}`;
+  } else if (cause instanceof AggregateError) {
+    const errors = getErrors(cause, options, deep);
+    if (errors !== void 0) {
+      message += `
+${errors}`;
+    }
+  }
+  return `
+${message}`;
+};
+const getStacktrace = (stack, options) => (stack.length > 0 ? "\n" : "") + stack.map((frame) => getMainFrame(frame, options)).join("\n");
+const internalRenderError = (error, options, deep) => {
+  const config = {
+    cwd: cwd(),
+    displayShortPath: false,
+    filterStacktrace: void 0,
+    framesMaxLimit: Number.POSITIVE_INFINITY,
+    hideErrorCauseCodeView: false,
+    hideErrorCodeView: false,
+    hideErrorErrorsCodeView: false,
+    hideErrorTitle: false,
+    hideMessage: false,
+    indentation: 4,
+    linesAbove: 2,
+    linesBelow: 3,
+    prefix: "",
+    showGutter: true,
+    showLineNumbers: true,
+    tabWidth: 4,
+    ...options,
+    color: {
+      fileLine: (value) => value,
+      gutter: (value) => value,
+      hint: (value) => value,
+      marker: (value) => value,
+      message: (value) => value,
+      method: (value) => value,
+      title: (value) => value,
+      ...options.color
+    }
+  };
+  const stack = parseStacktrace(error, {
+    filter: options.filterStacktrace,
+    frameLimit: config.framesMaxLimit
+  });
+  const mainFrame = stack.shift();
+  return [
+    options.hideMessage ? void 0 : getMessage(error, config, deep),
+    getHint(error, config, deep),
+    mainFrame ? getMainFrame(mainFrame, config, deep) : void 0,
+    mainFrame && !config.hideErrorCodeView ? getCode(mainFrame, config, deep) : void 0,
+    error instanceof AggregateError ? getErrors(error, config, deep) : void 0,
+    error.cause === void 0 ? void 0 : getCause(error, config, deep),
+    stack.length > 0 ? getStacktrace(stack, config) : void 0
+  ].filter(Boolean).join("\n").replaceAll("\\", "/");
+};
+const renderError = (error, options = {}) => {
+  if (options.framesMaxLimit !== void 0 && options.framesMaxLimit <= 0) {
+    throw new RangeError("The 'framesMaxLimit' option must be a positive number");
+  }
+  return internalRenderError(error, options, 0);
+};
+
+export { renderError };

package/dist/packem_shared/ruleBasedFinder-C2F8rQ30.js

@@ -0,0 +1,207 @@
+const code = (s) => `\`\`\`
+${s.trim()}
+\`\`\``;
+const bash = (s) => `\`\`\`bash
+${s.trim()}
+\`\`\``;
+const ts = (s) => `\`\`\`ts
+${s.trim()}
+\`\`\``;
+const js = (s) => `\`\`\`js
+${s.trim()}
+\`\`\``;
+const has = (message, ...needles) => {
+  const lower = message.toLowerCase();
+  return needles.some((n) => lower.includes(n.toLowerCase()));
+};
+const rules = [
+  {
+    name: "esm-cjs-interop",
+    test: (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;
+    }
+  },
+  {
+    name: "missing-default-export",
+    test: (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;
+    }
+  },
+  {
+    name: "port-in-use",
+    test: (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;
+    }
+  },
+  {
+    name: "file-not-found-or-case",
+    test: (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;
+    }
+  },
+  {
+    name: "ts-path-mapping",
+    test: (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;
+    }
+  },
+  {
+    name: "network-dns-enotfound",
+    test: (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;
+    }
+  },
+  {
+    name: "undefined-property",
+    test: (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;
+    }
+  }
+];
+const ruleBasedFinder = {
+  handle: 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.toSorted((a, b) => (a.match.priority || 0) - (b.match.priority || 0)).map((m) => `#### ${m.match.title}
+
+${m.match.md}`).join("\n\n---\n\n");
+      if (sections === "") {
+        return void 0;
+      }
+      return { body: sections, header: "### Potential fixes detected" };
+    } catch {
+      return void 0;
+    }
+  },
+  name: "ruleBasedHints",
+  priority: 0
+};
+
+export { ruleBasedFinder as default };