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

package/dist/esm/index.d.ts

@@ -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/esm/index.js

@@ -1,5 +1,25 @@
 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';
+const fromPropOptionsDefinition = (options) => {
+  let resolver;
+  if (!options.resolve) {
+    resolver = (options2) => options2.own;
+  } else if (options.resolve === true) {
+    resolver = (options2) => options2.flow.find((v) => v !== void 0);
+  } else if (typeof options.resolve === "function") {
+    resolver = options.resolve;
+  } else {
+    throw new Error("Invalid resolve option");
+  }
+  const serializer = options.serialize ?? false;
+  const deserializer = options.deserialize ?? false;
+  return {
+    ...options,
+    resolve: resolver,
+    serialize: serializer,
+    deserialize: deserializer
+  };
+};
 class PluginError0 {
   _plugin;
   Infer = void 0;
@@ -49,7 +69,7 @@ class PluginError0 {
       if (value === void 0) {
         throw new Error('PluginError0.use("prop", key, value) requires value');
       }
-      nextProps[key] = value;
+      nextProps[key] = fromPropOptionsDefinition(value);
     } else if (kind === "method") {
       const key = keyOrValue;
       if (value === void 0) {
@@ -75,10 +95,8 @@ class PluginError0 {
     });
   }
 }
-const OWN_SYMBOL = Symbol("Error0.own");
 class Error0 extends Error {
   static __pluginsMap;
-  __pluginsMap;
   static MAX_CAUSES_DEPTH = 99;
   static _plugins = [];
   static _resolvedPlugin;
@@ -164,122 +182,102 @@ class Error0 extends Error {
     this.name = "Error0";
     const ctor = this.constructor;
     const plugin = ctor._getResolvedPlugin();
-    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
-        }),
+        get: () => this._resolveByKey(key, plugin),
         set: (value) => {
-          ownStore[key] = value;
+          this.assign({ [key]: value });
         },
         enumerable: true,
         configurable: true
       });
       if (key in input) {
-        const ownValue = input[key];
-        ownStore[key] = typeof prop.init === "function" ? prop.init(ownValue) : ownValue;
+        const inputValue = input[key];
+        const ownValue = typeof prop.init === "function" ? prop.init(inputValue) : inputValue;
+        this.assign({ [key]: ownValue });
       }
     }
+    Error0.fixStack(input.cause);
   }
-  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) {
-      return Object.prototype.hasOwnProperty.call(ownStore, key);
-    }
-    return !!Object.getOwnPropertyDescriptor(object, key);
-  };
-  static _ownByKey(error, key) {
-    const ownStore = this._getOwnStore(error);
-    if (ownStore) {
-      return ownStore[key];
-    }
-    return error[key];
-  }
-  static _flowByKey(error, 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);
+  static fixStack(cause) {
+    try {
+      if (process.env.NODE_ENV !== "production") {
+        let nextCause = cause;
+        let depth = 0;
+        const maxDepth = 99;
+        while (nextCause && depth < maxDepth) {
+          ;
+          globalThis.__ERROR0_FIX_STACKTRACE__(nextCause);
+          nextCause = nextCause.cause;
+          depth++;
+        }
+      }
+    } catch {
     }
-    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 plugin.propKeys) {
-        ownValues[ownKey] = this._ownByKey(error0, ownKey);
-      }
-      return ownValues;
+      return error0.own ?? {};
     }
-    return this._ownByKey(error0, key);
-  }
-  own(key) {
-    const ctor = this.constructor;
-    if (key === void 0) {
-      return ctor.own(this);
-    }
-    return ctor._ownByKey(this, key);
+    return error0.own?.[key];
   }
   static flow(error, key) {
     const error0 = this.from(error);
-    return this._flowByKey(error0, key);
+    return error0.flow(key);
   }
   flow(key) {
-    const ctor = this.constructor;
-    return ctor._flowByKey(this, key);
+    const causes = this.causes(true);
+    const values = new Array(causes.length);
+    for (let i = 0; i < causes.length; i += 1) {
+      values[i] = causes[i].own?.[key];
+    }
+    return values;
   }
