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

package/src/index.ts

@@ -1,55 +1,99 @@
-export type ErrorExtensionPropOptions<TInputValue, TOutputValue, TError extends Error0 = Error0> = {
-  init: (input: TInputValue) => TOutputValue
+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, 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)
+  | false
+type ErrorPluginPropDeserialize<TOutputValue> =
+  | ((options: { value: unknown; serialized: Record<string, unknown> }) => TOutputValue | undefined)
+  | false
+type ErrorPluginPropOptionsBase<TOutputValue, TError extends Error0, TResolveValue extends TOutputValue | undefined> = {
   resolve: (options: {
     value: TOutputValue | undefined
     flow: Array<TOutputValue | undefined>
     error: TError
-  }) => TOutputValue | undefined
-  serialize: (options: { value: TOutputValue; error: TError; isPublic: boolean }) => unknown
-  deserialize: (options: { value: unknown; serialized: Record<string, unknown> }) => TOutputValue | undefined
+  }) => 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>
 }
-export type ErrorExtensionMethodFn<
+type ErrorPluginPropOptionsWithoutInit<
   TOutputValue,
-  TArgs extends unknown[] = unknown[],
+  TError extends Error0,
+  TResolveValue extends TOutputValue | undefined,
+> = ErrorPluginPropOptionsBase<TOutputValue, TError, TResolveValue> & {
+  init?: undefined
+}
+export type ErrorPluginPropOptions<
+  TInputValue = undefined,
+  TOutputValue = unknown,
   TError extends Error0 = Error0,
-> = (error: TError, ...args: TArgs) => TOutputValue
-export type ErrorExtensionRefineResult<TOutputProps extends Record<string, unknown>> = Partial<TOutputProps> | undefined
-export type ErrorExtensionRefineFn<
+  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
+) => 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 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>,
-  TMethods extends ErrorExtensionMethods = Record<never, never>,
+export type ErrorPlugin<
+  TProps extends ErrorPluginProps = Record<never, never>,
+  TMethods extends ErrorPluginMethods = Record<never, never>,
 > = {
   props?: TProps
   methods?: TMethods
-  refine?: Array<ErrorExtensionRefineFn<Error0, ExtensionOutputProps<TProps>>>
+  adapt?: Array<ErrorPluginAdaptFn<Error0, PluginOutputProps<TProps>>>
 }
-type AddPropToExtensionProps<
-  TProps extends ErrorExtensionProps,
+type AddPropToPluginProps<
+  TProps extends ErrorPluginProps,
   TKey extends string,
   TInputValue,
   TOutputValue,
-> = TProps & Record<TKey, ErrorExtensionPropOptions<TInputValue, TOutputValue>>
-type AddMethodToExtensionMethods<
-  TMethods extends ErrorExtensionMethods,
+  TResolveValue extends TOutputValue | undefined = TOutputValue | undefined,
+> = TProps & Record<TKey, ErrorPluginPropOptions<TInputValue, TOutputValue, Error0, TResolveValue>>
+type AddMethodToPluginMethods<
+  TMethods extends ErrorPluginMethods,
   TKey extends string,
   TArgs extends unknown[],
   TOutputValue,
-> = TMethods & Record<TKey, 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, any, any, infer TResolveValue>
+    ? TResolveValue
+    : never
 }
-export type ErrorExtensionsMap = {
+export type ErrorPluginsMap = {
   props: Record<string, { init: unknown; resolve: unknown }>
   methods: Record<string, ErrorMethodRecord>
 }
@@ -57,30 +101,32 @@ 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]['init']
-        }>
+    : ErrorInputBase & ErrorInputPluginProps<TPluginsMap>
 
