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

package/dist/cjs/index.d.cts

@@ -35,6 +35,18 @@ type ErrorPluginPropOptionsWithoutInit<TOutputValue, TError extends Error0, TRes
     init?: undefined;
 };
 type ErrorPluginPropOptions<TInputValue = undefined, TOutputValue = unknown, TError extends Error0 = Error0, TResolveValue extends TOutputValue | undefined = TOutputValue | undefined> = ErrorPluginPropOptionsWithInit<TInputValue, TOutputValue, TError, TResolveValue> | ErrorPluginPropOptionsWithoutInit<TOutputValue, TError, TResolveValue>;
+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;
 type ErrorPluginAdaptResult<TOutputProps extends Record<string, unknown>> = Partial<TOutputProps> | undefined;
@@ -116,15 +128,17 @@ type ErrorResolvedProps<TPluginsMap extends ErrorPluginsMap> = {
 type ErrorOwnProps<TPluginsMap extends ErrorPluginsMap> = {
     [TKey in keyof TPluginsMap['props']]: TPluginsMap['props'][TKey]['output'] | undefined;
 };
+type ErrorResolveMethods<TPluginsMap extends ErrorPluginsMap> = {
+    resolve: () => ErrorResolvedProps<TPluginsMap>;
+};
+type Error0ResolvedInstance<TPluginsMap extends ErrorPluginsMap> = Error0 & ErrorResolved<TPluginsMap> & ErrorResolveMethods<TPluginsMap>;
 type ErrorOwnMethods<TPluginsMap extends ErrorPluginsMap> = {
-    own: {
-        (): ErrorOwnProps<TPluginsMap>;
-        <TKey extends keyof TPluginsMap['props'] & string>(key: TKey): ErrorOwnProps<TPluginsMap>[TKey];
-    };
+    own?: Partial<ErrorOwnProps<TPluginsMap>>;
     flow: <TKey extends keyof TPluginsMap['props'] & string>(key: TKey) => Array<ErrorOwnProps<TPluginsMap>[TKey]>;
+    assign: (props: Partial<ErrorOwnProps<TPluginsMap>>) => Error0ResolvedInstance<TPluginsMap>;
 };
-type ErrorResolveMethods<TPluginsMap extends ErrorPluginsMap> = {
-    resolve: () => ErrorResolvedProps<TPluginsMap>;
+type InstanceError0<TPluginsMap extends ErrorPluginsMap> = Error0ResolvedInstance<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & {
+    readonly __pluginsMap?: TPluginsMap;
 };
 type BindInstanceMethod<TMethod> = TMethod extends (error: any, ...args: infer TArgs) => infer TOutput ? (...args: TArgs) => TOutput : never;
 type BindStaticMethod<TMethod> = TMethod extends (error: any, ...args: infer TArgs) => infer TOutput ? (error: unknown, ...args: TArgs) => TOutput : never;
@@ -183,12 +197,8 @@ type PluginsMapOfInstance<TInstance> = TInstance extends {
     __pluginsMap?: infer TPluginsMap;
 } ? TPluginsMap extends ErrorPluginsMap ? TPluginsMap : EmptyPluginsMap : EmptyPluginsMap;
 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;
 declare class PluginError0<TProps extends ErrorPluginProps = Record<never, never>, TMethods extends ErrorPluginMethods = Record<never, never>> {
     private readonly _plugin;
@@ -197,38 +207,36 @@ declare class PluginError0<TProps extends ErrorPluginProps = Record<never, never
         methods: TMethods;
     };
     constructor(plugin?: ErrorPlugin<ErrorPluginProps, ErrorPluginMethods>);
-    prop<TKey extends string, TInputValue = undefined, TOutputValue = unknown, TResolveValue extends TOutputValue | undefined = TOutputValue | undefined>(key: TKey, value: ErrorPluginPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>, TResolveValue>): PluginError0<AddPropToPluginProps<TProps, TKey, TInputValue, TOutputValue, TResolveValue>, TMethods>;
+    prop<TKey extends string, TInputValue = undefined, TOutputValue = unknown, TResolveValue extends TOutputValue | undefined = TOutputValue | undefined>(key: TKey, value: ErrorPluginPropOptionsDefinition<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>, TResolveValue>): PluginError0<AddPropToPluginProps<TProps, TKey, TInputValue, TOutputValue, TResolveValue>, TMethods>;
     method<TKey extends string, TMethod extends (error: BuilderError0<TProps, TMethods>, ...args: any[]) => any>(key: TKey, value: TMethod): PluginError0<TProps, AddMethodToPluginMethods<TMethods, TKey, TMethod>>;
     adapt(value: ErrorPluginAdaptFn<BuilderError0<TProps, TMethods>, PluginOutputProps<TProps>>): PluginError0<TProps, TMethods>;
     stack(value: ErrorPluginStack<BuilderError0<TProps, TMethods>>): PluginError0<TProps, TMethods>;
     cause(value: ErrorPluginCause<BuilderError0<TProps, TMethods>>): PluginError0<TProps, TMethods>;
     message(value: ErrorPluginMessage<BuilderError0<TProps, TMethods>>): PluginError0<TProps, TMethods>;
-    use<TKey extends string, TInputValue = undefined, TOutputValue = unknown, TResolveValue extends TOutputValue | undefined = TOutputValue | undefined>(kind: 'prop', key: TKey, value: ErrorPluginPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>, TResolveValue>): PluginError0<AddPropToPluginProps<TProps, TKey, TInputValue, TOutputValue, TResolveValue>, TMethods>;
+    use<TKey extends string, TInputValue = undefined, TOutputValue = unknown, TResolveValue extends TOutputValue | undefined = TOutputValue | undefined>(kind: 'prop', key: TKey, 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', key: TKey, value: TMethod): PluginError0<TProps, AddMethodToPluginMethods<TMethods, TKey, TMethod>>;
     use(kind: 'adapt', value: ErrorPluginAdaptFn<BuilderError0<TProps, TMethods>, PluginOutputProps<TProps>>): 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>;
 }
+type ErrorOwnStore = Record<string, unknown>;
 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 (message: string, input?: ErrorInput<TPluginsMap>): InstanceError0<TPluginsMap>;
     new (input: {
         message: string;
-    } & ErrorInput<TPluginsMap>): Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap> & {
-        readonly __pluginsMap?: TPluginsMap;
-    };
+    } & 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>;
     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];
