@devp0nt/error0 1.0.0-next.53 → 1.0.0-next.55

package/src/index.ts

@@ -54,7 +54,7 @@ type ErrorPluginPropOptionsWithoutInit<
 > = ErrorPluginPropOptionsBase<TOutputValue, TError, TResolveValue> & {
   init?: undefined
 }
-export type ErrorPluginPropOptions<
+type ErrorPluginPropOptions<
   TInputValue = undefined,
   TOutputValue = unknown,
   TError extends Error0 = Error0,
@@ -62,49 +62,83 @@ export type ErrorPluginPropOptions<
 > =
   | ErrorPluginPropOptionsWithInit<TInputValue, TOutputValue, TError, TResolveValue>
   | ErrorPluginPropOptionsWithoutInit<TOutputValue, TError, TResolveValue>
-export type ErrorPluginMethodFn<TOutputValue, TArgs extends unknown[] = unknown[], TError extends Error0 = Error0> = (
+
+type ErrorPluginPropOptionsBaseDefinition<
+  TOutputValue,
+  TError extends Error0,
+  TResolveValue extends TOutputValue | undefined,
+> = {
+  resolve?: ((options: ErrorPluginPropOptionsResolveOptions<TOutputValue, TError>) => TResolveValue) | boolean
+  serialize?: ErrorPluginPropSerialize<TOutputValue, TError, TResolveValue>
+  deserialize?: ErrorPluginPropDeserialize<TOutputValue>
+}
+type ErrorPluginPropOptionsWithInitDefinition<
+  TInputValue,
+  TOutputValue,
+  TError extends Error0,
+  TResolveValue extends TOutputValue | undefined,
+> = ErrorPluginPropOptionsBaseDefinition<TOutputValue, TError, TResolveValue> & {
+  init: ErrorPluginPropInit<TInputValue, TOutputValue>
+}
+type ErrorPluginPropOptionsWithoutInitDefinition<
+  TOutputValue,
+  TError extends Error0,
+  TResolveValue extends TOutputValue | undefined,
+> = ErrorPluginPropOptionsBaseDefinition<TOutputValue, TError, TResolveValue> & {
+  init?: undefined
+}
+type ErrorPluginPropOptionsDefinition<
+  TInputValue = undefined,
+  TOutputValue = unknown,
+  TError extends Error0 = Error0,
+  TResolveValue extends TOutputValue | undefined = TOutputValue | undefined,
+> =
+  | ErrorPluginPropOptionsWithInitDefinition<TInputValue, TOutputValue, TError, TResolveValue>
+  | ErrorPluginPropOptionsWithoutInitDefinition<TOutputValue, TError, TResolveValue>
+
+type ErrorPluginMethodFn<TOutputValue, TArgs extends unknown[] = unknown[], TError extends Error0 = Error0> = (
   error: TError,
   ...args: TArgs
 ) => TOutputValue
 type ErrorPluginAnyMethodFn = (error: any, ...args: any[]) => any
-export type ErrorPluginAdaptResult<TOutputProps extends Record<string, unknown>> = Partial<TOutputProps> | undefined
-export type ErrorPluginAdaptFn<
+type ErrorPluginAdaptResult<TOutputProps extends Record<string, unknown>> = Partial<TOutputProps> | undefined
+type ErrorPluginAdaptFn<
   TError extends Error0 = Error0,
   TOutputProps extends Record<string, unknown> = Record<never, never>,
 > = ((error: TError) => void) | ((error: TError) => ErrorPluginAdaptResult<TOutputProps>)
-export type ErrorPluginStackSerialize<TError extends Error0> = (options: {
+type ErrorPluginStackSerialize<TError extends Error0> = (options: {
   value: string | undefined
   error: TError
   isPublic: boolean
 }) => unknown
-export type ErrorPluginStack<TError extends Error0 = Error0> = { serialize: ErrorPluginStackSerialize<TError> }
-export type ErrorPluginCauseSerialize<TError extends Error0> = (options: {
+type ErrorPluginStack<TError extends Error0 = Error0> = { serialize: ErrorPluginStackSerialize<TError> }
+type ErrorPluginCauseSerialize<TError extends Error0> = (options: {
   cause: unknown
   error: TError
   isPublic: boolean
   is: (cause: unknown) => boolean
   serialize: (cause: unknown) => Record<string, unknown>
 }) => unknown
-export type ErrorPluginCauseDeserialize = (options: {
+type ErrorPluginCauseDeserialize = (options: {
   cause: unknown
   error: Record<string, unknown>
   isSerialized: (serializedCause: unknown) => boolean
   fromSerialized: (serializedCause: unknown) => Error0
 }) => unknown
-export type ErrorPluginCause<TError extends Error0 = Error0> = {
+type ErrorPluginCause<TError extends Error0 = Error0> = {
   serialize: ErrorPluginCauseSerialize<TError>
   deserialize: ErrorPluginCauseDeserialize
 }
-export type ErrorPluginMessageSerialize<TError extends Error0> = (options: {
+type ErrorPluginMessageSerialize<TError extends Error0> = (options: {
   value: string
   error: TError
   isPublic: boolean
 }) => unknown
-export type ErrorPluginMessage<TError extends Error0 = Error0> = { serialize: ErrorPluginMessageSerialize<TError> }
+type ErrorPluginMessage<TError extends Error0 = Error0> = { serialize: ErrorPluginMessageSerialize<TError> }
 type ErrorMethodRecord = { fn: ErrorPluginAnyMethodFn }
 
-export type ErrorPluginProps = { [key: string]: ErrorPluginPropOptions<any, any> }
-export type ErrorPluginMethods = { [key: string]: ErrorPluginAnyMethodFn }
+type ErrorPluginProps = { [key: string]: ErrorPluginPropOptions<any, any> }
+type ErrorPluginMethods = { [key: string]: ErrorPluginAnyMethodFn }
 
 export type ErrorPlugin<
   TProps extends ErrorPluginProps = Record<never, never>,
@@ -134,12 +168,12 @@ type PluginOutputProps<TProps extends ErrorPluginProps> = {
     ? TResolveValue
     : never
 }
-export type ErrorPluginsMap = {
+type ErrorPluginsMap = {
   props: Record<string, { init: unknown; output: unknown; resolve: unknown }>
   methods: Record<string, ErrorMethodRecord>
 }
-export type IsEmptyObject<T> = keyof T extends never ? true : false
-export type ErrorInputBase = {
+type IsEmptyObject<T> = keyof T extends never ? true : false
+type ErrorInputBase = {
   cause?: unknown
 }
 type ErrorInputPluginProps<TPluginsMap extends ErrorPluginsMap> = {
@@ -147,7 +181,7 @@ type ErrorInputPluginProps<TPluginsMap extends ErrorPluginsMap> = {
     ? never
     : TKey]?: TPluginsMap['props'][TKey]['init']
 }
-export type ErrorInput<TPluginsMap extends ErrorPluginsMap> =
+type ErrorInput<TPluginsMap extends ErrorPluginsMap> =
   IsEmptyObject<TPluginsMap['props']> extends true
     ? ErrorInputBase
     : ErrorInputBase & ErrorInputPluginProps<TPluginsMap>
@@ -158,16 +192,19 @@ type ErrorResolvedProps<TPluginsMap extends ErrorPluginsMap> = {
 type ErrorOwnProps<TPluginsMap extends ErrorPluginsMap> = {
   [TKey in keyof TPluginsMap['props']]: TPluginsMap['props'][TKey]['output'] | undefined
 }
-type ErrorOwnMethods<TPluginsMap extends ErrorPluginsMap> = {
-  own: {
-    (): ErrorOwnProps<TPluginsMap>
-    <TKey extends keyof TPluginsMap['props'] & string>(key: TKey): ErrorOwnProps<TPluginsMap>[TKey]
-  }
-  flow: <TKey extends keyof TPluginsMap['props'] & string>(key: TKey) => Array<ErrorOwnProps<TPluginsMap>[TKey]>
-}
 type ErrorResolveMethods<TPluginsMap extends ErrorPluginsMap> = {
   resolve: () => ErrorResolvedProps<TPluginsMap>
 }
+type Error0ResolvedInstance<TPluginsMap extends ErrorPluginsMap> = Error0 &
+  ErrorResolved<TPluginsMap> &
+  ErrorResolveMethods<TPluginsMap>
+type ErrorOwnMethods<TPluginsMap extends ErrorPluginsMap> = {
+  own?: Partial<ErrorOwnProps<TPluginsMap>>
+  flow: <TKey extends keyof TPluginsMap['props'] & string>(key: TKey) => Array<ErrorOwnProps<TPluginsMap>[TKey]>
+  assign: (props: Partial<ErrorOwnProps<TPluginsMap>>) => Error0ResolvedInstance<TPluginsMap>
+}
+export type InstanceError0<TPluginsMap extends ErrorPluginsMap> = Error0ResolvedInstance<TPluginsMap> &
+  ErrorOwnMethods<TPluginsMap> & { readonly __pluginsMap?: TPluginsMap }
 // type BindInstanceMethod<TMethod> = TMethod extends {
 //   (error: any, ...args: infer TArgs1): infer TOutput1
 //   (error: any, ...args: infer TArgs2): infer TOutput2
@@ -243,8 +280,7 @@ type BindStaticMethod<TMethod> = TMethod extends (error: any, ...args: infer TAr
 type ErrorMethods<TPluginsMap extends ErrorPluginsMap> = {
   [TKey in keyof TPluginsMap['methods']]: BindInstanceMethod<TPluginsMap['methods'][TKey]['fn']>
 }
-export type ErrorResolved<TPluginsMap extends ErrorPluginsMap> = ErrorResolvedProps<TPluginsMap> &
-  ErrorMethods<TPluginsMap>
+type ErrorResolved<TPluginsMap extends ErrorPluginsMap> = ErrorResolvedProps<TPluginsMap> & ErrorMethods<TPluginsMap>
 
 type ErrorStaticMethods<TPluginsMap extends ErrorPluginsMap> = {
   [TKey in keyof TPluginsMap['methods']]: BindStaticMethod<TPluginsMap['methods'][TKey]['fn']>
@@ -269,6 +305,29 @@ type ErrorPluginResolved = {
 const RESERVED_STACK_PROP_ERROR = 'Error0: "stack" is a reserved prop key. Use .stack(...) plugin API instead'
 const RESERVED_MESSAGE_PROP_ERROR = 'Error0: "message" is a reserved prop key. Use .message(...) plugin API instead'
 
+const fromPropOptionsDefinition = (
+  options: ErrorPluginPropOptionsDefinition<any, any, any, any>,
+): ErrorPluginPropOptions<any, any, any, any> => {
+  let resolver: ErrorPluginPropOptions<unknown>['resolve']
+  if (!options.resolve) {
+    resolver = (options: ErrorPluginPropOptionsResolveOptions<any, any>) => options.own
+  } else if (options.resolve === true) {
+    resolver = (options: ErrorPluginPropOptionsResolveOptions<any, any>) => options.flow.find((v) => v !== undefined)
+  } else if (typeof options.resolve === 'function') {
+    resolver = options.resolve
+  } else {
+    throw new Error('Invalid resolve option')
+  }
+  const serializer: ErrorPluginPropOptions<unknown>['serialize'] = options.serialize ?? false
+  const deserializer: ErrorPluginPropOptions<unknown>['deserialize'] = options.deserialize ?? false
+  return {
+    ...options,
+    resolve: resolver,
+    serialize: serializer,
+    deserialize: deserializer,
+  }
+}
+
 type PluginPropsMapOf<TPlugin extends ErrorPlugin> = {
   [TKey in keyof NonNullable<TPlugin['props']>]: NonNullable<TPlugin['props']>[TKey] extends ErrorPluginPropOptions<
     any,
@@ -329,16 +388,10 @@ type PluginsMapFromParts<
   TProps extends ErrorPluginProps,
   TMethods extends ErrorPluginMethods,
 > = ErrorPluginsMapOfPlugin<ErrorPlugin<TProps, TMethods>>
-type ErrorInstanceOfMap<TMap extends ErrorPluginsMap> = Error0 &
-  ErrorResolved<TMap> &
-  ErrorOwnMethods<TMap> &
-  ErrorResolveMethods<TMap> & { readonly __pluginsMap?: TMap }
-type BuilderError0<TProps extends ErrorPluginProps, TMethods extends ErrorPluginMethods> = Error0 &
-  ErrorResolved<PluginsMapFromParts<TProps, TMethods>> &
-  ErrorOwnMethods<PluginsMapFromParts<TProps, TMethods>> &
-  ErrorResolveMethods<PluginsMapFromParts<TProps, TMethods>> & {
-    readonly __pluginsMap?: PluginsMapFromParts<TProps, TMethods>
-  }
+type ErrorInstanceOfMap<TMap extends ErrorPluginsMap> = InstanceError0<TMap>
+type BuilderError0<TProps extends ErrorPluginProps, TMethods extends ErrorPluginMethods> = InstanceError0<
+  PluginsMapFromParts<TProps, TMethods>
+>
 
 type PluginOfBuilder<TBuilder> =
   TBuilder extends PluginError0<infer TProps, infer TMethods> ? ErrorPlugin<TProps, TMethods> : never
@@ -372,7 +425,7 @@ export class PluginError0<
     TResolveValue extends TOutputValue | undefined = TOutputValue | undefined,
   >(
     key: TKey,
-    value: ErrorPluginPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>, TResolveValue>,
+    value: ErrorPluginPropOptionsDefinition<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>, TResolveValue>,
   ): PluginError0<AddPropToPluginProps<TProps, TKey, TInputValue, TOutputValue, TResolveValue>, TMethods> {
     return this.use('prop', key, value)
   }
@@ -410,7 +463,7 @@ export class PluginError0<
   >(
     kind: 'prop',
     key: TKey,
-    value: ErrorPluginPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>, TResolveValue>,
+    value: ErrorPluginPropOptionsDefinition<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>, TResolveValue>,
   ): PluginError0<AddPropToPluginProps<TProps, TKey, TInputValue, TOutputValue, TResolveValue>, TMethods>
   use<TKey extends string, TMethod extends (error: BuilderError0<TProps, TMethods>, ...args: any[]) => any>(
     kind: 'method',
@@ -427,7 +480,7 @@ export class PluginError0<
   use(
     kind: 'prop' | 'method' | 'adapt' | 'stack' | 'cause' | 'message',
     keyOrValue: unknown,
-    value?: ErrorPluginPropOptions<unknown, unknown, any> | ErrorPluginMethodFn<unknown, unknown[], any>,
+    value?: ErrorPluginPropOptionsDefinition<unknown, unknown, any> | ErrorPluginMethodFn<unknown, unknown[], any>,
   ): PluginError0<any, any> {
     const nextProps: ErrorPluginProps = { ...(this._plugin.props ?? {}) }
     const nextMethods: ErrorPluginMethods = { ...(this._plugin.methods ?? {}) }
@@ -446,7 +499,7 @@ export class PluginError0<
       if (value === undefined) {
         throw new Error('PluginError0.use("prop", key, value) requires value')
       }
-      nextProps[key] = value as ErrorPluginPropOptions<any, any>
+      nextProps[key] = fromPropOptionsDefinition(value as ErrorPluginPropOptionsDefinition<any, any>)
     } else if (kind === 'method') {
       const key = keyOrValue as string
       if (value === undefined) {
@@ -473,41 +526,27 @@ export class PluginError0<
   }
 }
 
-const OWN_SYMBOL: unique symbol = Symbol('Error0.own')
 type ErrorOwnStore = Record<string, unknown>
 
 export type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> = {
   MAX_CAUSES_DEPTH: number
-  new (
-    message: string,
-    input?: ErrorInput<TPluginsMap>,
-  ): Error0 &
-    ErrorResolved<TPluginsMap> &
-    ErrorOwnMethods<TPluginsMap> &
-    ErrorResolveMethods<TPluginsMap> & { readonly __pluginsMap?: TPluginsMap }
-  new (
-    input: { message: string } & ErrorInput<TPluginsMap>,
-  ): Error0 &
-    ErrorResolved<TPluginsMap> &
-    ErrorOwnMethods<TPluginsMap> &
-    ErrorResolveMethods<TPluginsMap> & { readonly __pluginsMap?: TPluginsMap }
+  new (message: string, input?: ErrorInput<TPluginsMap>): InstanceError0<TPluginsMap>
+  new (input: { message: string } & ErrorInput<TPluginsMap>): InstanceError0<TPluginsMap>
   readonly __pluginsMap?: TPluginsMap
-  from: (
-    error: unknown,
-  ) => Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap>
-  round: (
-    error: unknown,
-    isPublic?: boolean,
-  ) => Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap>
+  from: <TThis extends ClassError0<any>>(this: TThis, error: unknown) => InstanceType<TThis>
+  round: <TThis extends ClassError0<any>>(this: TThis, error: unknown, isPublic?: boolean) => InstanceType<TThis>
+  // flat: <TThis extends ClassError0<any>>(this: TThis, error: unknown, keepCauses?: boolean) => InstanceType<TThis>
   causes: {
     (error: unknown, instancesOnly?: false): unknown[]
-    (
-      error: unknown,
-      instancesOnly: true,
-    ): Array<Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap>>
+    (error: unknown, instancesOnly: true): Array<InstanceError0<TPluginsMap>>
   }
   resolve: (error: unknown) => ErrorResolvedProps<TPluginsMap>
   serialize: (error: unknown, isPublic?: boolean) => Record<string, unknown>
+  assign: <TThis extends ClassError0<any>>(
+    this: TThis,
+    error: unknown,
+    props: Partial<ErrorOwnProps<PluginsMapOf<TThis>>>,
+  ) => InstanceError0<PluginsMapOf<TThis>>
   own: {
     (error: object): ErrorOwnProps<TPluginsMap>
     <TKey extends keyof TPluginsMap['props'] & string>(error: object, key: TKey): ErrorOwnProps<TPluginsMap>[TKey]
@@ -516,24 +555,6 @@ export type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> =
     error: object,
     key: TKey,
   ) => Array<ErrorOwnProps<TPluginsMap>[TKey]>
-  // prop: <
-  //   TKey extends string,
-  //   TInputValue = undefined,
-  //   TOutputValue = unknown,
-  //   TResolveValue extends TOutputValue | undefined = TOutputValue | undefined,
-  // >(
-  //   key: TKey,
-  //   value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TPluginsMap>, TResolveValue>,
-  // ) => ClassError0<ExtendErrorPluginsMapWithProp<TPluginsMap, TKey, TInputValue, TOutputValue, TResolveValue>>
-  // method: <TKey extends string, TMethod extends (error: ErrorInstanceOfMap<TPluginsMap>, ...args: any[]) => any>(
-  //   key: TKey,
-  //   value: TMethod,
-  // ) => ClassError0<ExtendErrorPluginsMapWithMethod<TPluginsMap, TKey, TMethod>>
-  // adapt: (
-  //   value: ErrorPluginAdaptFn<ErrorInstanceOfMap<TPluginsMap>, ErrorResolvedProps<TPluginsMap>>,
-  // ) => ClassError0<TPluginsMap>
-  // stack: (value: ErrorPluginStack<ErrorInstanceOfMap<TPluginsMap>>) => ClassError0<TPluginsMap>
-  // cause: (value: ErrorPluginCause<ErrorInstanceOfMap<TPluginsMap>>) => ClassError0<TPluginsMap>
   use: {
     <TBuilder extends PluginError0>(
       plugin: TBuilder,
@@ -566,10 +587,11 @@ export type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> =
 
 export class Error0 extends Error {
   static readonly __pluginsMap?: EmptyPluginsMap
-  readonly __pluginsMap?: EmptyPluginsMap
+  declare readonly __pluginsMap?: EmptyPluginsMap
   static MAX_CAUSES_DEPTH = 99
   protected static _plugins: ErrorPlugin[] = []
   protected static _resolvedPlugin?: ErrorPluginResolved
+  declare own?: ErrorOwnStore
 
   private static readonly _emptyPlugin: ErrorPluginResolved = {
     props: {},
@@ -675,63 +697,43 @@ export class Error0 extends Error {
 
     const ctor = this.constructor as typeof Error0
     const plugin = ctor._getResolvedPlugin()
-    const ownStore = Object.create(null) as ErrorOwnStore
-    Object.defineProperty(this, OWN_SYMBOL, { value: ownStore, writable: true, enumerable: false, configurable: true })
+    // const ownStore = Object.create(null) as ErrorOwnStore
+    // Object.defineProperty(this, OWN_SYMBOL, { value: ownStore, writable: true, enumerable: false, configurable: true })
 
     for (const [key, prop] of plugin.propEntries) {
       if (key === 'stack') {
         continue
       }
       Object.defineProperty(this, key, {
-        get: () =>
-          prop.resolve({
-            own: ownStore[key],
-            flow: this.flow(key as never),
-            error: this,
-          }),
+        get: () => this._resolveByKey(key, plugin),
         set: (value) => {
-          ownStore[key] = value
+          this.assign({ [key]: value } as never)
         },
         enumerable: true,
         configurable: true,
       })
       if (key in input) {
-        const ownValue = (input as Record<string, unknown>)[key]
-        ownStore[key] = typeof prop.init === 'function' ? prop.init(ownValue) : ownValue
+        const inputValue = (input as Record<string, unknown>)[key]
+        const ownValue = typeof prop.init === 'function' ? prop.init(inputValue) : inputValue
+        this.assign({ [key]: ownValue } as never)
       }
     }
+    Error0.fixStack(input.cause)
   }
 
-  private static _getOwnStore(object: object): ErrorOwnStore | undefined {
-    const record = object as Record<string | symbol, unknown>
-    const existing = record[OWN_SYMBOL]
-    if (existing && typeof existing === 'object') {
-      return existing as ErrorOwnStore
-    }
-    return undefined
-  }
-
-  private static readonly isOwnProperty = (object: object, key: string): boolean => {
-    const ownStore = this._getOwnStore(object)
-    if (ownStore) {
-      return Object.prototype.hasOwnProperty.call(ownStore, key)
-    }
-    return !!Object.getOwnPropertyDescriptor(object, key)
-  }
-  private static _ownByKey(error: object, key: string): unknown {
-    const ownStore = this._getOwnStore(error)
-    if (ownStore) {
-      return ownStore[key]
-    }
-    return (error as Record<string, unknown>)[key]
-  }
-  private static _flowByKey(error: object, key: string): unknown[] {
-    const causes = this.causes(error, true)
-    const values = new Array<unknown>(causes.length)
-    for (let i = 0; i < causes.length; i += 1) {
-      values[i] = this._ownByKey(causes[i], key)
-    }
-    return values
+  private static fixStack(cause: unknown): void {
+    try {
+      if (process.env.NODE_ENV !== 'production') {
+        let nextCause = cause
+        let depth = 0
+        const maxDepth = 99
+        while (nextCause && depth < maxDepth) {
+          ;(globalThis as any).__ERROR0_FIX_STACKTRACE__(nextCause)
+          nextCause = (nextCause as any).cause
+          depth++
+        }
+      }
+    } catch {}
   }
 
   static own<TThis extends typeof Error0>(this: TThis, error: unknown): ErrorOwnProps<PluginsMapOf<TThis>>
@@ -743,26 +745,9 @@ export class Error0 extends Error {
   static own(error: unknown, key?: string): unknown {
     const error0 = this.from(error)
     if (key === undefined) {
-      const ownValues: Record<string, unknown> = {}
-      const plugin = this._getResolvedPlugin()
-      for (const ownKey of plugin.propKeys) {
-        ownValues[ownKey] = this._ownByKey(error0, ownKey)
-      }
-      return ownValues
-    }
-    return this._ownByKey(error0, key)
-  }
-  own<TThis extends Error0>(this: TThis): ErrorOwnProps<PluginsMapOfInstance<TThis>>
-  own<TThis extends Error0, TKey extends keyof PluginsMapOfInstance<TThis>['props'] & string>(
-    this: TThis,
-    key: TKey,
-  ): ErrorOwnProps<PluginsMapOfInstance<TThis>>[TKey]
-  own(key?: string): unknown {
-    const ctor = this.constructor as typeof Error0
-    if (key === undefined) {
-      return ctor.own(this)
+      return error0.own ?? {}
     }
-    return ctor._ownByKey(this, key)
+    return error0.own?.[key]
   }
 
   static flow<TThis extends typeof Error0, TKey extends keyof PluginsMapOf<TThis>['props'] & string>(
@@ -772,57 +757,68 @@ export class Error0 extends Error {
   ): Array<ErrorOwnProps<PluginsMapOf<TThis>>[TKey]>
   static flow(error: unknown, key: string): unknown[] {
     const error0 = this.from(error)
-    return this._flowByKey(error0, key)
+    return error0.flow(key as never)
   }
   flow<TThis extends Error0, TKey extends keyof PluginsMapOfInstance<TThis>['props'] & string>(
     this: TThis,
     key: TKey,
   ): Array<ErrorOwnProps<PluginsMapOfInstance<TThis>>[TKey]>
   flow(key: string): unknown[] {
-    const ctor = this.constructor as typeof Error0
-    return ctor._flowByKey(this, key)
+    const causes = this.causes(true)
+    const values = new Array<unknown>(causes.length)
+    for (let i = 0; i < causes.length; i += 1) {
+      values[i] = causes[i].own?.[key]
+    }
+    return values
   }
 
-  static _resolveByKey(error: Error0, key: string, plugin: ErrorPluginResolved): unknown {
-    try {
-      const options = {
-        get own() {
-          return error.own(key as never)
-        },
-        get flow() {
-          return error.flow(key as never)
-        },
-        error,
-      }
-      const prop = plugin.props[key]
-      const resolver = prop.resolve
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      if (!resolver) {
-        return (error as any)[key]
-      }
-      return resolver(options as ErrorPluginPropOptionsResolveOptions<any, any>)
-    } catch {
-      // eslint-disable-next-line no-console
-      console.error(`Error0: failed to resolve property ${key}`, error)
-      return undefined
+  private readonly _resolveByKeyCache = new Map<string, unknown>()
+  private _resolveByKey(key: string, plugin: ErrorPluginResolved): unknown {
+    // eslint-disable-next-line consistent-this, @typescript-eslint/no-this-alias
+    const error = this
+    if (this._resolveByKeyCache.has(key)) {
+      return this._resolveByKeyCache.get(key)
     }
+    const value = (() => {
+      try {
+        const options = {
+          get flow() {
+            return error.flow(key as never)
+          },
+          own: error.own?.[key],
+          error,
+        }
+        const prop = plugin.props[key]
+        const resolver = prop.resolve
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (!resolver) {
+          return (error as any)[key]
+        }
+        return resolver(options as ErrorPluginPropOptionsResolveOptions<any, any>)
+      } catch {
+        // eslint-disable-next-line no-console
+        console.error(`Error0: failed to resolve property ${key}`, error)
+        return undefined
+      }
+    })()
+    this._resolveByKeyCache.set(key, value)
+    return value
   }
 
   static resolve<TThis extends typeof Error0>(this: TThis, error: unknown): ErrorResolvedProps<PluginsMapOf<TThis>>
   static resolve(error: unknown): Record<string, unknown>
   static resolve(error: unknown): Record<string, unknown> {
-    const error0 = this.from(error)
-    const resolved: Record<string, unknown> = {}
-    const plugin = this._getResolvedPlugin()
-    for (const key of plugin.propKeys) {
-      resolved[key] = this._resolveByKey(error0, key, plugin)
-    }
-    return resolved
+    return this.from(error).resolve()
   }
   resolve<TThis extends Error0>(this: TThis): ErrorResolvedProps<PluginsMapOfInstance<TThis>>
   resolve(): Record<string, unknown> {
     const ctor = this.constructor as typeof Error0
-    return ctor.resolve(this)
+    const plugin = ctor._getResolvedPlugin()
+    const resolved: Record<string, unknown> = {}
+    for (const key of plugin.propKeys) {
+      resolved[key] = this._resolveByKey(key, plugin)
+    }
+    return resolved
   }
 
   static causes(error: unknown, instancesOnly?: false): unknown[]
@@ -866,6 +862,7 @@ export class Error0 extends Error {
     return !this.is(error) && typeof error === 'object' && error !== null && 'name' in error && error.name === 'Error0'
   }
 
+  static from<TThis extends typeof Error0>(this: TThis, error: unknown): InstanceType<TThis>
   static from(error: unknown): Error0 {
     if (this.is(error)) {
       return error
@@ -876,8 +873,61 @@ export class Error0 extends Error {
     return this._fromNonError0(error)
   }
 
+  static round<TThis extends typeof Error0>(this: TThis, error: unknown, isPublic?: boolean): InstanceType<TThis>
   static round(error: unknown, isPublic = false): Error0 {
-    return this.from(this.serialize(error, isPublic))
+    return this.from(error).round(isPublic)
+  }
+  round<TThis extends Error0>(this: TThis, isPublic = true): TThis {
+    const ctor = this.constructor as typeof Error0
+    return ctor.from(this.serialize(isPublic)) as TThis
+  }
+
+  // static flat<TThis extends typeof Error0>(this: TThis, error: unknown, keepCauses?: boolean): InstanceType<TThis>
+  // static flat(error: unknown, keepCauses = false): Error0 {
+  //   return this.from(error).flat(keepCauses)
+  // }
+  // flat<TThis extends Error0>(this: TThis, keepCauses = false): TThis {
+  //   const ctor = this.constructor as typeof Error0
+  //   // eslint-disable-next-line new-cap
+  //   const error = new ctor(this.message) as TThis
+  //   if (keepCauses) {
+  //     error.cause = this.cause
+  //   }
+  //   error.assign({
+  //     // ...this.own,
+  //     ...this.resolve(),
+  //   } as never)
+  //   error.stack =
+  //     this.causes()
+  //       .map((cause, index) => {
+  //         return cause instanceof Error && cause.stack && typeof cause.stack === 'string'
+  //           ? index === 0
+  //             ? cause.stack
+  //             : cause.stack.split('\n').slice(1).join('\n')
+  //           : undefined
+  //       })
+  //       .join('\n') || undefined
+  //   return error
+  // }
+
+  static assign<TThis extends typeof Error0>(
+    this: TThis,
+    error: unknown,
+    props: Partial<ErrorOwnProps<PluginsMapOf<TThis>>>,
+  ): InstanceType<TThis>
+  static assign(error: unknown, props: Record<string, unknown>): Error0 {
+    const error0 = this.from(error)
+    return error0.assign(props)
+  }
+  assign<TThis extends Error0>(this: TThis, props: Partial<ErrorOwnProps<PluginsMapOfInstance<TThis>>>): TThis
+  assign(props: Record<string, unknown>): this {
+    this.own = Object.assign(this.own ?? {}, props)
+    this._resolveByKeyCache.clear()
+    // const values = Object.values(props)
+    // if (values.every((value) => value === undefined)) {
+    //   this.own = undefined
+    // }
+    return this
   }
 
   private static _applyAdapt(error: Error0): Error0 {
@@ -885,7 +935,7 @@ export class Error0 extends Error {
     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)
+        error.assign(adapted)
       }
     }
     return error
@@ -994,49 +1044,6 @@ export class Error0 extends Error {
     }
   }
 
-  // static prop<
-  //   TThis extends typeof Error0,
-  //   TKey extends string,
-  //   TInputValue = undefined,
-  //   TOutputValue = unknown,
-  //   TResolveValue extends TOutputValue | undefined = TOutputValue | undefined,
-  // >(
-  //   this: TThis,
-  //   key: TKey,
-  //   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, TMethod extends (error: ErrorInstanceOfMap<PluginsMapOf<TThis>>, ...args: any[]) => any>(
-  //   this: TThis,
-  //   key: TKey,
-  //   value: TMethod,
-  // ): ClassError0<ExtendErrorPluginsMapWithMethod<PluginsMapOf<TThis>, TKey, TMethod>> {
-  //   return this.use('method', key, value)
-  // }
-
-  // static adapt<TThis extends typeof Error0>(
-  //   this: TThis,
-  //   value: ErrorPluginAdaptFn<ErrorInstanceOfMap<PluginsMapOf<TThis>>, ErrorResolvedProps<PluginsMapOf<TThis>>>,
-  // ): ClassError0<PluginsMapOf<TThis>> {
-  //   return this.use('adapt', value)
-  // }
-
-  // static stack<TThis extends typeof Error0>(
-  //   this: TThis,
-  //   value: ErrorPluginStack<ErrorInstanceOfMap<PluginsMapOf<TThis>>>,
-  // ): ClassError0<PluginsMapOf<TThis>> {
-  //   return this.use('stack', value)
-  // }
-
-  // static cause<TThis extends typeof Error0>(
-  //   this: TThis,
-  //   value: ErrorPluginCause<ErrorInstanceOfMap<PluginsMapOf<TThis>>>,
-  // ): ClassError0<PluginsMapOf<TThis>> {
-  //   return this.use('cause', value)
-  // }
-
   static use<TThis extends typeof Error0, TBuilder extends PluginError0>(
     this: TThis,
     plugin: TBuilder,
@@ -1051,7 +1058,12 @@ export class Error0 extends Error {
     this: TThis,
     kind: 'prop',
     key: TKey,
-    value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<PluginsMapOf<TThis>>, TResolveValue>,
+    value: ErrorPluginPropOptionsDefinition<
+      TInputValue,
+      TOutputValue,
+      ErrorInstanceOfMap<PluginsMapOf<TThis>>,
+      TResolveValue
+    >,
   ): ClassError0<ExtendErrorPluginsMapWithProp<PluginsMapOf<TThis>, TKey, TInputValue, TOutputValue, TResolveValue>>
   static use<
     TThis extends typeof Error0,
@@ -1087,8 +1099,8 @@ export class Error0 extends Error {
     this: typeof Error0,
     first: PluginError0 | 'prop' | 'method' | 'adapt' | 'stack' | 'cause' | 'message',
     key?: unknown,
-    value?: ErrorPluginPropOptions<unknown> | ErrorPluginMethodFn<unknown>,
-  ): ClassError0 {
+    value?: ErrorPluginPropOptionsDefinition<unknown> | ErrorPluginMethodFn<unknown>,
+  ): ClassError0<any> {
     if (first instanceof PluginError0) {
       return this._useWithPlugin(this._pluginFromBuilder(first))
     }
@@ -1150,7 +1162,7 @@ export class Error0 extends Error {
         throw new Error(RESERVED_MESSAGE_PROP_ERROR)
       }
       return this._useWithPlugin({
-        props: { [key]: value as ErrorPluginPropOptions<unknown> },
+        props: { [key]: fromPropOptionsDefinition(value as ErrorPluginPropOptionsDefinition<any, any>) },
       })
     }
     return this._useWithPlugin({
@@ -1163,10 +1175,14 @@ export class Error0 extends Error {
   }
 
   static serialize(error: unknown, isPublic = true): Record<string, unknown> {
-    const error0 = this.from(error)
-    const plugin = this._getResolvedPlugin()
-    const resolveByKey = (targetError: Error0, key: string, targetPlugin: ErrorPluginResolved): unknown =>
-      this._resolveByKey(targetError, key, targetPlugin)
+    return this.from(error).serialize(isPublic)
+  }
+
+  serialize(isPublic = true): Record<string, unknown> {
+    // eslint-disable-next-line consistent-this, @typescript-eslint/no-this-alias
+    const error0 = this
+    const ctor = error0.constructor as typeof Error0
+    const plugin = ctor._getResolvedPlugin()
     const messagePlugin = plugin.message
     let serializedMessage: unknown = error0.message
     try {
@@ -1191,15 +1207,13 @@ export class Error0 extends Error {
       }
       try {
         const options = {
-          get own() {
-            return error0.own(key as never)
-          },
           get flow() {
             return error0.flow(key as never)
           },
           get resolved() {
-            return resolveByKey(error0, key, plugin)
+            return error0._resolveByKey(key, plugin)
           },
+          own: error0.own?.[key],
           error: error0,
           isPublic,
         }
@@ -1234,8 +1248,8 @@ export class Error0 extends Error {
           cause: (error0 as { cause?: unknown }).cause,
           error: error0,
           isPublic,
-          is: (cause) => this.is(cause),
-          serialize: (cause) => this.serialize(cause, isPublic),
+          is: (cause) => ctor.is(cause),
+          serialize: (cause) => ctor.serialize(cause, isPublic),
         })
         if (serializedCause !== undefined) {
           json.cause = serializedCause
@@ -1247,14 +1261,4 @@ export class Error0 extends Error {
     }
     return json
   }
-
-  serialize(isPublic = true): Record<string, unknown> {
-    const ctor = this.constructor as typeof Error0
-    return ctor.serialize(this, isPublic)
-  }
-
-  round<TThis extends Error0>(this: TThis, isPublic = true): TThis {
-    const ctor = this.constructor as typeof Error0
-    return ctor.round(this, isPublic) as TThis
-  }
 }