@devp0nt/error0 1.0.0-next.46 → 1.0.0-next.48

package/src/index.ts

@@ -59,15 +59,24 @@ export 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: { value: string | undefined; error: TError; isPublic: boolean }) => unknown)
-  | boolean
-  | 'merge'
-export type ErrorPluginStack<TError extends Error0 = Error0> = ErrorPluginStackSerialize<TError>
-export type ErrorPluginCauseSerialize<TError extends Error0> =
-  | ((options: { value: unknown; error: TError; isPublic: boolean }) => unknown)
-  | boolean
-export type ErrorPluginCause<TError extends Error0 = Error0> = ErrorPluginCauseSerialize<TError>
+export 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: {
+  value: unknown
+  error: TError
+  isPublic: boolean
+}) => unknown
+export type ErrorPluginCause<TError extends Error0 = Error0> = { serialize: ErrorPluginCauseSerialize<TError> }
+export type ErrorPluginMessageSerialize<TError extends Error0> = (options: {
+  value: string
+  error: TError
+  isPublic: boolean
+}) => unknown
+export type ErrorPluginMessage<TError extends Error0 = Error0> = { serialize: ErrorPluginMessageSerialize<TError> }
 type ErrorMethodRecord = {
   args: unknown[]
   output: unknown
@@ -85,6 +94,7 @@ export type ErrorPlugin<
   adapt?: Array<ErrorPluginAdaptFn<Error0, PluginOutputProps<TProps>>>
   stack?: ErrorPluginStack
   cause?: ErrorPluginCause
+  message?: ErrorPluginMessage
 }
 type AddPropToPluginProps<
   TProps extends ErrorPluginProps,
@@ -169,8 +179,10 @@ type ErrorPluginResolved = {
   adapt: Array<ErrorPluginAdaptFn<Error0, Record<string, unknown>>>
   stack?: ErrorPluginStack
   cause?: ErrorPluginCause
+  message?: ErrorPluginMessage
 }
 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'
 
 type PluginPropsMapOf<TPlugin extends ErrorPlugin> = {
   [TKey in keyof NonNullable<TPlugin['props']>]: NonNullable<TPlugin['props']>[TKey] extends ErrorPluginPropOptions<
@@ -227,7 +239,7 @@ type PluginsMapOf<TClass> = TClass extends { __pluginsMap?: infer TPluginsMap }
     ? TPluginsMap
     : EmptyPluginsMap
   : EmptyPluginsMap
-type PluginsMapOfInstance<TInstance> = TInstance extends { constructor: { __pluginsMap?: infer TPluginsMap } }
+type PluginsMapOfInstance<TInstance> = TInstance extends { __pluginsMap?: infer TPluginsMap }
   ? TPluginsMap extends ErrorPluginsMap
     ? TPluginsMap
     : EmptyPluginsMap
@@ -262,6 +274,7 @@ export class PluginError0<
       adapt: [...(plugin?.adapt ?? [])],
       stack: plugin?.stack,
       cause: plugin?.cause,
+      message: plugin?.message,
     }
   }
 
@@ -298,6 +311,10 @@ export class PluginError0<
     return this.use('cause', value)
   }
 
+  message(value: ErrorPluginMessage<BuilderError0<TProps, TMethods>>): PluginError0<TProps, TMethods> {
+    return this.use('message', value)
+  }
+
   use<
     TKey extends string,
     TInputValue = undefined,
@@ -319,8 +336,9 @@ export class PluginError0<
   ): PluginError0<TProps, TMethods>
   use(kind: 'stack', value: ErrorPluginStack<BuilderError0<TProps, TMethods>>): PluginError0<TProps, TMethods>
   use(kind: 'cause', value: ErrorPluginCause<BuilderError0<TProps, TMethods>>): PluginError0<TProps, TMethods>
