@visulima/error 4.4.18 → 4.6.0

package/CHANGELOG.md

@@ -1,3 +1,33 @@
+## @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
+
+* add error solution finder, added new format helper for trace ([82508bc](https://github.com/visulima/visulima/commit/82508bc42476da034b10c4023c823755a3c6b120))
+
+### Bug Fixes
+
+* **error:** remove find cache dir dependency and add caching interface ([#514](https://github.com/visulima/visulima/issues/514)) ([caa1bfa](https://github.com/visulima/visulima/commit/caa1bfaf656009d76bcc2991e4a7ff706451670d))
+
+### Miscellaneous Chores
+
+* update dependencies and remove obsolete documentation ([9e5e3c2](https://github.com/visulima/visulima/commit/9e5e3c2a68acf50d4b7abf8545d0edb85bb89078))
+* update LICENSE.md with bundled dependencies and their licenses; add new fixture in pnpm-lock.yaml ([49d02a7](https://github.com/visulima/visulima/commit/49d02a7307168d9d2400e846d6f822a631d536e7))
+
 ## @visulima/error [4.4.18](https://github.com/visulima/visulima/compare/@visulima/error@4.4.17...@visulima/error@4.4.18) (2025-06-04)
 
 

package/LICENSE.md

@@ -27,6 +27,131 @@ The published @visulima/error artifact additionally contains code with the follo
 MIT
 
 # Bundled dependencies:
+## @visulima/path
+License: MIT
+By: Daniel Bannert
+Repository: git+https://github.com/visulima/visulima.git
+
+> MIT License
+>
+> Copyright (c) 2024 visulima
+>
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+>
+> ---
+>
+> MIT License
+>
+> Copyright (c) Pooya Parsa <pooya@pi0.io> - Daniel Roe <daniel@roe.dev>
+>
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+>
+> ---
+>
+> Copyright Joyent, Inc. and other Node contributors.
+>
+> Permission is hereby granted, free of charge, to any person obtaining a
+> copy of this software and associated documentation files (the
+> "Software"), to deal in the Software without restriction, including
+> without limitation the rights to use, copy, modify, merge, publish,
+> distribute, sublicense, and/or sell copies of the Software, and to permit
+> persons to whom the Software is furnished to do so, subject to the
+> following conditions:
+>
+> The above copyright notice and this permission notice shall be included
+> in all copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+> OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+> NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+> DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+> OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+> USE OR OTHER DEALINGS IN THE SOFTWARE.
+>
+> ---
+>
+> Bundled zeptomatch (https://github.com/fabiospampinato/zeptomatch)
+>
+> The MIT License (MIT)
+>
+> Copyright (c) 2023-present Fabio Spampinato
+>
+> Permission is hereby granted, free of charge, to any person obtaining a
+> copy of this software and associated documentation files (the "Software"),
+> to deal in the Software without restriction, including without limitation
+> the rights to use, copy, modify, merge, publish, distribute, sublicense,
+> and/or sell copies of the Software, and to permit persons to whom the
+> Software is furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+> FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+> DEALINGS IN THE SOFTWARE.
+>
+>
+>
+> # Licenses of bundled dependencies
+> The published @visulima/path artifact additionally contains code with the following licenses:
+> MIT
+>
+> # Bundled dependencies:
+> ## binary-extensions
+> License: MIT
+> By: Sindre Sorhus
+> Repository: sindresorhus/binary-extensions
+>
+> > MIT License
+> >
+> > Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+> > Copyright (c) Paul Miller (https://paulmillr.com)
+> >
+> > Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> >
+> > The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> >
+> > THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
 ## is-plain-obj
 License: MIT
 By: Sindre Sorhus

package/README.md

@@ -39,6 +39,21 @@ yarn add @visulima/error
 pnpm add @visulima/error
 ```
 
+### Optional: AI integration
+
+If you want to generate AI-powered solution hints, install these optional peer dependencies in your app:
+
+```sh
+# pnpm
+pnpm add ai
+
+# npm
+npm i ai
+
+# yarn
+yarn add ai
+```
+
 ## Usage
 
 ### Extend the VisulimaError
@@ -228,6 +243,109 @@ console.log(stack);
 // ];
 ```
 
+### Format stacktrace to a string
+
+Turn parsed frames into a printable stack string (Node-style), optionally with a header line.
+
+```ts
+import { parseStacktrace, stringifyStackFrames, formatStackFrameLine } from "@visulima/error";
+
+const error = new Error("Boom");
+
+const frames = parseStacktrace(error);
+
+// Full stack as a single string with a header ("Error: Boom")
+const stackText = stringifyStackFrames(frames, {
+    header: { name: error.name, message: error.message },
+});
+console.log(stackText);
+
+// Format a single frame line (e.g., for custom rendering)
+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
+- `formatStackFrameLine(frame)`
+    - `frame`: `Trace`
+    - returns a single formatted line like `"    at myMethod (/path/file.ts:10:5)"`
+
+## Solutions (finders)
+
+Generate helpful hints to fix an error. Two finders ship out of the box:
+
+- Rule-based finder: provides best-effort fixes for common errors (ESM/CJS mix, missing default export, DNS issues, hydration mismatch, etc.)
+- Error-hint finder: reads `error.hint` you attach to an `Error` or `VisulimaError`
+
+Both return a `Solution` (`{ header?: string; body: string }`) or `undefined`.
+
+```ts
+import { codeFrame } from "@visulima/error";
+import { ruleBasedFinder, errorHintFinder } from "@visulima/error";
+
+const error = new Error("Cannot read properties of undefined (reading 'x')");
+
+const source = "const o = undefined\nconsole.log(o.x)\n";
+const snippet = codeFrame(source, { start: { line: 2, column: 13 } });
+
+const fileCtx = {
+    file: "/path/to/file.ts",
+    line: 2,
+    language: "ts",
+    snippet,
+};
+
+// 1) Rule-based finder
+const ruleHint = await ruleBasedFinder.handle(error, fileCtx);
+if (ruleHint) {
+    console.log(ruleHint.header);
+    console.log(ruleHint.body);
+}
+
+// 2) Error-hint finder (reads error.hint)
+const custom = new Error("failed") as Error & { hint?: unknown };
+custom.hint = ["Check the environment variables.", "Ensure the service is reachable."];
+const hintHint = await errorHintFinder.handle(custom, { file: "", line: 0 });
+```
+
+### AI solution helper (optional)
+
+You can build an AI prompt with rich context and render the LLM result into a nice HTML snippet.
+
+```ts
+import { aiPrompt, aiSolutionResponse } from "@visulima/error/solution/ai";
+// or
+// import aiPrompt from "@visulima/error/solution/ai/prompt";
+
+const prompt = aiPrompt({
+    applicationType: undefined,
+    error,
+    file: fileCtx,
+});
+
+// Send `prompt` to your LLM of choice.
+// When you receive the model's text output, format it for display:
+const html = aiSolutionResponse(modelText);
+```
+
+You may also use a convenience finder that calls an AI provider for you (requires optional peer dep `ai`):
+
+```ts
+import { aiFinder } from "@visulima/error/solution/ai";
+import { createOpenAI } from "@ai-sdk/openai";
+
+const client = createOpenAI(apiKey ? { apiKey } : undefined);
+
+const findAI = aiFinder(client(modelId), {
+    temperature: 0,
+});
+
+const aiHint = await findAI.handle(error, fileCtx);
+```
+
 ### API
 
 #### error
@@ -278,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
@@ -374,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';