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

package/src/index.ts

@@ -20,7 +20,7 @@ type ErrorPluginPropDeserialize<TOutputValue> =
   | false
 type ErrorPluginPropOptionsBase<TOutputValue, TError extends Error0, TResolveValue extends TOutputValue | undefined> = {
   resolve: (options: {
-    value: TOutputValue | undefined
+    own: TOutputValue | undefined
     flow: Array<TOutputValue | undefined>
     error: TError
   }) => TResolveValue
@@ -59,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
@@ -74,6 +83,8 @@ export type ErrorPlugin<
   props?: TProps
   methods?: TMethods
   adapt?: Array<ErrorPluginAdaptFn<Error0, PluginOutputProps<TProps>>>
+  stack?: ErrorPluginStack
+  cause?: ErrorPluginCause
 }
 type AddPropToPluginProps<
   TProps extends ErrorPluginProps,
@@ -94,7 +105,7 @@ type PluginOutputProps<TProps extends ErrorPluginProps> = {
     : 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
@@ -114,6 +125,19 @@ export type ErrorInput<TPluginsMap extends ErrorPluginsMap> =
 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 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[]
@@ -135,7 +159,7 @@ 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>
 }
 
@@ -143,16 +167,23 @@ type ErrorPluginResolved = {
   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,
-    any,
+    infer TOutputValue,
     any,
     infer TResolveValue
   >
-    ? { init: InferPluginPropInput<NonNullable<TPlugin['props']>[TKey]>; resolve: TResolveValue }
+    ? {
+        init: InferPluginPropInput<NonNullable<TPlugin['props']>[TKey]>
+        output: TOutputValue
+        resolve: TResolveValue
+      }
     : never
 }
 type PluginMethodsMapOf<TPlugin extends ErrorPlugin> = {
@@ -196,6 +227,11 @@ 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,
@@ -224,6 +260,8 @@ export class PluginError0<
       props: { ...(plugin?.props ?? {}) },
       methods: { ...(plugin?.methods ?? {}) },
       adapt: [...(plugin?.adapt ?? [])],
+      stack: plugin?.stack,
+      cause: plugin?.cause,
     }
   }
 
@@ -252,6 +290,14 @@ export class PluginError0<
     return this.use('adapt', value)
   }
 
+  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,
@@ -271,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')
       }
@@ -291,23 +344,45 @@ 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 & ErrorResolved<TPluginsMap>
-  new (input: { message: string } & ErrorInput<TPluginsMap>): Error0 & ErrorResolved<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 & ErrorResolved<TPluginsMap>
+  from: (
+    error: unknown,
+  ) => Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap>
+  resolve: (error: unknown) => ErrorResolvedProps<TPluginsMap>
   serialize: (error: unknown, isPublic?: boolean) => Record<string, unknown>
+  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,
+  ) => Array<ErrorOwnProps<TPluginsMap>[TKey]>
   prop: <
     TKey extends string,
     TInputValue = undefined,
@@ -324,6 +399,8 @@ export type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> =
   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,
@@ -347,6 +424,8 @@ export 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>
   }
   plugin: () => PluginError0
 } & ErrorStaticMethods<TPluginsMap>
@@ -359,6 +438,8 @@ export class Error0 extends Error {
     props: {},
     methods: {},
     adapt: [],
+    stack: undefined,
+    cause: undefined,
   }
 
   private static _getResolvedPlugin(this: typeof Error0): ErrorPluginResolved {
@@ -368,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
   }
@@ -392,6 +482,9 @@ 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]
         if (typeof prop.init === 'function') {
@@ -401,7 +494,7 @@ export class Error0 extends Error {
         }
       } 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,
@@ -429,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[]
@@ -473,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) {
@@ -532,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
   }
@@ -598,6 +791,8 @@ 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,
     }
   }
 
@@ -630,6 +825,20 @@ export class Error0 extends Error {
     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,
@@ -657,21 +866,53 @@ export class Error0 extends Error {
     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(
     this: typeof Error0,
-    first: PluginError0 | 'prop' | 'method' | 'adapt',
-    key?: string | ErrorPluginAdaptFn<any, any>,
+    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) {
@@ -679,6 +920,9 @@ 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> },
       })
@@ -694,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,
@@ -708,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,
@@ -727,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)
   }