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

package/src/index.ts

@@ -1,585 +1,716 @@
-import { Meta0 } from '@devp0nt/meta0'
-import { type AxiosError, HttpStatusCode, isAxiosError } from 'axios'
-import get from 'lodash/get.js'
-import { ZodError } from 'zod'
-
-// TODO: В эррор0 добавить ориджинал
-// TODO: store tags as array from all causes
-// TODO: not use self stack if toError0
-// TODO: fix default message in extended error0, should be used in constuctor of Error0
-// TODO: remove defaults prop from getPropsFromUnknown
-// TODO: code has enum type, fn to check if code exists
-
-export interface Error0Input {
-  message?: string
-  tag?: string
-  code?: string
-  httpStatus?: HttpStatusCode | HttpStatusCodeString
-  expected?: boolean | ExpectedFn
-  clientMessage?: string
-  cause?: Error0Cause
-  stack?: string
-  meta?: Meta0.Meta0OrValueTypeNullish
-  zodError?: ZodError
-  axiosError?: AxiosError
+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
 }
-
-interface Error0GeneralProps {
-  message: Error0Input['message']
-  tag: Error0Input['tag']
-  code: Error0Input['code']
-  httpStatus: number | undefined
-  expected: boolean | undefined
-  clientMessage: Error0Input['clientMessage']
-  anyMessage: string | undefined
-  cause: Error0Input['cause']
-  stack: Error['stack']
-  meta: Meta0.ValueType
-  zodError?: ZodError
-  axiosError?: AxiosError
+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<
+  TError extends Error0 = Error0,
+  TOutputProps extends Record<string, unknown> = Record<never, never>,
+> = ((error: TError) => void) | ((error: TError) => ErrorExtensionRefineResult<TOutputProps>)
+type ErrorMethodRecord = {
+  args: unknown[]
+  output: unknown
 }
 
-type HttpStatusCodeString = keyof typeof HttpStatusCode
-type Error0Cause = Error | Error0 | unknown
-type ExpectedFn = (error: Error0GeneralProps) => boolean | undefined
-
-const isFilled = <T>(value: T): value is NonNullable<T> => value !== null && value !== undefined && value !== ''
+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 ErrorExtension<
+  TProps extends ErrorExtensionProps = Record<never, never>,
+  TComputed extends ErrorExtensionComputed = Record<never, never>,
+  TMethods extends ErrorExtensionMethods = Record<never, never>,
+> = {
+  props?: TProps
+  computed?: TComputed
+  methods?: TMethods
+  refine?: Array<ErrorExtensionRefineFn<Error0, ExtensionOutputProps<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,
+  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
+}
+export type ErrorExtensionsMap = {
+  props: Record<string, { input: unknown; output: unknown }>
+  computed: Record<string, 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
+    ? ErrorInputBase
+    : ErrorInputBase &
+        Partial<{
+          [TKey in keyof TExtensionsMap['props']]: TExtensionsMap['props'][TKey]['input']
+        }>
+
+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 ErrorOutputMethods<TExtensionsMap extends ErrorExtensionsMap> = {
+  [TKey in keyof TExtensionsMap['methods']]: TExtensionsMap['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>
+
+type ErrorStaticMethods<TExtensionsMap extends ErrorExtensionsMap> = {
+  [TKey in keyof TExtensionsMap['methods']]: TExtensionsMap['methods'][TKey] extends {
+    args: infer TArgs extends unknown[]
+    output: infer TOutput
+  }
+    ? (error: unknown, ...args: TArgs) => TOutput
+    : never
+}
 
-export class Error0 extends Error {
-  public readonly __I_AM_ERROR_0: true = true
-
-  public readonly tag?: Error0GeneralProps['tag']
-  public readonly code?: Error0GeneralProps['code']
-  public readonly httpStatus?: Error0GeneralProps['httpStatus']
-  public readonly expected?: Error0GeneralProps['expected']
-  public readonly clientMessage?: Error0GeneralProps['clientMessage']
-  public readonly anyMessage?: Error0GeneralProps['anyMessage']
-  public override readonly cause?: Error0GeneralProps['cause']
-  public readonly meta?: Meta0.Meta0OrValueTypeNullish
-  public readonly zodError?: Error0GeneralProps['zodError']
-  public readonly axiosError?: Error0GeneralProps['axiosError']
-
-  static defaultMessage = 'Unknown error'
-  static defaultCode?: Error0GeneralProps['code']
-  static defaultHttpStatus?: Error0GeneralProps['httpStatus']
-  static defaultExpected?: Error0GeneralProps['expected']
-  static defaultClientMessage?: Error0GeneralProps['clientMessage']
-  static defaultMeta?: Meta0.Meta0OrValueTypeNullish
-
-  public readonly propsOriginal: Error0GeneralProps
-
-  constructor(message: string)
-  constructor(input: Error0Input)
-  constructor(message: string, input: Error0Input)
-  constructor(error: Error)
-  constructor(error: Error, input: Error0Input)
-  constructor(value: unknown)
-  constructor(value: unknown, input: Error0Input)
-  constructor(...args: unknown[]) {
-    const input: Partial<Error0Input> = {}
-    if (args[0] instanceof Error) {
-      input.cause = args[0]
-    } else if (typeof args[0] === 'object' && args[0] !== null) {
-      Object.assign(input, args[0])
-    } else if (typeof args[0] === 'string') {
-      input.message = args[0]
-    }
-    if (typeof args[1] === 'object' && args[1] !== null) {
-      Object.assign(input, args[1])
-    }
-    const safeInput = Error0._safeParseInput(input)
+type EmptyExtensionsMap = {
+  props: Record<never, { input: never; output: never }>
+  computed: Record<never, never>
+  methods: Record<never, ErrorMethodRecord>
+}
 
-    const message = safeInput.message || Error0.defaultMessage
-    super(message)
-    Object.setPrototypeOf(this, (this.constructor as typeof Error0).prototype)
-    this.name = 'Error0'
+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>>>
+}
 
-    this.propsOriginal = (this.constructor as typeof Error0)._getSelfGeneralProps({
-      error0Input: safeInput,
-      message,
-      stack: safeInput.stack || this.stack,
-    })
-    const causesProps = (this.constructor as typeof Error0)._getCausesPropsFromError0Props(
-      this.propsOriginal,
-      (this.constructor as typeof Error0).defaultMaxLevel,
-    )
-    const propsFloated = (this.constructor as typeof Error0)._getSelfPropsFloated(causesProps)
-    this.tag = propsFloated.tag
-    this.code = propsFloated.code
-    this.httpStatus = propsFloated.httpStatus
-    this.expected = propsFloated.expected
-    this.clientMessage = propsFloated.clientMessage
-    this.cause = propsFloated.cause
-    this.stack = propsFloated.stack
-    this.meta = propsFloated.meta
-    this.zodError = propsFloated.zodError
-    this.axiosError = propsFloated.axiosError
-  }
-
-  // settings
-
-  static defaultMaxLevel = 10
-
-  // props
-
-  public static _safeParseInput(error0Input: Record<string, unknown>): Error0Input {
-    const result: Error0Input = {}
-    result.message = typeof error0Input.message === 'string' ? error0Input.message : undefined
-    result.tag = typeof error0Input.tag === 'string' ? error0Input.tag : undefined
-    result.code = typeof error0Input.code === 'string' ? error0Input.code : undefined
-    result.httpStatus =
-      typeof error0Input.httpStatus === 'number' || typeof error0Input.httpStatus === 'string'
-        ? (error0Input.httpStatus as never)
-        : undefined
-    result.expected =
-      typeof error0Input.expected === 'function' || typeof error0Input.expected === 'boolean'
-        ? (error0Input.expected as never)
-        : undefined
-    result.clientMessage = typeof error0Input.clientMessage === 'string' ? error0Input.clientMessage : undefined
-    result.cause = error0Input.cause
-    result.stack = typeof error0Input.stack === 'string' ? error0Input.stack : undefined
-    // result.meta0 =
-    //   error0Input.meta0 instanceof Meta0 ? error0Input.meta0 : undefined
-    // result.meta =
-    //   typeof error0Input.meta === "object" && error0Input.meta !== null
-    //     ? error0Input.meta
-    //     : undefined
-    result.meta =
-      error0Input.meta instanceof Meta0
-        ? error0Input.meta
-        : typeof error0Input.meta === 'object' && error0Input.meta !== null
-          ? (error0Input.meta as Meta0.ValueType)
-          : undefined
-    result.zodError = error0Input.zodError instanceof ZodError ? error0Input.zodError : undefined
-    result.axiosError = isAxiosError(error0Input.axiosError) ? error0Input.axiosError : undefined
-    return result
-  }
-
-  public static _getSelfGeneralProps({
-    error0Input,
-    message,
-    stack,
-  }: {
-    error0Input: Error0Input
-    message: string
-    stack: Error0GeneralProps['stack']
-  }): Error0GeneralProps {
-    // const meta = Meta0.merge(error0Input.meta0, error0Input.meta).value
-    const meta0 = Meta0.extend(error0Input.meta, this.defaultMeta)
-    const meta = meta0.getValue()
-    const finalTag = meta0.getFinalTag(error0Input.tag)
-    const clientMessage = error0Input.clientMessage || this.defaultClientMessage
-    const result: Error0GeneralProps = {
-      message: error0Input.message || this.defaultMessage,
-      tag: finalTag,
-      code: error0Input.code || meta.code || this.defaultCode,
-      httpStatus:
-        typeof error0Input.httpStatus === 'number'
-          ? error0Input.httpStatus
-          : error0Input.httpStatus &&
-              typeof error0Input.httpStatus === 'string' &&
-              error0Input.httpStatus in HttpStatusCode
-            ? HttpStatusCode[error0Input.httpStatus]
-            : meta.httpStatus || this.defaultHttpStatus,
-      expected: undefined,
-      clientMessage,
-      anyMessage: clientMessage || message,
-      cause: error0Input.cause,
-      stack: undefined,
-      meta,
-      zodError: error0Input.zodError,
-      axiosError: error0Input.axiosError,
-    }
-    result.expected = this._normalizeSelfExpected(
-      result,
-      typeof error0Input.expected === 'boolean' || typeof error0Input.expected === 'function'
-        ? error0Input.expected
-        : meta.expected || this.defaultExpected,
-    )
-    result.stack = this._removeConstructorStackPart(stack)
-    return result
-  }
-
-  public static _getSelfPropsFloated(causesProps: Error0GeneralProps[]): Error0GeneralProps {
-    const cause = this._getClosestPropValue(causesProps, 'cause')
-    const stack = this._mergeStack(causesProps[1]?.stack, causesProps[0]?.stack)
-    const closestTag = this._getClosestPropValue(causesProps, 'tag')
-    const meta = this._getMergedMetaValue(causesProps)
-    const tag = Meta0.getFinalTag(meta, closestTag)
-    const propsFloated: Error0GeneralProps = {
-      message: this._getClosestPropValue(causesProps, 'message'),
-      tag,
-      code: this._getClosestPropValue(causesProps, 'code'),
-      httpStatus: this._getClosestPropValue(causesProps, 'httpStatus'),
-      expected: this._isExpected(causesProps),
-      clientMessage: this._getClosestPropValue(causesProps, 'clientMessage'),
-      cause,
-      stack,
-      anyMessage: causesProps[0].anyMessage,
-      meta,
-      zodError: this._getClosestPropValue(causesProps, 'zodError'),
-      axiosError: this._getClosestPropValue(causesProps, 'axiosError'),
-    }
-    return propsFloated
+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 }
+    : 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 (
+    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 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 ExtendErrorExtensionsMapWithProp<
+  TMap extends ErrorExtensionsMap,
+  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,
+  TKey extends string,
+  TArgs extends unknown[],
+  TOutputValue,
+> = ExtendErrorExtensionsMap<
+  TMap,
+  ErrorExtension<Record<never, never>, Record<never, never>, Record<TKey, ErrorExtensionMethodFn<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>,
+> {
+  private readonly _extension: ErrorExtension<ErrorExtensionProps, ErrorExtensionComputed, ErrorExtensionMethods>
+
+  readonly Infer = undefined as unknown as {
+    props: TProps
+    computed: TComputed
+    methods: TMethods
   }
 
-  // sepcial
-
-  public static _getExtraError0PropsByZodError(zodError: ZodError): Partial<Error0GeneralProps> {
-    return {
-      message: `Zod Validation Error: ${zodError.message}`,
+  constructor(extension?: ErrorExtension<ErrorExtensionProps, ErrorExtensionComputed, ErrorExtensionMethods>) {
+    this._extension = {
+      props: { ...(extension?.props ?? {}) },
+      computed: { ...(extension?.computed ?? {}) },
+      methods: { ...(extension?.methods ?? {}) },
+      refine: [...(extension?.refine ?? [])],
     }
   }
 
-  public static _getExtraError0PropsByAxiosError(axiosError: AxiosError): Partial<Error0GeneralProps> {
-    return {
-      message: 'Axios Error',
-      meta: {
-        axiosData: (() => {
-          try {
-            return JSON.stringify(axiosError.response?.data)
-          } catch {
-            return undefined
-          }
-        })(),
-        axiosStatus: axiosError.response?.status,
-      },
-    }
+  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)
   }
 
-  public static _assignError0Props(
-    error0Props: Error0GeneralProps,
-    extraError0Props: Partial<Error0GeneralProps>,
-  ): void {
-    const metaValue = Meta0.mergeValues(error0Props.meta, extraError0Props.meta)
-    Object.assign(error0Props, extraError0Props, { meta: metaValue })
+  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)
   }
 
-  // expected
+  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)
+  }
 
-  public static _normalizeSelfExpected(
-    error0Props: Error0GeneralProps,
-    expectedProvided: Error0Input['expected'],
-  ): boolean | undefined {
-    if (typeof expectedProvided === 'function') {
-      return expectedProvided(error0Props)
-    }
-    return expectedProvided
+  refine(
+    value: ErrorExtensionRefineFn<BuilderError0<TProps, TComputed, TMethods>, ExtensionOutputProps<TProps>>,
+  ): ExtensionError0<TProps, TComputed, TMethods> {
+    return this.extend('refine', value)
   }
 
-  public static _isExpected(causesProps: Error0GeneralProps[]): boolean {
-    let hasExpectedTrue = false
-    for (const causeProps of causesProps) {
-      if (causeProps.expected === false) {
-        return false
+  extend<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>(
+    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 ?? []),
+    ]
+    if (kind === 'prop') {
+      const key = keyOrValue as string
+      if (value === undefined) {
+        throw new Error('ExtensionError0.extend("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')
       }
-      if (causeProps.expected === true) {
-        hasExpectedTrue = true
+      nextComputed[key] = value as ErrorExtensionCopmputedFn<any>
+    } else if (kind === 'method') {
+      const key = keyOrValue as string
+      if (value === undefined) {
+        throw new Error('ExtensionError0.extend("method", key, value) requires value')
       }
+      nextMethods[key] = value as ErrorExtensionMethodFn<any, any[]>
+    } else {
+      nextRefine.push(keyOrValue as ErrorExtensionRefineFn<Error0, Record<string, unknown>>)
     }
-    return hasExpectedTrue
+    return new ExtensionError0({
+      props: nextProps,
+      computed: nextComputed,
+      methods: nextMethods,
+      refine: nextRefine,
+    })
   }
+}
 
-  // getters
+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>>>
+    <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>>
+    <TKey extends string, TArgs extends unknown[], TOutputValue>(
+      kind: 'method',
+      key: TKey,
+      value: ErrorExtensionMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<TExtensionsMap>>,
+    ): ClassError0<ExtendErrorExtensionsMapWithMethod<TExtensionsMap, TKey, TArgs, TOutputValue>>
+    (
+      kind: 'refine',
+      value: ErrorExtensionRefineFn<ErrorInstanceOfMap<TExtensionsMap>, ErrorOutputProps<TExtensionsMap>>,
+    ): ClassError0<TExtensionsMap>
+  }
+  extension: () => ExtensionError0
+} & ErrorStaticMethods<TExtensionsMap>
 
-  public static _getPropsFromUnknown(error: unknown, defaults?: Error0Input): Error0GeneralProps {
-    if (typeof error !== 'object' || error === null) {
-      return {
-        message: undefined,
-        tag: undefined,
-        code: undefined,
-        httpStatus: undefined,
-        expected: undefined,
-        clientMessage: undefined,
-        anyMessage: this.defaultMessage,
-        cause: undefined,
-        stack: undefined,
-        zodError: undefined,
-        axiosError: undefined,
-        meta: {},
-      }
-    }
-    const message = 'message' in error && typeof error.message === 'string' ? error.message : undefined
-    const clientMessage =
-      'clientMessage' in error && typeof error.clientMessage === 'string'
-        ? error.clientMessage
-        : defaults?.clientMessage || undefined
-    const result: Error0GeneralProps = {
-      message,
-      code: 'code' in error && typeof error.code === 'string' ? error.code : defaults?.code || undefined,
-      clientMessage,
-      anyMessage: clientMessage || message || this.defaultMessage,
-      expected: undefined,
-      stack: 'stack' in error && typeof error.stack === 'string' ? error.stack : undefined,
-      tag: 'tag' in error && typeof error.tag === 'string' ? error.tag : defaults?.tag || undefined,
-      cause: 'cause' in error ? error.cause : defaults?.cause || undefined,
-      meta:
-        'meta' in error && typeof error.meta === 'object' && error.meta !== null
-          ? Meta0.getValue(error.meta as Meta0.ValueType)
-          : Meta0.getValue(defaults?.meta) || {},
-      httpStatus:
-        'httpStatus' in error && typeof error.httpStatus === 'number' && error.httpStatus in HttpStatusCode
-          ? error.httpStatus
-          : typeof defaults?.httpStatus === 'string'
-            ? HttpStatusCode[defaults.httpStatus]
-            : defaults?.httpStatus,
-      zodError:
-        'zodError' in error && error.zodError instanceof ZodError
-          ? error.zodError
-          : error instanceof ZodError
-            ? error
-            : defaults?.zodError,
-      axiosError:
-        'axiosError' in error && isAxiosError(error.axiosError)
-          ? error.axiosError
-          : isAxiosError(error)
-            ? error
-            : defaults?.axiosError,
-    }
-    result.expected = this._normalizeSelfExpected(
-      result,
-      'expected' in error && (typeof error.expected === 'boolean' || typeof error.expected === 'function')
-        ? (error.expected as ExpectedFn)
-        : defaults?.expected || undefined,
-    )
-    if (result.zodError) {
-      this._assignError0Props(result, this._getExtraError0PropsByZodError(result.zodError))
-    }
-    if (result.axiosError) {
-      this._assignError0Props(result, this._getExtraError0PropsByAxiosError(result.axiosError))
-    }
-    return result
+export class Error0 extends Error {
+  static readonly __extensionsMap?: EmptyExtensionsMap
+  protected static _extensions: ErrorExtension[] = []
+
+  private static readonly _emptyExtension: ErrorExtensionResolved = {
+    props: {},
+    computed: {},
+    methods: {},
+    refine: [],
   }
 
-  public static _getCausesPropsFromUnknown(error: unknown, maxLevel: number): Error0GeneralProps[] {
-    if (!error) {
-      return []
-    }
-    const causeProps = this._getPropsFromUnknown(error)
-    const causesProps: Error0GeneralProps[] = [causeProps]
-    if (!causeProps.cause) {
-      return causesProps
+  private static _getResolvedExtension(this: typeof Error0): ErrorExtensionResolved {
+    const resolved: ErrorExtensionResolved = {
+      props: {},
+      computed: {},
+      methods: {},
+      refine: [],
     }
-    if (maxLevel > 0) {
-      causesProps.push(...this._getCausesPropsFromUnknown(this._getPropsFromUnknown(causeProps.cause), maxLevel - 1))
+    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))
     }
-    return causesProps
+    return resolved
   }
 
-  public static _getCausesPropsFromError0Props(
-    error0Props: Error0GeneralProps,
-    maxLevel: number,
-  ): Error0GeneralProps[] {
-    return [error0Props, ...this._getCausesPropsFromUnknown(error0Props.cause, maxLevel - 1)]
-  }
+  constructor(message: string, input?: ErrorInput<EmptyExtensionsMap>)
+  constructor(input: { message: string } & ErrorInput<EmptyExtensionsMap>)
+  constructor(
+    ...args:
+      | [message: string, input?: ErrorInput<EmptyExtensionsMap>]
+      | [{ message: string } & ErrorInput<EmptyExtensionsMap>]
+  ) {
+    const [first, second] = args
+    const input = typeof first === 'string' ? { message: first, ...(second ?? {}) } : first
+
+    super(input.message, { cause: input.cause })
+    this.name = 'Error0'
 
-  public static _getClosestPropValue<TPropKey extends keyof Error0GeneralProps>(
-    causesProps: Error0GeneralProps[],
-    propKey: TPropKey,
-  ): NonNullable<Error0GeneralProps[TPropKey]> | undefined {
-    for (const causeProps of causesProps) {
-      const propValue = causeProps[propKey]
-      if (isFilled(propValue)) {
-        return propValue as NonNullable<Error0GeneralProps[TPropKey]>
+    const ctor = this.constructor as typeof Error0
+    const extension = ctor._getResolvedExtension()
+
+    for (const [key, prop] of Object.entries(extension.props)) {
+      if (key in input) {
+        const ownValue = (input as Record<string, unknown>)[key]
+        ;(this as Record<string, unknown>)[key] = prop.input(ownValue)
+      } else {
+        Object.defineProperty(this, key, {
+          get: () => prop.output(this),
+          set: (value) => {
+            Object.defineProperty(this, key, {
+              value,
+              writable: true,
+              enumerable: true,
+              configurable: true,
+            })
+          },
+          enumerable: true,
+          configurable: true,
+        })
       }
     }
-    return undefined
+
+    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 getClosestByGetter<TResult>(
-  //   causesProps: Error0GeneralProps[],
-  //   getter: (props: Error0GeneralProps) => TResult,
-  // ): NonNullable<TResult> | undefined {
-  //   for (const causeProps of causesProps) {
-  //     const result = getter(causeProps)
-  //     if (isFilled(result)) {
-  //       return result
-  //     }
-  //   }
-  //   return undefined
-  // }
-
-  public static _getFilledPropValues<TPropKey extends keyof Error0Input>(
-    causesProps: Error0GeneralProps[],
-    propKey: TPropKey,
-  ): NonNullable<Error0GeneralProps[TPropKey]>[] {
-    const values: NonNullable<Error0GeneralProps[TPropKey]>[] = []
-    for (const causeProps of causesProps) {
-      const propValue = causeProps[propKey]
-      if (isFilled(propValue)) {
-        values.push(propValue as NonNullable<Error0GeneralProps[TPropKey]>)
+  private static readonly isSelfProperty = (object: object, key: string): boolean => {
+    const d = Object.getOwnPropertyDescriptor(object, key)
+    if (!d) return false
+    if (typeof d.get === 'function' || typeof d.set === 'function') {
+      if ('name' in object && object.name === 'Error0') {
+        return false
+      } else {
+        return true
       }
     }
-    return values
+    return true
   }
 
-  public static _getMergedMetaValue(causesProps: Error0GeneralProps[]): Meta0.ValueType {
-    const metas = this._getFilledPropValues(causesProps, 'meta')
-    if (metas.length === 0) {
-      return {}
-    } else if (metas.length === 1) {
-      return metas[0]
-    } else {
-      return Meta0.mergeValues(metas[0], ...metas.slice(1))
+  static own(error: object, key: string): unknown {
+    if (this.isSelfProperty(error, key)) {
+      return (error as Record<string, unknown>)[key]
     }
+    return undefined
+  }
+  own(key: string): unknown {
+    const ctor = this.constructor as typeof Error0
+    return ctor.own(this, key)
   }
 
-  // stack
+  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
+    })
+  }
+  flow(key: string, policy: ErrorFlowPolicy = 'likeError0'): unknown[] {
+    const ctor = this.constructor as typeof Error0
+    return ctor.flow(this, key, policy)
+  }
 
-  public static _removeConstructorStackPart(stack: Error0GeneralProps['stack']): Error0GeneralProps['stack'] {
-    if (!stack) {
-      return stack
-    }
-    let lines = stack.split('\n')
-    const removeAllLinesContains = (search: string) => {
-      lines = lines.filter((line) => !line.includes(search))
+  static causes(error: object, policy: ErrorFlowPolicy = 'all'): object[] {
+    const causes: object[] = []
+    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)
+      current = (current as { cause?: unknown }).cause
     }
-    removeAllLinesContains('at new Error0')
-    removeAllLinesContains('at _toError0')
-    removeAllLinesContains('at Error0.from')
-    removeAllLinesContains('at Error0._toError0')
-    return lines.join('\n')
-  }
 
-  public static _mergeStack(
-    prevStack: Error0GeneralProps['stack'],
-    nextStack: Error0GeneralProps['stack'],
-  ): Error0GeneralProps['stack'] {
-    return [nextStack, prevStack].filter(Boolean).join('\n\n') || undefined
+    return causes
+  }
+  causes(policy: ErrorFlowPolicy = 'all'): object[] {
+    const ctor = this.constructor as typeof Error0
+    return ctor.causes(this, policy)
   }
 
-  // transformations
+  static is(error: unknown): error is Error0 {
+    return error instanceof this
+  }
 
   static isError0(error: unknown): error is Error0 {
     return error instanceof Error0
   }
 
-  static isLikelyError0(error: unknown): error is Error0 {
-    if (error instanceof Error0) {
-      return true
+  static isLikeError0(error: unknown): error is Error0 | object {
+    return (
+      error instanceof Error0 ||
+      (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)
+    }
+    return this._fromNonError0(error)
+  }
 
-    if (typeof error === 'object' && error !== null) {
-      if ('__I_AM_ERROR_0' in error && error.__I_AM_ERROR_0 === true) {
-        return true
+  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)
       }
     }
-
-    return false
+    return error
   }
 
-  public static _toError0(error: unknown, inputOverride: Error0Input = {}): Error0 {
-    if (error instanceof Error0) {
-      return error
+  private static _fromLikeError0(error: unknown): Error0 {
+    const message = this._extractMessage(error)
+    if (typeof error !== 'object' || error === null) {
+      return this._applyRefine(new this(message, { cause: error }))
     }
 
-    if (typeof error === 'string') {
-      return new Error0(error, inputOverride)
+    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) {
+        ;(recreated as unknown as Record<string, unknown>)[key] = value
+      }
     }
+    ;(recreated as unknown as { cause?: unknown }).cause = errorRecord.cause
+    if (typeof errorRecord.stack === 'string') {
+      recreated.stack = errorRecord.stack
+    }
+    return this._applyRefine(recreated)
+  }
 
-    if (typeof error !== 'object' || error === null) {
-      return new Error0({
-        message: this.defaultMessage,
-        ...inputOverride,
+  private static _fromNonError0(error: unknown): Error0 {
+    const message = this._extractMessage(error)
+    return this._applyRefine(new this(message, { cause: error }))
+  }
+
+  private static _extractMessage(error: unknown): string {
+    return (
+      (typeof error === 'string'
+        ? error
+        : typeof error === 'object' && error !== null && 'message' in error && typeof error.message === 'string'
+          ? error.message
+          : undefined) || 'Unknown error'
+    )
+  }
+
+  private static _extendWithExtension(
+    this: typeof Error0,
+    extension: ErrorExtension<ErrorExtensionProps, ErrorExtensionComputed, ErrorExtensionMethods>,
+  ): ClassError0 {
+    const Base = this as unknown as typeof Error0
+    const Error0Extended = class Error0 extends Base {}
+    ;(Error0Extended as typeof Error0)._extensions = [...Base._extensions, extension]
+
+    const resolved = (Error0Extended as typeof Error0)._getResolvedExtension()
+    for (const [key, method] of Object.entries(resolved.methods)) {
+      Object.defineProperty((Error0Extended as typeof Error0).prototype, key, {
+        value: function (...args: unknown[]) {
+          return method(this as Error0, ...args)
+        },
+        writable: true,
+        enumerable: true,
+        configurable: true,
+      })
+      Object.defineProperty(Error0Extended, key, {
+        value: function (error: unknown, ...args: unknown[]) {
+          return method(this.from(error), ...args)
+        },
+        writable: true,
+        enumerable: true,
+        configurable: true,
       })
     }
 
-    const inputFromData = get(error, 'data')
-    if (inputFromData) {
-      if (Error0.isLikelyError0(inputFromData)) {
-        return this._toError0(inputFromData, inputOverride)
-      }
+    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>
+    }
+    return {
+      props: { ...(extensionRecord._extension.props ?? {}) },
+      computed: { ...(extensionRecord._extension.computed ?? {}) },
+      methods: { ...(extensionRecord._extension.methods ?? {}) },
+      refine: [...(extensionRecord._extension.refine ?? [])],
     }
+  }
 
-    const inputFromDataError0 = get(error, 'data.error0')
-    if (inputFromDataError0) {
-      if (Error0.isLikelyError0(inputFromDataError0)) {
-        return this._toError0(inputFromDataError0, inputOverride)
+  static extend<TThis extends typeof Error0, TBuilder extends ExtensionError0>(
+    this: TThis,
+    extension: TBuilder,
+  ): ClassError0<ExtendErrorExtensionsMap<ExtensionsMapOf<TThis>, ExtensionOfBuilder<TBuilder>>>
+  static extend<TThis extends typeof Error0, TKey extends string, TInputValue, 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>(
+    this: TThis,
+    kind: 'computed',
+    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>(
+    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>(
+    this: TThis,
+    kind: 'refine',
+    value: ErrorExtensionRefineFn<ErrorInstanceOfMap<ExtensionsMapOf<TThis>>, ErrorOutputProps<ExtensionsMapOf<TThis>>>,
+  ): ClassError0<ExtensionsMapOf<TThis>>
+  static extend(
+    this: typeof Error0,
+    first: ExtensionError0 | 'prop' | 'computed' | 'method' | 'refine',
+    key?: string | ErrorExtensionRefineFn<any, any>,
+    value?:
+      | ErrorExtensionPropOptions<unknown, unknown>
+      | ErrorExtensionCopmputedFn<unknown>
+      | ErrorExtensionMethodFn<unknown>,
+  ): ClassError0 {
+    if (first instanceof ExtensionError0) {
+      return this._extendWithExtension(this._extensionFromBuilder(first))
+    }
+    if (first === 'refine') {
+      if (typeof key !== 'function') {
+        throw new Error('Error0.extend("refine", value) requires refine function')
       }
+      return this._extendWithExtension({
+        refine: [key],
+      })
+    }
+    if (typeof key !== 'string' || value === undefined) {
+      throw new Error('Error0.extend(kind, key, value) requires key and value')
     }
 
-    return new Error0(this._getPropsFromUnknown(error, inputOverride))
-  }
-
-  static from(error: unknown, inputOverride?: Error0Input): Error0 {
-    return this._toError0(error, inputOverride)
-  }
-
-  static extend(props: {
-    defaultMessage?: Error0GeneralProps['message']
-    defaultCode?: Error0GeneralProps['code']
-    defaultHttpStatus?: Error0GeneralProps['httpStatus']
-    defaultExpected?: Error0GeneralProps['expected']
-    defaultClientMessage?: Error0GeneralProps['clientMessage']
-    defaultMeta?: Meta0.Meta0OrValueTypeNullish
-  }) {
-    const parent = this
-    return class Error0 extends parent {
-      static override defaultMessage = props.defaultMessage ?? parent.defaultMessage
-      static override defaultCode = props.defaultCode ?? parent.defaultCode
-      static override defaultHttpStatus = props.defaultHttpStatus ?? parent.defaultHttpStatus
-      static override defaultExpected = props.defaultExpected ?? parent.defaultExpected
-      static override defaultClientMessage = props.defaultClientMessage ?? parent.defaultClientMessage
-      static override defaultMeta = Meta0.extend(props.defaultMeta, parent.defaultMeta)
+    if (first === 'prop') {
+      return this._extendWithExtension({
+        props: { [key]: value as ErrorExtensionPropOptions<unknown, unknown> },
+      })
+    }
+    if (first === 'computed') {
+      return this._extendWithExtension({
+        computed: { [key]: value as ErrorExtensionCopmputedFn<unknown> },
+      })
     }
+    return this._extendWithExtension({
+      methods: { [key]: value as ErrorExtensionMethodFn<unknown> },
+    })
   }
 
-  static extendCollection<T extends Record<string, typeof Error0>>(
-    classes: T,
-    props: {
-      defaultMessage?: Error0GeneralProps['message']
-      defaultCode?: Error0GeneralProps['code']
-      defaultHttpStatus?: Error0GeneralProps['httpStatus']
-      defaultExpected?: Error0GeneralProps['expected']
-      defaultClientMessage?: Error0GeneralProps['clientMessage']
-      defaultMeta?: Meta0.Meta0OrValueTypeNullish
-    },
-  ): T {
-    return Object.fromEntries(Object.entries(classes).map(([name, Class]) => [name, Class.extend(props)])) as T
+  static extension(): ExtensionError0 {
+    return new ExtensionError0()
   }
 
-  toJSON() {
-    return {
-      message: this.message,
-      tag: this.tag,
-      code: this.code,
-      httpStatus: this.httpStatus,
-      expected: this.expected,
-      clientMessage: this.clientMessage,
-      anyMessage: this.anyMessage,
-      cause: this.cause,
-      meta: Meta0.getValue(this.meta),
-      stack: this.stack,
-      __I_AM_ERROR_0: this.__I_AM_ERROR_0,
+  static serialize(error: unknown, isPublic = true): object {
+    const error0 = this.from(error)
+    const jsonWithUndefined: Record<string, unknown> = {
+      name: error0.name,
+      message: error0.message,
+      cause: error0.cause,
+      stack: error0.stack,
     }
+
+    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
+        }
+      }
+    }
+    return Object.fromEntries(Object.entries(jsonWithUndefined).filter(([, value]) => value !== undefined)) as object
   }
-  static toJSON(error: unknown, inputOverride?: Error0Input) {
-    const error0 = this.from(error, inputOverride)
-    return error0.toJSON()
-  }
-
-  toResponse(data?: Record<string, unknown>) {
-    return Response.json(
-      {
-        ...this.toJSON(),
-        ...data,
-      },
-      {
-        status: this.httpStatus,
-        statusText: this.message,
-      },
-    )
-  }
-}
 
-export namespace Error0 {
-  export type JSON = ReturnType<Error0['toJSON']>
-  export type Collection = Record<string, typeof Error0>
+  serialize(isPublic = true): object {
+    const ctor = this.constructor as typeof Error0
+    return ctor.serialize(this, isPublic)
+  }
 }
-
-export const e0s = {
-  Default: Error0,
-  Expected: Error0.extend({
-    defaultExpected: true,
-  }) as typeof Error0,
-} satisfies Error0.Collection