@visulima/error 5.0.3 → 5.0.4

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## @visulima/error [5.0.4](https://github.com/visulima/visulima/compare/@visulima/error@5.0.3...@visulima/error@5.0.4) (2025-11-07)
+
+### Bug Fixes
+
+* update TypeScript configurations and improve linting across multiple packages ([6f25ec7](https://github.com/visulima/visulima/commit/6f25ec7841da7246f8f9166efc5292a7089d37ee))
+
+### Miscellaneous Chores
+
+* update npm and pnpm configurations for monorepo optimization ([#564](https://github.com/visulima/visulima/issues/564)) ([5512b42](https://github.com/visulima/visulima/commit/5512b42f672c216b6a3c9e39035199a4ebd9a4b8))
+
+
+### Dependencies
+
+* **@visulima/path:** upgraded to 2.0.3
+
 ## @visulima/error [5.0.3](https://github.com/visulima/visulima/compare/@visulima/error@5.0.2...@visulima/error@5.0.3) (2025-11-05)
 
 ### Bug Fixes

package/dist/code-frame/index.js

@@ -1,6 +1,125 @@
-var M=Object.defineProperty;var v=(t,e)=>M(t,"name",{value:e,configurable:!0});var F=Object.defineProperty,P=v((t,e)=>F(t,"name",{value:e,configurable:!0}),"r$1");const E=P(t=>t.replaceAll(/\r\n|\r(?!\n)|\n/gu,`
-`),"normalizeLF"),S=globalThis.process||Object.create(null),y={versions:{}},k=new Proxy(S,{get(t,e){if(e in t)return t[e];if(e in y)return y[e]}});var W=Object.defineProperty,T=v((t,e)=>W(t,"name",{value:e,configurable:!0}),"b");const _=T((t,e,h,n)=>{const f={column:0,line:-1,...t.start},i={...f,...t.end},o=f.line,l=f.column,u=i.line,m=i.column;let g=Math.max(o-(h+1),0),p=Math.min(e.length,u+n);o===-1&&(g=0),u===-1&&(p=e.length);const b=u-o,a={};if(b)for(let r=0;r<=b;r++){const s=r+o;if(!l)a[s]=!0;else if(r===0){const c=e[s-1]?.length;a[s]=[l,(c??0)-l+1]}else if(r===b)a[s]=[0,m];else{const c=e[s-r]?.length;a[s]=[0,c]}}else l===m?a[o]=l?[l,0]:!0:a[o]=[l,(m??0)-(l??0)];return{end:p,markerLines:a,start:g}},"getMarkerLines");var B=Object.defineProperty,$=v((t,e)=>B(t,"name",{value:e,configurable:!0}),"o");const C=k.platform==="win32"&&!k.env?.WT_SESSION?">":"❯",I=$((t,e,h)=>{const n={linesAbove:2,linesBelow:3,prefix:"",showGutter:!0,tabWidth:4,...h,color:{gutter:$(r=>r,"gutter"),marker:$(r=>r,"marker"),message:$(r=>r,"message"),...h?.color}},f=e.start&&typeof e.start.column=="number";let i=E(t).split(`
-`);typeof n?.tabWidth=="number"&&(i=i.map(r=>r.replaceAll("	"," ".repeat(n.tabWidth))));const{end:o,markerLines:l,start:u}=_(e,i,n.linesAbove,n.linesBelow),m=String(o).length,{gutter:g,marker:p,message:b}=n.color;let a=i.slice(u,o).map((r,s)=>{const c=u+1+s,d=l[c],j=` ${c}`.slice(-m),O=!l[c+1],x=` ${j}${n.showGutter?" |":""}`;if(d){let A="";if(Array.isArray(d)){const w=r.replaceAll(/[^\t]/g," ").slice(0,Math.max(d[0]-1,0)),L=d[1]||1;A=[`
- `,n.prefix+g(x.replaceAll(/\d/g," "))," ",w,p("^").repeat(L)].join(""),O&&n.message&&(A+=` ${b(n.message)}`)}return[n.prefix+p(C),g(x),r.length>0?` ${r}`:"",A].join("")}return`${n.prefix} ${g(x)}${r.length>0?` ${r}`:""}`}).join(`
-`);return n.message&&!f&&(a=`${n.prefix+" ".repeat(m+1)+n.message}
-${a}`),a},"codeFrame");export{C as CODE_FRAME_POINTER,I as codeFrame};
+const normalizeLF = (code) => code.replaceAll(/\r\n|\r(?!\n)|\n/gu, "\n");
+
+const _process = globalThis.process || /* @__PURE__ */ Object.create(null);
+const processShims = {
+  versions: {}
+};
+const process = new Proxy(_process, {
+  get(target, property) {
+    if (property in target) {
+      return target[property];
+    }
+    if (property in processShims) {
+      return processShims[property];
+    }
+    return void 0;
+  }
+});
+
+const getMarkerLines = (loc, source, linesAbove, linesBelow) => {
+  const startLoc = {
+    column: 0,
+    // @ts-expect-error Can be overwritten
+    line: -1,
+    ...loc.start
+  };
+  const endLoc = {
+    ...startLoc,
+    ...loc.end
+  };
+  const startLine = startLoc.line;
+  const startColumn = startLoc.column;
+  const endLine = endLoc.line;
+  const endColumn = endLoc.column;
+  let start = Math.max(startLine - (linesAbove + 1), 0);
+  let end = Math.min(source.length, endLine + linesBelow);
+  if (startLine === -1) {
+    start = 0;
+  }
+  if (endLine === -1) {
+    end = source.length;
+  }
+  const lineDiff = endLine - startLine;
+  const markerLines = {};
+  if (lineDiff) {
+    for (let index = 0; index <= lineDiff; index++) {
+      const lineNumber = index + startLine;
+      if (!startColumn) {
+        markerLines[lineNumber] = true;
+      } else if (index === 0) {
+        const sourceLength = source[lineNumber - 1]?.length;
+        markerLines[lineNumber] = [startColumn, (sourceLength ?? 0) - startColumn + 1];
+      } else if (index === lineDiff) {
+        markerLines[lineNumber] = [0, endColumn];
+      } else {
+        const sourceLength = source[lineNumber - index]?.length;
+        markerLines[lineNumber] = [0, sourceLength];
+      }
+    }
+  } else if (startColumn === endColumn) {
+    markerLines[startLine] = startColumn ? [startColumn, 0] : true;
+  } else {
+    markerLines[startLine] = [startColumn, (endColumn ?? 0) - (startColumn ?? 0)];
+  }
+  return { end, markerLines, start };
+};
+
+const CODE_FRAME_POINTER = process.platform === "win32" && !process.env?.WT_SESSION ? ">" : "❯";
+const codeFrame = (source, loc, options) => {
+  const config = {
+    // grab 2 lines before, and 3 lines after focused line
+    linesAbove: 2,
+    linesBelow: 3,
+    prefix: "",
+    showGutter: true,
+    tabWidth: 4,
+    ...options,
+    color: {
+      gutter: (value) => value,
+      marker: (value) => value,
+      message: (value) => value,
+      ...options?.color
+    }
+  };
+  const hasColumns = loc.start && typeof loc.start.column === "number";
+  let lines = normalizeLF(source).split("\n");
+  if (typeof config?.tabWidth === "number") {
+    lines = lines.map((ln) => ln.replaceAll("	", " ".repeat(config.tabWidth)));
+  }
+  const { end, markerLines, start } = getMarkerLines(loc, lines, config.linesAbove, config.linesBelow);
+  const numberMaxWidth = String(end).length;
+  const { gutter: colorizeGutter, marker: colorizeMarker, message: colorizeMessage } = config.color;
+  let frame = lines.slice(start, end).map((line, index) => {
+    const number = start + 1 + index;
+    const hasMarker = markerLines[number];
+    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+    const lastMarkerLine = !markerLines[number + 1];
+    const gutter = ` ${paddedNumber}${config.showGutter ? " |" : ""}`;
+    if (hasMarker) {
+      let markerLine = "";
+      if (Array.isArray(hasMarker)) {
+        const markerSpacing = line.replaceAll(/[^\t]/g, " ").slice(0, Math.max(hasMarker[0] - 1, 0));
+        const numberOfMarkers = hasMarker[1] || 1;
+        markerLine = [
+          "\n ",
+          config.prefix + colorizeGutter(gutter.replaceAll(/\d/g, " ")),
+          " ",
+          markerSpacing,
+          colorizeMarker("^").repeat(numberOfMarkers)
+        ].join("");
+        if (lastMarkerLine && config.message) {
+          markerLine += ` ${colorizeMessage(config.message)}`;
+        }
+      }
+      return [config.prefix + colorizeMarker(CODE_FRAME_POINTER), colorizeGutter(gutter), line.length > 0 ? ` ${line}` : "", markerLine].join("");
+    }
+    return `${config.prefix} ${colorizeGutter(gutter)}${line.length > 0 ? ` ${line}` : ""}`;
+  }).join("\n");
+  if (config.message && !hasColumns) {
+    frame = `${config.prefix + " ".repeat(numberMaxWidth + 1) + config.message}
+${frame}`;
+  }
+  return frame;
+};
+
+export { CODE_FRAME_POINTER, codeFrame };

package/dist/error/index.js

@@ -1 +1,8 @@
-import{default as e}from"../packem_shared/captureRawStackTrace-CQPNHvBG.js";import{default as t}from"../packem_shared/getErrorCauses-geeK5cwE.js";import{renderError as i}from"../packem_shared/renderError-ZMlMvw1N.js";import{default as m}from"../packem_shared/deserializeError-BJM8Kd6G.js";import{addKnownErrorConstructor as p,isErrorLike as u}from"../packem_shared/addKnownErrorConstructor-BqqnTSZp.js";import{default as d}from"../packem_shared/NonError-CS10kwil.js";import{serialize as n}from"../packem_shared/serializeError-CTpDr3CL.js";import{VisulimaError as z,isVisulimaError as k}from"../packem_shared/isVisulimaError-jVZgumOU.js";export{d as NonError,z as VisulimaError,p as addKnownErrorConstructor,e as captureRawStackTrace,m as deserializeError,t as getErrorCauses,u as isErrorLike,k as isVisulimaError,i as renderError,n as serializeError};
+export { default as captureRawStackTrace } from '../packem_shared/captureRawStackTrace-ySw7cU0U.js';
+export { default as getErrorCauses } from '../packem_shared/getErrorCauses-DpUsmuqw.js';
+export { renderError } from '../packem_shared/renderError-C30PRFtU.js';
+export { default as deserializeError } from '../packem_shared/deserializeError-E0VQnnm0.js';
+export { addKnownErrorConstructor, isErrorLike } from '../packem_shared/addKnownErrorConstructor-s_3SsXtQ.js';
+export { default as NonError } from '../packem_shared/NonError-D5FGLYKY.js';
+export { serialize as serializeError } from '../packem_shared/serializeError-BZ62KiYZ.js';
+export { VisulimaError, isVisulimaError } from '../packem_shared/isVisulimaError-DA7QsCxH.js';

package/dist/index.js

@@ -1 +1,16 @@
-import{CODE_FRAME_POINTER as o,codeFrame as a}from"./code-frame/index.js";import{default as f}from"./packem_shared/indexToLineColumn-B1F7aNZh.js";import{default as m}from"./solution/ai/ai-prompt.js";import{default as p}from"./packem_shared/aiSolutionResponse-RD0AK1jh.js";import{default as l}from"./packem_shared/errorHintFinder-C_g0nvml.js";import{default as x}from"./packem_shared/ruleBasedFinder-P88d0gpK.js";import{default as E}from"./packem_shared/captureRawStackTrace-CQPNHvBG.js";import{default as k}from"./packem_shared/deserializeError-BJM8Kd6G.js";import{default as S}from"./packem_shared/getErrorCauses-geeK5cwE.js";import{default as R}from"./packem_shared/NonError-CS10kwil.js";import{default as L}from"./packem_shared/parseStacktrace-Dnxnc4PL.js";import{addKnownErrorConstructor as w,isErrorLike as N}from"./packem_shared/addKnownErrorConstructor-BqqnTSZp.js";import{VisulimaError as P,isVisulimaError as V}from"./packem_shared/isVisulimaError-jVZgumOU.js";import{renderError as g}from"./packem_shared/renderError-ZMlMvw1N.js";import{serialize as B}from"./packem_shared/serializeError-CTpDr3CL.js";import{formatStackFrameLine as H,formatStacktrace as I}from"./packem_shared/formatStackFrameLine-iU54KA81.js";export{o as CODE_FRAME_POINTER,R as NonError,P as VisulimaError,w as addKnownErrorConstructor,m as aiPrompt,p as aiSolutionResponse,E as captureRawStackTrace,a as codeFrame,k as deserializeError,l as errorHintFinder,H as formatStackFrameLine,I as formatStacktrace,S as getErrorCauses,f as indexToLineColumn,N as isErrorLike,V as isVisulimaError,L as parseStacktrace,g as renderError,x as ruleBasedFinder,B as serializeError};
+export { CODE_FRAME_POINTER, codeFrame } from './code-frame/index.js';
+export { default as indexToLineColumn } from './packem_shared/indexToLineColumn-Bg8UW1bU.js';
+export { default as aiPrompt } from './solution/ai/ai-prompt.js';
+export { default as aiSolutionResponse } from './packem_shared/aiSolutionResponse-CJBMLS9t.js';
+export { default as errorHintFinder } from './packem_shared/errorHintFinder-DEaeRnRW.js';
+export { default as ruleBasedFinder } from './packem_shared/ruleBasedFinder-C2F8rQ30.js';
+export { default as captureRawStackTrace } from './packem_shared/captureRawStackTrace-ySw7cU0U.js';
+export { default as deserializeError } from './packem_shared/deserializeError-E0VQnnm0.js';
+export { default as getErrorCauses } from './packem_shared/getErrorCauses-DpUsmuqw.js';
+export { default as NonError } from './packem_shared/NonError-D5FGLYKY.js';
+export { default as parseStacktrace } from './packem_shared/parseStacktrace-oQvk7wYp.js';
+export { addKnownErrorConstructor, isErrorLike } from './packem_shared/addKnownErrorConstructor-s_3SsXtQ.js';
+export { VisulimaError, isVisulimaError } from './packem_shared/isVisulimaError-DA7QsCxH.js';
+export { renderError } from './packem_shared/renderError-C30PRFtU.js';
+export { serialize as serializeError } from './packem_shared/serializeError-BZ62KiYZ.js';
+export { formatStackFrameLine, formatStacktrace } from './packem_shared/formatStackFrameLine-D3_6oSWZ.js';

package/dist/packem_shared/NonError-D5FGLYKY.js

@@ -0,0 +1,8 @@
+class NonError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NonError";
+  }
+}
+
+export { NonError as default };

package/dist/packem_shared/addKnownErrorConstructor-s_3SsXtQ.js

@@ -0,0 +1,30 @@
+const defaultErrorConstructors = /* @__PURE__ */ new Map([
+  ["Error", Error],
+  ["EvalError", EvalError],
+  ["RangeError", RangeError],
+  ["ReferenceError", ReferenceError],
+  ["SyntaxError", SyntaxError],
+  ["TypeError", TypeError],
+  ["URIError", URIError]
+]);
+if (typeof AggregateError !== "undefined") {
+  defaultErrorConstructors.set("AggregateError", AggregateError);
+}
+const addKnownErrorConstructor = (constructor, name) => {
+  let instance;
+  try {
+    instance = new constructor();
+  } catch (error) {
+    throw new Error(`The error constructor "${constructor.name}" is not compatible`, { cause: error });
+  }
+  const resolvedName = name ?? instance.name;
+  if (defaultErrorConstructors.has(resolvedName)) {
+    throw new Error(`The error constructor "${resolvedName}" is already known.`);
+  }
+  defaultErrorConstructors.set(resolvedName, constructor);
+};
+const getKnownErrorConstructors = () => new Map(defaultErrorConstructors);
+const getErrorConstructor = (name) => defaultErrorConstructors.get(name);
+const isErrorLike = (value) => value !== null && typeof value === "object" && typeof value.name === "string" && typeof value.message === "string" && (getErrorConstructor(value.name) !== void 0 || value.name === "Error");
+
+export { addKnownErrorConstructor, getErrorConstructor, getKnownErrorConstructors, isErrorLike };

package/dist/packem_shared/aiFinder-HftEgsry.js

@@ -0,0 +1,277 @@
+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 {
+  createHash
+} = __cjs_getBuiltinModule("node:crypto");
+const {
+  existsSync,
+  readFileSync,
+  mkdirSync,
+  writeFileSync
+} = __cjs_getBuiltinModule("node:fs");
+const {
+  tmpdir
+} = __cjs_getBuiltinModule("node:os");
+import { generateText } from 'ai';
+import aiPrompt from '../solution/ai/ai-prompt.js';
+import aiSolutionResponse from './aiSolutionResponse-CJBMLS9t.js';
+
+const DRIVE_LETTER_START_RE = /^[A-Z]:\//i;
+const normalizeWindowsPath = (input = "") => {
+  if (!input) {
+    return input;
+  }
+  return input.replaceAll("\\", "/").replace(DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+};
+const UNC_REGEX = /^[/\\]{2}/;
+const IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Z]:[/\\]/i;
+const DRIVE_LETTER_RE = /^[A-Z]:$/i;
+const normalizeString = (path2, allowAboveRoot) => {
+  let result = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char;
+  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;
+};
+const isAbsolute = (path2) => IS_ABSOLUTE_RE.test(path2);
+const normalize = 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;
+};
+const join = (...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);
+};
+
+const DEFAULT_HEADER = "## Ai Generated Solution";
+const DEFAULT_ERROR_MESSAGE = "Creation of a AI solution failed.";
+const generateCacheKey = (error, file, temperature) => {
+  const keyData = {
+    error: {
+      message: error.message,
+      name: error.name,
+      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");
+};
+const getCacheDirectory = (directory) => {
+  if (directory) {
+    return directory;
+  }
+  return join(tmpdir(), "visulima-error-cache");
+};
+const ensureCacheDirectory = (cacheDirectory) => {
+  if (!existsSync(cacheDirectory)) {
+    mkdirSync(cacheDirectory, { recursive: true });
+  }
+};
+const getCacheFilePath = (cacheDirectory, key) => join(cacheDirectory, `${key}.json`);
+const readFromCache = (cacheFilePath, ttl) => {
+  try {
+    if (!existsSync(cacheFilePath)) {
+      return void 0;
+    }
+    const cacheContent = readFileSync(cacheFilePath, "utf8");
+    const cacheEntry = JSON.parse(cacheContent);
+    const now = Date.now();
+    if (now - cacheEntry.timestamp > ttl) {
+      return void 0;
+    }
+    return cacheEntry.solution;
+  } catch {
+    return void 0;
+  }
+};
+const writeToCache = (cacheFilePath, solution, ttl) => {
+  try {
+    const cacheEntry = {
+      solution,
+      timestamp: Date.now(),
+      ttl
+    };
+    writeFileSync(cacheFilePath, JSON.stringify(cacheEntry, null, 2), "utf8");
+  } catch {
+  }
+};
+const aiFinder = (model, options) => {
+  return {
+    handle: async (error, file) => {
+      const cacheOptions = options?.cache;
+      const temperature = options?.temperature ?? 0;
+      const ttl = cacheOptions?.ttl ?? 24 * 60 * 60 * 1e3;
+      const cacheDirectory = getCacheDirectory(cacheOptions?.directory);
+      if (cacheOptions?.enabled !== false) {
+        const cacheKey = generateCacheKey(error, file, temperature);
+        const cacheFilePath = getCacheFilePath(cacheDirectory, cacheKey);
+        const cachedSolution = readFromCache(cacheFilePath, ttl);
+        if (cachedSolution) {
+          return cachedSolution;
+        }
+        ensureCacheDirectory(cacheDirectory);
+      }
+      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(messageContent),
+            header: DEFAULT_HEADER
+          };
+        } else {
+          solution = {
+            body: aiSolutionResponse(DEFAULT_ERROR_MESSAGE),
+            header: DEFAULT_HEADER
+          };
+        }
+        if (cacheOptions?.enabled !== false) {
+          const cacheKey = generateCacheKey(error, file, temperature);
+          const cacheFilePath = getCacheFilePath(cacheDirectory, 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 cacheFilePath = getCacheFilePath(cacheDirectory, cacheKey);
+          writeToCache(cacheFilePath, solution, ttl);
+        }
+        return solution;
+      }
+    },
+    name: "AI SDK",
+    priority: 99
+  };
+};
+
+export { aiFinder as default };

