@visulima/error 4.5.0 → 4.6.0

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## @visulima/error [4.6.0](https://github.com/visulima/visulima/compare/@visulima/error@4.5.0...@visulima/error@4.6.0) (2025-09-12)
+
+### Features
+
+* **error:** enhance error constructor handling and serialization tests ([036ba31](https://github.com/visulima/visulima/commit/036ba31acb182e9fa8c6e0b78ea10cf9f57c75f3))
+* **error:** enhance error serialization and deserialization functionality ([3b07347](https://github.com/visulima/visulima/commit/3b073474807b40c65f692b037fccc6fe152cdc5b))
+
+### Bug Fixes
+
+* **error:** enhance error serialization tests to preserve serialized values ([5ab8db3](https://github.com/visulima/visulima/commit/5ab8db3968142313b2f5c48b13605b843a1f0a1e))
+
+### Miscellaneous Chores
+
+* update dependencies and fix linting issues ([0e802fe](https://github.com/visulima/visulima/commit/0e802fe02bb9ed791659cb5f3c77605ae5b42ec8))
+
 ## @visulima/error [4.5.0](https://github.com/visulima/visulima/compare/@visulima/error@4.4.18...@visulima/error@4.5.0) (2025-09-07)
 
 ### Features

package/README.md

@@ -267,11 +267,11 @@ const firstLine = formatStackFrameLine(frames[0]);
 #### API
 
 - `stringifyStackFrames(frames, options?)`
-  - `frames`: `Trace[]` — parsed frames from `parseStacktrace`
-  - `options.header`: `{ name?: string; message?: string }` — optional first-line header
+    - `frames`: `Trace[]` — parsed frames from `parseStacktrace`
+    - `options.header`: `{ name?: string; message?: string }` — optional first-line header
 - `formatStackFrameLine(frame)`
-  - `frame`: `Trace`
-  - returns a single formatted line like `"    at myMethod (/path/file.ts:10:5)"`
+    - `frame`: `Trace`
+    - returns a single formatted line like `"    at myMethod (/path/file.ts:10:5)"`
 
 ## Solutions (finders)
 
@@ -396,6 +396,67 @@ const errorString = JSON.stringify(errorObject);
 const newErrorObject = JSON.parse(errorString);
 ```
 
+## `deserialize` an error object
+
+Deserialize a previously serialized error back to an Error instance.
+
+- Automatically detects error-like objects
+- Reconstructs proper Error instances with correct constructors
+- Handles custom error classes registered with `addKnownErrorConstructor`
+- Supports AggregateError deserialization
+- Preserves error properties and cause chains
+- Wraps non-error-like objects in NonError
+
+```ts
+import { serializeError, deserializeError } from "@visulima/error";
+
+const error = new TypeError("example");
+const serialized = serializeError(error);
+
+// Deserialize back to Error instance
+const deserialized = deserializeError(serialized);
+
+console.log(deserialized instanceof TypeError); // true
+console.log(deserialized.message); // "example"
+```
+
+### Registering Custom Error Constructors
+
+```ts
+import { addKnownErrorConstructor, deserializeError } from "@visulima/error";
+
+class CustomError extends Error {
+    constructor(message: string, code: number) {
+        super(message);
+        this.name = "CustomError";
+        this.code = code;
+    }
+}
+
+// Register the custom error constructor
+addKnownErrorConstructor(CustomError);
+
+// Now it can be deserialized properly
+const serialized = { name: "CustomError", message: "test", code: 42 };
+const deserialized = deserializeError(serialized);
+
+console.log(deserialized instanceof CustomError); // true
+console.log(deserialized.code); // 42
+```
+
+### NonError for Non-Error Objects
+
+When deserializing objects that don't look like errors, they're wrapped in a `NonError`:
+
+```ts
+import { deserializeError, NonError } from "@visulima/error";
+
+const deserialized = deserializeError({ foo: "bar" });
+
+console.log(deserialized instanceof NonError); // true
+console.log(deserialized.message); // '{"foo":"bar"}'
+```
+
 ## renderError - pretty print an error
 
 ```ts
@@ -492,6 +553,89 @@ Default: `false`
 
 Hide the error message.
 
+### `deserializeError`
+
+Deserialize a value back to its original form. If the value looks like a serialized error, it will be reconstructed as an Error instance. Otherwise, it will be wrapped in a NonError.
+
+```ts
+import { deserializeError } from "@visulima/error";
+
+const deserialized = deserializeError({ name: "TypeError", message: "example" });
+
+console.log(deserialized instanceof TypeError); // true
+```
+
+#### value
+
+Type: `unknown`
+
+The value to deserialize.
+
+#### options
+
+Type: `object`
+
+##### options.maxDepth
+
+Type: `number` \
+Default: `Number.POSITIVE_INFINITY`
+
+The maximum depth to deserialize nested objects.
+
+### `NonError`
+
+A class for wrapping non-error-like objects during deserialization.
+
+```ts
+import { NonError } from "@visulima/error";
+
+const nonError = new NonError("some message");
+
+console.log(nonError instanceof Error); // true
+console.log(nonError.name); // "NonError"
+```
+
+### `addKnownErrorConstructor`
+
+Add a known error constructor to the registry for proper deserialization.
+
+```ts
+import { addKnownErrorConstructor } from "@visulima/error";
+
+class CustomError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = "CustomError";
+    }
+}
+
+addKnownErrorConstructor(CustomError);
+```
+
+#### constructor
+
+Type: `new (...args: unknown[]) => Error`
+
+The error constructor to add to the registry.
+
+### `isErrorLike`
+
+Check if an object looks like a serialized error.
+
+```ts
+import { isErrorLike } from "@visulima/error";
+
+const obj = { name: "TypeError", message: "example" };
+
+console.log(isErrorLike(obj)); // true
+```
+
+#### value
+
+Type: `unknown`
+
+The value to check.
+
 ### captureRawStackTrace
 
 Capture a raw stack trace.

package/dist/code-frame/index.cjs

@@ -102,9 +102,9 @@ const codeFrame = /* @__PURE__ */ __name((source, loc, options) => {
   let frame = lines.slice(start, end).map((line, index) => {
     const number = start + 1 + index;
     const hasMarker = markerLines[number];
-    const paddedNumber = (" " + number).slice(-numberMaxWidth);
+    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
     const lastMarkerLine = !markerLines[number + 1];
-    const gutter = " " + paddedNumber + (config.showGutter ? " |" : "");
+    const gutter = ` ${paddedNumber}${config.showGutter ? " |" : ""}`;
     if (hasMarker) {
       let markerLine = "";
       if (Array.isArray(hasMarker)) {
@@ -121,12 +121,13 @@ const codeFrame = /* @__PURE__ */ __name((source, loc, options) => {
           markerLine += ` ${colorizeMessage(config.message)}`;
         }
       }
-      return [config.prefix + colorizeMarker(CODE_FRAME_POINTER), colorizeGutter(gutter), line.length > 0 ? " " + line : "", markerLine].join("");
+      return [config.prefix + colorizeMarker(CODE_FRAME_POINTER), colorizeGutter(gutter), line.length > 0 ? ` ${line}` : "", markerLine].join("");
     }
-    return config.prefix + " " + colorizeGutter(gutter) + (line.length > 0 ? " " + line : "");
+    return `${config.prefix} ${colorizeGutter(gutter)}${line.length > 0 ? ` ${line}` : ""}`;
   }).join("\n");
   if (config.message && !hasColumns) {
-    frame = config.prefix + " ".repeat(numberMaxWidth + 1) + config.message + "\n" + frame;
+    frame = `${config.prefix + " ".repeat(numberMaxWidth + 1) + config.message}
+${frame}`;
   }
   return frame;
 }, "codeFrame");

package/dist/code-frame/index.mjs

@@ -98,9 +98,9 @@ const codeFrame = /* @__PURE__ */ __name((source, loc, options) => {
   let frame = lines.slice(start, end).map((line, index) => {
     const number = start + 1 + index;
     const hasMarker = markerLines[number];
-    const paddedNumber = (" " + number).slice(-numberMaxWidth);
+    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
     const lastMarkerLine = !markerLines[number + 1];
-    const gutter = " " + paddedNumber + (config.showGutter ? " |" : "");
+    const gutter = ` ${paddedNumber}${config.showGutter ? " |" : ""}`;
     if (hasMarker) {
       let markerLine = "";
       if (Array.isArray(hasMarker)) {
@@ -117,12 +117,13 @@ const codeFrame = /* @__PURE__ */ __name((source, loc, options) => {
           markerLine += ` ${colorizeMessage(config.message)}`;
         }
       }
-      return [config.prefix + colorizeMarker(CODE_FRAME_POINTER), colorizeGutter(gutter), line.length > 0 ? " " + line : "", markerLine].join("");
+      return [config.prefix + colorizeMarker(CODE_FRAME_POINTER), colorizeGutter(gutter), line.length > 0 ? ` ${line}` : "", markerLine].join("");
     }
-    return config.prefix + " " + colorizeGutter(gutter) + (line.length > 0 ? " " + line : "");
+    return `${config.prefix} ${colorizeGutter(gutter)}${line.length > 0 ? ` ${line}` : ""}`;
   }).join("\n");
   if (config.message && !hasColumns) {
-    frame = config.prefix + " ".repeat(numberMaxWidth + 1) + config.message + "\n" + frame;
+    frame = `${config.prefix + " ".repeat(numberMaxWidth + 1) + config.message}
+${frame}`;
   }
   return frame;
 }, "codeFrame");

package/dist/error/index.cjs

@@ -4,15 +4,22 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 
 const captureRawStackTrace = require('../packem_shared/captureRawStackTrace-ClSI1tHb.cjs');
 const getErrorCauses = require('../packem_shared/getErrorCauses-miTeYJEG.cjs');
-const renderError = require('../packem_shared/renderError-CXZTAXig.cjs');
-const serializeError = require('../packem_shared/serializeError-CT7s0Ffk.cjs');
-const isVisulimaError = require('../packem_shared/isVisulimaError-BVLWvREw.cjs');
+const renderError = require('../packem_shared/renderError-n3kXGdYj.cjs');
+const deserializeError = require('../packem_shared/deserializeError-Be3qOGBQ.cjs');
+const addKnownErrorConstructor = require('../packem_shared/addKnownErrorConstructor-J1_ZUURa.cjs');
+const NonError = require('../packem_shared/NonError-DqwGL5Cy.cjs');
+const serializeError = require('../packem_shared/serializeError-Dt7oFM2R.cjs');
+const isVisulimaError = require('../packem_shared/isVisulimaError-Bb1_TB6w.cjs');
 
 
 
 exports.captureRawStackTrace = captureRawStackTrace;
 exports.getErrorCauses = getErrorCauses;
 exports.renderError = renderError.renderError;
+exports.deserializeError = deserializeError;
+exports.addKnownErrorConstructor = addKnownErrorConstructor.addKnownErrorConstructor;
+exports.isErrorLike = addKnownErrorConstructor.isErrorLike;
+exports.NonError = NonError;
 exports.serializeError = serializeError.serialize;
 exports.VisulimaError = isVisulimaError.VisulimaError;
 exports.isVisulimaError = isVisulimaError.isVisulimaError;

package/dist/error/index.d.cts

@@ -54,6 +54,20 @@ type Options$1 = Omit<CodeFrameOptions, "message | prefix"> & {
 };
 declare const renderError: (error: AggregateError | Error | VisulimaError, options?: Partial<Options$1>) => string;
 
+interface DeserializeOptions {
+    maxDepth?: number;
+}
+type DeserializeOptionsType = DeserializeOptions;
+declare const deserialize: (value: unknown, options?: DeserializeOptionsType) => Error;
+
+type ErrorConstructor = new (...arguments_: any[]) => Error;
+declare const addKnownErrorConstructor: (constructor: ErrorConstructor, name?: string) => void;
+declare const isErrorLike: (value: unknown) => value is {
+    message?: string;
+    name?: string;
+    stack?: string;
+};
+
 type SerializedError<ErrorType = Error> = Record<PropertyKey, unknown> & {
     aggregateErrors?: SerializedError<ErrorType>[];
     cause?: unknown;
@@ -64,6 +78,10 @@ type SerializedError<ErrorType = Error> = Record<PropertyKey, unknown> & {
     stack?: string;
 };
 
+declare class NonError extends Error {
+    constructor(message: string);
+}
+
 interface JsonError extends Error {
     toJSON: () => SerializedError;
 }
@@ -74,4 +92,4 @@ type Options = {
 };
 declare const serialize: (error: AggregateError | Error | JsonError, options?: Options) => SerializedError;
 
-export { type ErrorHint, type ErrorLocation, type ErrorProperties, type Options as ErrorWithCauseSerializerOptions, type Options$1 as RenderErrorOptions, type SerializedError, VisulimaError, captureRawStackTrace, getErrorCauses, isVisulimaError, renderError, serialize as serializeError };
+export { type ErrorHint, type ErrorLocation, type ErrorProperties, type Options as ErrorWithCauseSerializerOptions, NonError, type Options$1 as RenderErrorOptions, type SerializedError, VisulimaError, addKnownErrorConstructor, captureRawStackTrace, deserialize as deserializeError, getErrorCauses, isErrorLike, isVisulimaError, renderError, serialize as serializeError };

package/dist/error/index.d.mts

@@ -54,6 +54,20 @@ type Options$1 = Omit<CodeFrameOptions, "message | prefix"> & {
 };
 declare const renderError: (error: AggregateError | Error | VisulimaError, options?: Partial<Options$1>) => string;
 
+interface DeserializeOptions {
+    maxDepth?: number;
+}
+type DeserializeOptionsType = DeserializeOptions;
+declare const deserialize: (value: unknown, options?: DeserializeOptionsType) => Error;
+
+type ErrorConstructor = new (...arguments_: any[]) => Error;
+declare const addKnownErrorConstructor: (constructor: ErrorConstructor, name?: string) => void;
+declare const isErrorLike: (value: unknown) => value is {
+    message?: string;
+    name?: string;
+    stack?: string;
+};
+
 type SerializedError<ErrorType = Error> = Record<PropertyKey, unknown> & {
     aggregateErrors?: SerializedError<ErrorType>[];
     cause?: unknown;
@@ -64,6 +78,10 @@ type SerializedError<ErrorType = Error> = Record<PropertyKey, unknown> & {
     stack?: string;
 };
 
+declare class NonError extends Error {
+    constructor(message: string);
+}
+
 interface JsonError extends Error {
     toJSON: () => SerializedError;
 }
@@ -74,4 +92,4 @@ type Options = {
 };
 declare const serialize: (error: AggregateError | Error | JsonError, options?: Options) => SerializedError;
 
-export { type ErrorHint, type ErrorLocation, type ErrorProperties, type Options as ErrorWithCauseSerializerOptions, type Options$1 as RenderErrorOptions, type SerializedError, VisulimaError, captureRawStackTrace, getErrorCauses, isVisulimaError, renderError, serialize as serializeError };
+export { type ErrorHint, type ErrorLocation, type ErrorProperties, type Options as ErrorWithCauseSerializerOptions, NonError, type Options$1 as RenderErrorOptions, type SerializedError, VisulimaError, addKnownErrorConstructor, captureRawStackTrace, deserialize as deserializeError, getErrorCauses, isErrorLike, isVisulimaError, renderError, serialize as serializeError };

package/dist/error/index.d.ts

@@ -54,6 +54,20 @@ type Options$1 = Omit<CodeFrameOptions, "message | prefix"> & {
 };
 declare const renderError: (error: AggregateError | Error | VisulimaError, options?: Partial<Options$1>) => string;
 
+interface DeserializeOptions {
+    maxDepth?: number;
+}
+type DeserializeOptionsType = DeserializeOptions;
+declare const deserialize: (value: unknown, options?: DeserializeOptionsType) => Error;
+
+type ErrorConstructor = new (...arguments_: any[]) => Error;
+declare const addKnownErrorConstructor: (constructor: ErrorConstructor, name?: string) => void;
+declare const isErrorLike: (value: unknown) => value is {
+    message?: string;
+    name?: string;
+    stack?: string;
+};
+
 type SerializedError<ErrorType = Error> = Record<PropertyKey, unknown> & {
     aggregateErrors?: SerializedError<ErrorType>[];
     cause?: unknown;
@@ -64,6 +78,10 @@ type SerializedError<ErrorType = Error> = Record<PropertyKey, unknown> & {
     stack?: string;
 };
 
+declare class NonError extends Error {
+    constructor(message: string);
+}
+
 interface JsonError extends Error {
     toJSON: () => SerializedError;
 }
@@ -74,4 +92,4 @@ type Options = {
 };
 declare const serialize: (error: AggregateError | Error | JsonError, options?: Options) => SerializedError;
 
-export { type ErrorHint, type ErrorLocation, type ErrorProperties, type Options as ErrorWithCauseSerializerOptions, type Options$1 as RenderErrorOptions, type SerializedError, VisulimaError, captureRawStackTrace, getErrorCauses, isVisulimaError, renderError, serialize as serializeError };
+export { type ErrorHint, type ErrorLocation, type ErrorProperties, type Options as ErrorWithCauseSerializerOptions, NonError, type Options$1 as RenderErrorOptions, type SerializedError, VisulimaError, addKnownErrorConstructor, captureRawStackTrace, deserialize as deserializeError, getErrorCauses, isErrorLike, isVisulimaError, renderError, serialize as serializeError };

package/dist/error/index.mjs

@@ -1,5 +1,8 @@
 export { default as captureRawStackTrace } from '../packem_shared/captureRawStackTrace-Tl3Rqkat.mjs';
 export { default as getErrorCauses } from '../packem_shared/getErrorCauses-CG_JRE6j.mjs';
-export { renderError } from '../packem_shared/renderError-BWpM2m6k.mjs';
-export { serialize as serializeError } from '../packem_shared/serializeError-DusTUACt.mjs';
-export { VisulimaError, isVisulimaError } from '../packem_shared/isVisulimaError-H6TqEA42.mjs';
+export { renderError } from '../packem_shared/renderError-Cn8M0fQ3.mjs';
+export { default as deserializeError } from '../packem_shared/deserializeError-DuzHucBb.mjs';
+export { addKnownErrorConstructor, isErrorLike } from '../packem_shared/addKnownErrorConstructor-DBmmT2OF.mjs';
+export { default as NonError } from '../packem_shared/NonError-BrwMc2LE.mjs';
+export { serialize as serializeError } from '../packem_shared/serializeError-DHIelq5o.mjs';
+export { VisulimaError, isVisulimaError } from '../packem_shared/isVisulimaError-zyd80Gui.mjs';

package/dist/index.cjs

@@ -3,17 +3,20 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
 
 const codeFrame_index = require('./code-frame/index.cjs');
-const indexToLineColumn = require('./packem_shared/indexToLineColumn-DjmjeiIY.cjs');
+const indexToLineColumn = require('./packem_shared/indexToLineColumn-Cro5eT8v.cjs');
 const solution_ai_aiPrompt = require('./solution/ai/ai-prompt.cjs');
-const aiSolutionResponse = require('./packem_shared/aiSolutionResponse-BPckbL56.cjs');
+const aiSolutionResponse = require('./packem_shared/aiSolutionResponse-Cqi0mFxy.cjs');
 const errorHintFinder = require('./packem_shared/errorHintFinder-DZugFHq0.cjs');
-const ruleBasedFinder = require('./packem_shared/ruleBasedFinder-y_-5kbeT.cjs');
+const ruleBasedFinder = require('./packem_shared/ruleBasedFinder-CkybTSHw.cjs');
 const captureRawStackTrace = require('./packem_shared/captureRawStackTrace-ClSI1tHb.cjs');
+const deserializeError = require('./packem_shared/deserializeError-Be3qOGBQ.cjs');
 const getErrorCauses = require('./packem_shared/getErrorCauses-miTeYJEG.cjs');
-const parseStacktrace = require('./packem_shared/parseStacktrace-6pFoXW43.cjs');
-const isVisulimaError = require('./packem_shared/isVisulimaError-BVLWvREw.cjs');
-const renderError = require('./packem_shared/renderError-CXZTAXig.cjs');
-const serializeError = require('./packem_shared/serializeError-CT7s0Ffk.cjs');
+const NonError = require('./packem_shared/NonError-DqwGL5Cy.cjs');
+const parseStacktrace = require('./packem_shared/parseStacktrace-woJgU2XY.cjs');
+const addKnownErrorConstructor = require('./packem_shared/addKnownErrorConstructor-J1_ZUURa.cjs');
+const isVisulimaError = require('./packem_shared/isVisulimaError-Bb1_TB6w.cjs');
+const renderError = require('./packem_shared/renderError-n3kXGdYj.cjs');
+const serializeError = require('./packem_shared/serializeError-Dt7oFM2R.cjs');
 const formatStackFrameLine = require('./packem_shared/formatStackFrameLine-DcXSX--m.cjs');
 
 
@@ -26,8 +29,12 @@ exports.aiSolutionResponse = aiSolutionResponse;
 exports.errorHintFinder = errorHintFinder;
 exports.ruleBasedFinder = ruleBasedFinder;
 exports.captureRawStackTrace = captureRawStackTrace;
+exports.deserializeError = deserializeError;
 exports.getErrorCauses = getErrorCauses;
+exports.NonError = NonError;
 exports.parseStacktrace = parseStacktrace;
+exports.addKnownErrorConstructor = addKnownErrorConstructor.addKnownErrorConstructor;
+exports.isErrorLike = addKnownErrorConstructor.isErrorLike;
 exports.VisulimaError = isVisulimaError.VisulimaError;
 exports.isVisulimaError = isVisulimaError.isVisulimaError;
 exports.renderError = renderError.renderError;

package/dist/index.d.cts

@@ -3,7 +3,7 @@ export { default as aiPrompt } from './solution/ai/ai-prompt.cjs';
 export { a as aiSolutionResponse } from './packem_shared/ai-solution-response-BuaDQAEU.cjs';
 export { errorHintFinder, ruleBasedFinder } from './solution/index.cjs';
 export { S as Solution, a as SolutionError, b as SolutionFinder, c as SolutionFinderFile } from './packem_shared/types-BtQS7FHG.cjs';
-export { ErrorHint, ErrorLocation, ErrorProperties, ErrorWithCauseSerializerOptions, RenderErrorOptions, SerializedError, VisulimaError, captureRawStackTrace, getErrorCauses, isVisulimaError, renderError, serializeError } from './error/index.cjs';
+export { ErrorHint, ErrorLocation, ErrorProperties, ErrorWithCauseSerializerOptions, NonError, RenderErrorOptions, SerializedError, VisulimaError, addKnownErrorConstructor, captureRawStackTrace, deserializeError, getErrorCauses, isErrorLike, isVisulimaError, renderError, serializeError } from './error/index.cjs';
 export { Trace, TraceType, formatStackFrameLine, formatStacktrace, parseStacktrace } from './stacktrace/index.cjs';
 export { C as CodeFrameLocation, a as CodeFrameNodeLocation, b as CodeFrameOptions, c as ColorizeMethod } from './packem_shared/types-CrVmNoPV.cjs';
 

package/dist/index.d.mts

@@ -3,7 +3,7 @@ export { default as aiPrompt } from './solution/ai/ai-prompt.mjs';
 export { a as aiSolutionResponse } from './packem_shared/ai-solution-response-BuaDQAEU.mjs';
 export { errorHintFinder, ruleBasedFinder } from './solution/index.mjs';
 export { S as Solution, a as SolutionError, b as SolutionFinder, c as SolutionFinderFile } from './packem_shared/types-BtQS7FHG.mjs';
-export { ErrorHint, ErrorLocation, ErrorProperties, ErrorWithCauseSerializerOptions, RenderErrorOptions, SerializedError, VisulimaError, captureRawStackTrace, getErrorCauses, isVisulimaError, renderError, serializeError } from './error/index.mjs';
+export { ErrorHint, ErrorLocation, ErrorProperties, ErrorWithCauseSerializerOptions, NonError, RenderErrorOptions, SerializedError, VisulimaError, addKnownErrorConstructor, captureRawStackTrace, deserializeError, getErrorCauses, isErrorLike, isVisulimaError, renderError, serializeError } from './error/index.mjs';
 export { Trace, TraceType, formatStackFrameLine, formatStacktrace, parseStacktrace } from './stacktrace/index.mjs';
 export { C as CodeFrameLocation, a as CodeFrameNodeLocation, b as CodeFrameOptions, c as ColorizeMethod } from './packem_shared/types-CrVmNoPV.mjs';
 

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export { default as aiPrompt } from './solution/ai/ai-prompt.js';
 export { a as aiSolutionResponse } from './packem_shared/ai-solution-response-BuaDQAEU.js';
 export { errorHintFinder, ruleBasedFinder } from './solution/index.js';
 export { S as Solution, a as SolutionError, b as SolutionFinder, c as SolutionFinderFile } from './packem_shared/types-BtQS7FHG.js';
-export { ErrorHint, ErrorLocation, ErrorProperties, ErrorWithCauseSerializerOptions, RenderErrorOptions, SerializedError, VisulimaError, captureRawStackTrace, getErrorCauses, isVisulimaError, renderError, serializeError } from './error/index.js';
+export { ErrorHint, ErrorLocation, ErrorProperties, ErrorWithCauseSerializerOptions, NonError, RenderErrorOptions, SerializedError, VisulimaError, addKnownErrorConstructor, captureRawStackTrace, deserializeError, getErrorCauses, isErrorLike, isVisulimaError, renderError, serializeError } from './error/index.js';
 export { Trace, TraceType, formatStackFrameLine, formatStacktrace, parseStacktrace } from './stacktrace/index.js';
 export { C as CodeFrameLocation, a as CodeFrameNodeLocation, b as CodeFrameOptions, c as ColorizeMethod } from './packem_shared/types-CrVmNoPV.js';
 

package/dist/index.mjs

@@ -1,13 +1,16 @@
 export { CODE_FRAME_POINTER, codeFrame } from './code-frame/index.mjs';
-export { default as indexToLineColumn } from './packem_shared/indexToLineColumn-Dx91YDU1.mjs';
+export { default as indexToLineColumn } from './packem_shared/indexToLineColumn-CKQKtKEK.mjs';
 export { default as aiPrompt } from './solution/ai/ai-prompt.mjs';
-export { default as aiSolutionResponse } from './packem_shared/aiSolutionResponse-bDi4ad8f.mjs';
+export { default as aiSolutionResponse } from './packem_shared/aiSolutionResponse-BaN1M990.mjs';
 export { default as errorHintFinder } from './packem_shared/errorHintFinder-CQy_qIK3.mjs';
-export { default as ruleBasedFinder } from './packem_shared/ruleBasedFinder-BYrndubA.mjs';
+export { default as ruleBasedFinder } from './packem_shared/ruleBasedFinder-Cbmc6N7f.mjs';
 export { default as captureRawStackTrace } from './packem_shared/captureRawStackTrace-Tl3Rqkat.mjs';
+export { default as deserializeError } from './packem_shared/deserializeError-DuzHucBb.mjs';
 export { default as getErrorCauses } from './packem_shared/getErrorCauses-CG_JRE6j.mjs';
-export { default as parseStacktrace } from './packem_shared/parseStacktrace-BKGoWCwC.mjs';
-export { VisulimaError, isVisulimaError } from './packem_shared/isVisulimaError-H6TqEA42.mjs';
-export { renderError } from './packem_shared/renderError-BWpM2m6k.mjs';
-export { serialize as serializeError } from './packem_shared/serializeError-DusTUACt.mjs';
+export { default as NonError } from './packem_shared/NonError-BrwMc2LE.mjs';
+export { default as parseStacktrace } from './packem_shared/parseStacktrace-BlguTUcF.mjs';
+export { addKnownErrorConstructor, isErrorLike } from './packem_shared/addKnownErrorConstructor-DBmmT2OF.mjs';
+export { VisulimaError, isVisulimaError } from './packem_shared/isVisulimaError-zyd80Gui.mjs';
+export { renderError } from './packem_shared/renderError-Cn8M0fQ3.mjs';
+export { serialize as serializeError } from './packem_shared/serializeError-DHIelq5o.mjs';
 export { formatStackFrameLine, formatStacktrace } from './packem_shared/formatStackFrameLine-DqkmKWH3.mjs';

package/dist/packem_shared/NonError-BrwMc2LE.mjs

@@ -0,0 +1,13 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class NonError extends Error {
+  static {
+    __name(this, "NonError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "NonError";
+  }
+}
+
+export { NonError as default };

package/dist/packem_shared/NonError-DqwGL5Cy.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class NonError extends Error {
+  static {
+    __name(this, "NonError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "NonError";
+  }
+}
+
+module.exports = NonError;

package/dist/packem_shared/addKnownErrorConstructor-DBmmT2OF.mjs

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 = /* @__PURE__ */ __name((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);
+}, "addKnownErrorConstructor");
+const getKnownErrorConstructors = /* @__PURE__ */ __name(() => new Map(defaultErrorConstructors), "getKnownErrorConstructors");
+const getErrorConstructor = /* @__PURE__ */ __name((name) => defaultErrorConstructors.get(name), "getErrorConstructor");
+const isErrorLike = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && typeof value.name === "string" && typeof value.message === "string" && (getErrorConstructor(value.name) !== void 0 || value.name === "Error"), "isErrorLike");
+
+export { addKnownErrorConstructor, getErrorConstructor, getKnownErrorConstructors, isErrorLike };

package/dist/packem_shared/addKnownErrorConstructor-J1_ZUURa.cjs

@@ -0,0 +1,39 @@
+'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 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 = /* @__PURE__ */ __name((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);
+}, "addKnownErrorConstructor");
+const getKnownErrorConstructors = /* @__PURE__ */ __name(() => new Map(defaultErrorConstructors), "getKnownErrorConstructors");
+const getErrorConstructor = /* @__PURE__ */ __name((name) => defaultErrorConstructors.get(name), "getErrorConstructor");
+const isErrorLike = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && typeof value.name === "string" && typeof value.message === "string" && (getErrorConstructor(value.name) !== void 0 || value.name === "Error"), "isErrorLike");
+
+exports.addKnownErrorConstructor = addKnownErrorConstructor;
+exports.getErrorConstructor = getErrorConstructor;
+exports.getKnownErrorConstructors = getKnownErrorConstructors;
+exports.isErrorLike = isErrorLike;