@devp0nt/error0 1.0.0-next.42 → 1.0.0-next.44

package/src/index.ts

@@ -6,9 +6,11 @@ type InferFirstArg<TFn> = TFn extends (...args: infer TArgs) => unknown
     ? TFirst
     : undefined
   : undefined
-type InferPluginPropInput<TProp extends ErrorPluginPropOptions<any, any, any>> = NormalizeUnknownToUndefined<
-  InferFirstArg<TProp['init']>
->
+type InferPluginPropInput<TProp extends ErrorPluginPropOptions<any, any, any, any>> = TProp extends {
+  init: infer TInit
+}
+  ? NormalizeUnknownToUndefined<InferFirstArg<TInit>>
+  : undefined
 type ErrorPluginPropInit<TInputValue, TOutputValue> = ((input: TInputValue) => TOutputValue) | (() => TOutputValue)
 type ErrorPluginPropSerialize<TOutputValue, TError extends Error0> =
   | ((options: { value: TOutputValue; error: TError; isPublic: boolean }) => unknown)
@@ -16,17 +18,38 @@ type ErrorPluginPropSerialize<TOutputValue, TError extends Error0> =
 type ErrorPluginPropDeserialize<TOutputValue> =
   | ((options: { value: unknown; serialized: Record<string, unknown> }) => TOutputValue | undefined)
   | false
-
-export type ErrorPluginPropOptions<TInputValue, TOutputValue, TError extends Error0 = Error0> = {
-  init: ErrorPluginPropInit<TInputValue, TOutputValue>
+type ErrorPluginPropOptionsBase<TOutputValue, TError extends Error0, TResolveValue extends TOutputValue | undefined> = {
   resolve: (options: {
-    value: TOutputValue | undefined
+    own: TOutputValue | undefined
     flow: Array<TOutputValue | undefined>
     error: TError
-  }) => TOutputValue | undefined
-  serialize: ErrorPluginPropSerialize<TOutputValue, TError>
+  }) => TResolveValue
+  serialize: ErrorPluginPropSerialize<TResolveValue, TError>
   deserialize: ErrorPluginPropDeserialize<TOutputValue>
 }