+  use(kind: 'message', value: ErrorPluginMessage<BuilderError0<TProps, TMethods>>): PluginError0<TProps, TMethods>
   use(
-    kind: 'prop' | 'method' | 'adapt' | 'stack' | 'cause',
+    kind: 'prop' | 'method' | 'adapt' | 'stack' | 'cause' | 'message',
     keyOrValue: unknown,
     value?: ErrorPluginPropOptions<unknown, unknown, any> | ErrorPluginMethodFn<unknown, unknown[], any>,
   ): PluginError0<any, any> {
@@ -329,11 +347,15 @@ export class PluginError0<
     const nextAdapt: Array<ErrorPluginAdaptFn<Error0, Record<string, unknown>>> = [...(this._plugin.adapt ?? [])]
     let nextStack: ErrorPluginStack | undefined = this._plugin.stack
     let nextCause: ErrorPluginCause | undefined = this._plugin.cause
+    let nextMessage: ErrorPluginMessage | undefined = this._plugin.message
     if (kind === 'prop') {
       const key = keyOrValue as string
       if (key === 'stack') {
         throw new Error(RESERVED_STACK_PROP_ERROR)
       }
+      if (key === 'message') {
+        throw new Error(RESERVED_MESSAGE_PROP_ERROR)
+      }
       if (value === undefined) {
         throw new Error('PluginError0.use("prop", key, value) requires value')
       }
@@ -348,8 +370,10 @@ export class PluginError0<
       nextAdapt.push(keyOrValue as ErrorPluginAdaptFn<Error0, Record<string, unknown>>)
     } else if (kind === 'stack') {
       nextStack = keyOrValue as ErrorPluginStack
-    } else {
+    } else if (kind === 'cause') {
       nextCause = keyOrValue as ErrorPluginCause
+    } else {
+      nextMessage = keyOrValue as ErrorPluginMessage
     }
     return new PluginError0({
       props: nextProps,
@@ -357,6 +381,7 @@ export class PluginError0<
       adapt: nextAdapt,
       stack: nextStack,
       cause: nextCause,
+      message: nextMessage,
     })
   }
 }
