@devp0nt/error0 1.0.0-next.47 → 1.0.0-next.49

package/src/index.ts

@@ -12,19 +12,31 @@ type InferPluginPropInput<TProp extends ErrorPluginPropOptions<any, any, any, an
   ? NormalizeUnknownToUndefined<InferFirstArg<TInit>>
   : undefined
 type ErrorPluginPropInit<TInputValue, TOutputValue> = ((input: TInputValue) => TOutputValue) | (() => TOutputValue)
-type ErrorPluginPropSerialize<TOutputValue, TError extends Error0> =
-  | ((options: { value: TOutputValue; error: TError; isPublic: boolean }) => unknown)
+type ErrorPluginPropSerializeOptions<
+  TOutputValue,
+  TError extends Error0,
+  TResolveValue extends TOutputValue | undefined,
+> = {
+  own: TOutputValue | undefined
+  flow: Array<TOutputValue | undefined>
+  resolved: TResolveValue
+  error: TError
+  isPublic: boolean
+}
+type ErrorPluginPropSerialize<TOutputValue, TError extends Error0, TResolveValue extends TOutputValue | undefined> =
+  | ((options: ErrorPluginPropSerializeOptions<TOutputValue, TError, TResolveValue>) => unknown)
   | false
 type ErrorPluginPropDeserialize<TOutputValue> =
-  | ((options: { value: unknown; serialized: Record<string, unknown> }) => TOutputValue | undefined)
+  | ((options: { value: unknown; record: Record<string, unknown> }) => TOutputValue | undefined)
   | false
+type ErrorPluginPropOptionsResolveOptions<TOutputValue, TError extends Error0> = {
+  own: TOutputValue | undefined
+  flow: Array<TOutputValue | undefined>
+  error: TError
+}
 type ErrorPluginPropOptionsBase<TOutputValue, TError extends Error0, TResolveValue extends TOutputValue | undefined> = {
-  resolve: (options: {
-    own: TOutputValue | undefined
-    flow: Array<TOutputValue | undefined>
-    error: TError
-  }) => TResolveValue
-  serialize: ErrorPluginPropSerialize<TResolveValue, TError>
+  resolve: (options: ErrorPluginPropOptionsResolveOptions<TOutputValue, TError>) => TResolveValue
+  serialize: ErrorPluginPropSerialize<TOutputValue, TError, TResolveValue>
   deserialize: ErrorPluginPropDeserialize<TOutputValue>
 }
 type ErrorPluginPropOptionsWithInit<
@@ -180,6 +192,9 @@ type ErrorPluginResolved = {
   stack?: ErrorPluginStack
   cause?: ErrorPluginCause
   message?: ErrorPluginMessage
+  propKeys: string[]
+  propEntries: Array<[string, ErrorPluginPropOptions<unknown>]>
+  methodEntries: Array<[string, ErrorPluginMethodFn<unknown>]>
 }
 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'
@@ -249,9 +264,16 @@ type PluginsMapFromParts<
   TProps extends ErrorPluginProps,
   TMethods extends ErrorPluginMethods,
 > = ErrorPluginsMapOfPlugin<ErrorPlugin<TProps, TMethods>>
-type ErrorInstanceOfMap<TMap extends ErrorPluginsMap> = Error0 & ErrorResolved<TMap>
+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>>
+  ErrorResolved<PluginsMapFromParts<TProps, TMethods>> &
+  ErrorOwnMethods<PluginsMapFromParts<TProps, TMethods>> &
+  ErrorResolveMethods<PluginsMapFromParts<TProps, TMethods>> & {
+    readonly __pluginsMap?: PluginsMapFromParts<TProps, TMethods>
+  }
 
 type PluginOfBuilder<TBuilder> =
   TBuilder extends PluginError0<infer TProps, infer TMethods> ? ErrorPlugin<TProps, TMethods> : never
@@ -386,7 +408,11 @@ 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>,
@@ -404,6 +430,17 @@ export type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> =
   from: (
     error: unknown,
   ) => Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap>