package/dist/packem_shared/aiSolutionResponse-CJBMLS9t.js

@@ -0,0 +1,34 @@
+const between = (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.slice(adjustedStartPosition, endPosition).trim();
+};
+const aiSolutionResponse = (rawText) => {
+  const description = between("FIX", "ENDFIX", rawText);
+  if (!description) {
+    return [
+      "No solution found.",
+      // eslint-disable-next-line no-secrets/no-secrets
+      `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.`;
+};
+
+export { aiSolutionResponse as default };

package/dist/packem_shared/captureRawStackTrace-ySw7cU0U.js

@@ -0,0 +1,10 @@
+const captureRawStackTrace = () => {
+  if (!Error.captureStackTrace) {
+    return void 0;
+  }
+  const stack = new Error();
+  Error.captureStackTrace(stack);
+  return stack.stack;
+};
+
+export { captureRawStackTrace as default };

package/dist/packem_shared/deserializeError-E0VQnnm0.js

@@ -0,0 +1,116 @@
+import { i as isPlainObject } from './index-y_UPkY2Z.js';
+import { isErrorLike, getErrorConstructor } from './addKnownErrorConstructor-s_3SsXtQ.js';
+import NonError from './NonError-D5FGLYKY.js';
+
+const defaultOptions = {
+  maxDepth: Number.POSITIVE_INFINITY
+};
+const deserializePlainObject = (object, options, depth = 0) => {
+  if (isErrorLike(object)) {
+    return reconstructError(object, options, depth);
+  }
+  if (options.maxDepth !== void 0 && depth >= options.maxDepth) {
+    return new NonError(JSON.stringify(object));
+  }
+  return new NonError(JSON.stringify(object));
+};
+const reconstructAggregateError = (Constructor, errors, message, options, depth) => {
+  const reconstructedErrors = errors.map((error_) => deserializeValue(error_, options, depth + 1));
+  return new Constructor(reconstructedErrors, message);
+};
+const reconstructError = (serialized, options, depth) => {
+  if (options.maxDepth !== void 0 && depth >= options.maxDepth) {
+    return new NonError(JSON.stringify(serialized));
+  }
+  const { cause, errors, message, name, stack, ...properties } = serialized;
+  const Constructor = getErrorConstructor(name) || Error;
+  const error = name === "AggregateError" && Array.isArray(errors) ? reconstructAggregateError(Constructor, errors, message, options, depth) : new Constructor(message);
+  if (!error.name && name) {
+    error.name = name;
+  }
+  if (message !== void 0) {
+    error.message = message;
+  }
+  if (stack) {
+    error.stack = stack;
+  }
+  restoreErrorProperties(error, properties, cause, name, options, depth);
+  if (cause !== void 0) {
+    error.cause = deserializeValue(cause, options, depth + 1);
+  }
+  makePropertiesEnumerable(error, serialized);
+  return error;
+};
+const deserializeValue = (value, options, depth) => {
+  if (isPlainObject(value)) {
+    return deserializePlainObject(value, options, depth);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => deserializeValue(item, options, depth));
+  }
+  return value;
+};
+const restoreErrorProperties = (error, properties, cause, name, options, depth) => {
+  const errorCopy = error;
+  for (const [key, value] of Object.entries(properties)) {
+    if (key === "cause" && cause !== void 0) {
+      continue;
+    } else if (key === "errors" && name === "AggregateError") {
+      continue;
+    } else {
+      errorCopy[key] = deserializeValue(value, options, depth + 1);
+    }
+  }
+};
+const makePropertiesEnumerable = (error, serialized) => {
+  const errorProperties = /* @__PURE__ */ new Set();
+  errorProperties.add("name");
+  errorProperties.add("message");
+  errorProperties.add("stack");
+  for (const key of Object.keys(serialized)) {
+    errorProperties.add(key);
+  }
+  for (const key of errorProperties) {
+    if (key in error) {
+      const descriptor = Object.getOwnPropertyDescriptor(error, key);
+      if (descriptor && !descriptor.enumerable) {
+        Object.defineProperty(error, key, {
+          ...descriptor,
+          enumerable: true
+        });
+      }
+    }
+  }
+};
+const handlePrimitive = (value) => new NonError(JSON.stringify(value));
+const handleArray = (value) => new NonError(JSON.stringify(value));
+const handlePlainObject = (value, config) => {
+  if (isErrorLike(value)) {
+    return reconstructError(value, config, 0);
+  }
+  return deserializePlainObject(value, config);
+};
+const deserialize = (value, options = {}) => {
+  const config = { ...defaultOptions, ...options };
+  if (value instanceof Error) {
+    return value;
+  }
+  if (value === null) {
+    return handlePrimitive(null);
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return handlePrimitive(value);
+  }
+  if (Array.isArray(value)) {
+    return handleArray(value);
+  }
+  if (isErrorLike(value)) {
+    return reconstructError(value, config, 0);
+  }
+  if (isPlainObject(value)) {
+    return handlePlainObject(value, config);
+  }
+  return new NonError(JSON.stringify(value));
+};
+
+export { deserialize as default };