-type ErrorOutputProps<TExtensionsMap extends ErrorExtensionsMap> = {
-  [TKey in keyof TExtensionsMap['props']]?: TExtensionsMap['props'][TKey]['resolve']
+type ErrorResolvedProps<TPluginsMap extends ErrorPluginsMap> = {
+  [TKey in keyof TPluginsMap['props']]: TPluginsMap['props'][TKey]['resolve']
 }
-type ErrorOutputMethods<TExtensionsMap extends ErrorExtensionsMap> = {
-  [TKey in keyof TExtensionsMap['methods']]: TExtensionsMap['methods'][TKey] extends {
+type ErrorMethods<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> &
-  ErrorOutputMethods<TExtensionsMap>
+export type ErrorResolved<TPluginsMap extends ErrorPluginsMap> = ErrorResolvedProps<TPluginsMap> &
+  ErrorMethods<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
   }
@@ -88,228 +134,253 @@ type ErrorStaticMethods<TExtensionsMap extends ErrorExtensionsMap> = {
     : never
 }
 
-type EmptyExtensionsMap = {
+type EmptyPluginsMap = {
   props: Record<never, { init: never; resolve: never }>
   methods: Record<never, ErrorMethodRecord>
 }
 
-type ErrorExtensionResolved = {
-  props: Record<string, ErrorExtensionPropOptions<unknown, unknown>>
-  methods: Record<string, ErrorExtensionMethodFn<unknown>>
-  refine: Array<ErrorExtensionRefineFn<Error0, Record<string, unknown>>>
+type ErrorPluginResolved = {
+  props: Record<string, ErrorPluginPropOptions<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>
-    ? { init: TInputValue; resolve: TOutputValue }
+type PluginPropsMapOf<TPlugin extends ErrorPlugin> = {
+  [TKey in keyof NonNullable<TPlugin['props']>]: NonNullable<TPlugin['props']>[TKey] extends ErrorPluginPropOptions<
+    any,
+    any,
+    any,
+    infer TResolveValue
+  >
+    ? { init: InferPluginPropInput<NonNullable<TPlugin['props']>[TKey]>; resolve: TResolveValue }
     : 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>
-  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']
-  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 ExtendErrorExtensionsMapWithMethod<
-  TMap extends ErrorExtensionsMap,
+  TResolveValue extends TOutputValue | undefined = TOutputValue | undefined,
+> = ExtendErrorPluginsMap<
+  TMap,
+  ErrorPlugin<Record<TKey, ErrorPluginPropOptions<TInputValue, TOutputValue, Error0, TResolveValue>>>
+>
+type ExtendErrorPluginsMapWithMethod<
+  TMap extends ErrorPluginsMap,
   TKey extends string,
   TArgs extends unknown[],
   TOutputValue,
-> = ExtendErrorExtensionsMap<
+> = ExtendErrorPluginsMap<
   TMap,
-  ErrorExtension<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,
-  TMethods extends ErrorExtensionMethods,
-> = ErrorExtensionsMapOfExtension<ErrorExtension<TProps, TMethods>>
-type ErrorInstanceOfMap<TMap extends ErrorExtensionsMap> = Error0 & ErrorOutput<TMap>
-type BuilderError0<TProps extends ErrorExtensionProps, TMethods extends ErrorExtensionMethods> = Error0 &
-  ErrorOutput<ExtensionsMapFromParts<TProps, TMethods>>
-
-type ExtensionOfBuilder<TBuilder> =
-  TBuilder extends ExtensionError0<infer TProps, infer TMethods> ? ErrorExtension<TProps, TMethods> : never
-
-export class ExtensionError0<
-  TProps extends ErrorExtensionProps = 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 & ErrorResolved<TMap>
+type BuilderError0<TProps extends ErrorPluginProps, TMethods extends ErrorPluginMethods> = Error0 &
+  ErrorResolved<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, ErrorExtensionMethods>
+  private readonly _plugin: ErrorPlugin<ErrorPluginProps, ErrorPluginMethods>
 
   readonly Infer = undefined as unknown as {
     props: TProps
     methods: TMethods
   }
 
-  constructor(extension?: ErrorExtension<ErrorExtensionProps, ErrorExtensionMethods>) {
-    this._extension = {
-      props: { ...(extension?.props ?? {}) },
-      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>(
+  prop<
+    TKey extends string,
+    TInputValue = undefined,
+    TOutputValue = unknown,
+    TResolveValue extends TOutputValue | undefined = TOutputValue | undefined,
+  >(
     key: TKey,
-    value: ErrorExtensionPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>>,
-  ): ExtensionError0<AddPropToExtensionProps<TProps, TKey, TInputValue, TOutputValue>, TMethods> {
-    return this.extend('prop', key, value)
+    value: ErrorPluginPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>, TResolveValue>,
+  ): PluginError0<AddPropToPluginProps<TProps, TKey, TInputValue, TOutputValue, TResolveValue>, TMethods> {
+    return this.use('prop', key, value)
   }
 
   method<TKey extends string, TArgs extends unknown[], TOutputValue>(
     key: TKey,
-    value: ErrorExtensionMethodFn<TOutputValue, TArgs, BuilderError0<TProps, TMethods>>,
-  ): ExtensionError0<TProps, 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, TMethods>, ExtensionOutputProps<TProps>>,
-  ): ExtensionError0<TProps, 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 = undefined,
+    TOutputValue = unknown,
+    TResolveValue extends TOutputValue | undefined = TOutputValue | undefined,
+  >(
     kind: 'prop',
     key: TKey,
-    value: ErrorExtensionPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>>,
-  ): ExtensionError0<AddPropToExtensionProps<TProps, TKey, TInputValue, TOutputValue>, TMethods>
-  extend<TKey extends string, TArgs extends unknown[], TOutputValue>(
+    value: ErrorPluginPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>, TResolveValue>,
+  ): PluginError0<AddPropToPluginProps<TProps, TKey, TInputValue, TOutputValue, TResolveValue>, TMethods>
+  use<TKey extends string, TArgs extends unknown[], TOutputValue>(
     kind: 'method',
     key: TKey,
-    value: ErrorExtensionMethodFn<TOutputValue, TArgs, BuilderError0<TProps, TMethods>>,
-  ): ExtensionError0<TProps, AddMethodToExtensionMethods<TMethods, TKey, TArgs, TOutputValue>>
-  extend(
-    kind: 'refine',
-    value: ErrorExtensionRefineFn<BuilderError0<TProps, TMethods>, ExtensionOutputProps<TProps>>,
-  ): ExtensionError0<TProps, TMethods>
-  extend(
-    kind: 'prop' | 'method' | 'refine',
-    keyOrValue: string | ErrorExtensionRefineFn<any, any>,
-    value?: ErrorExtensionPropOptions<unknown, unknown, any> | ErrorExtensionMethodFn<unknown, unknown[], any>,
-  ): ExtensionError0<any, any> {
-    const nextProps: ErrorExtensionProps = { ...(this._extension.props ?? {}) }
-    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>
+      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,
       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>
+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>
+  readonly __pluginsMap?: TPluginsMap
+  from: (error: unknown) => Error0 & ErrorResolved<TPluginsMap>
   serialize: (error: unknown, isPublic?: boolean) => Record<string, unknown>
-  prop: <TKey extends string, TInputValue, TOutputValue>(
+  prop: <
+    TKey extends string,
+    TInputValue = undefined,
+    TOutputValue = unknown,
+    TResolveValue extends TOutputValue | undefined = TOutputValue | undefined,
+  >(
     key: TKey,
-    value: ErrorExtensionPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TExtensionsMap>>,
-  ) => ClassError0<ExtendErrorExtensionsMapWithProp<TExtensionsMap, TKey, TInputValue, TOutputValue>>
+    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: ErrorExtensionMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<TExtensionsMap>>,
-  ) => ClassError0<ExtendErrorExtensionsMapWithMethod<TExtensionsMap, TKey, TArgs, TOutputValue>>
-  refine: (
-    value: ErrorExtensionRefineFn<ErrorInstanceOfMap<TExtensionsMap>, ErrorOutputProps<TExtensionsMap>>,
-  ) => ClassError0<TExtensionsMap>
-  extend: {
-    <TBuilder extends ExtensionError0>(
-      extension: TBuilder,
-    ): ClassError0<ExtendErrorExtensionsMap<TExtensionsMap, ExtensionOfBuilder<TBuilder>>>
-    <TKey extends string, TInputValue, TOutputValue>(
+    value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<TPluginsMap>>,
+  ) => ClassError0<ExtendErrorPluginsMapWithMethod<TPluginsMap, TKey, TArgs, TOutputValue>>
+  adapt: (
+    value: ErrorPluginAdaptFn<ErrorInstanceOfMap<TPluginsMap>, ErrorResolvedProps<TPluginsMap>>,
+  ) => ClassError0<TPluginsMap>
+  use: {
+    <TBuilder extends PluginError0>(
+      plugin: TBuilder,
+    ): ClassError0<ExtendErrorPluginsMap<TPluginsMap, PluginOfBuilder<TBuilder>>>
+    <
+      TKey extends string,
+      TInputValue = undefined,
+      TOutputValue = unknown,
+      TResolveValue extends TOutputValue | undefined = TOutputValue | undefined,
+    >(
       kind: 'prop',
       key: TKey,
-      value: ErrorExtensionPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TExtensionsMap>>,
-    ): ClassError0<ExtendErrorExtensionsMapWithProp<TExtensionsMap, 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,
-      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>, ErrorResolvedProps<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: {},
     methods: {},
-    refine: [],
+    adapt: [],
   }
 
-  private static _getResolvedExtension(this: typeof Error0): ErrorExtensionResolved {
-    const resolved: ErrorExtensionResolved = {
+  private static _getResolvedPlugin(this: typeof Error0): ErrorPluginResolved {
+    const resolved: ErrorPluginResolved = {
       props: {},
       methods: {},
-      refine: [],
+      adapt: [],
     }
-    for (const extension of this._extensions) {
-      Object.assign(resolved.props, extension.props ?? this._emptyExtension.props)
-      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
@@ -318,12 +389,16 @@ 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.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 }),
@@ -426,12 +501,12 @@ export class Error0 extends 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
@@ -440,13 +515,16 @@ export class Error0 extends Error {
   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 extension = this._getResolvedExtension()
-    const propsEntries = Object.entries(extension.props)
+    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
       }
@@ -468,7 +546,7 @@ export class Error0 extends Error {
 
   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 {
@@ -481,15 +559,15 @@ export class Error0 extends Error {
     )
   }
 
-  private static _extendWithExtension(
+  private static _useWithPlugin(
     this: typeof Error0,
-    extension: ErrorExtension<ErrorExtensionProps, 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[]) {
@@ -512,96 +590,106 @@ export class Error0 extends Error {
     return Error0Extended as unknown as ClassError0
   }
 
-  private static _extensionFromBuilder(
-    extension: ExtensionError0,
-  ): ErrorExtension<ErrorExtensionProps, ErrorExtensionMethods> {
-    const extensionRecord = extension as unknown as {
-      _extension: ErrorExtension<ErrorExtensionProps, ErrorExtensionMethods>
+  private static _pluginFromBuilder(plugin: PluginError0): ErrorPlugin<ErrorPluginProps, ErrorPluginMethods> {
+    const pluginRecord = plugin as unknown as {
+      _plugin: ErrorPlugin<ErrorPluginProps, ErrorPluginMethods>
     }
     return {
-      props: { ...(extensionRecord._extension.props ?? {}) },
-      methods: { ...(extensionRecord._extension.methods ?? {}) },
-      refine: [...(extensionRecord._extension.refine ?? [])],
+      props: { ...(pluginRecord._plugin.props ?? {}) },
+      methods: { ...(pluginRecord._plugin.methods ?? {}) },
+      adapt: [...(pluginRecord._plugin.adapt ?? [])],
     }
   }
 
-  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: ErrorExtensionPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<ExtensionsMapOf<TThis>>>,
-  ): ClassError0<ExtendErrorExtensionsMapWithProp<ExtensionsMapOf<TThis>, TKey, TInputValue, TOutputValue>> {
-    return this.extend('prop', key, value)
+    value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<PluginsMapOf<TThis>>, TResolveValue>,
+  ): ClassError0<ExtendErrorPluginsMapWithProp<PluginsMapOf<TThis>, TKey, TInputValue, TOutputValue, TResolveValue>> {
+    return this.use('prop', key, value)
   }
 
   static method<TThis extends typeof Error0, TKey extends string, TArgs extends unknown[], TOutputValue>(
     this: TThis,
     key: TKey,
-    value: ErrorExtensionMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<ExtensionsMapOf<TThis>>>,
-  ): ClassError0<ExtendErrorExtensionsMapWithMethod<ExtensionsMapOf<TThis>, TKey, TArgs, TOutputValue>> {
-    return this.extend('method', key, value)
+    value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<PluginsMapOf<TThis>>>,
+  ): ClassError0<ExtendErrorPluginsMapWithMethod<PluginsMapOf<TThis>, TKey, TArgs, TOutputValue>> {
+    return this.use('method', key, value)
   }
 
-  static refine<TThis extends typeof Error0>(
+  static adapt<TThis extends typeof Error0>(
     this: TThis,
-    value: ErrorExtensionRefineFn<ErrorInstanceOfMap<ExtensionsMapOf<TThis>>, ErrorOutputProps<ExtensionsMapOf<TThis>>>,
-  ): ClassError0<ExtensionsMapOf<TThis>> {
-    return this.extend('refine', value)
+    value: ErrorPluginAdaptFn<ErrorInstanceOfMap<PluginsMapOf<TThis>>, ErrorResolvedProps<PluginsMapOf<TThis>>>,
+  ): ClassError0<PluginsMapOf<TThis>> {
+    return this.use('adapt', value)
   }
 
-  static extend<TThis extends typeof Error0, TBuilder extends ExtensionError0>(
+  static use<TThis extends typeof Error0, TBuilder extends PluginError0>(
     this: TThis,
-    extension: TBuilder,
-  ): ClassError0<ExtendErrorExtensionsMap<ExtensionsMapOf<TThis>, ExtensionOfBuilder<TBuilder>>>
-  static extend<TThis extends typeof Error0, TKey extends string, TInputValue, TOutputValue>(
+    plugin: TBuilder,
+  ): ClassError0<ExtendErrorPluginsMap<PluginsMapOf<TThis>, PluginOfBuilder<TBuilder>>>
+  static use<
+    TThis extends typeof Error0,
+    TKey extends string,
+    TInputValue = undefined,
+    TOutputValue = unknown,
+    TResolveValue extends TOutputValue | undefined = TOutputValue | undefined,
+  >(
     this: TThis,
     kind: 'prop',
     key: TKey,
-    value: ErrorExtensionPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<ExtensionsMapOf<TThis>>>,
-  ): ClassError0<ExtendErrorExtensionsMapWithProp<ExtensionsMapOf<TThis>, TKey, TInputValue, TOutputValue>>
-  static extend<TThis extends typeof Error0, TKey extends string, TArgs extends unknown[], 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',
     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>>, ErrorResolvedProps<PluginsMapOf<TThis>>>,
+  ): ClassError0<PluginsMapOf<TThis>>
+  static use(
     this: typeof Error0,
-    first: ExtensionError0 | 'prop' | 'method' | 'refine',
-    key?: string | ErrorExtensionRefineFn<any, any>,
-    value?: ErrorExtensionPropOptions<unknown, unknown> | ErrorExtensionMethodFn<unknown>,
+    first: PluginError0 | 'prop' | 'method' | 'adapt',
+    key?: string | ErrorPluginAdaptFn<any, any>,
+    value?: ErrorPluginPropOptions<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> },
       })
     }
-    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): Record<string, unknown> {
@@ -609,13 +697,16 @@ export class Error0 extends Error {
     const json: Record<string, unknown> = {
       name: error0.name,
       message: error0.message,
-      // we do not serialize causes, it is enough that we have floated props and refine helper
+      // we do not serialize causes, it is enough that we have floated props and adapt helper
       // cause: error0.cause,
     }
 
-    const extension = this._getResolvedExtension()
-    const propsEntries = Object.entries(extension.props)
+    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 })