@@ -365,14 +390,24 @@ export type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> =
   new (
     message: string,
     input?: ErrorInput<TPluginsMap>,
-  ): Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap>
+  ): Error0 &
+    ErrorResolved<TPluginsMap> &
+    ErrorOwnMethods<TPluginsMap> &
+    ErrorResolveMethods<TPluginsMap> & { readonly __pluginsMap?: TPluginsMap }
   new (
     input: { message: string } & ErrorInput<TPluginsMap>,
-  ): Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap>
+  ): Error0 &
+    ErrorResolved<TPluginsMap> &
+    ErrorOwnMethods<TPluginsMap> &
+    ErrorResolveMethods<TPluginsMap> & { readonly __pluginsMap?: 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>
   resolve: (error: unknown) => ErrorResolvedProps<TPluginsMap>
   serialize: (error: unknown, isPublic?: boolean) => Record<string, unknown>
   own: {
@@ -426,12 +461,14 @@ export type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> =
     ): ClassError0<TPluginsMap>
     (kind: 'stack', value: ErrorPluginStack<ErrorInstanceOfMap<TPluginsMap>>): ClassError0<TPluginsMap>
     (kind: 'cause', value: ErrorPluginCause<ErrorInstanceOfMap<TPluginsMap>>): ClassError0<TPluginsMap>
+    (kind: 'message', value: ErrorPluginMessage<ErrorInstanceOfMap<TPluginsMap>>): ClassError0<TPluginsMap>
   }
   plugin: () => PluginError0
 } & ErrorStaticMethods<TPluginsMap>
 
 export class Error0 extends Error {
   static readonly __pluginsMap?: EmptyPluginsMap
+  readonly __pluginsMap?: EmptyPluginsMap
   protected static _plugins: ErrorPlugin[] = []
 
   private static readonly _emptyPlugin: ErrorPluginResolved = {
@@ -440,6 +477,7 @@ export class Error0 extends Error {
     adapt: [],
     stack: undefined,
     cause: undefined,
+    message: undefined,
   }
 
   private static _getResolvedPlugin(this: typeof Error0): ErrorPluginResolved {
@@ -452,6 +490,9 @@ export class Error0 extends Error {
       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))
@@ -461,6 +502,9 @@ export class Error0 extends Error {
       if (typeof plugin.cause !== 'undefined') {
         resolved.cause = plugin.cause
       }
+      if (typeof plugin.message !== 'undefined') {
+        resolved.message = plugin.message
+      }
     }
     return resolved
   }
@@ -673,6 +717,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) {
@@ -710,8 +758,7 @@ export class Error0 extends Error {
     }
     // we do not serialize causes
     // ;(recreated as unknown as { cause?: unknown }).cause = errorRecord.cause
-    const stackPlugin = plugin.stack
-    if (stackPlugin !== false && 'stack' in errorRecord) {
+    if ('stack' in errorRecord) {
       try {
         if (typeof errorRecord.stack === 'string') {
           recreated.stack = errorRecord.stack
@@ -721,8 +768,8 @@ export class Error0 extends Error {
         console.error('Error0: failed to deserialize stack', errorRecord)
       }
     }
-    const causePlugin = plugin.cause ?? false
-    if (causePlugin && 'cause' in errorRecord) {
+    const causePlugin = plugin.cause
+    if (causePlugin?.serialize && 'cause' in errorRecord) {
       try {
         if (this.isSerialized(errorRecord.cause)) {
           ;(recreated as { cause?: unknown }).cause = this._fromSerialized(errorRecord.cause)
@@ -793,6 +840,7 @@ export class Error0 extends Error {
       adapt: [...(pluginRecord._plugin.adapt ?? [])],
       stack: pluginRecord._plugin.stack,
       cause: pluginRecord._plugin.cause,
+      message: pluginRecord._plugin.message,
     }
   }
 
@@ -876,9 +924,14 @@ export class Error0 extends Error {
     kind: 'cause',
     value: ErrorPluginCause<ErrorInstanceOfMap<PluginsMapOf<TThis>>>,
   ): ClassError0<PluginsMapOf<TThis>>
+  static use<TThis extends typeof Error0>(
+    this: TThis,
+    kind: 'message',
+    value: ErrorPluginMessage<ErrorInstanceOfMap<PluginsMapOf<TThis>>>,
+  ): ClassError0<PluginsMapOf<TThis>>
   static use(
     this: typeof Error0,
-    first: PluginError0 | 'prop' | 'method' | 'adapt' | 'stack' | 'cause',
+    first: PluginError0 | 'prop' | 'method' | 'adapt' | 'stack' | 'cause' | 'message',
     key?: unknown,
     value?: ErrorPluginPropOptions<unknown> | ErrorPluginMethodFn<unknown>,
   ): ClassError0 {
@@ -889,8 +942,8 @@ export class Error0 extends Error {
       if (typeof key === 'undefined') {
         throw new Error('Error0.use("stack", value) requires stack plugin value')
       }
-      if (key !== 'merge' && typeof key !== 'boolean' && typeof key !== 'function') {
-        throw new Error('Error0.use("stack", value) expects function | boolean | "merge"')
+      if (typeof key !== 'object' || key === null || typeof (key as { serialize?: unknown }).serialize !== 'function') {
+        throw new Error('Error0.use("stack", value) expects { serialize: function }')
       }
       return this._useWithPlugin({
         stack: key as ErrorPluginStack,
@@ -900,13 +953,24 @@ export class Error0 extends Error {
       if (typeof key === 'undefined') {
         throw new Error('Error0.use("cause", value) requires cause plugin value')
       }
-      if (typeof key !== 'boolean' && typeof key !== 'function') {
-        throw new Error('Error0.use("cause", value) expects function | boolean')
+      if (typeof key !== 'object' || key === null || typeof (key as { serialize?: unknown }).serialize !== 'function') {
+        throw new Error('Error0.use("cause", value) expects { serialize: function }')
       }
       return this._useWithPlugin({
         cause: key as ErrorPluginCause,
       })
     }
+    if (first === 'message') {
+      if (typeof key === 'undefined') {
+        throw new Error('Error0.use("message", value) requires message plugin value')
+      }
+      if (typeof key !== 'object' || key === null || typeof (key as { serialize?: unknown }).serialize !== 'function') {
+        throw new Error('Error0.use("message", value) expects { serialize: function }')
+      }
+      return this._useWithPlugin({
+        message: key as ErrorPluginMessage,
+      })
+    }
     if (first === 'adapt') {
       if (typeof key !== 'function') {
         throw new Error('Error0.use("adapt", value) requires adapt function')
@@ -923,6 +987,9 @@ export class Error0 extends Error {
       if (key === 'stack') {
         throw new Error(RESERVED_STACK_PROP_ERROR)
       }
+      if (key === 'message') {
+        throw new Error(RESERVED_MESSAGE_PROP_ERROR)
+      }
       return this._useWithPlugin({
         props: { [key]: value as ErrorPluginPropOptions<unknown> },
       })
@@ -940,14 +1007,25 @@ export class Error0 extends Error {
     const error0 = this.from(error)
     const resolvedProps = this.resolve(error0)
     const resolvedRecord = resolvedProps as Record<string, unknown>
+    const plugin = this._getResolvedPlugin()
+    const messagePlugin = plugin.message
+    let serializedMessage: unknown = error0.message
+    try {
+      if (messagePlugin) {
+        serializedMessage = messagePlugin.serialize({ value: error0.message, error: error0, isPublic })
+      }
+    } catch {
+      // eslint-disable-next-line no-console
+      console.error('Error0: failed to serialize message', error0)
+      serializedMessage = error0.message
+    }
     const json: Record<string, unknown> = {
       name: error0.name,
-      message: error0.message,
+      message: serializedMessage,
       // we do not serialize causes, it is enough that we have floated props and adapt helper
       // cause: error0.cause,
     }
 
-    const plugin = this._getResolvedPlugin()
     const propsEntries = Object.entries(plugin.props)
     for (const [key, prop] of propsEntries) {
       if (prop.serialize === false) {
@@ -964,48 +1042,31 @@ export class Error0 extends Error {
         console.error(`Error0: failed to serialize property ${key}`, resolvedRecord)
       }
     }
-    const stackSerialize = plugin.stack
-    if (stackSerialize !== false) {
-      try {
-        let serializedStack: unknown
-        if (stackSerialize === 'merge') {
-          serializedStack = error0
-            .causes()
-            .map((cause) => {
-              return cause instanceof Error ? cause.stack : undefined
-            })
-            .filter((value): value is string => typeof value === 'string')
-            .join('\n')
-        } else if (typeof stackSerialize === 'function') {
-          serializedStack = stackSerialize({ value: error0.stack, error: error0, isPublic })
-        } else {
-          serializedStack = error0.stack
-        }
-        if (serializedStack !== undefined) {
-          json.stack = serializedStack
-        }
-      } catch {
-        // eslint-disable-next-line no-console
-        console.error('Error0: failed to serialize stack', error0)
+    const stackPlugin = plugin.stack
+    try {
+      let serializedStack: unknown
+      if (stackPlugin) {
+        serializedStack = stackPlugin.serialize({ value: error0.stack, error: error0, isPublic })
+      } else {
+        serializedStack = error0.stack
       }
+      if (serializedStack !== undefined) {
+        json.stack = serializedStack
+      }
+    } catch {
+      // eslint-disable-next-line no-console
+      console.error('Error0: failed to serialize stack', error0)
     }
-    const causeSerialize = plugin.cause ?? false
-    if (causeSerialize) {
+    const causePlugin = plugin.cause
+    if (causePlugin?.serialize) {
       try {
-        if (causeSerialize === true) {
-          const causeValue = (error0 as { cause?: unknown }).cause
-          if (this.is(causeValue)) {
-            json.cause = this.serialize(causeValue, isPublic)
-          }
-        } else {
-          const serializedCause = causeSerialize({
-            value: (error0 as { cause?: unknown }).cause,
-            error: error0,
-            isPublic,
-          })
-          if (serializedCause !== undefined) {
-            json.cause = serializedCause
-          }
+        const serializedCause = causePlugin.serialize({
+          value: (error0 as { cause?: unknown }).cause,
+          error: error0,
+          isPublic,
+        })
+        if (serializedCause !== undefined) {
+          json.cause = serializedCause
         }
       } catch {
         // eslint-disable-next-line no-console
@@ -1022,4 +1083,9 @@ export class Error0 extends Error {
     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

@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'bun:test'
+import { Error0 } from '../index.js'
+import { causeSerializePlugin } from './cause-serialize.js'
+
+describe('causeSerializePlugin', () => {
+  const statusPlugin = Error0.plugin().use('prop', 'status', {
+    init: (input: number) => input,
+    resolve: ({ flow }) => flow.find((value) => typeof value === 'number'),
+    serialize: ({ value }) => value,
+    deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
+  })
+
+  const codes = ['NOT_FOUND', 'BAD_REQUEST', 'UNAUTHORIZED'] as const
+  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),
+    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 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 })
+
+    const json = AppError.serialize(error, false)
+    expect(typeof json.cause).toBe('object')
+    expect((json.cause as any).message).toBe('cause')
+    expect((json.cause as any).status).toBe(409)
+    expect((json.cause as any).code).toBe('NOT_FOUND')
+    expect((json.cause as any).cause).toBeDefined()
+    expect((json.cause as any).cause.message).toBe('deep cause')
+    expect((json.cause as any).cause.status).toBe(undefined)
+    expect((json.cause as any).cause.code).toBe(undefined)
+    expect((json.cause as any).cause.cause).toBeUndefined()
+
+    const recreated = AppError.from(json)
+    expect(recreated).toBeInstanceOf(AppError)
+    expect(recreated.cause).toBeInstanceOf(AppError)
+    expect((recreated.cause as any).status).toBe(409)
+    expect((recreated.cause as any).code).toBe('NOT_FOUND')
+    expect((recreated.cause as any).cause).toBeInstanceOf(AppError)
+    expect((recreated.cause as any).cause.message).toBe('deep cause')
+    expect((recreated.cause as any).cause.status).toBe(undefined)
+    expect((recreated.cause as any).cause.code).toBe(undefined)
+    expect((recreated.cause as any).cause.cause).toBeUndefined()
+  })
+})

package/src/plugins/cause-serialize.ts

@@ -0,0 +1,11 @@
+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
+  },
+})

package/src/plugins/expected.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'bun:test'
+import { Error0 } from '../index.js'
+import { expectedPlugin } from './expected.js'
+
+describe('expectedPlugin', () => {
+  const statusPlugin = Error0.plugin().use('prop', 'status', {
+    init: (input: number) => input,
+    resolve: ({ flow }) => flow.find((value) => typeof value === 'number'),
+    serialize: ({ value }) => value,
+    deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
+  })
+
+  it('can be used to control error tracker behavior', () => {
+    const AppError = Error0.use(statusPlugin).use(expectedPlugin)
+    const errorExpected = new AppError('test', { status: 400, expected: true })
+    const errorUnexpected = new AppError('test', { status: 400, expected: false })
+    const usualError = new Error('test')
+    const errorFromUsualError = AppError.from(usualError)
+    const errorWithExpectedErrorAsCause = new AppError('test', { status: 400, cause: errorExpected })
+    const errorWithUnexpectedErrorAsCause = new AppError('test', { status: 400, cause: errorUnexpected })
+    expect(errorExpected.expected).toBe(true)
+    expect(errorUnexpected.expected).toBe(false)
+    expect(AppError.isExpected(usualError)).toBe(false)
+    expect(errorFromUsualError.expected).toBe(false)
+    expect(errorFromUsualError.isExpected()).toBe(false)
+    expect(errorWithExpectedErrorAsCause.expected).toBe(true)
+    expect(errorWithExpectedErrorAsCause.isExpected()).toBe(true)
+    expect(errorWithUnexpectedErrorAsCause.expected).toBe(false)
+    expect(errorWithUnexpectedErrorAsCause.isExpected()).toBe(false)
+  })
+
+  it('resolves to false when any cause has false', () => {
+    const AppError = Error0.use(expectedPlugin)
+    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 })
+    expect(leaf.expected).toBe(false)
+    expect(leaf.isExpected()).toBe(false)
+  })
+
+  it('treats undefined expected as unexpected', () => {
+    const AppError = Error0.use(expectedPlugin)
+    const error = new AppError('without expected')
+    expect(error.expected).toBe(false)
+    expect(error.isExpected()).toBe(false)
+  })
+})

package/src/plugins/expected.ts

@@ -0,0 +1,25 @@
+import { Error0 } from '../index.js'
+
+const isExpected = (flow: unknown[]) => {
+  let expected = false
+  for (const value of flow) {
+    if (value === false) {
+      return false
+    }
+    if (value === true) {
+      expected = true
+    }
+  }
+  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'))
+  })

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

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'bun:test'
+import { Error0 } from '../index.js'
+import { messageMergePlugin } from './message-merge.js'
+
+describe('messageMergePlugin', () => {
+  const statusPlugin = Error0.plugin().use('prop', 'status', {
+    init: (input: number) => input,
+    resolve: ({ flow }) => flow.find((value) => typeof value === 'number'),
+    serialize: ({ value }) => value,
+    deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
+  })
+
+  const codes = ['NOT_FOUND', 'BAD_REQUEST', 'UNAUTHORIZED'] as const
+  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)),
+    serialize: ({ value, isPublic }) => (isPublic ? undefined : value),
+    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 error1 = new AppError('test1', { status: 400, code: 'NOT_FOUND' })
+    const error2 = new AppError('test2', { status: 401, cause: error1 })
+    expect(error1.message).toBe('test1')
+    expect(error2.message).toBe('test2')
+    expect(error1.serialize().message).toBe('test1')
+    expect(error2.serialize().message).toBe('test2: test1')
+  })
+})

package/src/plugins/message-merge.ts

@@ -0,0 +1,15 @@
+import { Error0 } from '../index.js'
+
+export const messageMergePlugin = Error0.plugin().use('message', {
+  serialize: ({ error }) => {
+    return (
+      error
+        .causes()
+        .map((cause) => {
+          return cause instanceof Error ? cause.message : undefined
+        })
+        .filter((value): value is string => typeof value === 'string')
+        .join(': ') || 'Unknown error'
+    )
+  },
+})

package/src/plugins/meta.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'bun:test'
+import { Error0 } from '../index.js'
+import { metaPlugin } from './meta.js'
+
+describe('metaPlugin', () => {
+  it('merges meta across causes into current error', () => {
+    const AppError = Error0.use(metaPlugin)
+    const root = new AppError('root', { meta: { requestId: 'r1', source: 'db' } })
+    const leaf = new AppError('leaf', { meta: { route: '/ideas', source: 'api' }, cause: root })
+    expect(leaf.resolve().meta).toEqual({
+      requestId: 'r1',
+      source: 'api',
+      route: '/ideas',
+    })
+  })
+
+  it('serializes meta only for private output and keeps json-safe values', () => {
+    const AppError = Error0.use(metaPlugin)
+    const error = new AppError('test', {
+      meta: {
+        ok: true,
+        nested: { id: 1 },
+        skip: () => 'x',
+      },
+    })
+    expect(AppError.serialize(error, false).meta).toEqual({
+      ok: true,
+      nested: { id: 1 },
+    })
+    expect('meta' in AppError.serialize(error, true)).toBe(false)
+  })
+})