-  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;
+  _resolveByKeyCache = /* @__PURE__ */ new Map();
+  _resolveByKey(key, plugin) {
+    const error = this;
+    if (this._resolveByKeyCache.has(key)) {
+      return this._resolveByKeyCache.get(key);
     }
+    const value = (() => {
+      try {
+        const options = {
+          get flow() {
+            return error.flow(key);
+          },
+          own: error.own?.[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;
+      }
+    })();
+    this._resolveByKeyCache.set(key, value);
+    return value;
   }
   static resolve(error) {
-    const error0 = this.from(error);
+    return this.from(error).resolve();
+  }
+  resolve() {
+    const ctor = this.constructor;
+    const plugin = ctor._getResolvedPlugin();
     const resolved = {};
-    const plugin = this._getResolvedPlugin();
     for (const key of plugin.propKeys) {
-      resolved[key] = this._resolveByKey(error0, key, plugin);
+      resolved[key] = this._resolveByKey(key, plugin);
     }
     return resolved;
   }
-  resolve() {
-    const ctor = this.constructor;
-    return ctor.resolve(this);
-  }
   static causes(error, instancesOnly) {
     const causes = [];
     let current = error;
@@ -324,14 +322,27 @@ class Error0 extends Error {
     return this._fromNonError0(error);
   }
   static round(error, isPublic = false) {
-    return this.from(this.serialize(error, isPublic));
+    return this.from(error).round(isPublic);
+  }
+  round(isPublic = true) {
+    const ctor = this.constructor;
+    return ctor.from(this.serialize(isPublic));
+  }
+  static assign(error, props) {
+    const error0 = this.from(error);
+    return error0.assign(props);
+  }
+  assign(props) {
+    this.own = Object.assign(this.own ?? {}, props);
+    this._resolveByKeyCache.clear();
+    return this;
   }
   static _applyAdapt(error) {
     const plugin = this._getResolvedPlugin();
     for (const adapt of plugin.adapt) {
       const adapted = adapt(error);
       if (adapted && typeof adapted === "object") {
-        Object.assign(error, adapted);
+        error.assign(adapted);
       }
     }
     return error;
@@ -478,7 +489,7 @@ class Error0 extends Error {
         throw new Error(RESERVED_MESSAGE_PROP_ERROR);
       }
       return this._useWithPlugin({
-        props: { [key]: value }
+        props: { [key]: fromPropOptionsDefinition(value) }
       });
     }
     return this._useWithPlugin({
@@ -489,9 +500,12 @@ class Error0 extends Error {
     return new PluginError0();
   }
   static serialize(error, isPublic = true) {
-    const error0 = this.from(error);
-    const plugin = this._getResolvedPlugin();
-    const resolveByKey = (targetError, key, targetPlugin) => this._resolveByKey(targetError, key, targetPlugin);
+    return this.from(error).serialize(isPublic);
+  }
+  serialize(isPublic = true) {
+    const error0 = this;
+    const ctor = error0.constructor;
+    const plugin = ctor._getResolvedPlugin();
     const messagePlugin = plugin.message;
     let serializedMessage = error0.message;
     try {
@@ -514,15 +528,13 @@ class Error0 extends Error {
       }
       try {
         const options = {
-          get own() {
-            return error0.own(key);
-          },
           get flow() {
             return error0.flow(key);
           },
           get resolved() {
-            return resolveByKey(error0, key, plugin);
+            return error0._resolveByKey(key, plugin);
           },
+          own: error0.own?.[key],
           error: error0,
           isPublic
         };
@@ -555,8 +567,8 @@ class Error0 extends Error {
           cause: error0.cause,
           error: error0,
           isPublic,
-          is: (cause) => this.is(cause),
-          serialize: (cause) => this.serialize(cause, isPublic)
+          is: (cause) => ctor.is(cause),
+          serialize: (cause) => ctor.serialize(cause, isPublic)
         });
         if (serializedCause !== void 0) {
           json.cause = serializedCause;
@@ -567,14 +579,6 @@ class Error0 extends Error {
     }
     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,