@visulima/error 4.4.18 → 4.6.0

package/dist/packem_shared/aiFinder-CFHvOjD8.mjs

@@ -0,0 +1,257 @@
+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-BaN1M990.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: {
+      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");
+}, "generateCacheKey");
+const getCacheDirectory = /* @__PURE__ */ __name((directory) => {
+  if (directory) {
+    return directory;
+  }
+  return join(tmpdir(), "visulima-error-cache");
+}, "getCacheDirectory");
+const ensureCacheDirectory = /* @__PURE__ */ __name((cacheDirectory) => {
+  if (!existsSync(cacheDirectory)) {
+    mkdirSync(cacheDirectory, { recursive: true });
+  }
+}, "ensureCacheDirectory");
+const getCacheFilePath = /* @__PURE__ */ __name((cacheDirectory, key) => join(cacheDirectory, `${key}.json`), "getCacheFilePath");
+const readFromCache = /* @__PURE__ */ __name((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;
+  }
+}, "readFromCache");
+const writeToCache = /* @__PURE__ */ __name((cacheFilePath, solution, ttl) => {
+  try {
+    const cacheEntry = {
+      solution,
+      timestamp: Date.now(),
+      ttl
+    };
+    writeFileSync(cacheFilePath, JSON.stringify(cacheEntry, null, 2), "utf8");
+  } 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;
+      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;
+      }
+    }, "handle"),
+    name: "AI SDK",
+    priority: 99
+  };
+}, "aiFinder");
+
+export { aiFinder as default };

package/dist/packem_shared/aiSolutionResponse-BaN1M990.mjs

@@ -0,0 +1,36 @@
+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.slice(adjustedStartPosition, endPosition).trim();
+}, "between");
+const aiSolutionResponse = /* @__PURE__ */ __name((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.`;
+}, "aiSolutionResponse");
+
+export { aiSolutionResponse as default };

package/dist/packem_shared/aiSolutionResponse-Cqi0mFxy.cjs

@@ -0,0 +1,38 @@
+'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.slice(adjustedStartPosition, endPosition).trim();
+}, "between");
+const aiSolutionResponse = /* @__PURE__ */ __name((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.`;
+}, "aiSolutionResponse");
+
+module.exports = aiSolutionResponse;

package/dist/packem_shared/deserializeError-Be3qOGBQ.cjs

@@ -0,0 +1,120 @@
+'use strict';
+
+const index = require('./index-C53Tqb7g.cjs');
+const addKnownErrorConstructor = require('./addKnownErrorConstructor-J1_ZUURa.cjs');
+const NonError = require('./NonError-DqwGL5Cy.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const defaultOptions = {
+  maxDepth: Number.POSITIVE_INFINITY
+};
+const deserializePlainObject = /* @__PURE__ */ __name((object, options, depth = 0) => {
+  if (addKnownErrorConstructor.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));
+}, "deserializePlainObject");
+const reconstructAggregateError = /* @__PURE__ */ __name((Constructor, errors, message, options, depth) => {
+  const reconstructedErrors = errors.map((error_) => deserializeValue(error_, options, depth + 1));
+  return new Constructor(reconstructedErrors, message);
+}, "reconstructAggregateError");
+const reconstructError = /* @__PURE__ */ __name((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 = addKnownErrorConstructor.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;
+}, "reconstructError");
+const deserializeValue = /* @__PURE__ */ __name((value, options, depth) => {
+  if (index.isPlainObject(value)) {
+    return deserializePlainObject(value, options, depth);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => deserializeValue(item, options, depth));
+  }
+  return value;
+}, "deserializeValue");
+const restoreErrorProperties = /* @__PURE__ */ __name((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);
+    }
+  }
+}, "restoreErrorProperties");
+const makePropertiesEnumerable = /* @__PURE__ */ __name((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
+        });
+      }
+    }
+  }
+}, "makePropertiesEnumerable");
+const handlePrimitive = /* @__PURE__ */ __name((value) => new NonError(JSON.stringify(value)), "handlePrimitive");
+const handleArray = /* @__PURE__ */ __name((value) => new NonError(JSON.stringify(value)), "handleArray");
+const handlePlainObject = /* @__PURE__ */ __name((value, config) => {
+  if (addKnownErrorConstructor.isErrorLike(value)) {
+    return reconstructError(value, config, 0);
+  }
+  return deserializePlainObject(value, config);
+}, "handlePlainObject");
+const deserialize = /* @__PURE__ */ __name((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 (addKnownErrorConstructor.isErrorLike(value)) {
+    return reconstructError(value, config, 0);
+  }
+  if (index.isPlainObject(value)) {
+    return handlePlainObject(value, config);
+  }
+  return new NonError(JSON.stringify(value));
+}, "deserialize");
+
+module.exports = deserialize;

package/dist/packem_shared/deserializeError-DuzHucBb.mjs

@@ -0,0 +1,118 @@
+import { i as isPlainObject } from './index-BmoOJLvu.mjs';
+import { isErrorLike, getErrorConstructor } from './addKnownErrorConstructor-DBmmT2OF.mjs';
+import NonError from './NonError-BrwMc2LE.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const defaultOptions = {
+  maxDepth: Number.POSITIVE_INFINITY
+};
+const deserializePlainObject = /* @__PURE__ */ __name((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));
+}, "deserializePlainObject");
+const reconstructAggregateError = /* @__PURE__ */ __name((Constructor, errors, message, options, depth) => {
+  const reconstructedErrors = errors.map((error_) => deserializeValue(error_, options, depth + 1));
+  return new Constructor(reconstructedErrors, message);
+}, "reconstructAggregateError");
+const reconstructError = /* @__PURE__ */ __name((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;
+}, "reconstructError");
+const deserializeValue = /* @__PURE__ */ __name((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;
+}, "deserializeValue");
+const restoreErrorProperties = /* @__PURE__ */ __name((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);
+    }
+  }
+}, "restoreErrorProperties");
+const makePropertiesEnumerable = /* @__PURE__ */ __name((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
+        });
+      }
+    }
+  }
+}, "makePropertiesEnumerable");
+const handlePrimitive = /* @__PURE__ */ __name((value) => new NonError(JSON.stringify(value)), "handlePrimitive");
+const handleArray = /* @__PURE__ */ __name((value) => new NonError(JSON.stringify(value)), "handleArray");
+const handlePlainObject = /* @__PURE__ */ __name((value, config) => {
+  if (isErrorLike(value)) {
+    return reconstructError(value, config, 0);
+  }
+  return deserializePlainObject(value, config);
+}, "handlePlainObject");
+const deserialize = /* @__PURE__ */ __name((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));
+}, "deserialize");
+
+export { deserialize 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 };