@@ -251,6 +259,7 @@ declare class Error0 extends Error {
     static MAX_CAUSES_DEPTH: number;
     protected static _plugins: ErrorPlugin[];
     protected static _resolvedPlugin?: ErrorPluginResolved;
+    own?: ErrorOwnStore;
     private static readonly _emptyPlugin;
     private static _indexResolvedPlugin;
     private static _applyPlugin;
@@ -260,17 +269,13 @@ declare class Error0 extends Error {
     constructor(input: {
         message: string;
     } & ErrorInput<EmptyPluginsMap>);
-    private static _getOwnStore;
-    private static readonly isOwnProperty;
-    private static _ownByKey;
-    private static _flowByKey;
+    private static fixStack;
     static own<TThis extends typeof Error0>(this: TThis, error: unknown): ErrorOwnProps<PluginsMapOf<TThis>>;
     static own<TThis extends typeof Error0, TKey extends keyof PluginsMapOf<TThis>['props'] & string>(this: TThis, error: unknown, key: TKey): ErrorOwnProps<PluginsMapOf<TThis>>[TKey];
-    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];
     static flow<TThis extends typeof Error0, TKey extends keyof PluginsMapOf<TThis>['props'] & string>(this: TThis, error: unknown, key: TKey): Array<ErrorOwnProps<PluginsMapOf<TThis>>[TKey]>;
     flow<TThis extends Error0, TKey extends keyof PluginsMapOfInstance<TThis>['props'] & string>(this: TThis, key: TKey): Array<ErrorOwnProps<PluginsMapOfInstance<TThis>>[TKey]>;
-    static _resolveByKey(error: Error0, key: string, plugin: ErrorPluginResolved): unknown;
+    private readonly _resolveByKeyCache;
+    private _resolveByKey;
     static resolve<TThis extends typeof Error0>(this: TThis, error: unknown): ErrorResolvedProps<PluginsMapOf<TThis>>;
     static resolve(error: unknown): Record<string, unknown>;
     resolve<TThis extends Error0>(this: TThis): ErrorResolvedProps<PluginsMapOfInstance<TThis>>;
@@ -280,8 +285,11 @@ declare class Error0 extends Error {
     causes<TThis extends Error0>(this: TThis, instancesOnly: true): [TThis, ...TThis[]];
     static is<T extends typeof Error0>(this: T, error: unknown): error is InstanceType<T>;
     static isSerialized(error: unknown): error is Record<string, unknown>;
-    static from(error: unknown): Error0;
-    static round(error: unknown, isPublic?: boolean): Error0;
+    static from<TThis extends typeof Error0>(this: TThis, error: unknown): InstanceType<TThis>;
+    static round<TThis extends typeof Error0>(this: TThis, error: unknown, isPublic?: boolean): InstanceType<TThis>;
+    round<TThis extends Error0>(this: TThis, isPublic?: boolean): TThis;
+    static assign<TThis extends typeof Error0>(this: TThis, error: unknown, props: Partial<ErrorOwnProps<PluginsMapOf<TThis>>>): InstanceType<TThis>;
+    assign<TThis extends Error0>(this: TThis, props: Partial<ErrorOwnProps<PluginsMapOfInstance<TThis>>>): TThis;
     private static _applyAdapt;
     private static _fromSerialized;
     private static _fromNonError0;
@@ -289,7 +297,7 @@ declare class Error0 extends Error {
     private static _useWithPlugin;
     private static _pluginFromBuilder;
     static use<TThis extends typeof Error0, TBuilder extends PluginError0>(this: TThis, plugin: TBuilder): ClassError0<ExtendErrorPluginsMap<PluginsMapOf<TThis>, PluginOfBuilder<TBuilder>>>;
-    static use<TThis extends typeof Error0, TKey extends string, TInputValue = undefined, TOutputValue = unknown, TResolveValue extends TOutputValue | undefined = TOutputValue | undefined>(this: TThis, kind: 'prop', key: TKey, value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<PluginsMapOf<TThis>>, TResolveValue>): ClassError0<ExtendErrorPluginsMapWithProp<PluginsMapOf<TThis>, TKey, TInputValue, TOutputValue, TResolveValue>>;
+    static use<TThis extends typeof Error0, TKey extends string, TInputValue = undefined, TOutputValue = unknown, TResolveValue extends TOutputValue | undefined = TOutputValue | undefined>(this: TThis, kind: 'prop', key: TKey, value: ErrorPluginPropOptionsDefinition<TInputValue, TOutputValue, ErrorInstanceOfMap<PluginsMapOf<TThis>>, TResolveValue>): ClassError0<ExtendErrorPluginsMapWithProp<PluginsMapOf<TThis>, TKey, TInputValue, TOutputValue, TResolveValue>>;
     static use<TThis extends typeof Error0, TKey extends string, TMethod extends (error: ErrorInstanceOfMap<PluginsMapOf<TThis>>, ...args: any[]) => any>(this: TThis, kind: 'method', key: TKey, value: TMethod): ClassError0<ExtendErrorPluginsMapWithMethod<PluginsMapOf<TThis>, TKey, TMethod>>;
     static use<TThis extends typeof Error0>(this: TThis, kind: 'adapt', value: ErrorPluginAdaptFn<ErrorInstanceOfMap<PluginsMapOf<TThis>>, ErrorResolvedProps<PluginsMapOf<TThis>>>): ClassError0<PluginsMapOf<TThis>>;
     static use<TThis extends typeof Error0>(this: TThis, kind: 'stack', value: ErrorPluginStack<ErrorInstanceOfMap<PluginsMapOf<TThis>>>): ClassError0<PluginsMapOf<TThis>>;
@@ -298,7 +306,6 @@ declare class Error0 extends Error {
     static plugin(): PluginError0;
     static serialize(error: unknown, isPublic?: boolean): Record<string, unknown>;
     serialize(isPublic?: boolean): Record<string, unknown>;
-    round<TThis extends Error0>(this: TThis, isPublic?: boolean): TThis;
 }
 
-export { type ClassError0, Error0, type ErrorInput, type ErrorInputBase, type ErrorPlugin, type ErrorPluginAdaptFn, type ErrorPluginAdaptResult, type ErrorPluginCause, type ErrorPluginCauseDeserialize, type ErrorPluginCauseSerialize, type ErrorPluginMessage, type ErrorPluginMessageSerialize, type ErrorPluginMethodFn, type ErrorPluginMethods, type ErrorPluginPropOptions, type ErrorPluginProps, type ErrorPluginStack, type ErrorPluginStackSerialize, type ErrorPluginsMap, type ErrorResolved, type IsEmptyObject, PluginError0 };
+export { type ClassError0, Error0, type ErrorPlugin, type InstanceError0, PluginError0 };

package/dist/cjs/plugins/code.d.cts

@@ -1,8 +1,46 @@
-import { PluginError0, ErrorPluginPropOptions, Error0 } from '../index.cjs';
+import { PluginError0, Error0 } from '../index.cjs';
 
 declare const codePlugin: <TCode extends string>({ codes, isPublic, }?: {
     codes?: TCode[];
     isPublic?: boolean;
-}) => PluginError0<Record<never, never> & Record<"code", ErrorPluginPropOptions<TCode, TCode, Error0, TCode | undefined>>, Record<never, never>>;
+}) => PluginError0<Record<never, never> & Record<"code", ({
+    resolve: (options: {
+        own: TCode | undefined;
+        flow: (TCode | undefined)[];
+        error: Error0;
+    }) => TCode | undefined;
+    serialize: false | ((options: {
+        own: TCode | undefined;
+        flow: (TCode | undefined)[];
+        resolved: TCode | undefined;
+        error: Error0;
+        isPublic: boolean;
+    }) => unknown);
+    deserialize: false | ((options: {
+        value: unknown;
+        record: Record<string, unknown>;
+    }) => TCode | undefined);
+} & {
+    init: ((input: TCode) => TCode) | (() => TCode);
+}) | ({
+    resolve: (options: {
+        own: TCode | undefined;
+        flow: (TCode | undefined)[];
+        error: Error0;
+    }) => TCode | undefined;
+    serialize: false | ((options: {
+        own: TCode | undefined;
+        flow: (TCode | undefined)[];
+        resolved: TCode | undefined;
+        error: Error0;
+        isPublic: boolean;
+    }) => unknown);
+    deserialize: false | ((options: {
+        value: unknown;
+        record: Record<string, unknown>;
+    }) => TCode | undefined);
+} & {
+    init?: undefined;
+})>, Record<never, never>>;
 
 export { codePlugin };

package/dist/cjs/plugins/expected.d.cts

@@ -1,25 +1,67 @@
-import { Error0, PluginError0, ErrorPluginPropOptions } from '../index.cjs';
+import { Error0, PluginError0 } from '../index.cjs';
 
 declare const expectedPlugin: <TError extends Error0>({ isPublic, override, }?: {
     isPublic?: boolean;
     override?: (error: TError) => boolean | undefined;
-}) => PluginError0<Record<never, never> & Record<"expected", ErrorPluginPropOptions<boolean, boolean, Error0, boolean>>, Record<never, never> & Record<"isExpected", (error: Error0 & {
+}) => PluginError0<Record<never, never> & Record<"expected", ({
+    resolve: (options: {
+        own: boolean | undefined;
+        flow: (boolean | undefined)[];
+        error: Error0;
+    }) => boolean;
+    serialize: false | ((options: {
+        own: boolean | undefined;
+        flow: (boolean | undefined)[];
+        resolved: boolean;
+        error: Error0;
+        isPublic: boolean;
+    }) => unknown);
+    deserialize: false | ((options: {
+        value: unknown;
+        record: Record<string, unknown>;
+    }) => boolean | undefined);
+} & {
+    init: ((input: boolean) => boolean) | (() => boolean);
+}) | ({
+    resolve: (options: {
+        own: boolean | undefined;
+        flow: (boolean | undefined)[];
+        error: Error0;
+    }) => boolean;
+    serialize: false | ((options: {
+        own: boolean | undefined;
+        flow: (boolean | undefined)[];
+        resolved: boolean;
+        error: Error0;
+        isPublic: boolean;
+    }) => unknown);
+    deserialize: false | ((options: {
+        value: unknown;
+        record: Record<string, unknown>;
+    }) => boolean | undefined);
+} & {
+    init?: undefined;
+})>, Record<never, never> & Record<"isExpected", (error: Error0 & {
     expected: boolean;
 } & {} & {
-    own: {
-        (): {
-            expected: boolean | undefined;
-        };
-        <TKey extends "expected">(key: TKey): {
-            expected: boolean | undefined;
-        }[TKey];
+    resolve: () => {
+        expected: boolean;
     };
+} & {
+    own?: Partial<{
+        expected: boolean | undefined;
+    }> | undefined;
     flow: <TKey extends "expected">(key: TKey) => {
         expected: boolean | undefined;
     }[TKey][];
-} & {
-    resolve: () => {
+    assign: (props: Partial<{
+        expected: boolean | undefined;
+    }>) => Error0 & {
         expected: boolean;
+    } & {} & {
+        resolve: () => {
+            expected: boolean;
+        };
     };
 } & {
     readonly __pluginsMap?: {

package/dist/cjs/plugins/meta.d.cts

@@ -1,7 +1,45 @@
-import { PluginError0, ErrorPluginPropOptions, Error0 } from '../index.cjs';
+import { PluginError0, Error0 } from '../index.cjs';
 
 declare const metaPlugin: ({ isPublic }?: {
     isPublic?: boolean;
-}) => PluginError0<Record<never, never> & Record<"meta", ErrorPluginPropOptions<Record<string, unknown>, Record<string, unknown>, Error0, Record<string, unknown> | undefined>>, Record<never, never>>;
+}) => PluginError0<Record<never, never> & Record<"meta", ({
+    resolve: (options: {
+        own: Record<string, unknown> | undefined;
+        flow: (Record<string, unknown> | undefined)[];
+        error: Error0;
+    }) => Record<string, unknown> | undefined;
+    serialize: false | ((options: {
+        own: Record<string, unknown> | undefined;
+        flow: (Record<string, unknown> | undefined)[];
+        resolved: Record<string, unknown> | undefined;
+        error: Error0;
+        isPublic: boolean;
+    }) => unknown);
+    deserialize: false | ((options: {
+        value: unknown;
+        record: Record<string, unknown>;
+    }) => Record<string, unknown> | undefined);
+} & {
+    init: ((input: Record<string, unknown>) => Record<string, unknown>) | (() => Record<string, unknown>);
+}) | ({
+    resolve: (options: {
+        own: Record<string, unknown> | undefined;
+        flow: (Record<string, unknown> | undefined)[];
+        error: Error0;
+    }) => Record<string, unknown> | undefined;
+    serialize: false | ((options: {
+        own: Record<string, unknown> | undefined;
+        flow: (Record<string, unknown> | undefined)[];
+        resolved: Record<string, unknown> | undefined;
+        error: Error0;
+        isPublic: boolean;
+    }) => unknown);
+    deserialize: false | ((options: {
+        value: unknown;
+        record: Record<string, unknown>;
+    }) => Record<string, unknown> | undefined);
+} & {
+    init?: undefined;
+})>, Record<never, never>>;
 
 export { metaPlugin };

package/dist/cjs/plugins/stack-merge.cjs

@@ -30,9 +30,9 @@ const stackMergePlugin = ({
     if (!isPublic && _isPublic) {
       return void 0;
     }
-    return error.causes().map((cause) => {
-      return cause instanceof Error ? cause.stack : void 0;
-    }).filter((value) => typeof value === "string").join(delimiter);
+    return error.causes().flatMap((cause) => {
+      return cause instanceof Error && cause.stack && typeof cause.stack === "string" ? cause.stack : [];
+    }).join(delimiter);
   }
 });
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/plugins/stack-merge.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/plugins/stack-merge.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const stackMergePlugin = ({\n  isPublic = false,\n  delimiter = '\\n',\n}: { isPublic?: boolean; delimiter?: string } = {}) =>\n  Error0.plugin().stack({\n    serialize: ({ error, isPublic: _isPublic }) => {\n      if (!isPublic && _isPublic) {\n        return undefined\n      }\n      return error\n        .causes()\n        .map((cause) => {\n          return cause instanceof Error ? cause.stack : undefined\n        })\n        .filter((value): value is string => typeof value === 'string')\n        .join(delimiter)\n    },\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAuB;AAEhB,MAAM,mBAAmB,CAAC;AAAA,EAC/B,WAAW;AAAA,EACX,YAAY;AACd,IAAgD,CAAC,MAC/C,gBAAO,OAAO,EAAE,MAAM;AAAA,EACpB,WAAW,CAAC,EAAE,OAAO,UAAU,UAAU,MAAM;AAC7C,QAAI,CAAC,YAAY,WAAW;AAC1B,aAAO;AAAA,IACT;AACA,WAAO,MACJ,OAAO,EACP,IAAI,CAAC,UAAU;AACd,aAAO,iBAAiB,QAAQ,MAAM,QAAQ;AAAA,IAChD,CAAC,EACA,OAAO,CAAC,UAA2B,OAAO,UAAU,QAAQ,EAC5D,KAAK,SAAS;AAAA,EACnB;AACF,CAAC;","names":[]}
+{"version":3,"sources":["../../../src/plugins/stack-merge.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const stackMergePlugin = ({\n  isPublic = false,\n  delimiter = '\\n',\n}: { isPublic?: boolean; delimiter?: string } = {}) =>\n  Error0.plugin().stack({\n    serialize: ({ error, isPublic: _isPublic }) => {\n      if (!isPublic && _isPublic) {\n        return undefined\n      }\n      return error\n        .causes()\n        .flatMap((cause) => {\n          return cause instanceof Error && cause.stack && typeof cause.stack === 'string' ? cause.stack : []\n        })\n        .join(delimiter)\n    },\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAuB;AAEhB,MAAM,mBAAmB,CAAC;AAAA,EAC/B,WAAW;AAAA,EACX,YAAY;AACd,IAAgD,CAAC,MAC/C,gBAAO,OAAO,EAAE,MAAM;AAAA,EACpB,WAAW,CAAC,EAAE,OAAO,UAAU,UAAU,MAAM;AAC7C,QAAI,CAAC,YAAY,WAAW;AAC1B,aAAO;AAAA,IACT;AACA,WAAO,MACJ,OAAO,EACP,QAAQ,CAAC,UAAU;AAClB,aAAO,iBAAiB,SAAS,MAAM,SAAS,OAAO,MAAM,UAAU,WAAW,MAAM,QAAQ,CAAC;AAAA,IACnG,CAAC,EACA,KAAK,SAAS;AAAA,EACnB;AACF,CAAC;","names":[]}

package/dist/cjs/plugins/status.d.cts

@@ -1,9 +1,47 @@
-import { PluginError0, ErrorPluginPropOptions, Error0 } from '../index.cjs';
+import { PluginError0, Error0 } from '../index.cjs';
 
 declare const statusPlugin: <TStatuses extends Record<string, number> = Record<never, number>>({ isPublic, statuses, strict, }?: {
     isPublic?: boolean;
     statuses?: TStatuses;
     strict?: boolean;
-}) => PluginError0<Record<never, never> & Record<"status", ErrorPluginPropOptions<number | Extract<keyof TStatuses, string>, number | undefined, Error0, number | undefined>>, Record<never, never>>;
+}) => PluginError0<Record<never, never> & Record<"status", ({
+    resolve: (options: {
+        own: number | undefined;
+        flow: (number | undefined)[];
+        error: Error0;
+    }) => number | undefined;
+    serialize: false | ((options: {
+        own: number | undefined;
+        flow: (number | undefined)[];
+        resolved: number | undefined;
+        error: Error0;
+        isPublic: boolean;
+    }) => unknown);
+    deserialize: false | ((options: {
+        value: unknown;
+        record: Record<string, unknown>;
+    }) => number | undefined);
+} & {
+    init: ((input: number | Extract<keyof TStatuses, string>) => number | undefined) | (() => number | undefined);
+}) | ({
+    resolve: (options: {
+        own: number | undefined;
+        flow: (number | undefined)[];
+        error: Error0;
+    }) => number | undefined;
+    serialize: false | ((options: {
+        own: number | undefined;
+        flow: (number | undefined)[];
+        resolved: number | undefined;
+        error: Error0;
+        isPublic: boolean;
+    }) => unknown);
+    deserialize: false | ((options: {
+        value: unknown;
+        record: Record<string, unknown>;
+    }) => number | undefined);
+} & {
+    init?: undefined;
+})>, Record<never, never>>;
 
 export { statusPlugin };

package/dist/cjs/plugins/tags.d.cts

@@ -1,26 +1,68 @@
-import { PluginError0, ErrorPluginPropOptions, Error0 } from '../index.cjs';
+import { PluginError0, Error0 } from '../index.cjs';
 
 declare const tagsPlugin: <TTag extends string>({ isPublic, tags, strict, }?: {
     isPublic?: boolean;
     tags?: TTag[] | readonly TTag[];
     strict?: boolean;
-}) => PluginError0<Record<never, never> & Record<"tags", ErrorPluginPropOptions<string[], string[], Error0, string[] | undefined>>, Record<never, never> & Record<"hasTag", (error: Error0 & {
+}) => PluginError0<Record<never, never> & Record<"tags", ({
+    resolve: (options: {
+        own: string[] | undefined;
+        flow: (string[] | undefined)[];
+        error: Error0;
+    }) => string[] | undefined;
+    serialize: false | ((options: {
+        own: string[] | undefined;
+        flow: (string[] | undefined)[];
+        resolved: string[] | undefined;
+        error: Error0;
+        isPublic: boolean;
+    }) => unknown);
+    deserialize: false | ((options: {
+        value: unknown;
+        record: Record<string, unknown>;
+    }) => string[] | undefined);
+} & {
+    init: ((input: string[]) => string[]) | (() => string[]);
+}) | ({
+    resolve: (options: {
+        own: string[] | undefined;
+        flow: (string[] | undefined)[];
+        error: Error0;
+    }) => string[] | undefined;
+    serialize: false | ((options: {
+        own: string[] | undefined;
+        flow: (string[] | undefined)[];
+        resolved: string[] | undefined;
+        error: Error0;
+        isPublic: boolean;
+    }) => unknown);
+    deserialize: false | ((options: {
+        value: unknown;
+        record: Record<string, unknown>;
+    }) => string[] | undefined);
+} & {
+    init?: undefined;
+})>, Record<never, never> & Record<"hasTag", (error: Error0 & {
     tags: string[] | undefined;
 } & {} & {
-    own: {
-        (): {
-            tags: string[] | undefined;
-        };
-        <TKey extends "tags">(key: TKey): {
-            tags: string[] | undefined;
-        }[TKey];
+    resolve: () => {
+        tags: string[] | undefined;
     };
+} & {
+    own?: Partial<{
+        tags: string[] | undefined;
+    }> | undefined;
     flow: <TKey extends "tags">(key: TKey) => {
         tags: string[] | undefined;
     }[TKey][];
-} & {
-    resolve: () => {
+    assign: (props: Partial<{
         tags: string[] | undefined;
+    }>) => Error0 & {
+        tags: string[] | undefined;
+    } & {} & {
+        resolve: () => {
+            tags: string[] | undefined;
+        };
     };
 } & {
     readonly __pluginsMap?: {