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

package/src/index.ts

@@ -1,95 +1,102 @@
-export type ErrorExtensionPropOptions<TInputValue, TOutputValue, TError extends Error0 = Error0> = {
-  input: (value: TInputValue) => TOutputValue
-  output: (error: TError) => TOutputValue
-  serialize: (value: TOutputValue, error: TError, isPublic: boolean) => unknown
+type IsUnknown<T> = unknown extends T ? ([T] extends [unknown] ? true : false) : false
+type NormalizeUnknownToUndefined<T> = IsUnknown<T> extends true ? undefined : T
+type IsOnlyUndefined<T> = [Exclude<T, undefined>] extends [never] ? true : false
+type InferFirstArg<TFn> = TFn extends (...args: infer TArgs) => unknown
+  ? TArgs extends [infer TFirst, ...unknown[]]
+    ? TFirst
+    : undefined
+  : undefined
+type InferPluginPropInput<TProp extends ErrorPluginPropOptions<any, any, any>> = NormalizeUnknownToUndefined<
+  InferFirstArg<TProp['init']>
+>
+type ErrorPluginPropInit<TInputValue, TOutputValue> = ((input: TInputValue) => TOutputValue) | (() => TOutputValue)
+type ErrorPluginPropSerialize<TOutputValue, TError extends Error0> =
+  | ((options: { value: TOutputValue; error: TError; isPublic: boolean }) => unknown)
+  | false
+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>
+  resolve: (options: {
+    value: TOutputValue | undefined
+    flow: Array<TOutputValue | undefined>
+    error: TError
+  }) => TOutputValue | undefined
+  serialize: ErrorPluginPropSerialize<TOutputValue, TError>
+  deserialize: ErrorPluginPropDeserialize<TOutputValue>
 }
-export type ErrorExtensionCopmputedFn<TOutputValue, TError extends Error0 = Error0> = (error: TError) => TOutputValue
-export type ErrorExtensionMethodFn<
-  TOutputValue,
-  TArgs extends unknown[] = unknown[],
-  TError extends Error0 = Error0,
-> = (error: TError, ...args: TArgs) => TOutputValue
-export type ErrorExtensionRefineResult<TOutputProps extends Record<string, unknown>> = Partial<TOutputProps> | undefined
-export type ErrorExtensionRefineFn<
+export type ErrorPluginMethodFn<TOutputValue, TArgs extends unknown[] = unknown[], TError extends Error0 = Error0> = (
+  error: TError,
+  ...args: TArgs
+) => TOutputValue
+export type ErrorPluginAdaptResult<TOutputProps extends Record<string, unknown>> = Partial<TOutputProps> | undefined
+export type ErrorPluginAdaptFn<
   TError extends Error0 = Error0,
   TOutputProps extends Record<string, unknown> = Record<never, never>,
-> = ((error: TError) => void) | ((error: TError) => ErrorExtensionRefineResult<TOutputProps>)
+> = ((error: TError) => void) | ((error: TError) => ErrorPluginAdaptResult<TOutputProps>)
 type ErrorMethodRecord = {
   args: unknown[]
   output: unknown
 }
 
-export type ErrorExtensionProps = { [key: string]: ErrorExtensionPropOptions<any, any> }
-export type ErrorExtensionComputed = { [key: string]: ErrorExtensionCopmputedFn<any> }
-export type ErrorExtensionMethods = { [key: string]: ErrorExtensionMethodFn<any, any[]> }
+export type ErrorPluginProps = { [key: string]: ErrorPluginPropOptions<any, any> }
+export type ErrorPluginMethods = { [key: string]: ErrorPluginMethodFn<any, any[]> }
 
-export type ErrorExtension<
-  TProps extends ErrorExtensionProps = Record<never, never>,
-  TComputed extends ErrorExtensionComputed = Record<never, never>,
-  TMethods extends ErrorExtensionMethods = Record<never, never>,
+export type ErrorPlugin<
+  TProps extends ErrorPluginProps = Record<never, never>,
+  TMethods extends ErrorPluginMethods = Record<never, never>,
 > = {
   props?: TProps
-  computed?: TComputed
   methods?: TMethods
-  refine?: Array<ErrorExtensionRefineFn<Error0, ExtensionOutputProps<TProps>>>
+  adapt?: Array<ErrorPluginAdaptFn<Error0, PluginOutputProps<TProps>>>
 }
-type AddPropToExtensionProps<
-  TProps extends ErrorExtensionProps,
-  TKey extends string,
-  TInputValue,
-  TOutputValue,
-> = TProps & Record<TKey, ErrorExtensionPropOptions<TInputValue, TOutputValue>>
-type AddComputedToExtensionComputed<
-  TComputed extends ErrorExtensionComputed,
-  TKey extends string,
-  TOutputValue,
-> = TComputed & Record<TKey, ErrorExtensionCopmputedFn<TOutputValue>>
-type AddMethodToExtensionMethods<
-  TMethods extends ErrorExtensionMethods,
+type AddPropToPluginProps<TProps extends ErrorPluginProps, TKey extends string, TInputValue, TOutputValue> = TProps &
+  Record<TKey, ErrorPluginPropOptions<TInputValue, TOutputValue>>
+type AddMethodToPluginMethods<
+  TMethods extends ErrorPluginMethods,
   TKey extends string,
   TArgs extends unknown[],
   TOutputValue,