+type ErrorPluginPropOptionsWithInit<
+  TInputValue,
+  TOutputValue,
+  TError extends Error0,
+  TResolveValue extends TOutputValue | undefined,
+> = ErrorPluginPropOptionsBase<TOutputValue, TError, TResolveValue> & {
+  init: ErrorPluginPropInit<TInputValue, TOutputValue>
+}
+type ErrorPluginPropOptionsWithoutInit<
+  TOutputValue,
+  TError extends Error0,
+  TResolveValue extends TOutputValue | undefined,
+> = ErrorPluginPropOptionsBase<TOutputValue, TError, TResolveValue> & {
+  init?: undefined
+}
+export type ErrorPluginPropOptions<
+  TInputValue = undefined,
+  TOutputValue = unknown,
+  TError extends Error0 = Error0,
+  TResolveValue extends TOutputValue | undefined = TOutputValue | undefined,
+> =
+  | ErrorPluginPropOptionsWithInit<TInputValue, TOutputValue, TError, TResolveValue>
+  | ErrorPluginPropOptionsWithoutInit<TOutputValue, TError, TResolveValue>
 export type ErrorPluginMethodFn<TOutputValue, TArgs extends unknown[] = unknown[], TError extends Error0 = Error0> = (
   error: TError,
   ...args: TArgs
@@ -36,6 +59,15 @@ export type ErrorPluginAdaptFn<
   TError extends Error0 = Error0,
   TOutputProps extends Record<string, unknown> = Record<never, never>,
 > = ((error: TError) => void) | ((error: TError) => ErrorPluginAdaptResult<TOutputProps>)
+export type ErrorPluginStackSerialize<TError extends Error0> =
+  | ((options: { value: string | undefined; error: TError; isPublic: boolean }) => unknown)
+  | boolean
+  | 'merge'
+export type ErrorPluginStack<TError extends Error0 = Error0> = ErrorPluginStackSerialize<TError>
+export type ErrorPluginCauseSerialize<TError extends Error0> =
+  | ((options: { value: unknown; error: TError; isPublic: boolean }) => unknown)
+  | boolean
+export type ErrorPluginCause<TError extends Error0 = Error0> = ErrorPluginCauseSerialize<TError>
 type ErrorMethodRecord = {
   args: unknown[]
   output: unknown
@@ -51,9 +83,16 @@ export type ErrorPlugin<
   props?: TProps
   methods?: TMethods
   adapt?: Array<ErrorPluginAdaptFn<Error0, PluginOutputProps<TProps>>>
+  stack?: ErrorPluginStack
+  cause?: ErrorPluginCause
 }
-type AddPropToPluginProps<TProps extends ErrorPluginProps, TKey extends string, TInputValue, TOutputValue> = TProps &
-  Record<TKey, ErrorPluginPropOptions<TInputValue, TOutputValue>>
+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,
@@ -61,10 +100,12 @@ type AddMethodToPluginMethods<
   TOutputValue,
 > = TMethods & Record<TKey, ErrorPluginMethodFn<TOutputValue, TArgs>>
 type PluginOutputProps<TProps extends ErrorPluginProps> = {
-  [TKey in keyof TProps]: TProps[TKey] extends ErrorPluginPropOptions<any, infer TOutputValue> ? TOutputValue : never
+  [TKey in keyof TProps]: TProps[TKey] extends ErrorPluginPropOptions<any, any, any, infer TResolveValue>
+    ? TResolveValue
+    : never
 }
 export type ErrorPluginsMap = {
-  props: Record<string, { init: unknown; resolve: unknown }>
+  props: Record<string, { init: unknown; output: unknown; resolve: unknown }>
   methods: Record<string, ErrorMethodRecord>
 }
 export type IsEmptyObject<T> = keyof T extends never ? true : false
@@ -81,10 +122,23 @@ export type ErrorInput<TPluginsMap extends ErrorPluginsMap> =
     ? ErrorInputBase
     : ErrorInputBase & ErrorInputPluginProps<TPluginsMap>
 
-type ErrorOutputProps<TPluginsMap extends ErrorPluginsMap> = {
-  [TKey in keyof TPluginsMap['props']]: TPluginsMap['props'][TKey]['resolve'] | undefined
+type ErrorResolvedProps<TPluginsMap extends ErrorPluginsMap> = {
+  [TKey in keyof TPluginsMap['props']]: TPluginsMap['props'][TKey]['resolve']
+}
+type ErrorOwnProps<TPluginsMap extends ErrorPluginsMap> = {
+  [TKey in keyof TPluginsMap['props']]: TPluginsMap['props'][TKey]['output'] | undefined
+}
+type ErrorOwnMethods<TPluginsMap extends ErrorPluginsMap> = {
+  own: {
+    (): ErrorOwnProps<TPluginsMap>
+    <TKey extends keyof TPluginsMap['props'] & string>(key: TKey): ErrorOwnProps<TPluginsMap>[TKey]
+  }
+  flow: <TKey extends keyof TPluginsMap['props'] & string>(key: TKey) => Array<ErrorOwnProps<TPluginsMap>[TKey]>
 }
-type ErrorOutputMethods<TPluginsMap extends ErrorPluginsMap> = {
+type ErrorResolveMethods<TPluginsMap extends ErrorPluginsMap> = {
+  resolve: () => ErrorResolvedProps<TPluginsMap>
+}
+type ErrorMethods<TPluginsMap extends ErrorPluginsMap> = {
   [TKey in keyof TPluginsMap['methods']]: TPluginsMap['methods'][TKey] extends {
     args: infer TArgs extends unknown[]
     output: infer TOutput
@@ -92,8 +146,8 @@ type ErrorOutputMethods<TPluginsMap extends ErrorPluginsMap> = {
     ? (...args: TArgs) => TOutput
     : never
 }
-export type ErrorOutput<TPluginsMap extends ErrorPluginsMap> = ErrorOutputProps<TPluginsMap> &
-  ErrorOutputMethods<TPluginsMap>
+export type ErrorResolved<TPluginsMap extends ErrorPluginsMap> = ErrorResolvedProps<TPluginsMap> &
+  ErrorMethods<TPluginsMap>
 
 type ErrorStaticMethods<TPluginsMap extends ErrorPluginsMap> = {
   [TKey in keyof TPluginsMap['methods']]: TPluginsMap['methods'][TKey] extends {
@@ -105,22 +159,31 @@ type ErrorStaticMethods<TPluginsMap extends ErrorPluginsMap> = {
 }
 
 type EmptyPluginsMap = {
-  props: Record<never, { init: never; resolve: never }>
+  props: Record<never, { init: never; output: never; resolve: never }>
   methods: Record<never, ErrorMethodRecord>
 }
 
 type ErrorPluginResolved = {
-  props: Record<string, ErrorPluginPropOptions<unknown, unknown>>
+  props: Record<string, ErrorPluginPropOptions<unknown>>
   methods: Record<string, ErrorPluginMethodFn<unknown>>
   adapt: Array<ErrorPluginAdaptFn<Error0, Record<string, unknown>>>
+  stack?: ErrorPluginStack
+  cause?: ErrorPluginCause
 }
+const RESERVED_STACK_PROP_ERROR = 'Error0: "stack" is a reserved prop key. Use .stack(...) plugin API instead'
 
 type PluginPropsMapOf<TPlugin extends ErrorPlugin> = {
   [TKey in keyof NonNullable<TPlugin['props']>]: NonNullable<TPlugin['props']>[TKey] extends ErrorPluginPropOptions<
     any,
-    infer TOutputValue
+    infer TOutputValue,
+    any,
+    infer TResolveValue
   >
-    ? { init: InferPluginPropInput<NonNullable<TPlugin['props']>[TKey]>; resolve: TOutputValue }
+    ? {
+        init: InferPluginPropInput<NonNullable<TPlugin['props']>[TKey]>
+        output: TOutputValue
+        resolve: TResolveValue
+      }
     : never
 }
 type PluginMethodsMapOf<TPlugin extends ErrorPlugin> = {
@@ -144,7 +207,11 @@ type ExtendErrorPluginsMapWithProp<
   TKey extends string,
   TInputValue,
   TOutputValue,
-> = ExtendErrorPluginsMap<TMap, ErrorPlugin<Record<TKey, ErrorPluginPropOptions<TInputValue, TOutputValue>>>>
+  TResolveValue extends TOutputValue | undefined = TOutputValue | undefined,
+> = ExtendErrorPluginsMap<
+  TMap,
+  ErrorPlugin<Record<TKey, ErrorPluginPropOptions<TInputValue, TOutputValue, Error0, TResolveValue>>>
+>
 type ExtendErrorPluginsMapWithMethod<
   TMap extends ErrorPluginsMap,
   TKey extends string,
@@ -160,14 +227,19 @@ type PluginsMapOf<TClass> = TClass extends { __pluginsMap?: infer TPluginsMap }
     ? TPluginsMap
     : EmptyPluginsMap
   : EmptyPluginsMap
+type PluginsMapOfInstance<TInstance> = TInstance extends { constructor: { __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 & ErrorOutput<TMap>
+type ErrorInstanceOfMap<TMap extends ErrorPluginsMap> = Error0 & ErrorResolved<TMap>
 type BuilderError0<TProps extends ErrorPluginProps, TMethods extends ErrorPluginMethods> = Error0 &
-  ErrorOutput<PluginsMapFromParts<TProps, TMethods>>
+  ErrorResolved<PluginsMapFromParts<TProps, TMethods>>
 
 type PluginOfBuilder<TBuilder> =
   TBuilder extends PluginError0<infer TProps, infer TMethods> ? ErrorPlugin<TProps, TMethods> : never
@@ -188,13 +260,20 @@ export class PluginError0<
       props: { ...(plugin?.props ?? {}) },
       methods: { ...(plugin?.methods ?? {}) },
       adapt: [...(plugin?.adapt ?? [])],
+      stack: plugin?.stack,
+      cause: plugin?.cause,
     }
   }
 
-  prop<TKey extends string, TInputValue, TOutputValue>(
+  prop<
+    TKey extends string,
+    TInputValue = undefined,
+    TOutputValue = unknown,
+    TResolveValue extends TOutputValue | undefined = TOutputValue | undefined,
+  >(
     key: TKey,
-    value: ErrorPluginPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>>,
-  ): PluginError0<AddPropToPluginProps<TProps, TKey, TInputValue, TOutputValue>, TMethods> {
+    value: ErrorPluginPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>, TResolveValue>,
+  ): PluginError0<AddPropToPluginProps<TProps, TKey, TInputValue, TOutputValue, TResolveValue>, TMethods> {
     return this.use('prop', key, value)
   }
 
@@ -211,11 +290,24 @@ export class PluginError0<
     return this.use('adapt', value)
   }
 
-  use<TKey extends string, TInputValue, TOutputValue>(
+  stack(value: ErrorPluginStack<BuilderError0<TProps, TMethods>>): PluginError0<TProps, TMethods> {
+    return this.use('stack', value)
+  }
+
+  cause(value: ErrorPluginCause<BuilderError0<TProps, TMethods>>): PluginError0<TProps, TMethods> {
+    return this.use('cause', value)
+  }
+
+  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>>,
-  ): PluginError0<AddPropToPluginProps<TProps, TKey, TInputValue, TOutputValue>, TMethods>
+    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,
@@ -225,16 +317,23 @@ export class PluginError0<
     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: 'prop' | 'method' | 'adapt',
-    keyOrValue: string | ErrorPluginAdaptFn<any, any>,
+    kind: 'prop' | 'method' | 'adapt' | 'stack' | 'cause',
+    keyOrValue: unknown,
     value?: ErrorPluginPropOptions<unknown, unknown, any> | ErrorPluginMethodFn<unknown, unknown[], any>,
   ): PluginError0<any, any> {
     const nextProps: ErrorPluginProps = { ...(this._plugin.props ?? {}) }
     const nextMethods: ErrorPluginMethods = { ...(this._plugin.methods ?? {}) }
     const nextAdapt: Array<ErrorPluginAdaptFn<Error0, Record<string, unknown>>> = [...(this._plugin.adapt ?? [])]
+    let nextStack: ErrorPluginStack | undefined = this._plugin.stack
+    let nextCause: ErrorPluginCause | undefined = this._plugin.cause
     if (kind === 'prop') {
       const key = keyOrValue as string
+      if (key === 'stack') {
+        throw new Error(RESERVED_STACK_PROP_ERROR)
+      }
       if (value === undefined) {
         throw new Error('PluginError0.use("prop", key, value) requires value')
       }
@@ -245,43 +344,77 @@ export class PluginError0<
         throw new Error('PluginError0.use("method", key, value) requires value')
       }
       nextMethods[key] = value as ErrorPluginMethodFn<any, any[]>
-    } else {
+    } else if (kind === 'adapt') {
       nextAdapt.push(keyOrValue as ErrorPluginAdaptFn<Error0, Record<string, unknown>>)
+    } else if (kind === 'stack') {
+      nextStack = keyOrValue as ErrorPluginStack
+    } else {
+      nextCause = keyOrValue as ErrorPluginCause
     }
     return new PluginError0({
       props: nextProps,
       methods: nextMethods,
       adapt: nextAdapt,
+      stack: nextStack,
+      cause: nextCause,
     })
   }
 }
 
 export type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> = {
-  new (message: string, input?: ErrorInput<TPluginsMap>): Error0 & ErrorOutput<TPluginsMap>
-  new (input: { message: string } & ErrorInput<TPluginsMap>): Error0 & ErrorOutput<TPluginsMap>
+  new (
+    message: string,
+    input?: ErrorInput<TPluginsMap>,
+  ): Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap>
+  new (
+    input: { message: string } & ErrorInput<TPluginsMap>,
+  ): Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap>
   readonly __pluginsMap?: TPluginsMap
-  from: (error: unknown) => Error0 & ErrorOutput<TPluginsMap>
+  from: (
+    error: unknown,
+  ) => Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap>
+  resolve: (error: unknown) => ErrorResolvedProps<TPluginsMap>
   serialize: (error: unknown, isPublic?: boolean) => Record<string, unknown>
-  prop: <TKey extends string, TInputValue, TOutputValue>(
+  own: {
+    (error: object): ErrorOwnProps<TPluginsMap>
+    <TKey extends keyof TPluginsMap['props'] & string>(error: object, key: TKey): ErrorOwnProps<TPluginsMap>[TKey]
+  }
+  flow: <TKey extends keyof TPluginsMap['props'] & string>(
+    error: object,
     key: TKey,
-    value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TPluginsMap>>,
-  ) => ClassError0<ExtendErrorPluginsMapWithProp<TPluginsMap, TKey, TInputValue, TOutputValue>>
+  ) => 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>, ErrorOutputProps<TPluginsMap>>,
+    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, TOutputValue>(
+    <
+      TKey extends string,
+      TInputValue = undefined,
+      TOutputValue = unknown,
+      TResolveValue extends TOutputValue | undefined = TOutputValue | undefined,
+    >(
       kind: 'prop',
       key: TKey,
-      value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TPluginsMap>>,
-    ): ClassError0<ExtendErrorPluginsMapWithProp<TPluginsMap, TKey, TInputValue, TOutputValue>>
+      value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TPluginsMap>, TResolveValue>,
+    ): ClassError0<ExtendErrorPluginsMapWithProp<TPluginsMap, TKey, TInputValue, TOutputValue, TResolveValue>>
     <TKey extends string, TArgs extends unknown[], TOutputValue>(
       kind: 'method',
       key: TKey,
@@ -289,8 +422,10 @@ export type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> =
     ): ClassError0<ExtendErrorPluginsMapWithMethod<TPluginsMap, TKey, TArgs, TOutputValue>>
     (
       kind: 'adapt',
-      value: ErrorPluginAdaptFn<ErrorInstanceOfMap<TPluginsMap>, ErrorOutputProps<TPluginsMap>>,
+      value: ErrorPluginAdaptFn<ErrorInstanceOfMap<TPluginsMap>, ErrorResolvedProps<TPluginsMap>>,
     ): ClassError0<TPluginsMap>
+    (kind: 'stack', value: ErrorPluginStack<ErrorInstanceOfMap<TPluginsMap>>): ClassError0<TPluginsMap>
+    (kind: 'cause', value: ErrorPluginCause<ErrorInstanceOfMap<TPluginsMap>>): ClassError0<TPluginsMap>
   }
   plugin: () => PluginError0
 } & ErrorStaticMethods<TPluginsMap>
@@ -303,6 +438,8 @@ export class Error0 extends Error {
     props: {},
     methods: {},
     adapt: [],
+    stack: undefined,
+    cause: undefined,
   }
 
   private static _getResolvedPlugin(this: typeof Error0): ErrorPluginResolved {
@@ -312,9 +449,18 @@ export class Error0 extends Error {
       adapt: [],
     }
     for (const plugin of this._plugins) {
+      if (plugin.props && 'stack' in plugin.props) {
+        throw new Error(RESERVED_STACK_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))
+      if (typeof plugin.stack !== 'undefined') {
+        resolved.stack = plugin.stack
+      }
+      if (typeof plugin.cause !== 'undefined') {
+        resolved.cause = plugin.cause
+      }
     }
     return resolved
   }
@@ -336,12 +482,19 @@ export class Error0 extends Error {
     const plugin = ctor._getResolvedPlugin()
 
     for (const [key, prop] of Object.entries(plugin.props)) {
+      if (key === 'stack') {
+        continue
+      }
       if (key in input) {
         const ownValue = (input as Record<string, unknown>)[key]
-        ;(this as Record<string, unknown>)[key] = prop.init(ownValue)
+        if (typeof prop.init === 'function') {
+          ;(this as Record<string, unknown>)[key] = prop.init(ownValue)
+        } else {
+          ;(this as Record<string, unknown>)[key] = ownValue
+        }
       } else {
         Object.defineProperty(this, key, {
-          get: () => prop.resolve({ value: undefined, flow: this.flow(key), error: this }),
+          get: () => prop.resolve({ own: undefined, flow: this.flow(key), error: this }),
           set: (value) => {
             Object.defineProperty(this, key, {
               value,
@@ -369,26 +522,105 @@ export class Error0 extends Error {
     }
     return true
   }
-
-  static own(error: object, key: string): unknown {
+  private static _ownByKey(error: object, key: string): unknown {
     if (this.isSelfProperty(error, key)) {
       return (error as Record<string, unknown>)[key]
     }
     return undefined
   }
-  own(key: string): unknown {
+  private static _flowByKey(error: object, key: string): unknown[] {
+    return this.causes(error, true).map((cause) => {
+      return this._ownByKey(cause, key)
+    })
+  }
+
+  static own<TThis extends typeof Error0>(this: TThis, error: unknown): ErrorOwnProps<PluginsMapOf<TThis>>
+  static own<TThis extends typeof Error0, TKey extends keyof PluginsMapOf<TThis>['props'] & string>(
+    this: TThis,
+    error: unknown,
+    key: TKey,
+  ): ErrorOwnProps<PluginsMapOf<TThis>>[TKey]
+  static own(error: unknown, key?: string): unknown {
+    const error0 = this.from(error)
+    if (key === undefined) {
+      const ownValues: Record<string, unknown> = {}
+      const plugin = this._getResolvedPlugin()
+      for (const ownKey of Object.keys(plugin.props)) {
+        ownValues[ownKey] = this._ownByKey(error0, ownKey)
+      }
+      return ownValues
+    }
+    return this._ownByKey(error0, key)
+  }
+  own<TThis extends Error0>(this: TThis): ErrorOwnProps<PluginsMapOfInstance<TThis>>
+  own<TThis extends Error0, TKey extends keyof PluginsMapOfInstance<TThis>['props'] & string>(
+    this: TThis,
+    key: TKey,
+  ): ErrorOwnProps<PluginsMapOfInstance<TThis>>[TKey]
+  own(key?: string): unknown {
     const ctor = this.constructor as typeof Error0
-    return ctor.own(this, key)
+    if (key === undefined) {
+      return ctor.own(this)
+    }
+    return ctor._ownByKey(this, key)
   }
 
-  static flow(error: object, key: string): unknown[] {
-    return this.causes(error, true).map((cause) => {
-      return this.own(cause, key)
-    })
+  static flow<TThis extends typeof Error0, TKey extends keyof PluginsMapOf<TThis>['props'] & string>(
+    this: TThis,
+    error: unknown,
+    key: TKey,
+  ): Array<ErrorOwnProps<PluginsMapOf<TThis>>[TKey]>
+  static flow(error: unknown, key: string): unknown[]
+  static flow(error: unknown, key: string): unknown[] {
+    const error0 = this.from(error)
+    return this._flowByKey(error0, key)
   }
+  flow<TThis extends Error0, TKey extends keyof PluginsMapOfInstance<TThis>['props'] & string>(
+    this: TThis,
+    key: TKey,
+  ): Array<ErrorOwnProps<PluginsMapOfInstance<TThis>>[TKey]>
+  flow(key: string): unknown[]
   flow(key: string): unknown[] {
     const ctor = this.constructor as typeof Error0
-    return ctor.flow(this, key)
+    return ctor._flowByKey(this, key)
+  }
+
+  static resolve<TThis extends typeof Error0>(this: TThis, error: unknown): ErrorResolvedProps<PluginsMapOf<TThis>>
+  static resolve(error: unknown): Record<string, unknown>
+  static resolve(error: unknown): Record<string, unknown> {
+    const error0 = this.from(error)
+    const resolved: Record<string, unknown> = {}
+    const plugin = this._getResolvedPlugin()
+    for (const [key, prop] of Object.entries(plugin.props)) {
+      try {
+        // resolved[key] = (error0 as unknown as Record<string, unknown>)[key]
+        const options = Object.defineProperties(
+          {
+            error: error0,
+          },
+          {
+            own: {
+              get: () => error0.own(key as never),
+            },
+            flow: {
+              get: () => error0.flow(key),
+            },
+          },
+        )
+        resolved[key] = prop.resolve(options as never)
+        // resolved[key] = prop.resolve({ own: error0.own(key as never), flow: error0.flow(key), error: error0 })
+      } catch {
+        // eslint-disable-next-line no-console
+        console.error(`Error0: failed to resolve property ${key}`, error0)
+      }
+    }
+    return resolved
+  }
+  resolve<TThis extends Error0>(this: TThis): ErrorResolvedProps<PluginsMapOfInstance<TThis>>
+  resolve(): Record<string, unknown>
+  resolve(): Record<string, unknown> {
+    const ctor = this.constructor as typeof Error0
+    return ctor.resolve(this)
   }
 
   static causes(error: unknown, instancesOnly?: false): unknown[]
@@ -413,8 +645,8 @@ export class Error0 extends Error {
     }
     return causes
   }
-  causes<T extends typeof Error0>(this: T, instancesOnly?: false): [InstanceType<T>, ...unknown[]]
-  causes<T extends typeof Error0>(this: T, instancesOnly: true): [InstanceType<T>, ...Array<InstanceType<T>>]
+  causes<TThis extends Error0>(this: TThis, instancesOnly?: false): [TThis, ...unknown[]]
+  causes<TThis extends Error0>(this: TThis, instancesOnly: true): [TThis, ...TThis[]]
   causes(instancesOnly?: boolean): unknown[] {
     const ctor = this.constructor as typeof Error0
     if (instancesOnly) {
@@ -472,14 +704,35 @@ export class Error0 extends Error {
         const value = prop.deserialize({ value: errorRecord[key], serialized: errorRecord })
         ;(recreated as unknown as Record<string, unknown>)[key] = value
       } catch {
-        // ignore
+        // eslint-disable-next-line no-console
+        console.error(`Error0: failed to deserialize property ${key}`, errorRecord)
       }
     }
     // we do not serialize causes
     // ;(recreated as unknown as { cause?: unknown }).cause = errorRecord.cause
-    const isStackInProps = propsEntries.some(([key]) => key === 'stack')
-    if (typeof errorRecord.stack === 'string' && !isStackInProps) {
-      recreated.stack = errorRecord.stack
+    const stackPlugin = plugin.stack
+    if (stackPlugin !== false && 'stack' in errorRecord) {
+      try {
+        if (typeof errorRecord.stack === 'string') {
+          recreated.stack = errorRecord.stack
+        }
+      } catch {
+        // eslint-disable-next-line no-console
+        console.error('Error0: failed to deserialize stack', errorRecord)
+      }
+    }
+    const causePlugin = plugin.cause ?? false
+    if (causePlugin && 'cause' in errorRecord) {
+      try {
+        if (this.isSerialized(errorRecord.cause)) {
+          ;(recreated as { cause?: unknown }).cause = this._fromSerialized(errorRecord.cause)
+        } else {
+          ;(recreated as { cause?: unknown }).cause = errorRecord.cause
+        }
+      } catch {
+        // eslint-disable-next-line no-console
+        console.error('Error0: failed to deserialize cause', errorRecord)
+      }
     }
     return recreated
   }
@@ -538,14 +791,22 @@ export class Error0 extends Error {
       props: { ...(pluginRecord._plugin.props ?? {}) },
       methods: { ...(pluginRecord._plugin.methods ?? {}) },
       adapt: [...(pluginRecord._plugin.adapt ?? [])],
+      stack: pluginRecord._plugin.stack,
+      cause: pluginRecord._plugin.cause,
     }
   }
 
-  static prop<TThis extends typeof Error0, TKey extends string, TInputValue, TOutputValue>(
+  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>>>,
-  ): ClassError0<ExtendErrorPluginsMapWithProp<PluginsMapOf<TThis>, TKey, TInputValue, TOutputValue>> {
+    value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<PluginsMapOf<TThis>>, TResolveValue>,
+  ): ClassError0<ExtendErrorPluginsMapWithProp<PluginsMapOf<TThis>, TKey, TInputValue, TOutputValue, TResolveValue>> {
     return this.use('prop', key, value)
   }
 
@@ -559,21 +820,41 @@ export class Error0 extends Error {
 
   static adapt<TThis extends typeof Error0>(
     this: TThis,
-    value: ErrorPluginAdaptFn<ErrorInstanceOfMap<PluginsMapOf<TThis>>, ErrorOutputProps<PluginsMapOf<TThis>>>,
+    value: ErrorPluginAdaptFn<ErrorInstanceOfMap<PluginsMapOf<TThis>>, ErrorResolvedProps<PluginsMapOf<TThis>>>,
   ): ClassError0<PluginsMapOf<TThis>> {
     return this.use('adapt', value)
   }
 
+  static stack<TThis extends typeof Error0>(
+    this: TThis,
+    value: ErrorPluginStack<ErrorInstanceOfMap<PluginsMapOf<TThis>>>,
+  ): ClassError0<PluginsMapOf<TThis>> {
+    return this.use('stack', value)
+  }
+
+  static cause<TThis extends typeof Error0>(
+    this: TThis,
+    value: ErrorPluginCause<ErrorInstanceOfMap<PluginsMapOf<TThis>>>,
+  ): ClassError0<PluginsMapOf<TThis>> {
+    return this.use('cause', value)
+  }
+
   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, TOutputValue>(
+  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>>>,
-  ): ClassError0<ExtendErrorPluginsMapWithProp<PluginsMapOf<TThis>, TKey, TInputValue, TOutputValue>>
+    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',
@@ -583,23 +864,55 @@ export class Error0 extends Error {
   static use<TThis extends typeof Error0>(
     this: TThis,
     kind: 'adapt',
-    value: ErrorPluginAdaptFn<ErrorInstanceOfMap<PluginsMapOf<TThis>>, ErrorOutputProps<PluginsMapOf<TThis>>>,
+    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(
     this: typeof Error0,
-    first: PluginError0 | 'prop' | 'method' | 'adapt',
-    key?: string | ErrorPluginAdaptFn<any, any>,
-    value?: ErrorPluginPropOptions<unknown, unknown> | ErrorPluginMethodFn<unknown>,
+    first: PluginError0 | 'prop' | 'method' | 'adapt' | 'stack' | 'cause',
+    key?: unknown,
+    value?: ErrorPluginPropOptions<unknown> | ErrorPluginMethodFn<unknown>,
   ): ClassError0 {
     if (first instanceof PluginError0) {
       return this._useWithPlugin(this._pluginFromBuilder(first))
     }
+    if (first === 'stack') {
+      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"')
+      }
+      return this._useWithPlugin({
+        stack: key as ErrorPluginStack,
+      })
+    }
+    if (first === 'cause') {
+      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')
+      }
+      return this._useWithPlugin({
+        cause: key as ErrorPluginCause,
+      })
+    }
     if (first === 'adapt') {
       if (typeof key !== 'function') {
         throw new Error('Error0.use("adapt", value) requires adapt function')
       }
       return this._useWithPlugin({
-        adapt: [key],
+        adapt: [key as ErrorPluginAdaptFn<Error0, Record<string, unknown>>],
       })
     }
     if (typeof key !== 'string' || value === undefined) {
@@ -607,8 +920,11 @@ export class Error0 extends Error {
     }
 
     if (first === 'prop') {
+      if (key === 'stack') {
+        throw new Error(RESERVED_STACK_PROP_ERROR)
+      }
       return this._useWithPlugin({
-        props: { [key]: value as ErrorPluginPropOptions<unknown, unknown> },
+        props: { [key]: value as ErrorPluginPropOptions<unknown> },
       })
     }
     return this._useWithPlugin({
@@ -622,6 +938,8 @@ export class Error0 extends Error {
 
   static serialize(error: unknown, isPublic = true): Record<string, unknown> {
     const error0 = this.from(error)
+    const resolvedProps = this.resolve(error0)
+    const resolvedRecord = resolvedProps as Record<string, unknown>
     const json: Record<string, unknown> = {
       name: error0.name,
       message: error0.message,
@@ -636,18 +954,63 @@ export class Error0 extends Error {
         continue
       }
       try {
-        const value = prop.resolve({ value: error0.own(key), flow: error0.flow(key), error: error0 })
+        const value = resolvedRecord[key]
         const jsonValue = prop.serialize({ value, error: error0, isPublic })
         if (jsonValue !== undefined) {
           json[key] = jsonValue
         }
       } catch {
-        // ignore
+        // eslint-disable-next-line no-console
+        console.error(`Error0: failed to serialize property ${key}`, resolvedRecord)
       }
     }
-    const isStackInProps = propsEntries.some(([key]) => key === 'stack')
-    if (!isStackInProps && typeof error0.stack === 'string') {
-      json.stack = error0.stack
+    const stackSerialize = plugin.stack
+    if (stackSerialize !== false) {
+      try {
+        let serializedStack: unknown
+        if (stackSerialize === 'merge') {
+          serializedStack = error0
+            .causes()
+            .map((cause) => {
+              return cause instanceof Error ? cause.stack : undefined
+            })
+            .filter((value): value is string => typeof value === 'string')
+            .join('\n')
+        } else if (typeof stackSerialize === 'function') {
+          serializedStack = stackSerialize({ value: error0.stack, error: error0, isPublic })
+        } else {
+          serializedStack = error0.stack
+        }
+        if (serializedStack !== undefined) {
+          json.stack = serializedStack
+        }
+      } catch {
+        // eslint-disable-next-line no-console
+        console.error('Error0: failed to serialize stack', error0)
+      }
+    }
+    const causeSerialize = plugin.cause ?? false
+    if (causeSerialize) {
+      try {
+        if (causeSerialize === true) {
+          const causeValue = (error0 as { cause?: unknown }).cause
+          if (this.is(causeValue)) {
+            json.cause = this.serialize(causeValue, isPublic)
+          }
+        } else {
+          const serializedCause = causeSerialize({
+            value: (error0 as { cause?: unknown }).cause,
+            error: error0,
+            isPublic,
+          })
+          if (serializedCause !== undefined) {
+            json.cause = serializedCause
+          }
+        }
+      } catch {
+        // eslint-disable-next-line no-console
+        console.error('Error0: failed to serialize cause', error0)
+      }
     }
     return Object.fromEntries(Object.entries(json).filter(([, value]) => value !== undefined)) as Record<
       string,
@@ -655,7 +1018,7 @@ export class Error0 extends Error {
     >
   }
 
-  serialize(isPublic = true): object {
+  serialize(isPublic = true): Record<string, unknown> {
     const ctor = this.constructor as typeof Error0
     return ctor.serialize(this, isPublic)
   }