@devp0nt/error0 1.0.0-next.45 → 1.0.0-next.47

package/dist/esm/index.d.ts

@@ -34,18 +34,30 @@ type ErrorPluginPropOptions<TInputValue = undefined, TOutputValue = unknown, TEr
 type ErrorPluginMethodFn<TOutputValue, TArgs extends unknown[] = unknown[], TError extends Error0 = Error0> = (error: TError, ...args: TArgs) => TOutputValue;
 type ErrorPluginAdaptResult<TOutputProps extends Record<string, unknown>> = Partial<TOutputProps> | undefined;
 type ErrorPluginAdaptFn<TError extends Error0 = Error0, TOutputProps extends Record<string, unknown> = Record<never, never>> = ((error: TError) => void) | ((error: TError) => ErrorPluginAdaptResult<TOutputProps>);
-type ErrorPluginStackSerialize<TError extends Error0> = ((options: {
+type ErrorPluginStackSerialize<TError extends Error0> = (options: {
     value: string | undefined;
     error: TError;
     isPublic: boolean;
-}) => unknown) | boolean | 'merge';
-type ErrorPluginStack<TError extends Error0 = Error0> = ErrorPluginStackSerialize<TError>;
-type ErrorPluginCauseSerialize<TError extends Error0> = ((options: {
+}) => unknown;
+type ErrorPluginStack<TError extends Error0 = Error0> = {
+    serialize: ErrorPluginStackSerialize<TError>;
+};
+type ErrorPluginCauseSerialize<TError extends Error0> = (options: {
     value: unknown;
     error: TError;
     isPublic: boolean;
-}) => unknown) | boolean;
-type ErrorPluginCause<TError extends Error0 = Error0> = ErrorPluginCauseSerialize<TError>;
+}) => unknown;
+type ErrorPluginCause<TError extends Error0 = Error0> = {
+    serialize: ErrorPluginCauseSerialize<TError>;
+};
+type ErrorPluginMessageSerialize<TError extends Error0> = (options: {
+    value: string;
+    error: TError;
+    isPublic: boolean;
+}) => unknown;
+type ErrorPluginMessage<TError extends Error0 = Error0> = {
+    serialize: ErrorPluginMessageSerialize<TError>;
+};
 type ErrorMethodRecord = {
     args: unknown[];
     output: unknown;
@@ -62,6 +74,7 @@ type ErrorPlugin<TProps extends ErrorPluginProps = Record<never, never>, TMethod
     adapt?: Array<ErrorPluginAdaptFn<Error0, PluginOutputProps<TProps>>>;
     stack?: ErrorPluginStack;
     cause?: ErrorPluginCause;
+    message?: ErrorPluginMessage;
 };
 type AddPropToPluginProps<TProps extends ErrorPluginProps, TKey extends string, TInputValue, TOutputValue, TResolveValue extends TOutputValue | undefined = TOutputValue | undefined> = TProps & Record<TKey, ErrorPluginPropOptions<TInputValue, TOutputValue, Error0, TResolveValue>>;
 type AddMethodToPluginMethods<TMethods extends ErrorPluginMethods, TKey extends string, TArgs extends unknown[], TOutputValue> = TMethods & Record<TKey, ErrorPluginMethodFn<TOutputValue, TArgs>>;
@@ -148,9 +161,7 @@ type PluginsMapOf<TClass> = TClass extends {
     __pluginsMap?: infer TPluginsMap;
 } ? TPluginsMap extends ErrorPluginsMap ? TPluginsMap : EmptyPluginsMap : EmptyPluginsMap;
 type PluginsMapOfInstance<TInstance> = TInstance extends {
-    constructor: {
-        __pluginsMap?: infer TPluginsMap;
-    };
+    __pluginsMap?: infer TPluginsMap;
 } ? TPluginsMap extends ErrorPluginsMap ? TPluginsMap : EmptyPluginsMap : EmptyPluginsMap;
 type PluginsMapFromParts<TProps extends ErrorPluginProps, TMethods extends ErrorPluginMethods> = ErrorPluginsMapOfPlugin<ErrorPlugin<TProps, TMethods>>;
 type ErrorInstanceOfMap<TMap extends ErrorPluginsMap> = Error0 & ErrorResolved<TMap>;
