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

package/src/index.ts

@@ -1,9 +1,13 @@
 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
+  init: (input: TInputValue) => TOutputValue
+  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
 }
-export type ErrorExtensionCopmputedFn<TOutputValue, TError extends Error0 = Error0> = (error: TError) => TOutputValue
 export type ErrorExtensionMethodFn<
   TOutputValue,
   TArgs extends unknown[] = unknown[],
@@ -20,16 +24,13 @@ type ErrorMethodRecord = {
 }
 
 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>>>
 }
@@ -39,11 +40,6 @@ type AddPropToExtensionProps<
   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,
@@ -54,8 +50,7 @@ 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>
+  props: Record<string, { init: unknown; resolve: unknown }>
   methods: Record<string, ErrorMethodRecord>
 }
 export type IsEmptyObject<T> = keyof T extends never ? true : false
@@ -67,14 +62,11 @@ export type ErrorInput<TExtensionsMap extends ErrorExtensionsMap> =
     ? ErrorInputBase
     : ErrorInputBase &
         Partial<{
-          [TKey in keyof TExtensionsMap['props']]: TExtensionsMap['props'][TKey]['input']
+          [TKey in keyof TExtensionsMap['props']]: TExtensionsMap['props'][TKey]['init']
         }>
 
 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]
+  [TKey in keyof TExtensionsMap['props']]?: TExtensionsMap['props'][TKey]['resolve']
 }
 type ErrorOutputMethods<TExtensionsMap extends ErrorExtensionsMap> = {
   [TKey in keyof TExtensionsMap['methods']]: TExtensionsMap['methods'][TKey] extends {
@@ -85,7 +77,6 @@ type ErrorOutputMethods<TExtensionsMap extends ErrorExtensionsMap> = {
     : never
 }
 export type ErrorOutput<TExtensionsMap extends ErrorExtensionsMap> = ErrorOutputProps<TExtensionsMap> &
-  ErrorOutputComputed<TExtensionsMap> &
   ErrorOutputMethods<TExtensionsMap>
 
 type ErrorStaticMethods<TExtensionsMap extends ErrorExtensionsMap> = {
@@ -98,14 +89,12 @@ type ErrorStaticMethods<TExtensionsMap extends ErrorExtensionsMap> = {
 }
 
 type EmptyExtensionsMap = {
-  props: Record<never, { input: never; output: never }>
-  computed: Record<never, never>
+  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>>>
 }
@@ -114,14 +103,7 @@ 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
+    ? { init: TInputValue; resolve: TOutputValue }
     : never
 }
 type ExtensionMethodsMapOf<TExtension extends ErrorExtension> = {
@@ -134,12 +116,10 @@ type ExtensionMethodsMapOf<TExtension extends ErrorExtension> = {
 }
 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<
@@ -148,14 +128,6 @@ type ExtendErrorExtensionsMapWithProp<
   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,
@@ -163,7 +135,7 @@ type ExtendErrorExtensionsMapWithMethod<
   TOutputValue,
 > = ExtendErrorExtensionsMap<
   TMap,
-  ErrorExtension<Record<never, never>, Record<never, never>, Record<TKey, ErrorExtensionMethodFn<TOutputValue, TArgs>>>
+  ErrorExtension<Record<never, never>, Record<TKey, ErrorExtensionMethodFn<TOutputValue, TArgs>>>
 >
 
 type ExtensionsMapOf<TClass> = TClass extends { __extensionsMap?: infer TExtensionsMap }
@@ -174,40 +146,29 @@ type ExtensionsMapOf<TClass> = TClass extends { __extensionsMap?: infer TExtensi
 
 type ExtensionsMapFromParts<
   TProps extends ErrorExtensionProps,
-  TComputed extends ErrorExtensionComputed,
   TMethods extends ErrorExtensionMethods,
-> = ErrorExtensionsMapOfExtension<ErrorExtension<TProps, TComputed, TMethods>>
+> = ErrorExtensionsMapOfExtension<ErrorExtension<TProps, 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 BuilderError0<TProps extends ErrorExtensionProps, TMethods extends ErrorExtensionMethods> = Error0 &
+  ErrorOutput<ExtensionsMapFromParts<TProps, 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'
+  TBuilder extends ExtensionError0<infer TProps, infer TMethods> ? ErrorExtension<TProps, TMethods> : never
 
 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>
+  private readonly _extension: ErrorExtension<ErrorExtensionProps, ErrorExtensionMethods>
 
   readonly Infer = undefined as unknown as {
     props: TProps
-    computed: TComputed
     methods: TMethods
   }
 
-  constructor(extension?: ErrorExtension<ErrorExtensionProps, ErrorExtensionComputed, ErrorExtensionMethods>) {
+  constructor(extension?: ErrorExtension<ErrorExtensionProps, ErrorExtensionMethods>) {
     this._extension = {
       props: { ...(extension?.props ?? {}) },
-      computed: { ...(extension?.computed ?? {}) },
       methods: { ...(extension?.methods ?? {}) },
       refine: [...(extension?.refine ?? [])],
     }
@@ -215,60 +176,44 @@ export class ExtensionError0<
 
   prop<TKey extends string, TInputValue, TOutputValue>(
     key: TKey,
-    value: ErrorExtensionPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TComputed, TMethods>>,
-  ): ExtensionError0<AddPropToExtensionProps<TProps, TKey, TInputValue, TOutputValue>, TComputed, TMethods> {
+    value: ErrorExtensionPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>>,
+  ): ExtensionError0<AddPropToExtensionProps<TProps, TKey, TInputValue, TOutputValue>, 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)
-  }
-
   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>> {
+    value: ErrorExtensionMethodFn<TOutputValue, TArgs, BuilderError0<TProps, TMethods>>,
+  ): ExtensionError0<TProps, AddMethodToExtensionMethods<TMethods, TKey, TArgs, TOutputValue>> {
     return this.extend('method', key, value)
   }
 
   refine(
-    value: ErrorExtensionRefineFn<BuilderError0<TProps, TComputed, TMethods>, ExtensionOutputProps<TProps>>,
-  ): ExtensionError0<TProps, TComputed, TMethods> {
+    value: ErrorExtensionRefineFn<BuilderError0<TProps, TMethods>, ExtensionOutputProps<TProps>>,
+  ): ExtensionError0<TProps, TMethods> {
     return this.extend('refine', value)
   }
 
   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>
+    value: ErrorExtensionPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>>,
+  ): ExtensionError0<AddPropToExtensionProps<TProps, TKey, TInputValue, 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>>
+    value: ErrorExtensionMethodFn<TOutputValue, TArgs, BuilderError0<TProps, TMethods>>,
+  ): ExtensionError0<TProps, AddMethodToExtensionMethods<TMethods, TKey, TArgs, TOutputValue>>
   extend(
     kind: 'refine',
-    value: ErrorExtensionRefineFn<BuilderError0<TProps, TComputed, TMethods>, ExtensionOutputProps<TProps>>,
-  ): ExtensionError0<TProps, TComputed, TMethods>
+    value: ErrorExtensionRefineFn<BuilderError0<TProps, TMethods>, ExtensionOutputProps<TProps>>,
+  ): ExtensionError0<TProps, TMethods>
   extend(
-    kind: 'prop' | 'computed' | 'method' | 'refine',
+    kind: 'prop' | 'method' | 'refine',
     keyOrValue: string | ErrorExtensionRefineFn<any, any>,
-    value?:
-      | ErrorExtensionPropOptions<unknown, unknown, any>
-      | ErrorExtensionCopmputedFn<unknown, any>
-      | ErrorExtensionMethodFn<unknown, unknown[], any>,
-  ): ExtensionError0<any, any, any> {
+    value?: ErrorExtensionPropOptions<unknown, unknown, any> | ErrorExtensionMethodFn<unknown, unknown[], any>,
+  ): ExtensionError0<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 ?? []),
@@ -279,12 +224,6 @@ export class ExtensionError0<
         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')
