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

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

@@ -22,14 +22,17 @@ __export(stack_merge_exports, {
 });
 module.exports = __toCommonJS(stack_merge_exports);
 var import__ = require('../index.cjs');
-const stackMergePlugin = import__.Error0.plugin().use("stack", {
+const stackMergePlugin = ({
+  hideWhenPublic = true,
+  delimiter = "\n"
+} = {}) => import__.Error0.plugin().use("stack", {
   serialize: ({ error, isPublic }) => {
-    if (isPublic) {
+    if (hideWhenPublic && isPublic) {
       return void 0;
     }
     return error.causes().map((cause) => {
       return cause instanceof Error ? cause.stack : void 0;
-    }).filter((value) => typeof value === "string").join("\n");
+    }).filter((value) => typeof value === "string").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 = Error0.plugin().use('stack', {\n  serialize: ({ error, isPublic }) => {\n    if (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('\\n')\n  },\n})\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAuB;AAEhB,MAAM,mBAAmB,gBAAO,OAAO,EAAE,IAAI,SAAS;AAAA,EAC3D,WAAW,CAAC,EAAE,OAAO,SAAS,MAAM;AAClC,QAAI,UAAU;AACZ,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,IAAI;AAAA,EACd;AACF,CAAC;","names":[]}
+{"version":3,"sources":["../../../src/plugins/stack-merge.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const stackMergePlugin = ({\n  hideWhenPublic = true,\n  delimiter = '\\n',\n}: { hideWhenPublic?: boolean; delimiter?: string } = {}) =>\n  Error0.plugin().use('stack', {\n    serialize: ({ error, isPublic }) => {\n      if (hideWhenPublic && 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,iBAAiB;AAAA,EACjB,YAAY;AACd,IAAsD,CAAC,MACrD,gBAAO,OAAO,EAAE,IAAI,SAAS;AAAA,EAC3B,WAAW,CAAC,EAAE,OAAO,SAAS,MAAM;AAClC,QAAI,kBAAkB,UAAU;AAC9B,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":[]}

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

@@ -1,5 +1,8 @@
 import { PluginError0 } from '../index.cjs';
 
-declare const stackMergePlugin: PluginError0<Record<never, never>, Record<never, never>>;
+declare const stackMergePlugin: ({ hideWhenPublic, delimiter, }?: {
+    hideWhenPublic?: boolean;
+    delimiter?: string;
+}) => PluginError0<Record<never, never>, Record<never, never>>;
 
 export { stackMergePlugin };

package/dist/cjs/plugins/tags.cjs

@@ -22,7 +22,7 @@ __export(tags_exports, {
 });
 module.exports = __toCommonJS(tags_exports);
 var import__ = require('../index.cjs');
-const tagsPlugin = import__.Error0.plugin().use("prop", "tags", {
+const tagsPlugin = ({ hideWhenPublic = true } = {}) => import__.Error0.plugin().use("prop", "tags", {
   init: (input) => input,
   resolve: ({ flow }) => {
     const merged = [];
@@ -33,7 +33,12 @@ const tagsPlugin = import__.Error0.plugin().use("prop", "tags", {
     }
     return merged.length > 0 ? Array.from(new Set(merged)) : void 0;
   },
-  serialize: ({ value, isPublic }) => isPublic ? void 0 : value,
+  serialize: ({ resolved, isPublic }) => {
+    if (hideWhenPublic && isPublic) {
+      return void 0;
+    }
+    return resolved;
+  },
   deserialize: ({ value }) => {
     if (!Array.isArray(value)) {
       return void 0;

package/dist/cjs/plugins/tags.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/plugins/tags.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const tagsPlugin = Error0.plugin().use('prop', 'tags', {\n  init: (input: string[]) => input,\n  resolve: ({ flow }) => {\n    const merged: string[] = []\n    for (const value of flow) {\n      if (Array.isArray(value)) {\n        merged.push(...value.filter((item): item is string => typeof item === 'string'))\n      }\n    }\n    return merged.length > 0 ? Array.from(new Set(merged)) : undefined\n  },\n  serialize: ({ value, isPublic }) => (isPublic ? undefined : value),\n  deserialize: ({ value }) => {\n    if (!Array.isArray(value)) {\n      return undefined\n    }\n    return value.filter((item): item is string => typeof item === 'string')\n  },\n})\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAuB;AAEhB,MAAM,aAAa,gBAAO,OAAO,EAAE,IAAI,QAAQ,QAAQ;AAAA,EAC5D,MAAM,CAAC,UAAoB;AAAA,EAC3B,SAAS,CAAC,EAAE,KAAK,MAAM;AACrB,UAAM,SAAmB,CAAC;AAC1B,eAAW,SAAS,MAAM;AACxB,UAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,eAAO,KAAK,GAAG,MAAM,OAAO,CAAC,SAAyB,OAAO,SAAS,QAAQ,CAAC;AAAA,MACjF;AAAA,IACF;AACA,WAAO,OAAO,SAAS,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,CAAC,IAAI;AAAA,EAC3D;AAAA,EACA,WAAW,CAAC,EAAE,OAAO,SAAS,MAAO,WAAW,SAAY;AAAA,EAC5D,aAAa,CAAC,EAAE,MAAM,MAAM;AAC1B,QAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACzB,aAAO;AAAA,IACT;AACA,WAAO,MAAM,OAAO,CAAC,SAAyB,OAAO,SAAS,QAAQ;AAAA,EACxE;AACF,CAAC;","names":[]}
+{"version":3,"sources":["../../../src/plugins/tags.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const tagsPlugin = ({ hideWhenPublic = true }: { hideWhenPublic?: boolean } = {}) =>\n  Error0.plugin().use('prop', 'tags', {\n    init: (input: string[]) => input,\n    resolve: ({ flow }) => {\n      const merged: string[] = []\n      for (const value of flow) {\n        if (Array.isArray(value)) {\n          merged.push(...value.filter((item): item is string => typeof item === 'string'))\n        }\n      }\n      return merged.length > 0 ? Array.from(new Set(merged)) : undefined\n    },\n    serialize: ({ resolved, isPublic }) => {\n      if (hideWhenPublic && isPublic) {\n        return undefined\n      }\n      return resolved\n    },\n    deserialize: ({ value }) => {\n      if (!Array.isArray(value)) {\n        return undefined\n      }\n      return value.filter((item): item is string => typeof item === 'string')\n    },\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAuB;AAEhB,MAAM,aAAa,CAAC,EAAE,iBAAiB,KAAK,IAAkC,CAAC,MACpF,gBAAO,OAAO,EAAE,IAAI,QAAQ,QAAQ;AAAA,EAClC,MAAM,CAAC,UAAoB;AAAA,EAC3B,SAAS,CAAC,EAAE,KAAK,MAAM;AACrB,UAAM,SAAmB,CAAC;AAC1B,eAAW,SAAS,MAAM;AACxB,UAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,eAAO,KAAK,GAAG,MAAM,OAAO,CAAC,SAAyB,OAAO,SAAS,QAAQ,CAAC;AAAA,MACjF;AAAA,IACF;AACA,WAAO,OAAO,SAAS,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,CAAC,IAAI;AAAA,EAC3D;AAAA,EACA,WAAW,CAAC,EAAE,UAAU,SAAS,MAAM;AACrC,QAAI,kBAAkB,UAAU;AAC9B,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AAAA,EACA,aAAa,CAAC,EAAE,MAAM,MAAM;AAC1B,QAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACzB,aAAO;AAAA,IACT;AACA,WAAO,MAAM,OAAO,CAAC,SAAyB,OAAO,SAAS,QAAQ;AAAA,EACxE;AACF,CAAC;","names":[]}

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

@@ -1,5 +1,7 @@
 import { PluginError0, ErrorPluginPropOptions, Error0 } from '../index.cjs';
 
-declare const tagsPlugin: PluginError0<Record<never, never> & Record<"tags", ErrorPluginPropOptions<string[], string[], Error0, string[] | undefined>>, Record<never, never>>;
+declare const tagsPlugin: ({ hideWhenPublic }?: {
+    hideWhenPublic?: boolean;
+}) => PluginError0<Record<never, never> & Record<"tags", ErrorPluginPropOptions<string[], string[], Error0, string[] | undefined>>, Record<never, never>>;
 
 export { tagsPlugin };

package/dist/esm/index.d.ts

@@ -6,22 +6,26 @@ type InferPluginPropInput<TProp extends ErrorPluginPropOptions<any, any, any, an
     init: infer TInit;
 } ? NormalizeUnknownToUndefined<InferFirstArg<TInit>> : undefined;
 type ErrorPluginPropInit<TInputValue, TOutputValue> = ((input: TInputValue) => TOutputValue) | (() => TOutputValue);
-type ErrorPluginPropSerialize<TOutputValue, TError extends Error0> = ((options: {
-    value: TOutputValue;
+type ErrorPluginPropSerializeOptions<TOutputValue, TError extends Error0, TResolveValue extends TOutputValue | undefined> = {
+    own: TOutputValue | undefined;
+    flow: Array<TOutputValue | undefined>;
+    resolved: TResolveValue;
     error: TError;
     isPublic: boolean;
-}) => unknown) | false;
+};
+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>;
+    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<TInputValue, TOutputValue, TError extends Error0, TResolveValue extends TOutputValue | undefined> = ErrorPluginPropOptionsBase<TOutputValue, TError, TResolveValue> & {
@@ -134,6 +138,17 @@ type EmptyPluginsMap = {
     }>;
     methods: Record<never, ErrorMethodRecord>;
 };
+type ErrorPluginResolved = {
+    props: Record<string, ErrorPluginPropOptions<unknown>>;
+    methods: Record<string, ErrorPluginMethodFn<unknown>>;
+    adapt: Array<ErrorPluginAdaptFn<Error0, Record<string, unknown>>>;
+    stack?: ErrorPluginStack;
+    cause?: ErrorPluginCause;
+    message?: ErrorPluginMessage;
+    propKeys: string[];
+    propEntries: Array<[string, ErrorPluginPropOptions<unknown>]>;
+    methodEntries: Array<[string, ErrorPluginMethodFn<unknown>]>;
+};
 type PluginPropsMapOf<TPlugin extends ErrorPlugin> = {
     [TKey in keyof NonNullable<TPlugin['props']>]: NonNullable<TPlugin['props']>[TKey] extends ErrorPluginPropOptions<any, infer TOutputValue, any, infer TResolveValue> ? {
         init: InferPluginPropInput<NonNullable<TPlugin['props']>[TKey]>;
@@ -164,8 +179,12 @@ 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>;
-type BuilderError0<TProps extends ErrorPluginProps, TMethods extends ErrorPluginMethods> = Error0 & ErrorResolved<PluginsMapFromParts<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 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;
@@ -188,6 +207,7 @@ declare class PluginError0<TProps extends ErrorPluginProps = Record<never, never
     use(kind: 'message', value: ErrorPluginMessage<BuilderError0<TProps, TMethods>>): PluginError0<TProps, TMethods>;
 }
 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;
     };
@@ -198,6 +218,11 @@ type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> = {
     };
     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>;
+    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: {
@@ -219,14 +244,20 @@ type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> = {
 declare class Error0 extends Error {
     static readonly __pluginsMap?: EmptyPluginsMap;
     readonly __pluginsMap?: EmptyPluginsMap;
+    static MAX_CAUSES_DEPTH: number;
     protected static _plugins: ErrorPlugin[];
+    protected static _resolvedPlugin?: ErrorPluginResolved;
     private static readonly _emptyPlugin;
+    private static _indexResolvedPlugin;
+    private static _applyPlugin;
+    private static _mergeResolvedPlugin;
     private static _getResolvedPlugin;
     constructor(message: string, input?: ErrorInput<EmptyPluginsMap>);
     constructor(input: {
         message: string;
     } & ErrorInput<EmptyPluginsMap>);
-    private static readonly isSelfProperty;
+    private static _getOwnStore;
+    private static readonly isOwnProperty;
     private static _ownByKey;
     private static _flowByKey;
     static own<TThis extends typeof Error0>(this: TThis, error: unknown): ErrorOwnProps<PluginsMapOf<TThis>>;
@@ -234,13 +265,11 @@ declare class Error0 extends Error {
     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]>;
-    static flow(error: unknown, key: string): unknown[];
     flow<TThis extends Error0, TKey extends keyof PluginsMapOfInstance<TThis>['props'] & string>(this: TThis, key: TKey): Array<ErrorOwnProps<PluginsMapOfInstance<TThis>>[TKey]>;
-    flow(key: string): unknown[];
+    static _resolveByKey(error: Error0, key: string, plugin: ErrorPluginResolved): unknown;
     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>>;
-    resolve(): Record<string, unknown>;
     static causes(error: unknown, instancesOnly?: false): unknown[];
     static causes<T extends typeof Error0>(this: T, error: unknown, instancesOnly: true): Array<InstanceType<T>>;
     causes<TThis extends Error0>(this: TThis, instancesOnly?: false): [TThis, ...unknown[]];
@@ -248,6 +277,7 @@ declare class Error0 extends Error {
     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;
     private static _applyAdapt;
     private static _fromSerialized;
     private static _fromNonError0;
@@ -264,6 +294,7 @@ 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 ErrorPluginCauseSerialize, type ErrorPluginMessage, type ErrorPluginMessageSerialize, type ErrorPluginMethodFn, type ErrorPluginMethods, type ErrorPluginPropOptions, type ErrorPluginProps, type ErrorPluginStack, type ErrorPluginStackSerialize, type ErrorPluginsMap, type ErrorResolved, type IsEmptyObject, PluginError0 };

package/dist/esm/index.js

@@ -75,45 +75,87 @@ class PluginError0 {
     });
   }
 }
+const OWN_SYMBOL = Symbol("Error0.own");
 class Error0 extends Error {
   static __pluginsMap;
   __pluginsMap;
+  static MAX_CAUSES_DEPTH = 99;
   static _plugins = [];
+  static _resolvedPlugin;
   static _emptyPlugin = {
     props: {},
     methods: {},
     adapt: [],
     stack: void 0,
     cause: void 0,
-    message: void 0
+    message: void 0,
+    propKeys: [],
+    propEntries: [],
+    methodEntries: []
   };
+  static _indexResolvedPlugin(resolved) {
+    return {
+      ...resolved,
+      propKeys: Object.keys(resolved.props),
+      propEntries: Object.entries(resolved.props),
+      methodEntries: Object.entries(resolved.methods)
+    };
+  }
+  static _applyPlugin(resolved, plugin) {
+    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;
+    }
+  }
+  static _mergeResolvedPlugin(base, plugin) {
+    const merged = {
+      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);
+  }
   static _getResolvedPlugin() {
+    if (Object.prototype.hasOwnProperty.call(this, "_resolvedPlugin") && this._resolvedPlugin) {
+      return this._resolvedPlugin;
+    }
     const resolved = {
       props: {},
       methods: {},
-      adapt: []
+      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(...args) {
     const [first, second] = args;
@@ -122,37 +164,43 @@ class Error0 extends Error {
     this.name = "Error0";
     const ctor = this.constructor;
     const plugin = ctor._getResolvedPlugin();
-    for (const [key, prop] of Object.entries(plugin.props)) {
+    const ownStore = /* @__PURE__ */ Object.create(null);
+    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),
+          error: this
+        }),
+        set: (value) => {
+          ownStore[key] = value;
+        },
+        enumerable: true,
+        configurable: true
+      });
       if (key in input) {
         const ownValue = input[key];
-        if (typeof prop.init === "function") {
-          ;
-          this[key] = prop.init(ownValue);
-        } else {
-          ;
-          this[key] = ownValue;
-        }
-      } else {
-        Object.defineProperty(this, key, {
-          get: () => prop.resolve({ own: void 0, 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;
       }
     }
   }
-  static isSelfProperty = (object, key) => {
+  static _getOwnStore(object) {
+    const record = object;
+    const existing = record[OWN_SYMBOL];
+    if (existing && typeof existing === "object") {
+      return existing;
+    }
+    return void 0;
+  }
+  static isOwnProperty = (object, key) => {
+    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") {
@@ -165,22 +213,29 @@ class Error0 extends Error {
     return true;
   };
   static _ownByKey(error, key) {
-    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[key];
     }
     return void 0;
   }
   static _flowByKey(error, key) {
-    return this.causes(error, true).map((cause) => {
-      return this._ownByKey(cause, key);
-    });
+    const causes = this.causes(error, true);
+    const values = new Array(causes.length);
+    for (let i = 0; i < causes.length; i += 1) {
+      values[i] = this._ownByKey(causes[i], key);
+    }
+    return values;
   }
   static own(error, key) {
     const error0 = this.from(error);
     if (key === void 0) {
       const ownValues = {};
       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;
@@ -202,29 +257,34 @@ class Error0 extends Error {
     const ctor = this.constructor;
     return ctor._flowByKey(this, key);
   }
+  static _resolveByKey(error, key, plugin) {
+    try {
+      const options = {
+        get own() {
+          return error.own(key);
+        },
+        get flow() {
+          return error.flow(key);
+        },
+        error
+      };
+      const prop = plugin.props[key];
+      const resolver = prop.resolve;
+      if (!resolver) {
+        return error[key];
+      }
+      return resolver(options);
+    } catch {
+      console.error(`Error0: failed to resolve property ${key}`, error);
+      return void 0;
+    }
+  }
   static resolve(error) {
     const error0 = this.from(error);
     const resolved = {};
     const plugin = this._getResolvedPlugin();
-    for (const [key, prop] of Object.entries(plugin.props)) {
-      try {
-        const options = Object.defineProperties(
-          {
-            error: error0
-          },
-          {
-            own: {
-              get: () => error0.own(key)
-            },
-            flow: {
-              get: () => error0.flow(key)
-            }
-          }
-        );
-        resolved[key] = prop.resolve(options);
-      } catch {
-        console.error(`Error0: failed to resolve property ${key}`, error0);
-      }
+    for (const key of plugin.propKeys) {
+      resolved[key] = this._resolveByKey(error0, key, plugin);
     }
     return resolved;
   }
@@ -235,9 +295,9 @@ class Error0 extends Error {
   static causes(error, instancesOnly) {
     const causes = [];
     let current = error;
-    const maxDepth = 99;
     const seen = /* @__PURE__ */ new Set();
-    for (let depth = 0; depth < maxDepth; depth += 1) {
+    let depth = 0;
+    while (depth < this.MAX_CAUSES_DEPTH) {
       if (seen.has(current)) {
         break;
       }
@@ -249,6 +309,7 @@ class Error0 extends Error {
         break;
       }
       current = current.cause;
+      depth += 1;
     }
     return causes;
   }
@@ -274,6 +335,9 @@ class Error0 extends Error {
     }
     return this._fromNonError0(error);
   }
+  static round(error, isPublic = false) {
+    return this.from(this.serialize(error, isPublic));
+  }
   static _applyAdapt(error) {
     const plugin = this._getResolvedPlugin();
     for (const adapt of plugin.adapt) {
@@ -292,8 +356,7 @@ class Error0 extends Error {
     const errorRecord = error;
     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;
       }
@@ -301,7 +364,7 @@ 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[key] = value;
       } catch {
         console.error(`Error0: failed to deserialize property ${key}`, errorRecord);
@@ -344,8 +407,9 @@ class Error0 extends Error {
     const Error0Extended = class Error0 extends Base {
     };
     Error0Extended._plugins = [...Base._plugins, plugin];
-    const resolved = Error0Extended._getResolvedPlugin();
-    for (const [key, method] of Object.entries(resolved.methods)) {
+    const resolved = this._mergeResolvedPlugin(Base._getResolvedPlugin(), plugin);
+    Error0Extended._resolvedPlugin = resolved;
+    for (const [key, method] of resolved.methodEntries) {
       Object.defineProperty(Error0Extended.prototype, key, {
         value: function(...args) {
           return method(this, ...args);
@@ -444,9 +508,8 @@ class Error0 extends Error {
   }
   static serialize(error, isPublic = true) {
     const error0 = this.from(error);
-    const resolvedProps = this.resolve(error0);
-    const resolvedRecord = resolvedProps;
     const plugin = this._getResolvedPlugin();
+    const resolveByKey = (targetError, key, targetPlugin) => this._resolveByKey(targetError, key, targetPlugin);
     const messagePlugin = plugin.message;
     let serializedMessage = error0.message;
     try {
@@ -458,24 +521,37 @@ class Error0 extends Error {
       serializedMessage = error0.message;
     }
     const json = {
-      name: error0.name,
-      message: serializedMessage
+      name: error0.name
       // we do not serialize causes, it is enough that we have floated props and adapt helper
       // cause: error0.cause,
     };
-    const propsEntries = Object.entries(plugin.props);
-    for (const [key, prop] of propsEntries) {
+    if (serializedMessage !== void 0) {
+      json.message = serializedMessage;
+    }
+    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);
+          },
+          get flow() {
+            return error0.flow(key);
+          },
+          get resolved() {
+            return resolveByKey(error0, key, plugin);
+          },
+          error: error0,
+          isPublic
+        };
+        const jsonValue = prop.serialize(options);
         if (jsonValue !== void 0) {
           json[key] = jsonValue;
         }
       } catch {
-        console.error(`Error0: failed to serialize property ${key}`, resolvedRecord);
+        console.error(`Error0: failed to serialize property ${key}`, error0);
       }
     }
     const stackPlugin = plugin.stack;
@@ -507,12 +583,16 @@ class Error0 extends Error {
         console.error("Error0: failed to serialize cause", error0);
       }
     }
-    return Object.fromEntries(Object.entries(json).filter(([, value]) => value !== void 0));
+    return json;
   }
   serialize(isPublic = true) {
     const ctor = this.constructor;
     return ctor.serialize(this, isPublic);
   }
+  round(isPublic = true) {
+    const ctor = this.constructor;
+    return ctor.round(this, isPublic);
+  }
 }
 export {
   Error0,