@@ -168,17 +179,23 @@ declare class PluginError0<TProps extends ErrorPluginProps = Record<never, never
     adapt(value: ErrorPluginAdaptFn<BuilderError0<TProps, TMethods>, PluginOutputProps<TProps>>): PluginError0<TProps, TMethods>;
     stack(value: ErrorPluginStack<BuilderError0<TProps, TMethods>>): PluginError0<TProps, TMethods>;
     cause(value: ErrorPluginCause<BuilderError0<TProps, TMethods>>): PluginError0<TProps, TMethods>;
+    message(value: ErrorPluginMessage<BuilderError0<TProps, TMethods>>): PluginError0<TProps, TMethods>;
     use<TKey extends string, TInputValue = undefined, TOutputValue = unknown, TResolveValue extends TOutputValue | undefined = TOutputValue | undefined>(kind: 'prop', key: TKey, value: ErrorPluginPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>, TResolveValue>): PluginError0<AddPropToPluginProps<TProps, TKey, TInputValue, TOutputValue, TResolveValue>, TMethods>;
     use<TKey extends string, TArgs extends unknown[], TOutputValue>(kind: 'method', key: TKey, value: ErrorPluginMethodFn<TOutputValue, TArgs, BuilderError0<TProps, TMethods>>): PluginError0<TProps, AddMethodToPluginMethods<TMethods, TKey, TArgs, TOutputValue>>;
     use(kind: 'adapt', value: ErrorPluginAdaptFn<BuilderError0<TProps, TMethods>, PluginOutputProps<TProps>>): PluginError0<TProps, TMethods>;
     use(kind: 'stack', value: ErrorPluginStack<BuilderError0<TProps, TMethods>>): PluginError0<TProps, TMethods>;
     use(kind: 'cause', value: ErrorPluginCause<BuilderError0<TProps, TMethods>>): PluginError0<TProps, TMethods>;
+    use(kind: 'message', value: ErrorPluginMessage<BuilderError0<TProps, TMethods>>): PluginError0<TProps, TMethods>;
 }
 type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> = {
-    new (message: string, input?: ErrorInput<TPluginsMap>): Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap>;
+    new (message: string, input?: ErrorInput<TPluginsMap>): Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap> & {
+        readonly __pluginsMap?: TPluginsMap;
+    };
     new (input: {
         message: string;
-    } & ErrorInput<TPluginsMap>): Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap>;
+    } & ErrorInput<TPluginsMap>): Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap> & {
+        readonly __pluginsMap?: TPluginsMap;
+    };
     readonly __pluginsMap?: TPluginsMap;
     from: (error: unknown) => Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap>;
     resolve: (error: unknown) => ErrorResolvedProps<TPluginsMap>;
@@ -188,11 +205,6 @@ type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> = {
         <TKey extends keyof TPluginsMap['props'] & string>(error: object, key: TKey): ErrorOwnProps<TPluginsMap>[TKey];
     };
     flow: <TKey extends keyof TPluginsMap['props'] & string>(error: object, key: TKey) => Array<ErrorOwnProps<TPluginsMap>[TKey]>;