-      }
-      nextComputed[key] = value as ErrorExtensionCopmputedFn<any>
     } else if (kind === 'method') {
       const key = keyOrValue as string
       if (value === undefined) {
@@ -296,7 +235,6 @@ export class ExtensionError0<
     }
     return new ExtensionError0({
       props: nextProps,
-      computed: nextComputed,
       methods: nextMethods,
       refine: nextRefine,
     })
@@ -308,7 +246,18 @@ export type ClassError0<TExtensionsMap extends ErrorExtensionsMap = EmptyExtensi
   new (input: { message: string } & ErrorInput<TExtensionsMap>): Error0 & ErrorOutput<TExtensionsMap>
   readonly __extensionsMap?: TExtensionsMap
   from: (error: unknown) => Error0 & ErrorOutput<TExtensionsMap>
-  serialize: (error: unknown, isPublic?: boolean) => object
+  serialize: (error: unknown, isPublic?: boolean) => Record<string, unknown>
+  prop: <TKey extends string, TInputValue, TOutputValue>(
+    key: TKey,
+    value: ErrorExtensionPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TExtensionsMap>>,
+  ) => ClassError0<ExtendErrorExtensionsMapWithProp<TExtensionsMap, TKey, TInputValue, TOutputValue>>
+  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,
@@ -318,11 +267,6 @@ export type ClassError0<TExtensionsMap extends ErrorExtensionsMap = EmptyExtensi
       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,
@@ -342,7 +286,6 @@ export class Error0 extends Error {
 
   private static readonly _emptyExtension: ErrorExtensionResolved = {
     props: {},
-    computed: {},
     methods: {},
     refine: [],
   }
@@ -350,13 +293,11 @@ export class Error0 extends Error {
   private static _getResolvedExtension(this: typeof Error0): ErrorExtensionResolved {
     const resolved: ErrorExtensionResolved = {
       props: {},
-      computed: {},
       methods: {},
       refine: [],
     }
     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))
     }
@@ -382,10 +323,10 @@ export class Error0 extends Error {
     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)
+        ;(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 +340,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,79 +366,62 @@ 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)
   }