+  round: (
+    error: unknown,
+    isPublic?: boolean,
+  ) => Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap>
+  causes: {
+    (error: unknown, instancesOnly?: false): unknown[]
+    (
+      error: unknown,
+      instancesOnly: true,
+    ): Array<Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap>>
+  }
   resolve: (error: unknown) => ErrorResolvedProps<TPluginsMap>
   serialize: (error: unknown, isPublic?: boolean) => Record<string, unknown>
   own: {
@@ -465,7 +502,9 @@ export type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> =
 export class Error0 extends Error {
   static readonly __pluginsMap?: EmptyPluginsMap
   readonly __pluginsMap?: EmptyPluginsMap
+  static MAX_CAUSES_DEPTH = 99
   protected static _plugins: ErrorPlugin[] = []
+  protected static _resolvedPlugin?: ErrorPluginResolved
 
   private static readonly _emptyPlugin: ErrorPluginResolved = {
     props: {},
@@ -474,35 +513,86 @@ export class Error0 extends Error {
     stack: undefined,
     cause: undefined,
     message: undefined,
+    propKeys: [],
+    propEntries: [],
+    methodEntries: [],
+  }
+
+  private static _indexResolvedPlugin(
+    resolved: Omit<ErrorPluginResolved, 'propKeys' | 'propEntries' | 'methodEntries'>,
+  ): ErrorPluginResolved {
+    return {
+      ...resolved,
+      propKeys: Object.keys(resolved.props),
+      propEntries: Object.entries(resolved.props),
+      methodEntries: Object.entries(resolved.methods),
+    }
+  }
+
+  private static _applyPlugin(
+    resolved: Omit<ErrorPluginResolved, 'propKeys' | 'propEntries' | 'methodEntries'>,
+    plugin: ErrorPlugin,
+  ): void {
+    if (plugin.props && 'stack' in plugin.props) {
+      throw new Error(RESERVED_STACK_PROP_ERROR)
+    }
+    if (plugin.props && 'message' in plugin.props) {
+      throw new Error(RESERVED_MESSAGE_PROP_ERROR)
+    }
+    Object.assign(resolved.props, plugin.props ?? this._emptyPlugin.props)
+    Object.assign(resolved.methods, plugin.methods ?? this._emptyPlugin.methods)
+    resolved.adapt.push(...(plugin.adapt ?? this._emptyPlugin.adapt))
+    if (typeof plugin.stack !== 'undefined') {
+      resolved.stack = plugin.stack
+    }
+    if (typeof plugin.cause !== 'undefined') {
+      resolved.cause = plugin.cause
+    }
+    if (typeof plugin.message !== 'undefined') {
+      resolved.message = plugin.message
+    }
+  }
+
+  private static _mergeResolvedPlugin(
+    this: typeof Error0,
+    base: ErrorPluginResolved,
+    plugin: ErrorPlugin,
+  ): ErrorPluginResolved {
+    const merged: Omit<ErrorPluginResolved, 'propKeys' | 'propEntries' | 'methodEntries'> = {
+      props: { ...base.props },
+      methods: { ...base.methods },
+      adapt: [...base.adapt],
+      stack: base.stack,
+      cause: base.cause,
+      message: base.message,
+    }
+    this._applyPlugin(merged, plugin)
+    return this._indexResolvedPlugin(merged)
   }
 
   private static _getResolvedPlugin(this: typeof Error0): ErrorPluginResolved {
+    if (Object.prototype.hasOwnProperty.call(this, '_resolvedPlugin') && this._resolvedPlugin) {
+      return this._resolvedPlugin
+    }
     const resolved: ErrorPluginResolved = {
       props: {},
       methods: {},
       adapt: [],
+      propKeys: [],
+      propEntries: [],
+      methodEntries: [],
     }
     for (const plugin of this._plugins) {
-      if (plugin.props && 'stack' in plugin.props) {
-        throw new Error(RESERVED_STACK_PROP_ERROR)
-      }
-      if (plugin.props && 'message' in plugin.props) {
-        throw new Error(RESERVED_MESSAGE_PROP_ERROR)
-      }
-      Object.assign(resolved.props, plugin.props ?? this._emptyPlugin.props)
-      Object.assign(resolved.methods, plugin.methods ?? this._emptyPlugin.methods)
-      resolved.adapt.push(...(plugin.adapt ?? this._emptyPlugin.adapt))
-      if (typeof plugin.stack !== 'undefined') {
-        resolved.stack = plugin.stack
-      }
-      if (typeof plugin.cause !== 'undefined') {
-        resolved.cause = plugin.cause
-      }
-      if (typeof plugin.message !== 'undefined') {
-        resolved.message = plugin.message
-      }
+      this._applyPlugin(resolved, plugin)
     }
-    return resolved
+    const indexed = this._indexResolvedPlugin(resolved)
+    Object.defineProperty(this, '_resolvedPlugin', {
+      value: indexed,
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    })
+    return indexed
   }
 
   constructor(message: string, input?: ErrorInput<EmptyPluginsMap>)
@@ -520,37 +610,47 @@ 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 })
 
-    for (const [key, prop] of Object.entries(plugin.props)) {
+    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,
+          }),
+        set: (value) => {
+          ownStore[key] = value
+        },
+        enumerable: true,
+        configurable: true,
+      })
       if (key in input) {
         const ownValue = (input as Record<string, unknown>)[key]
-        if (typeof prop.init === 'function') {
-          ;(this as Record<string, unknown>)[key] = prop.init(ownValue)
-        } else {
-          ;(this as Record<string, unknown>)[key] = ownValue
-        }
-      } else {
-        Object.defineProperty(this, key, {
-          get: () => prop.resolve({ own: undefined, flow: this.flow(key), error: this }),
-          set: (value) => {
-            Object.defineProperty(this, key, {
-              value,
-              writable: true,
-              enumerable: true,
-              configurable: true,
-            })
-          },
-          enumerable: true,
-          configurable: true,
-        })
+        ownStore[key] = typeof prop.init === 'function' ? prop.init(ownValue) : ownValue
       }
     }
   }
 