-    prop: <TKey extends string, TInputValue = undefined, TOutputValue = unknown, TResolveValue extends TOutputValue | undefined = TOutputValue | undefined>(key: TKey, value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TPluginsMap>, TResolveValue>) => ClassError0<ExtendErrorPluginsMapWithProp<TPluginsMap, TKey, TInputValue, TOutputValue, TResolveValue>>;
-    method: <TKey extends string, TArgs extends unknown[], TOutputValue>(key: TKey, value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<TPluginsMap>>) => ClassError0<ExtendErrorPluginsMapWithMethod<TPluginsMap, TKey, TArgs, TOutputValue>>;
-    adapt: (value: ErrorPluginAdaptFn<ErrorInstanceOfMap<TPluginsMap>, ErrorResolvedProps<TPluginsMap>>) => ClassError0<TPluginsMap>;
-    stack: (value: ErrorPluginStack<ErrorInstanceOfMap<TPluginsMap>>) => ClassError0<TPluginsMap>;
-    cause: (value: ErrorPluginCause<ErrorInstanceOfMap<TPluginsMap>>) => ClassError0<TPluginsMap>;
     use: {
         <TBuilder extends PluginError0>(plugin: TBuilder): ClassError0<ExtendErrorPluginsMap<TPluginsMap, PluginOfBuilder<TBuilder>>>;
         <TKey extends string, TInputValue = undefined, TOutputValue = unknown, TResolveValue extends TOutputValue | undefined = TOutputValue | undefined>(kind: 'prop', key: TKey, value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TPluginsMap>, TResolveValue>): ClassError0<ExtendErrorPluginsMapWithProp<TPluginsMap, TKey, TInputValue, TOutputValue, TResolveValue>>;
@@ -200,11 +212,13 @@ type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> = {
         (kind: 'adapt', value: ErrorPluginAdaptFn<ErrorInstanceOfMap<TPluginsMap>, ErrorResolvedProps<TPluginsMap>>): ClassError0<TPluginsMap>;
         (kind: 'stack', value: ErrorPluginStack<ErrorInstanceOfMap<TPluginsMap>>): ClassError0<TPluginsMap>;
         (kind: 'cause', value: ErrorPluginCause<ErrorInstanceOfMap<TPluginsMap>>): ClassError0<TPluginsMap>;
+        (kind: 'message', value: ErrorPluginMessage<ErrorInstanceOfMap<TPluginsMap>>): ClassError0<TPluginsMap>;
     };
     plugin: () => PluginError0;
 } & ErrorStaticMethods<TPluginsMap>;
 declare class Error0 extends Error {
     static readonly __pluginsMap?: EmptyPluginsMap;
+    readonly __pluginsMap?: EmptyPluginsMap;
     protected static _plugins: ErrorPlugin[];
     private static readonly _emptyPlugin;
     private static _getResolvedPlugin;
@@ -240,20 +254,16 @@ declare class Error0 extends Error {
     private static _extractMessage;
     private static _useWithPlugin;
     private static _pluginFromBuilder;
-    static prop<TThis extends typeof Error0, TKey extends string, TInputValue = undefined, TOutputValue = unknown, TResolveValue extends TOutputValue | undefined = TOutputValue | undefined>(this: TThis, key: TKey, value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<PluginsMapOf<TThis>>, TResolveValue>): ClassError0<ExtendErrorPluginsMapWithProp<PluginsMapOf<TThis>, TKey, TInputValue, TOutputValue, TResolveValue>>;
-    static method<TThis extends typeof Error0, TKey extends string, TArgs extends unknown[], TOutputValue>(this: TThis, key: TKey, value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<PluginsMapOf<TThis>>>): ClassError0<ExtendErrorPluginsMapWithMethod<PluginsMapOf<TThis>, TKey, TArgs, TOutputValue>>;
-    static adapt<TThis extends typeof Error0>(this: TThis, value: ErrorPluginAdaptFn<ErrorInstanceOfMap<PluginsMapOf<TThis>>, ErrorResolvedProps<PluginsMapOf<TThis>>>): ClassError0<PluginsMapOf<TThis>>;
-    static stack<TThis extends typeof Error0>(this: TThis, value: ErrorPluginStack<ErrorInstanceOfMap<PluginsMapOf<TThis>>>): ClassError0<PluginsMapOf<TThis>>;
-    static cause<TThis extends typeof Error0>(this: TThis, value: ErrorPluginCause<ErrorInstanceOfMap<PluginsMapOf<TThis>>>): ClassError0<PluginsMapOf<TThis>>;
     static use<TThis extends typeof Error0, TBuilder extends PluginError0>(this: TThis, plugin: TBuilder): ClassError0<ExtendErrorPluginsMap<PluginsMapOf<TThis>, PluginOfBuilder<TBuilder>>>;
     static use<TThis extends typeof Error0, TKey extends string, TInputValue = undefined, TOutputValue = unknown, TResolveValue extends TOutputValue | undefined = TOutputValue | undefined>(this: TThis, kind: 'prop', key: TKey, value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<PluginsMapOf<TThis>>, TResolveValue>): ClassError0<ExtendErrorPluginsMapWithProp<PluginsMapOf<TThis>, TKey, TInputValue, TOutputValue, TResolveValue>>;
     static use<TThis extends typeof Error0, TKey extends string, TArgs extends unknown[], TOutputValue>(this: TThis, kind: 'method', key: TKey, value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<PluginsMapOf<TThis>>>): ClassError0<ExtendErrorPluginsMapWithMethod<PluginsMapOf<TThis>, TKey, TArgs, TOutputValue>>;
     static use<TThis extends typeof Error0>(this: TThis, kind: 'adapt', value: ErrorPluginAdaptFn<ErrorInstanceOfMap<PluginsMapOf<TThis>>, ErrorResolvedProps<PluginsMapOf<TThis>>>): ClassError0<PluginsMapOf<TThis>>;
     static use<TThis extends typeof Error0>(this: TThis, kind: 'stack', value: ErrorPluginStack<ErrorInstanceOfMap<PluginsMapOf<TThis>>>): ClassError0<PluginsMapOf<TThis>>;
     static use<TThis extends typeof Error0>(this: TThis, kind: 'cause', value: ErrorPluginCause<ErrorInstanceOfMap<PluginsMapOf<TThis>>>): ClassError0<PluginsMapOf<TThis>>;
+    static use<TThis extends typeof Error0>(this: TThis, kind: 'message', value: ErrorPluginMessage<ErrorInstanceOfMap<PluginsMapOf<TThis>>>): ClassError0<PluginsMapOf<TThis>>;
     static plugin(): PluginError0;
     static serialize(error: unknown, isPublic?: boolean): Record<string, unknown>;
     serialize(isPublic?: boolean): Record<string, unknown>;
 }
 
-export { type ClassError0, Error0, type ErrorInput, type ErrorInputBase, type ErrorPlugin, type ErrorPluginAdaptFn, type ErrorPluginAdaptResult, type ErrorPluginCause, type ErrorPluginCauseSerialize, type ErrorPluginMethodFn, type ErrorPluginMethods, type ErrorPluginPropOptions, type ErrorPluginProps, type ErrorPluginStack, type ErrorPluginStackSerialize, type ErrorPluginsMap, type ErrorResolved, type IsEmptyObject, PluginError0 };
+export { type ClassError0, Error0, type ErrorInput, type ErrorInputBase, type ErrorPlugin, type ErrorPluginAdaptFn, type ErrorPluginAdaptResult, type ErrorPluginCause, type ErrorPluginCauseSerialize, type ErrorPluginMessage, type ErrorPluginMessageSerialize, type ErrorPluginMethodFn, type ErrorPluginMethods, type ErrorPluginPropOptions, type ErrorPluginProps, type ErrorPluginStack, type ErrorPluginStackSerialize, type ErrorPluginsMap, type ErrorResolved, type IsEmptyObject, PluginError0 };

package/dist/esm/index.js

@@ -1,4 +1,5 @@
 const RESERVED_STACK_PROP_ERROR = 'Error0: "stack" is a reserved prop key. Use .stack(...) plugin API instead';
+const RESERVED_MESSAGE_PROP_ERROR = 'Error0: "message" is a reserved prop key. Use .message(...) plugin API instead';
 class PluginError0 {
   _plugin;
   Infer = void 0;
@@ -8,7 +9,8 @@ class PluginError0 {
       methods: { ...plugin?.methods ?? {} },
       adapt: [...plugin?.adapt ?? []],
       stack: plugin?.stack,
-      cause: plugin?.cause
+      cause: plugin?.cause,
+      message: plugin?.message
     };
   }
   prop(key, value) {
@@ -26,17 +28,24 @@ class PluginError0 {
   cause(value) {
     return this.use("cause", value);
   }
+  message(value) {
+    return this.use("message", value);
+  }
   use(kind, keyOrValue, value) {
     const nextProps = { ...this._plugin.props ?? {} };
     const nextMethods = { ...this._plugin.methods ?? {} };
     const nextAdapt = [...this._plugin.adapt ?? []];
     let nextStack = this._plugin.stack;
     let nextCause = this._plugin.cause;
+    let nextMessage = this._plugin.message;
     if (kind === "prop") {
       const key = keyOrValue;
       if (key === "stack") {
         throw new Error(RESERVED_STACK_PROP_ERROR);
       }
+      if (key === "message") {
+        throw new Error(RESERVED_MESSAGE_PROP_ERROR);
+      }
       if (value === void 0) {
         throw new Error('PluginError0.use("prop", key, value) requires value');
       }
@@ -51,27 +60,32 @@ class PluginError0 {
       nextAdapt.push(keyOrValue);
     } else if (kind === "stack") {
       nextStack = keyOrValue;
-    } else {
+    } else if (kind === "cause") {
       nextCause = keyOrValue;
+    } else {
+      nextMessage = keyOrValue;
     }
     return new PluginError0({
       props: nextProps,
       methods: nextMethods,
       adapt: nextAdapt,
       stack: nextStack,
-      cause: nextCause
+      cause: nextCause,
+      message: nextMessage
     });
   }
 }
 class Error0 extends Error {
   static __pluginsMap;
+  __pluginsMap;
   static _plugins = [];
   static _emptyPlugin = {
     props: {},
     methods: {},
     adapt: [],
     stack: void 0,
-    cause: void 0
+    cause: void 0,
+    message: void 0
   };
   static _getResolvedPlugin() {
     const resolved = {
@@ -83,6 +97,9 @@ class Error0 extends Error {
       if (plugin.props && "stack" in plugin.props) {
         throw new Error(RESERVED_STACK_PROP_ERROR);
       }
+      if (plugin.props && "message" in plugin.props) {
+        throw new Error(RESERVED_MESSAGE_PROP_ERROR);
+      }
       Object.assign(resolved.props, plugin.props ?? this._emptyPlugin.props);
       Object.assign(resolved.methods, plugin.methods ?? this._emptyPlugin.methods);
       resolved.adapt.push(...plugin.adapt ?? this._emptyPlugin.adapt);
@@ -92,6 +109,9 @@ class Error0 extends Error {
       if (typeof plugin.cause !== "undefined") {
         resolved.cause = plugin.cause;
       }
+      if (typeof plugin.message !== "undefined") {
+        resolved.message = plugin.message;
+      }
     }
     return resolved;
   }
@@ -287,8 +307,7 @@ class Error0 extends Error {
         console.error(`Error0: failed to deserialize property ${key}`, errorRecord);
       }
     }
-    const stackPlugin = plugin.stack;
-    if (stackPlugin !== false && "stack" in errorRecord) {
+    if ("stack" in errorRecord) {
       try {
         if (typeof errorRecord.stack === "string") {
           recreated.stack = errorRecord.stack;
@@ -297,8 +316,8 @@ class Error0 extends Error {
         console.error("Error0: failed to deserialize stack", errorRecord);
       }
     }
-    const causePlugin = plugin.cause ?? false;
-    if (causePlugin && "cause" in errorRecord) {
+    const causePlugin = plugin.cause;
+    if (causePlugin?.serialize && "cause" in errorRecord) {
       try {
         if (this.isSerialized(errorRecord.cause)) {
           ;
@@ -353,24 +372,10 @@ class Error0 extends Error {
       methods: { ...pluginRecord._plugin.methods ?? {} },
       adapt: [...pluginRecord._plugin.adapt ?? []],
       stack: pluginRecord._plugin.stack,
-      cause: pluginRecord._plugin.cause
+      cause: pluginRecord._plugin.cause,
+      message: pluginRecord._plugin.message
     };
   }
-  static prop(key, value) {
-    return this.use("prop", key, value);
-  }
-  static method(key, value) {
-    return this.use("method", key, value);
-  }
-  static adapt(value) {
-    return this.use("adapt", value);
-  }
-  static stack(value) {
-    return this.use("stack", value);
-  }
-  static cause(value) {
-    return this.use("cause", value);
-  }
   static use(first, key, value) {
     if (first instanceof PluginError0) {
       return this._useWithPlugin(this._pluginFromBuilder(first));
@@ -379,8 +384,8 @@ class Error0 extends Error {
       if (typeof key === "undefined") {
         throw new Error('Error0.use("stack", value) requires stack plugin value');
       }
-      if (key !== "merge" && typeof key !== "boolean" && typeof key !== "function") {
-        throw new Error('Error0.use("stack", value) expects function | boolean | "merge"');
+      if (typeof key !== "object" || key === null || typeof key.serialize !== "function") {
+        throw new Error('Error0.use("stack", value) expects { serialize: function }');
       }
       return this._useWithPlugin({
         stack: key
@@ -390,13 +395,24 @@ class Error0 extends Error {
       if (typeof key === "undefined") {
         throw new Error('Error0.use("cause", value) requires cause plugin value');
       }
-      if (typeof key !== "boolean" && typeof key !== "function") {
-        throw new Error('Error0.use("cause", value) expects function | boolean');
+      if (typeof key !== "object" || key === null || typeof key.serialize !== "function") {
+        throw new Error('Error0.use("cause", value) expects { serialize: function }');
       }
       return this._useWithPlugin({
         cause: key
       });
     }
+    if (first === "message") {
+      if (typeof key === "undefined") {
+        throw new Error('Error0.use("message", value) requires message plugin value');
+      }
+      if (typeof key !== "object" || key === null || typeof key.serialize !== "function") {
+        throw new Error('Error0.use("message", value) expects { serialize: function }');
+      }
+      return this._useWithPlugin({
+        message: key
+      });
+    }
     if (first === "adapt") {
       if (typeof key !== "function") {
         throw new Error('Error0.use("adapt", value) requires adapt function');
@@ -412,6 +428,9 @@ class Error0 extends Error {
       if (key === "stack") {
         throw new Error(RESERVED_STACK_PROP_ERROR);
       }
+      if (key === "message") {
+        throw new Error(RESERVED_MESSAGE_PROP_ERROR);
+      }
       return this._useWithPlugin({
         props: { [key]: value }
       });
@@ -427,13 +446,23 @@ class Error0 extends Error {
     const error0 = this.from(error);
     const resolvedProps = this.resolve(error0);
     const resolvedRecord = resolvedProps;
+    const plugin = this._getResolvedPlugin();
+    const messagePlugin = plugin.message;
+    let serializedMessage = error0.message;
+    try {
+      if (messagePlugin) {
+        serializedMessage = messagePlugin.serialize({ value: error0.message, error: error0, isPublic });
+      }
+    } catch {
+      console.error("Error0: failed to serialize message", error0);
+      serializedMessage = error0.message;
+    }
     const json = {
       name: error0.name,
-      message: error0.message
+      message: serializedMessage
       // we do not serialize causes, it is enough that we have floated props and adapt helper
       // cause: error0.cause,
     };
-    const plugin = this._getResolvedPlugin();
     const propsEntries = Object.entries(plugin.props);
     for (const [key, prop] of propsEntries) {
       if (prop.serialize === false) {
@@ -449,43 +478,30 @@ class Error0 extends Error {
         console.error(`Error0: failed to serialize property ${key}`, resolvedRecord);
       }
     }
-    const stackSerialize = plugin.stack;
-    if (stackSerialize !== false) {
-      try {
-        let serializedStack;
-        if (stackSerialize === "merge") {
-          serializedStack = error0.causes().map((cause) => {
-            return cause instanceof Error ? cause.stack : void 0;
-          }).filter((value) => typeof value === "string").join("\n");
-        } else if (typeof stackSerialize === "function") {
-          serializedStack = stackSerialize({ value: error0.stack, error: error0, isPublic });
-        } else {
-          serializedStack = error0.stack;
-        }
-        if (serializedStack !== void 0) {
-          json.stack = serializedStack;
-        }
-      } catch {
-        console.error("Error0: failed to serialize stack", error0);
+    const stackPlugin = plugin.stack;
+    try {
+      let serializedStack;
+      if (stackPlugin) {
+        serializedStack = stackPlugin.serialize({ value: error0.stack, error: error0, isPublic });
+      } else {
+        serializedStack = error0.stack;
       }
+      if (serializedStack !== void 0) {
+        json.stack = serializedStack;
+      }
+    } catch {
+      console.error("Error0: failed to serialize stack", error0);
     }
-    const causeSerialize = plugin.cause ?? false;
-    if (causeSerialize) {
+    const causePlugin = plugin.cause;
+    if (causePlugin?.serialize) {
       try {
-        if (causeSerialize === true) {
-          const causeValue = error0.cause;
-          if (this.is(causeValue)) {
-            json.cause = this.serialize(causeValue, isPublic);
-          }
-        } else {
-          const serializedCause = causeSerialize({
-            value: error0.cause,
-            error: error0,
-            isPublic
-          });
-          if (serializedCause !== void 0) {
-            json.cause = serializedCause;
-          }
+        const serializedCause = causePlugin.serialize({
+          value: error0.cause,
+          error: error0,
+          isPublic
+        });
+        if (serializedCause !== void 0) {
+          json.cause = serializedCause;
         }
       } catch {
         console.error("Error0: failed to serialize cause", error0);