@@ -529,27 +437,33 @@ export class Error0 extends Error {
     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 }))
     }
-
     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 propsEntries = Object.entries(extension.props)
+    for (const [key, prop] of propsEntries) {
+      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 {
@@ -569,7 +483,7 @@ export class Error0 extends Error {
 
   private static _extendWithExtension(
     this: typeof Error0,
-    extension: ErrorExtension<ErrorExtensionProps, ErrorExtensionComputed, ErrorExtensionMethods>,
+    extension: ErrorExtension<ErrorExtensionProps, ErrorExtensionMethods>,
   ): ClassError0 {
     const Base = this as unknown as typeof Error0
     const Error0Extended = class Error0 extends Base {}
@@ -600,18 +514,40 @@ export class Error0 extends Error {
 
   private static _extensionFromBuilder(
     extension: ExtensionError0,
-  ): ErrorExtension<ErrorExtensionProps, ErrorExtensionComputed, ErrorExtensionMethods> {
+  ): ErrorExtension<ErrorExtensionProps, ErrorExtensionMethods> {
     const extensionRecord = extension as unknown as {
-      _extension: ErrorExtension<ErrorExtensionProps, ErrorExtensionComputed, ErrorExtensionMethods>
+      _extension: ErrorExtension<ErrorExtensionProps, ErrorExtensionMethods>
     }
     return {
       props: { ...(extensionRecord._extension.props ?? {}) },
-      computed: { ...(extensionRecord._extension.computed ?? {}) },
       methods: { ...(extensionRecord._extension.methods ?? {}) },
       refine: [...(extensionRecord._extension.refine ?? [])],
     }
   }
 
+  static prop<TThis extends typeof Error0, TKey extends string, TInputValue, TOutputValue>(
+    this: TThis,
+    key: TKey,
+    value: ErrorExtensionPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<ExtensionsMapOf<TThis>>>,
+  ): ClassError0<ExtendErrorExtensionsMapWithProp<ExtensionsMapOf<TThis>, TKey, TInputValue, TOutputValue>> {
+    return this.extend('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)
+  }
+
+  static refine<TThis extends typeof Error0>(
+    this: TThis,
+    value: ErrorExtensionRefineFn<ErrorInstanceOfMap<ExtensionsMapOf<TThis>>, ErrorOutputProps<ExtensionsMapOf<TThis>>>,
+  ): ClassError0<ExtensionsMapOf<TThis>> {
+    return this.extend('refine', value)
+  }
+
   static extend<TThis extends typeof Error0, TBuilder extends ExtensionError0>(
     this: TThis,
     extension: TBuilder,
@@ -622,12 +558,6 @@ export class Error0 extends Error {
     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',
@@ -641,12 +571,9 @@ export class Error0 extends Error {
   ): ClassError0<ExtensionsMapOf<TThis>>
   static extend(
     this: typeof Error0,
-    first: ExtensionError0 | 'prop' | 'computed' | 'method' | 'refine',
+    first: ExtensionError0 | 'prop' | 'method' | 'refine',
     key?: string | ErrorExtensionRefineFn<any, any>,
-    value?:
-      | ErrorExtensionPropOptions<unknown, unknown>
-      | ErrorExtensionCopmputedFn<unknown>
-      | ErrorExtensionMethodFn<unknown>,
+    value?: ErrorExtensionPropOptions<unknown, unknown> | ErrorExtensionMethodFn<unknown>,
   ): ClassError0 {
     if (first instanceof ExtensionError0) {
       return this._extendWithExtension(this._extensionFromBuilder(first))
@@ -668,11 +595,6 @@ export class Error0 extends Error {
         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> },
     })
@@ -682,31 +604,36 @@ export class Error0 extends Error {
     return new ExtensionError0()
   }
 
-  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 refine 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 propsEntries = Object.entries(extension.props)
+    for (const [key, prop] of propsEntries) {
+      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 {