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

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;
     };
@@ -199,6 +219,10 @@ 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: {
@@ -220,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>>;
@@ -235,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[]];

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;
   }
@@ -295,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;
       }
@@ -304,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);
@@ -347,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);
@@ -447,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 {
@@ -461,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;
@@ -510,7 +583,7 @@ 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;