-> = TMethods & Record<TKey, ErrorExtensionMethodFn<TOutputValue, TArgs>>
-type ExtensionOutputProps<TProps extends ErrorExtensionProps> = {
-  [TKey in keyof TProps]: TProps[TKey] extends ErrorExtensionPropOptions<any, infer TOutputValue> ? TOutputValue : never
+> = TMethods & Record<TKey, ErrorPluginMethodFn<TOutputValue, TArgs>>
+type PluginOutputProps<TProps extends ErrorPluginProps> = {
+  [TKey in keyof TProps]: TProps[TKey] extends ErrorPluginPropOptions<any, infer TOutputValue> ? TOutputValue : never
 }
-export type ErrorExtensionsMap = {
-  props: Record<string, { input: unknown; output: unknown }>
-  computed: Record<string, unknown>
+export type ErrorPluginsMap = {
+  props: Record<string, { init: unknown; resolve: unknown }>
   methods: Record<string, ErrorMethodRecord>
 }
 export type IsEmptyObject<T> = keyof T extends never ? true : false
 export type ErrorInputBase = {
   cause?: unknown
 }
-export type ErrorInput<TExtensionsMap extends ErrorExtensionsMap> =
-  IsEmptyObject<TExtensionsMap['props']> extends true
+type ErrorInputPluginProps<TPluginsMap extends ErrorPluginsMap> = {
+  [TKey in keyof TPluginsMap['props'] as IsOnlyUndefined<TPluginsMap['props'][TKey]['init']> extends true
+    ? never
+    : TKey]?: TPluginsMap['props'][TKey]['init']
+}
+export type ErrorInput<TPluginsMap extends ErrorPluginsMap> =
+  IsEmptyObject<TPluginsMap['props']> extends true
     ? ErrorInputBase
-    : ErrorInputBase &
-        Partial<{
-          [TKey in keyof TExtensionsMap['props']]: TExtensionsMap['props'][TKey]['input']
-        }>
+    : ErrorInputBase & ErrorInputPluginProps<TPluginsMap>
 
-type ErrorOutputProps<TExtensionsMap extends ErrorExtensionsMap> = {
-  [TKey in keyof TExtensionsMap['props']]: TExtensionsMap['props'][TKey]['output']
-}
-type ErrorOutputComputed<TExtensionsMap extends ErrorExtensionsMap> = {
-  [TKey in keyof TExtensionsMap['computed']]: TExtensionsMap['computed'][TKey]
+type ErrorOutputProps<TPluginsMap extends ErrorPluginsMap> = {
+  [TKey in keyof TPluginsMap['props']]: TPluginsMap['props'][TKey]['resolve'] | undefined
 }
-type ErrorOutputMethods<TExtensionsMap extends ErrorExtensionsMap> = {
-  [TKey in keyof TExtensionsMap['methods']]: TExtensionsMap['methods'][TKey] extends {
+type ErrorOutputMethods<TPluginsMap extends ErrorPluginsMap> = {
+  [TKey in keyof TPluginsMap['methods']]: TPluginsMap['methods'][TKey] extends {
     args: infer TArgs extends unknown[]
     output: infer TOutput
   }
     ? (...args: TArgs) => TOutput
     : never
 }
-export type ErrorOutput<TExtensionsMap extends ErrorExtensionsMap> = ErrorOutputProps<TExtensionsMap> &
-  ErrorOutputComputed<TExtensionsMap> &
-  ErrorOutputMethods<TExtensionsMap>
+export type ErrorOutput<TPluginsMap extends ErrorPluginsMap> = ErrorOutputProps<TPluginsMap> &
+  ErrorOutputMethods<TPluginsMap>
 
-type ErrorStaticMethods<TExtensionsMap extends ErrorExtensionsMap> = {
-  [TKey in keyof TExtensionsMap['methods']]: TExtensionsMap['methods'][TKey] extends {
+type ErrorStaticMethods<TPluginsMap extends ErrorPluginsMap> = {
+  [TKey in keyof TPluginsMap['methods']]: TPluginsMap['methods'][TKey] extends {
     args: infer TArgs extends unknown[]
     output: infer TOutput
   }
@@ -97,278 +104,227 @@ type ErrorStaticMethods<TExtensionsMap extends ErrorExtensionsMap> = {
     : never
 }
 
-type EmptyExtensionsMap = {
-  props: Record<never, { input: never; output: never }>
-  computed: Record<never, never>
+type EmptyPluginsMap = {
+  props: Record<never, { init: never; resolve: never }>
   methods: Record<never, ErrorMethodRecord>
 }
 
-type ErrorExtensionResolved = {
-  props: Record<string, ErrorExtensionPropOptions<unknown, unknown>>
-  computed: Record<string, ErrorExtensionCopmputedFn<unknown>>
-  methods: Record<string, ErrorExtensionMethodFn<unknown>>
-  refine: Array<ErrorExtensionRefineFn<Error0, Record<string, unknown>>>
+type ErrorPluginResolved = {
+  props: Record<string, ErrorPluginPropOptions<unknown, unknown>>
+  methods: Record<string, ErrorPluginMethodFn<unknown>>
+  adapt: Array<ErrorPluginAdaptFn<Error0, Record<string, unknown>>>
 }
 
-type ExtensionPropsMapOf<TExtension extends ErrorExtension> = {
-  [TKey in keyof NonNullable<TExtension['props']>]: NonNullable<
-    TExtension['props']
-  >[TKey] extends ErrorExtensionPropOptions<infer TInputValue, infer TOutputValue>
-    ? { input: TInputValue; output: TOutputValue }
+type PluginPropsMapOf<TPlugin extends ErrorPlugin> = {
+  [TKey in keyof NonNullable<TPlugin['props']>]: NonNullable<TPlugin['props']>[TKey] extends ErrorPluginPropOptions<
+    any,
+    infer TOutputValue
+  >
+    ? { init: InferPluginPropInput<NonNullable<TPlugin['props']>[TKey]>; resolve: TOutputValue }
     : never
 }
-type ExtensionComputedMapOf<TExtension extends ErrorExtension> = {
-  [TKey in keyof NonNullable<TExtension['computed']>]: NonNullable<
-    TExtension['computed']
-  >[TKey] extends ErrorExtensionCopmputedFn<infer TOutputValue>
-    ? TOutputValue
-    : never
-}
-type ExtensionMethodsMapOf<TExtension extends ErrorExtension> = {
-  [TKey in keyof NonNullable<TExtension['methods']>]: NonNullable<TExtension['methods']>[TKey] extends (
+type PluginMethodsMapOf<TPlugin extends ErrorPlugin> = {
+  [TKey in keyof NonNullable<TPlugin['methods']>]: NonNullable<TPlugin['methods']>[TKey] extends (
     error: Error0,
     ...args: infer TArgs extends unknown[]
   ) => infer TOutput
     ? { args: TArgs; output: TOutput }
     : never
 }
-type ErrorExtensionsMapOfExtension<TExtension extends ErrorExtension> = {
-  props: ExtensionPropsMapOf<TExtension>
-  computed: ExtensionComputedMapOf<TExtension>
-  methods: ExtensionMethodsMapOf<TExtension>
+type ErrorPluginsMapOfPlugin<TPlugin extends ErrorPlugin> = {
+  props: PluginPropsMapOf<TPlugin>
+  methods: PluginMethodsMapOf<TPlugin>
 }
-type ExtendErrorExtensionsMap<TMap extends ErrorExtensionsMap, TExtension extends ErrorExtension> = {
-  props: TMap['props'] & ErrorExtensionsMapOfExtension<TExtension>['props']
-  computed: TMap['computed'] & ErrorExtensionsMapOfExtension<TExtension>['computed']
-  methods: TMap['methods'] & ErrorExtensionsMapOfExtension<TExtension>['methods']
+type ExtendErrorPluginsMap<TMap extends ErrorPluginsMap, TPlugin extends ErrorPlugin> = {
+  props: TMap['props'] & ErrorPluginsMapOfPlugin<TPlugin>['props']
+  methods: TMap['methods'] & ErrorPluginsMapOfPlugin<TPlugin>['methods']
 }
-type ExtendErrorExtensionsMapWithProp<
-  TMap extends ErrorExtensionsMap,
+type ExtendErrorPluginsMapWithProp<
+  TMap extends ErrorPluginsMap,
   TKey extends string,
   TInputValue,
   TOutputValue,
-> = ExtendErrorExtensionsMap<TMap, ErrorExtension<Record<TKey, ErrorExtensionPropOptions<TInputValue, TOutputValue>>>>
-type ExtendErrorExtensionsMapWithComputed<
-  TMap extends ErrorExtensionsMap,
-  TKey extends string,
-  TOutputValue,
-> = ExtendErrorExtensionsMap<
-  TMap,
-  ErrorExtension<Record<never, never>, Record<TKey, ErrorExtensionCopmputedFn<TOutputValue>>>
->
-type ExtendErrorExtensionsMapWithMethod<
-  TMap extends ErrorExtensionsMap,
+> = ExtendErrorPluginsMap<TMap, ErrorPlugin<Record<TKey, ErrorPluginPropOptions<TInputValue, TOutputValue>>>>
+type ExtendErrorPluginsMapWithMethod<
+  TMap extends ErrorPluginsMap,
   TKey extends string,
   TArgs extends unknown[],
   TOutputValue,
-> = ExtendErrorExtensionsMap<
+> = ExtendErrorPluginsMap<
   TMap,
-  ErrorExtension<Record<never, never>, Record<never, never>, Record<TKey, ErrorExtensionMethodFn<TOutputValue, TArgs>>>
+  ErrorPlugin<Record<never, never>, Record<TKey, ErrorPluginMethodFn<TOutputValue, TArgs>>>
 >
 
-type ExtensionsMapOf<TClass> = TClass extends { __extensionsMap?: infer TExtensionsMap }
-  ? TExtensionsMap extends ErrorExtensionsMap
-    ? TExtensionsMap
-    : EmptyExtensionsMap
-  : EmptyExtensionsMap
-
-type ExtensionsMapFromParts<
-  TProps extends ErrorExtensionProps,
-  TComputed extends ErrorExtensionComputed,
-  TMethods extends ErrorExtensionMethods,
-> = ErrorExtensionsMapOfExtension<ErrorExtension<TProps, TComputed, TMethods>>
-type ErrorInstanceOfMap<TMap extends ErrorExtensionsMap> = Error0 & ErrorOutput<TMap>
-type BuilderError0<
-  TProps extends ErrorExtensionProps,
-  TComputed extends ErrorExtensionComputed,
-  TMethods extends ErrorExtensionMethods,
-> = Error0 & ErrorOutput<ExtensionsMapFromParts<TProps, TComputed, TMethods>>
-
-type ExtensionOfBuilder<TBuilder> =
-  TBuilder extends ExtensionError0<infer TProps, infer TComputed, infer TMethods>
-    ? ErrorExtension<TProps, TComputed, TMethods>
-    : never
-
-export type ErrorFlowPolicy = 'instance' | 'error0' | 'likeError0' | 'all'
-
-export class ExtensionError0<
-  TProps extends ErrorExtensionProps = Record<never, never>,
-  TComputed extends ErrorExtensionComputed = Record<never, never>,
-  TMethods extends ErrorExtensionMethods = Record<never, never>,
+type PluginsMapOf<TClass> = TClass extends { __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 BuilderError0<TProps extends ErrorPluginProps, TMethods extends ErrorPluginMethods> = Error0 &
+  ErrorOutput<PluginsMapFromParts<TProps, TMethods>>
+
+type PluginOfBuilder<TBuilder> =
+  TBuilder extends PluginError0<infer TProps, infer TMethods> ? ErrorPlugin<TProps, TMethods> : never
+
+export class PluginError0<
+  TProps extends ErrorPluginProps = Record<never, never>,
+  TMethods extends ErrorPluginMethods = Record<never, never>,
 > {
-  private readonly _extension: ErrorExtension<ErrorExtensionProps, ErrorExtensionComputed, ErrorExtensionMethods>
+  private readonly _plugin: ErrorPlugin<ErrorPluginProps, ErrorPluginMethods>
 
   readonly Infer = undefined as unknown as {
     props: TProps
-    computed: TComputed
     methods: TMethods
   }
 
-  constructor(extension?: ErrorExtension<ErrorExtensionProps, ErrorExtensionComputed, ErrorExtensionMethods>) {
-    this._extension = {
-      props: { ...(extension?.props ?? {}) },
-      computed: { ...(extension?.computed ?? {}) },
-      methods: { ...(extension?.methods ?? {}) },
-      refine: [...(extension?.refine ?? [])],
+  constructor(plugin?: ErrorPlugin<ErrorPluginProps, ErrorPluginMethods>) {
+    this._plugin = {
+      props: { ...(plugin?.props ?? {}) },
+      methods: { ...(plugin?.methods ?? {}) },
+      adapt: [...(plugin?.adapt ?? [])],
     }
   }
 
   prop<TKey extends string, TInputValue, TOutputValue>(
     key: TKey,
-    value: ErrorExtensionPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TComputed, TMethods>>,
-  ): ExtensionError0<AddPropToExtensionProps<TProps, TKey, TInputValue, TOutputValue>, TComputed, TMethods> {
-    return this.extend('prop', key, value)
-  }
-
-  computed<TKey extends string, TOutputValue>(
-    key: TKey,
-    value: ErrorExtensionCopmputedFn<TOutputValue, BuilderError0<TProps, TComputed, TMethods>>,
-  ): ExtensionError0<TProps, AddComputedToExtensionComputed<TComputed, TKey, TOutputValue>, TMethods> {
-    return this.extend('computed', key, value)
+    value: ErrorPluginPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>>,
+  ): PluginError0<AddPropToPluginProps<TProps, TKey, TInputValue, TOutputValue>, TMethods> {
+    return this.use('prop', key, value)
   }
 
   method<TKey extends string, TArgs extends unknown[], TOutputValue>(
     key: TKey,
-    value: ErrorExtensionMethodFn<TOutputValue, TArgs, BuilderError0<TProps, TComputed, TMethods>>,
-  ): ExtensionError0<TProps, TComputed, AddMethodToExtensionMethods<TMethods, TKey, TArgs, TOutputValue>> {
-    return this.extend('method', key, value)
+    value: ErrorPluginMethodFn<TOutputValue, TArgs, BuilderError0<TProps, TMethods>>,
+  ): PluginError0<TProps, AddMethodToPluginMethods<TMethods, TKey, TArgs, TOutputValue>> {
+    return this.use('method', key, value)
   }
 
-  refine(
-    value: ErrorExtensionRefineFn<BuilderError0<TProps, TComputed, TMethods>, ExtensionOutputProps<TProps>>,
-  ): ExtensionError0<TProps, TComputed, TMethods> {
-    return this.extend('refine', value)
+  adapt(
+    value: ErrorPluginAdaptFn<BuilderError0<TProps, TMethods>, PluginOutputProps<TProps>>,
+  ): PluginError0<TProps, TMethods> {
+    return this.use('adapt', value)
   }
 
-  extend<TKey extends string, TInputValue, TOutputValue>(
+  use<TKey extends string, TInputValue, TOutputValue>(
     kind: 'prop',
     key: TKey,
-    value: ErrorExtensionPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TComputed, TMethods>>,
-  ): ExtensionError0<AddPropToExtensionProps<TProps, TKey, TInputValue, TOutputValue>, TComputed, TMethods>
-  extend<TKey extends string, TOutputValue>(
-    kind: 'computed',
-    key: TKey,
-    value: ErrorExtensionCopmputedFn<TOutputValue, BuilderError0<TProps, TComputed, TMethods>>,
-  ): ExtensionError0<TProps, AddComputedToExtensionComputed<TComputed, TKey, TOutputValue>, TMethods>
-  extend<TKey extends string, TArgs extends unknown[], TOutputValue>(
+    value: ErrorPluginPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>>,
+  ): PluginError0<AddPropToPluginProps<TProps, TKey, TInputValue, TOutputValue>, TMethods>
+  use<TKey extends string, TArgs extends unknown[], TOutputValue>(
     kind: 'method',
     key: TKey,
-    value: ErrorExtensionMethodFn<TOutputValue, TArgs, BuilderError0<TProps, TComputed, TMethods>>,
-  ): ExtensionError0<TProps, TComputed, AddMethodToExtensionMethods<TMethods, TKey, TArgs, TOutputValue>>
-  extend(
-    kind: 'refine',
-    value: ErrorExtensionRefineFn<BuilderError0<TProps, TComputed, TMethods>, ExtensionOutputProps<TProps>>,
-  ): ExtensionError0<TProps, TComputed, TMethods>
-  extend(
-    kind: 'prop' | 'computed' | 'method' | 'refine',
-    keyOrValue: string | ErrorExtensionRefineFn<any, any>,
-    value?:
-      | ErrorExtensionPropOptions<unknown, unknown, any>
-      | ErrorExtensionCopmputedFn<unknown, any>
-      | ErrorExtensionMethodFn<unknown, unknown[], any>,
-  ): ExtensionError0<any, any, any> {
-    const nextProps: ErrorExtensionProps = { ...(this._extension.props ?? {}) }
-    const nextComputed: ErrorExtensionComputed = { ...(this._extension.computed ?? {}) }
-    const nextMethods: ErrorExtensionMethods = { ...(this._extension.methods ?? {}) }
-    const nextRefine: Array<ErrorExtensionRefineFn<Error0, Record<string, unknown>>> = [
-      ...(this._extension.refine ?? []),
-    ]
+    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: 'prop' | 'method' | 'adapt',
+    keyOrValue: string | ErrorPluginAdaptFn<any, any>,
+    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 ?? [])]
     if (kind === 'prop') {
       const key = keyOrValue as string
       if (value === undefined) {
-        throw new Error('ExtensionError0.extend("prop", key, value) requires value')
+        throw new Error('PluginError0.use("prop", key, value) requires value')
       }
-      nextProps[key] = value as ErrorExtensionPropOptions<any, any>
-    } else if (kind === 'computed') {
-      const key = keyOrValue as string
-      if (value === undefined) {
-        throw new Error('ExtensionError0.extend("computed", key, value) requires value')
-      }
-      nextComputed[key] = value as ErrorExtensionCopmputedFn<any>
+      nextProps[key] = value as ErrorPluginPropOptions<any, any>
     } else if (kind === 'method') {
       const key = keyOrValue as string
       if (value === undefined) {
-        throw new Error('ExtensionError0.extend("method", key, value) requires value')
+        throw new Error('PluginError0.use("method", key, value) requires value')
       }
-      nextMethods[key] = value as ErrorExtensionMethodFn<any, any[]>
+      nextMethods[key] = value as ErrorPluginMethodFn<any, any[]>
     } else {
-      nextRefine.push(keyOrValue as ErrorExtensionRefineFn<Error0, Record<string, unknown>>)
+      nextAdapt.push(keyOrValue as ErrorPluginAdaptFn<Error0, Record<string, unknown>>)
     }
-    return new ExtensionError0({
+    return new PluginError0({
       props: nextProps,
-      computed: nextComputed,
       methods: nextMethods,
-      refine: nextRefine,
+      adapt: nextAdapt,
     })
   }
 }
 
-export type ClassError0<TExtensionsMap extends ErrorExtensionsMap = EmptyExtensionsMap> = {
-  new (message: string, input?: ErrorInput<TExtensionsMap>): Error0 & ErrorOutput<TExtensionsMap>
-  new (input: { message: string } & ErrorInput<TExtensionsMap>): Error0 & ErrorOutput<TExtensionsMap>
-  readonly __extensionsMap?: TExtensionsMap
-  from: (error: unknown) => Error0 & ErrorOutput<TExtensionsMap>
-  serialize: (error: unknown, isPublic?: boolean) => object
-  extend: {
-    <TBuilder extends ExtensionError0>(
-      extension: TBuilder,
-    ): ClassError0<ExtendErrorExtensionsMap<TExtensionsMap, ExtensionOfBuilder<TBuilder>>>
+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>
+  readonly __pluginsMap?: TPluginsMap
+  from: (error: unknown) => Error0 & ErrorOutput<TPluginsMap>
+  serialize: (error: unknown, isPublic?: boolean) => Record<string, unknown>
+  prop: <TKey extends string, TInputValue, TOutputValue>(
+    key: TKey,
+    value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TPluginsMap>>,
+  ) => ClassError0<ExtendErrorPluginsMapWithProp<TPluginsMap, TKey, TInputValue, TOutputValue>>
+  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>>,
+  ) => ClassError0<TPluginsMap>
+  use: {
+    <TBuilder extends PluginError0>(
+      plugin: TBuilder,
+    ): ClassError0<ExtendErrorPluginsMap<TPluginsMap, PluginOfBuilder<TBuilder>>>
     <TKey extends string, TInputValue, TOutputValue>(
       kind: 'prop',
       key: TKey,
-      value: ErrorExtensionPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TExtensionsMap>>,
-    ): ClassError0<ExtendErrorExtensionsMapWithProp<TExtensionsMap, TKey, TInputValue, TOutputValue>>
-    <TKey extends string, TOutputValue>(
-      kind: 'computed',
-      key: TKey,
-      value: ErrorExtensionCopmputedFn<TOutputValue, ErrorInstanceOfMap<TExtensionsMap>>,
-    ): ClassError0<ExtendErrorExtensionsMapWithComputed<TExtensionsMap, TKey, TOutputValue>>
+      value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TPluginsMap>>,
+    ): ClassError0<ExtendErrorPluginsMapWithProp<TPluginsMap, TKey, TInputValue, TOutputValue>>
     <TKey extends string, TArgs extends unknown[], TOutputValue>(
       kind: 'method',
       key: TKey,
-      value: ErrorExtensionMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<TExtensionsMap>>,
-    ): ClassError0<ExtendErrorExtensionsMapWithMethod<TExtensionsMap, TKey, TArgs, TOutputValue>>
+      value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<TPluginsMap>>,
+    ): ClassError0<ExtendErrorPluginsMapWithMethod<TPluginsMap, TKey, TArgs, TOutputValue>>
     (
-      kind: 'refine',
-      value: ErrorExtensionRefineFn<ErrorInstanceOfMap<TExtensionsMap>, ErrorOutputProps<TExtensionsMap>>,
-    ): ClassError0<TExtensionsMap>
+      kind: 'adapt',
+      value: ErrorPluginAdaptFn<ErrorInstanceOfMap<TPluginsMap>, ErrorOutputProps<TPluginsMap>>,
+    ): ClassError0<TPluginsMap>
   }
-  extension: () => ExtensionError0
-} & ErrorStaticMethods<TExtensionsMap>
+  plugin: () => PluginError0
+} & ErrorStaticMethods<TPluginsMap>
 
 export class Error0 extends Error {
-  static readonly __extensionsMap?: EmptyExtensionsMap
-  protected static _extensions: ErrorExtension[] = []
+  static readonly __pluginsMap?: EmptyPluginsMap
+  protected static _plugins: ErrorPlugin[] = []
 
-  private static readonly _emptyExtension: ErrorExtensionResolved = {
+  private static readonly _emptyPlugin: ErrorPluginResolved = {
     props: {},
-    computed: {},
     methods: {},
-    refine: [],
+    adapt: [],
   }
 
-  private static _getResolvedExtension(this: typeof Error0): ErrorExtensionResolved {
-    const resolved: ErrorExtensionResolved = {
+  private static _getResolvedPlugin(this: typeof Error0): ErrorPluginResolved {
+    const resolved: ErrorPluginResolved = {
       props: {},
-      computed: {},
       methods: {},
-      refine: [],
+      adapt: [],
     }
-    for (const extension of this._extensions) {
-      Object.assign(resolved.props, extension.props ?? this._emptyExtension.props)
-      Object.assign(resolved.computed, extension.computed ?? this._emptyExtension.computed)
-      Object.assign(resolved.methods, extension.methods ?? this._emptyExtension.methods)
-      resolved.refine.push(...(extension.refine ?? this._emptyExtension.refine))
+    for (const plugin of this._plugins) {
+      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))
     }
     return resolved
   }
 
-  constructor(message: string, input?: ErrorInput<EmptyExtensionsMap>)
-  constructor(input: { message: string } & ErrorInput<EmptyExtensionsMap>)
+  constructor(message: string, input?: ErrorInput<EmptyPluginsMap>)
+  constructor(input: { message: string } & ErrorInput<EmptyPluginsMap>)
   constructor(
     ...args:
-      | [message: string, input?: ErrorInput<EmptyExtensionsMap>]
-      | [{ message: string } & ErrorInput<EmptyExtensionsMap>]
+      | [message: string, input?: ErrorInput<EmptyPluginsMap>]
+      | [{ message: string } & ErrorInput<EmptyPluginsMap>]
   ) {
     const [first, second] = args
     const input = typeof first === 'string' ? { message: first, ...(second ?? {}) } : first
@@ -377,15 +333,15 @@ export class Error0 extends Error {
     this.name = 'Error0'
 
     const ctor = this.constructor as typeof Error0
-    const extension = ctor._getResolvedExtension()
+    const plugin = ctor._getResolvedPlugin()
 
-    for (const [key, prop] of Object.entries(extension.props)) {
+    for (const [key, prop] of Object.entries(plugin.props)) {
       if (key in input) {
         const ownValue = (input as Record<string, unknown>)[key]
-        ;(this as Record<string, unknown>)[key] = prop.input(ownValue)
+        ;(this as Record<string, unknown>)[key] = prop.init(ownValue)
       } else {
         Object.defineProperty(this, key, {
-          get: () => prop.output(this),
+          get: () => prop.resolve({ value: undefined, flow: this.flow(key), error: this }),
           set: (value) => {
             Object.defineProperty(this, key, {
               value,
@@ -399,22 +355,6 @@ export class Error0 extends Error {
         })
       }
     }
-
-    for (const [key, computed] of Object.entries(extension.computed)) {
-      Object.defineProperty(this, key, {
-        get: () => computed(this),
-        set: (value) => {
-          Object.defineProperty(this, key, {
-            value,
-            writable: true,
-            enumerable: true,
-            configurable: true,
-          })
-        },
-        enumerable: true,
-        configurable: true,
-      })
-    }
   }
 
   private static readonly isSelfProperty = (object: object, key: string): boolean => {
@@ -441,120 +381,112 @@ export class Error0 extends Error {
     return ctor.own(this, key)
   }
 
-  static flow(error: object, key: string, policy: ErrorFlowPolicy = 'likeError0'): unknown[] {
-    return this.causes(error, policy).map((cause) => {
-      const causeRecord = cause as Record<string, unknown>
-      if (this.isSelfProperty(causeRecord, key)) {
-        return causeRecord[key]
-      }
-      return undefined
+  static flow(error: object, key: string): unknown[] {
+    return this.causes(error, true).map((cause) => {
+      return this.own(cause, key)
     })
   }
-  flow(key: string, policy: ErrorFlowPolicy = 'likeError0'): unknown[] {
+  flow(key: string): unknown[] {
     const ctor = this.constructor as typeof Error0
-    return ctor.flow(this, key, policy)
+    return ctor.flow(this, key)
   }
 
-  static causes(error: object, policy: ErrorFlowPolicy = 'all'): object[] {
-    const causes: object[] = []
+  static causes(error: unknown, instancesOnly?: false): unknown[]
+  static causes<T extends typeof Error0>(this: T, error: unknown, instancesOnly: true): Array<InstanceType<T>>
+  static causes(error: unknown, instancesOnly?: boolean): unknown[] {
+    const causes: unknown[] = []
     let current: unknown = error
     const maxDepth = 99
     const seen = new Set<unknown>()
-
     for (let depth = 0; depth < maxDepth; depth += 1) {
-      if (!current || typeof current !== 'object') {
-        break
-      }
       if (seen.has(current)) {
         break
       }
-      if (policy === 'instance') {
-        if (!this.is(current)) {
-          break
-        }
-      } else if (policy === 'error0') {
-        if (!this.isError0(current)) {
-          break
-        }
-      } else if (policy === 'likeError0') {
-        if (!this.isLikeError0(current)) {
-          break
-        }
-      }
       seen.add(current)
-      causes.push(current)
+      if (!instancesOnly || this.is(current)) {
+        causes.push(current)
+      }
+      if (!current || typeof current !== 'object') {
+        break
+      }
       current = (current as { cause?: unknown }).cause
     }
-
     return causes
   }
-  causes(policy: ErrorFlowPolicy = 'all'): object[] {
+  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(instancesOnly?: boolean): unknown[] {
     const ctor = this.constructor as typeof Error0
-    return ctor.causes(this, policy)
+    if (instancesOnly) {
+      return ctor.causes(this, true)
+    }
+    return ctor.causes(this)
   }
 
-  static is(error: unknown): error is Error0 {
+  static is<T extends typeof Error0>(this: T, error: unknown): error is InstanceType<T> {
     return error instanceof this
   }
 
-  static isError0(error: unknown): error is Error0 {
-    return error instanceof Error0
-  }
-
-  static isLikeError0(error: unknown): error is Error0 | object {
-    return (
-      error instanceof Error0 ||
-      (typeof error === 'object' && error !== null && 'name' in error && error.name === 'Error0')
-    )
+  static isSerialized(error: unknown): error is Record<string, unknown> {
+    return !this.is(error) && typeof error === 'object' && error !== null && 'name' in error && error.name === 'Error0'
   }
 
   static from(error: unknown): Error0 {
     if (this.is(error)) {
       return error
     }
-    if (this.isLikeError0(error)) {
-      return this._fromLikeError0(error)
+    if (this.isSerialized(error)) {
+      return this._fromSerialized(error)
     }
     return this._fromNonError0(error)
   }
 
-  private static _applyRefine(error: Error0): Error0 {
-    const extension = this._getResolvedExtension()
-    for (const refine of extension.refine) {
-      const refined = refine(error as any)
-      if (refined && typeof refined === 'object') {
-        Object.assign(error as unknown as Record<string, unknown>, refined)
+  private static _applyAdapt(error: Error0): Error0 {
+    const plugin = this._getResolvedPlugin()
+    for (const adapt of plugin.adapt) {
+      const adapted = adapt(error as any)
+      if (adapted && typeof adapted === 'object') {
+        Object.assign(error as unknown as Record<string, unknown>, adapted)
       }
     }
     return error
   }
 
-  private static _fromLikeError0(error: unknown): Error0 {
+  private static _fromSerialized(error: unknown): Error0 {
     const message = this._extractMessage(error)
     if (typeof error !== 'object' || error === null) {
-      return this._applyRefine(new this(message, { cause: error }))
+      return this._applyAdapt(new this(message, { cause: error }))
     }
-
     const errorRecord = error as Record<string, unknown>
     const recreated = new this(message)
-    const temp = new this(message, { cause: errorRecord })
-    const extension = this._getResolvedExtension()
-    for (const [key, prop] of Object.entries(extension.props)) {
-      const value = prop.output(temp)
-      if (value !== undefined) {
+    const plugin = this._getResolvedPlugin()
+    const propsEntries = Object.entries(plugin.props)
+    for (const [key, prop] of propsEntries) {
+      if (prop.deserialize === false) {
+        continue
+      }
+      if (!(key in errorRecord)) {
+        continue
+      }
+      try {
+        const value = prop.deserialize({ value: errorRecord[key], serialized: errorRecord })
         ;(recreated as unknown as Record<string, unknown>)[key] = value
+      } catch {
+        // ignore
       }
     }
-    ;(recreated as unknown as { cause?: unknown }).cause = errorRecord.cause
-    if (typeof errorRecord.stack === 'string') {
+    // 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
     }
-    return this._applyRefine(recreated)
+    return recreated
   }
 
   private static _fromNonError0(error: unknown): Error0 {
     const message = this._extractMessage(error)
-    return this._applyRefine(new this(message, { cause: error }))
+    return this._applyAdapt(new this(message, { cause: error }))
   }
 
   private static _extractMessage(error: unknown): string {
@@ -567,15 +499,15 @@ export class Error0 extends Error {
     )
   }
 
-  private static _extendWithExtension(
+  private static _useWithPlugin(
     this: typeof Error0,
-    extension: ErrorExtension<ErrorExtensionProps, ErrorExtensionComputed, ErrorExtensionMethods>,
+    plugin: ErrorPlugin<ErrorPluginProps, ErrorPluginMethods>,
   ): ClassError0 {
     const Base = this as unknown as typeof Error0
     const Error0Extended = class Error0 extends Base {}
-    ;(Error0Extended as typeof Error0)._extensions = [...Base._extensions, extension]
+    ;(Error0Extended as typeof Error0)._plugins = [...Base._plugins, plugin]
 
-    const resolved = (Error0Extended as typeof Error0)._getResolvedExtension()
+    const resolved = (Error0Extended as typeof Error0)._getResolvedPlugin()
     for (const [key, method] of Object.entries(resolved.methods)) {
       Object.defineProperty((Error0Extended as typeof Error0).prototype, key, {
         value: function (...args: unknown[]) {
@@ -598,115 +530,129 @@ export class Error0 extends Error {
     return Error0Extended as unknown as ClassError0
   }
 
-  private static _extensionFromBuilder(
-    extension: ExtensionError0,
-  ): ErrorExtension<ErrorExtensionProps, ErrorExtensionComputed, ErrorExtensionMethods> {
-    const extensionRecord = extension as unknown as {
-      _extension: ErrorExtension<ErrorExtensionProps, ErrorExtensionComputed, ErrorExtensionMethods>
+  private static _pluginFromBuilder(plugin: PluginError0): ErrorPlugin<ErrorPluginProps, ErrorPluginMethods> {
+    const pluginRecord = plugin as unknown as {
+      _plugin: ErrorPlugin<ErrorPluginProps, ErrorPluginMethods>
     }
     return {
-      props: { ...(extensionRecord._extension.props ?? {}) },
-      computed: { ...(extensionRecord._extension.computed ?? {}) },
-      methods: { ...(extensionRecord._extension.methods ?? {}) },
-      refine: [...(extensionRecord._extension.refine ?? [])],
+      props: { ...(pluginRecord._plugin.props ?? {}) },
+      methods: { ...(pluginRecord._plugin.methods ?? {}) },
+      adapt: [...(pluginRecord._plugin.adapt ?? [])],
     }
   }
 
-  static extend<TThis extends typeof Error0, TBuilder extends ExtensionError0>(
+  static prop<TThis extends typeof Error0, TKey extends string, TInputValue, TOutputValue>(
     this: TThis,
-    extension: TBuilder,
-  ): ClassError0<ExtendErrorExtensionsMap<ExtensionsMapOf<TThis>, ExtensionOfBuilder<TBuilder>>>
-  static extend<TThis extends typeof Error0, TKey extends string, TInputValue, TOutputValue>(
+    key: TKey,
+    value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<PluginsMapOf<TThis>>>,
+  ): ClassError0<ExtendErrorPluginsMapWithProp<PluginsMapOf<TThis>, TKey, TInputValue, TOutputValue>> {
+    return this.use('prop', key, value)
+  }
+
+  static method<TThis extends typeof Error0, TKey extends string, TArgs extends unknown[], TOutputValue>(
     this: TThis,
-    kind: 'prop',
     key: TKey,
-    value: ErrorExtensionPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<ExtensionsMapOf<TThis>>>,
-  ): ClassError0<ExtendErrorExtensionsMapWithProp<ExtensionsMapOf<TThis>, TKey, TInputValue, TOutputValue>>
-  static extend<TThis extends typeof Error0, TKey extends string, TOutputValue>(
+    value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<PluginsMapOf<TThis>>>,
+  ): ClassError0<ExtendErrorPluginsMapWithMethod<PluginsMapOf<TThis>, TKey, TArgs, TOutputValue>> {
+    return this.use('method', key, value)
+  }
+
+  static adapt<TThis extends typeof Error0>(
+    this: TThis,
+    value: ErrorPluginAdaptFn<ErrorInstanceOfMap<PluginsMapOf<TThis>>, ErrorOutputProps<PluginsMapOf<TThis>>>,
+  ): ClassError0<PluginsMapOf<TThis>> {
+    return this.use('adapt', 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>(
     this: TThis,
-    kind: 'computed',
+    kind: 'prop',
     key: TKey,
-    value: ErrorExtensionCopmputedFn<TOutputValue, ErrorInstanceOfMap<ExtensionsMapOf<TThis>>>,
-  ): ClassError0<ExtendErrorExtensionsMapWithComputed<ExtensionsMapOf<TThis>, TKey, TOutputValue>>
-  static extend<TThis extends typeof Error0, TKey extends string, TArgs extends unknown[], TOutputValue>(
+    value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<PluginsMapOf<TThis>>>,
+  ): ClassError0<ExtendErrorPluginsMapWithProp<PluginsMapOf<TThis>, TKey, TInputValue, TOutputValue>>
+  static use<TThis extends typeof Error0, TKey extends string, TArgs extends unknown[], TOutputValue>(
     this: TThis,
     kind: 'method',
     key: TKey,
-    value: ErrorExtensionMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<ExtensionsMapOf<TThis>>>,
-  ): ClassError0<ExtendErrorExtensionsMapWithMethod<ExtensionsMapOf<TThis>, TKey, TArgs, TOutputValue>>
-  static extend<TThis extends typeof Error0>(
+    value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<PluginsMapOf<TThis>>>,
+  ): ClassError0<ExtendErrorPluginsMapWithMethod<PluginsMapOf<TThis>, TKey, TArgs, TOutputValue>>
+  static use<TThis extends typeof Error0>(
     this: TThis,
-    kind: 'refine',
-    value: ErrorExtensionRefineFn<ErrorInstanceOfMap<ExtensionsMapOf<TThis>>, ErrorOutputProps<ExtensionsMapOf<TThis>>>,
-  ): ClassError0<ExtensionsMapOf<TThis>>
-  static extend(
+    kind: 'adapt',
+    value: ErrorPluginAdaptFn<ErrorInstanceOfMap<PluginsMapOf<TThis>>, ErrorOutputProps<PluginsMapOf<TThis>>>,
+  ): ClassError0<PluginsMapOf<TThis>>
+  static use(
     this: typeof Error0,
-    first: ExtensionError0 | 'prop' | 'computed' | 'method' | 'refine',
-    key?: string | ErrorExtensionRefineFn<any, any>,
-    value?:
-      | ErrorExtensionPropOptions<unknown, unknown>
-      | ErrorExtensionCopmputedFn<unknown>
-      | ErrorExtensionMethodFn<unknown>,
+    first: PluginError0 | 'prop' | 'method' | 'adapt',
+    key?: string | ErrorPluginAdaptFn<any, any>,
+    value?: ErrorPluginPropOptions<unknown, unknown> | ErrorPluginMethodFn<unknown>,
   ): ClassError0 {
-    if (first instanceof ExtensionError0) {
-      return this._extendWithExtension(this._extensionFromBuilder(first))
+    if (first instanceof PluginError0) {
+      return this._useWithPlugin(this._pluginFromBuilder(first))
     }
-    if (first === 'refine') {
+    if (first === 'adapt') {
       if (typeof key !== 'function') {
-        throw new Error('Error0.extend("refine", value) requires refine function')
+        throw new Error('Error0.use("adapt", value) requires adapt function')
       }
-      return this._extendWithExtension({
-        refine: [key],
+      return this._useWithPlugin({
+        adapt: [key],
       })
     }
     if (typeof key !== 'string' || value === undefined) {
-      throw new Error('Error0.extend(kind, key, value) requires key and value')
+      throw new Error('Error0.use(kind, key, value) requires key and value')
     }
 
     if (first === 'prop') {
-      return this._extendWithExtension({
-        props: { [key]: value as ErrorExtensionPropOptions<unknown, unknown> },
+      return this._useWithPlugin({
+        props: { [key]: value as ErrorPluginPropOptions<unknown, unknown> },
       })
     }
-    if (first === 'computed') {
-      return this._extendWithExtension({
-        computed: { [key]: value as ErrorExtensionCopmputedFn<unknown> },
-      })
-    }
-    return this._extendWithExtension({
-      methods: { [key]: value as ErrorExtensionMethodFn<unknown> },
+    return this._useWithPlugin({
+      methods: { [key]: value as ErrorPluginMethodFn<unknown> },
     })
   }
 
-  static extension(): ExtensionError0 {
-    return new ExtensionError0()
+  static plugin(): PluginError0 {
+    return new PluginError0()
   }
 
-  static serialize(error: unknown, isPublic = true): object {
+  static serialize(error: unknown, isPublic = true): Record<string, unknown> {
     const error0 = this.from(error)
-    const jsonWithUndefined: Record<string, unknown> = {
+    const json: Record<string, unknown> = {
       name: error0.name,
       message: error0.message,
-      cause: error0.cause,
-      stack: error0.stack,
+      // we do not serialize causes, it is enough that we have floated props and adapt helper
+      // cause: error0.cause,
     }
 
-    const extension = this._getResolvedExtension()
-    for (const [key, prop] of Object.entries(extension.props)) {
-      const value = prop.output(error0)
-      const jsonValue = prop.serialize(value, error0, isPublic)
-      if (jsonValue !== undefined) {
-        jsonWithUndefined[key] = jsonValue
-      } else {
-        try {
-          // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-          delete jsonWithUndefined[key]
-        } catch {
-          // ignore
+    const plugin = this._getResolvedPlugin()
+    const propsEntries = Object.entries(plugin.props)
+    for (const [key, prop] of propsEntries) {
+      if (prop.serialize === false) {
+        continue
+      }
+      try {
+        const value = prop.resolve({ value: error0.own(key), flow: error0.flow(key), error: error0 })
+        const jsonValue = prop.serialize({ value, error: error0, isPublic })
+        if (jsonValue !== undefined) {
+          json[key] = jsonValue
         }
+      } catch {
+        // ignore
       }
     }
-    return Object.fromEntries(Object.entries(jsonWithUndefined).filter(([, value]) => value !== undefined)) as object
+    const isStackInProps = propsEntries.some(([key]) => key === 'stack')
+    if (!isStackInProps && typeof error0.stack === 'string') {
+      json.stack = error0.stack
+    }
+    return Object.fromEntries(Object.entries(json).filter(([, value]) => value !== undefined)) as Record<
+      string,
+      unknown
+    >
   }
 
   serialize(isPublic = true): object {