-  private static readonly isSelfProperty = (object: object, key: string): boolean => {
+  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 && Object.prototype.hasOwnProperty.call(ownStore, key)) {
+      return true
+    }
     const d = Object.getOwnPropertyDescriptor(object, key)
     if (!d) return false
     if (typeof d.get === 'function' || typeof d.set === 'function') {
@@ -563,15 +663,22 @@ export class Error0 extends Error {
     return true
   }
   private static _ownByKey(error: object, key: string): unknown {
-    if (this.isSelfProperty(error, key)) {
+    const ownStore = this._getOwnStore(error)
+    if (ownStore && Object.prototype.hasOwnProperty.call(ownStore, key)) {
+      return ownStore[key]
+    }
+    if (this.isOwnProperty(error, key)) {
       return (error as Record<string, unknown>)[key]
     }
     return undefined
   }
   private static _flowByKey(error: object, key: string): unknown[] {
-    return this.causes(error, true).map((cause) => {
-      return this._ownByKey(cause, key)
-    })
+    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
   }
 
   static own<TThis extends typeof Error0>(this: TThis, error: unknown): ErrorOwnProps<PluginsMapOf<TThis>>
@@ -585,7 +692,7 @@ export class Error0 extends Error {
     if (key === undefined) {
       const ownValues: Record<string, unknown> = {}
       const plugin = this._getResolvedPlugin()
-      for (const ownKey of Object.keys(plugin.props)) {
+      for (const ownKey of plugin.propKeys) {
         ownValues[ownKey] = this._ownByKey(error0, ownKey)
       }
       return ownValues
@@ -610,7 +717,6 @@ export class Error0 extends Error {
     error: unknown,
     key: TKey,
   ): Array<ErrorOwnProps<PluginsMapOf<TThis>>[TKey]>
-  static flow(error: unknown, key: string): unknown[]
   static flow(error: unknown, key: string): unknown[] {
     const error0 = this.from(error)
     return this._flowByKey(error0, key)
@@ -619,45 +725,48 @@ export class Error0 extends Error {
     this: TThis,
     key: TKey,
   ): Array<ErrorOwnProps<PluginsMapOfInstance<TThis>>[TKey]>
-  flow(key: string): unknown[]
   flow(key: string): unknown[] {
     const ctor = this.constructor as typeof Error0
     return ctor._flowByKey(this, key)
   }
 
+  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
+    }
+  }
+
   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, prop] of Object.entries(plugin.props)) {
-      try {
-        // resolved[key] = (error0 as unknown as Record<string, unknown>)[key]
-        const options = Object.defineProperties(
-          {
-            error: error0,
-          },
-          {
-            own: {
-              get: () => error0.own(key as never),
-            },
-            flow: {
-              get: () => error0.flow(key),
-            },
-          },
-        )
-        resolved[key] = prop.resolve(options as never)
-        // resolved[key] = prop.resolve({ own: error0.own(key as never), flow: error0.flow(key), error: error0 })
-      } catch {
-        // eslint-disable-next-line no-console
-        console.error(`Error0: failed to resolve property ${key}`, error0)
-      }
+    for (const key of plugin.propKeys) {
+      resolved[key] = this._resolveByKey(error0, key, plugin)
     }
     return resolved
   }
   resolve<TThis extends Error0>(this: TThis): ErrorResolvedProps<PluginsMapOfInstance<TThis>>
-  resolve(): Record<string, unknown>
   resolve(): Record<string, unknown> {
     const ctor = this.constructor as typeof Error0
     return ctor.resolve(this)
@@ -668,9 +777,9 @@ export class Error0 extends Error {
   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) {
+    let depth = 0
+    while (depth < this.MAX_CAUSES_DEPTH) {
       if (seen.has(current)) {
         break
       }
@@ -682,6 +791,7 @@ export class Error0 extends Error {
         break
       }
       current = (current as { cause?: unknown }).cause
+      depth += 1
     }
     return causes
   }
@@ -713,6 +823,10 @@ export class Error0 extends Error {
     return this._fromNonError0(error)
   }
 
+  static round(error: unknown, isPublic = false): Error0 {
+    return this.from(this.serialize(error, isPublic))
+  }
+
   private static _applyAdapt(error: Error0): Error0 {
     const plugin = this._getResolvedPlugin()
     for (const adapt of plugin.adapt) {
@@ -732,8 +846,7 @@ export class Error0 extends Error {
     const errorRecord = error as Record<string, unknown>
     const recreated = new this(message)
     const plugin = this._getResolvedPlugin()
-    const propsEntries = Object.entries(plugin.props)
-    for (const [key, prop] of propsEntries) {
+    for (const [key, prop] of plugin.propEntries) {
       if (prop.deserialize === false) {
         continue
       }
@@ -741,7 +854,7 @@ export class Error0 extends Error {
         continue
       }
       try {
-        const value = prop.deserialize({ value: errorRecord[key], serialized: errorRecord })
+        const value = prop.deserialize({ value: errorRecord[key], record: errorRecord })
         ;(recreated as unknown as Record<string, unknown>)[key] = value
       } catch {
         // eslint-disable-next-line no-console
@@ -798,9 +911,9 @@ export class Error0 extends Error {
     const Base = this as unknown as typeof Error0
     const Error0Extended = class Error0 extends Base {}
     ;(Error0Extended as typeof Error0)._plugins = [...Base._plugins, plugin]
-
-    const resolved = (Error0Extended as typeof Error0)._getResolvedPlugin()
-    for (const [key, method] of Object.entries(resolved.methods)) {
+    const resolved = this._mergeResolvedPlugin(Base._getResolvedPlugin(), plugin)
+    ;(Error0Extended as typeof Error0)._resolvedPlugin = resolved
+    for (const [key, method] of resolved.methodEntries) {
       Object.defineProperty((Error0Extended as typeof Error0).prototype, key, {
         value: function (...args: unknown[]) {
           return method(this as Error0, ...args)
@@ -997,9 +1110,9 @@ export class Error0 extends Error {
 
   static serialize(error: unknown, isPublic = true): Record<string, unknown> {
     const error0 = this.from(error)
-    const resolvedProps = this.resolve(error0)
-    const resolvedRecord = resolvedProps as Record<string, unknown>
     const plugin = this._getResolvedPlugin()
+    const resolveByKey = (targetError: Error0, key: string, targetPlugin: ErrorPluginResolved): unknown =>
+      this._resolveByKey(targetError, key, targetPlugin)
     const messagePlugin = plugin.message
     let serializedMessage: unknown = error0.message
     try {
@@ -1013,25 +1126,38 @@ export class Error0 extends Error {
     }
     const json: Record<string, unknown> = {
       name: error0.name,
-      message: serializedMessage,
       // we do not serialize causes, it is enough that we have floated props and adapt helper
       // cause: error0.cause,
     }
+    if (serializedMessage !== undefined) {
+      json.message = serializedMessage
+    }
 
-    const propsEntries = Object.entries(plugin.props)
-    for (const [key, prop] of propsEntries) {
+    for (const [key, prop] of plugin.propEntries) {
       if (prop.serialize === false) {
         continue
       }
       try {
-        const value = resolvedRecord[key]
-        const jsonValue = prop.serialize({ value, error: error0, isPublic })
+        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)
+          },
+          error: error0,
+          isPublic,
+        }
+        const jsonValue = prop.serialize(options as ErrorPluginPropSerializeOptions<any, any, any>)
         if (jsonValue !== undefined) {
           json[key] = jsonValue
         }
       } catch {
         // eslint-disable-next-line no-console
-        console.error(`Error0: failed to serialize property ${key}`, resolvedRecord)
+        console.error(`Error0: failed to serialize property ${key}`, error0)
       }
     }
     const stackPlugin = plugin.stack
@@ -1065,14 +1191,16 @@ export class Error0 extends Error {
         console.error('Error0: failed to serialize cause', error0)
       }
     }
-    return Object.fromEntries(Object.entries(json).filter(([, value]) => value !== undefined)) as Record<
-      string,
-      unknown
-    >
+    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
+  }
 }

package/src/plugins/cause-serialize.test.ts

@@ -6,7 +6,7 @@ describe('causeSerializePlugin', () => {
   const statusPlugin = Error0.plugin().use('prop', 'status', {
     init: (input: number) => input,
     resolve: ({ flow }) => flow.find((value) => typeof value === 'number'),
-    serialize: ({ value }) => value,
+    serialize: ({ resolved }) => resolved,
     deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
   })
 
@@ -14,14 +14,16 @@ describe('causeSerializePlugin', () => {
   type Code = (typeof codes)[number]
   const codePlugin = Error0.plugin().use('prop', 'code', {
     init: (input: Code) => input,
-    resolve: ({ flow }) => flow.find((value) => typeof value === 'string' && codes.includes(value as Code)),
-    serialize: ({ value, isPublic }) => (isPublic ? undefined : value),
+    resolve: ({ flow }) => flow.find((value) => typeof value === 'string' && codes.includes(value)),
+    serialize: ({ resolved, isPublic }) => (isPublic ? undefined : resolved),
     deserialize: ({ value }) =>
       typeof value === 'string' && codes.includes(value as Code) ? (value as Code) : undefined,
   })
 
   it('serializes and deserializes nested Error0 causes', () => {
-    const AppError = Error0.use(statusPlugin).use(codePlugin).use(causeSerializePlugin)
+    const AppError = Error0.use(statusPlugin)
+      .use(codePlugin)
+      .use(causeSerializePlugin({ hideWhenPublic: false }))
     const deepCauseError = new AppError('deep cause')
     const causeError = new AppError('cause', { status: 409, code: 'NOT_FOUND', cause: deepCauseError })
     const error = new AppError('root', { status: 500, cause: causeError })

package/src/plugins/cause-serialize.ts

@@ -1,11 +1,15 @@
 import { Error0 } from '../index.js'
 
-export const causeSerializePlugin = Error0.plugin().use('cause', {
-  serialize: ({ value, error, isPublic }) => {
-    const ctor = error.constructor as typeof Error0
-    if (ctor.is(value)) {
-      return ctor.serialize(value, isPublic)
-    }
-    return undefined
-  },
-})
+export const causeSerializePlugin = ({ hideWhenPublic = true }: { hideWhenPublic?: boolean } = {}) =>
+  Error0.plugin().use('cause', {
+    serialize: ({ value, error, isPublic }) => {
+      if (hideWhenPublic && isPublic) {
+        return undefined
+      }
+      const ctor = error.constructor as typeof Error0
+      if (ctor.is(value)) {
+        return ctor.serialize(value, isPublic)
+      }
+      return undefined
+    },
+  })

package/src/plugins/expected.test.ts

@@ -6,12 +6,12 @@ describe('expectedPlugin', () => {
   const statusPlugin = Error0.plugin().use('prop', 'status', {
     init: (input: number) => input,
     resolve: ({ flow }) => flow.find((value) => typeof value === 'number'),
-    serialize: ({ value }) => value,
+    serialize: ({ resolved }) => resolved,
     deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
   })
 
   it('can be used to control error tracker behavior', () => {
-    const AppError = Error0.use(statusPlugin).use(expectedPlugin)
+    const AppError = Error0.use(statusPlugin).use(expectedPlugin({ hideWhenPublic: false }))
     const errorExpected = new AppError('test', { status: 400, expected: true })
     const errorUnexpected = new AppError('test', { status: 400, expected: false })
     const usualError = new Error('test')
@@ -30,7 +30,7 @@ describe('expectedPlugin', () => {
   })
 
   it('resolves to false when any cause has false', () => {
-    const AppError = Error0.use(expectedPlugin)
+    const AppError = Error0.use(expectedPlugin({ hideWhenPublic: false }))
     const root = new AppError('root', { expected: true })
     const middle = new AppError('middle', { expected: false, cause: root })
     const leaf = new AppError('leaf', { expected: false, cause: middle })
@@ -39,7 +39,7 @@ describe('expectedPlugin', () => {
   })
 
   it('treats undefined expected as unexpected', () => {
-    const AppError = Error0.use(expectedPlugin)
+    const AppError = Error0.use(expectedPlugin({ hideWhenPublic: false }))
     const error = new AppError('without expected')
     expect(error.expected).toBe(false)
     expect(error.isExpected()).toBe(false)

package/src/plugins/expected.ts

@@ -13,13 +13,19 @@ const isExpected = (flow: unknown[]) => {
   return expected
 }
 
-export const expectedPlugin = Error0.plugin()
-  .use('prop', 'expected', {
-    init: (input: boolean) => input,
-    resolve: ({ flow }) => isExpected(flow),
-    serialize: ({ value }) => value,
-    deserialize: ({ value }) => (typeof value === 'boolean' ? value : undefined),
-  })
-  .use('method', 'isExpected', (error) => {
-    return isExpected(error.flow('expected'))
-  })
+export const expectedPlugin = ({ hideWhenPublic = true }: { hideWhenPublic?: boolean } = {}) =>
+  Error0.plugin()
+    .use('prop', 'expected', {
+      init: (input: boolean) => input,
+      resolve: ({ flow }) => isExpected(flow),
+      serialize: ({ resolved, isPublic }) => {
+        if (hideWhenPublic && isPublic) {
+          return undefined
+        }
+        return resolved
+      },
+      deserialize: ({ value }) => (typeof value === 'boolean' ? value : undefined),
+    })
+    .use('method', 'isExpected', (error) => {
+      return isExpected(error.flow('expected'))
+    })

package/src/plugins/message-merge.test.ts

@@ -6,7 +6,7 @@ describe('messageMergePlugin', () => {
   const statusPlugin = Error0.plugin().use('prop', 'status', {
     init: (input: number) => input,
     resolve: ({ flow }) => flow.find((value) => typeof value === 'number'),
-    serialize: ({ value }) => value,
+    serialize: ({ resolved }) => resolved,
     deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
   })
 
@@ -15,13 +15,13 @@ describe('messageMergePlugin', () => {
   const codePlugin = Error0.plugin().use('prop', 'code', {
     init: (input: Code) => input,
     resolve: ({ flow }) => flow.find((value) => typeof value === 'string' && codes.includes(value)),
-    serialize: ({ value, isPublic }) => (isPublic ? undefined : value),
+    serialize: ({ resolved, isPublic }) => (isPublic ? undefined : resolved),
     deserialize: ({ value }) =>
       typeof value === 'string' && codes.includes(value as Code) ? (value as Code) : undefined,
   })
 
   it('can merge message across causes in one serialized value', () => {
-    const AppError = Error0.use(statusPlugin).use(codePlugin).use(messageMergePlugin)
+    const AppError = Error0.use(statusPlugin).use(codePlugin).use(messageMergePlugin())
     const error1 = new AppError('test1', { status: 400, code: 'NOT_FOUND' })
     const error2 = new AppError('test2', { status: 401, cause: error1 })
     expect(error1.message).toBe('test1')