@devp0nt/error0 1.0.0-next.5 → 1.0.0-next.51

package/dist/esm/index.js

@@ -1,400 +1,589 @@
-import { Meta0 } from "@devp0nt/meta0";
-import { HttpStatusCode, isAxiosError } from "axios";
-import get from "lodash/get.js";
-import { ZodError } from "zod";
-const isFilled = (value) => value !== null && value !== void 0 && value !== "";
-class Error0 extends Error {
-  __I_AM_ERROR_0 = true;
-  tag;
-  code;
-  httpStatus;
-  expected;
-  clientMessage;
-  anyMessage;
-  cause;
-  meta;
-  zodError;
-  axiosError;
-  static defaultMessage = "Unknown error";
-  static defaultCode;
-  static defaultHttpStatus;
-  static defaultExpected;
-  static defaultClientMessage;
-  static defaultMeta;
-  propsOriginal;
-  constructor(...args) {
-    const input = {};
-    if (args[0] instanceof Error) {
-      input.cause = args[0];
-    } else if (typeof args[0] === "object" && args[0] !== null) {
-      Object.assign(input, args[0]);
-    } else if (typeof args[0] === "string") {
-      input.message = args[0];
-    }
-    if (typeof args[1] === "object" && args[1] !== null) {
-      Object.assign(input, args[1]);
-    }
-    const safeInput = Error0._safeParseInput(input);
-    const message = safeInput.message || Error0.defaultMessage;
-    super(message);
-    Object.setPrototypeOf(this, this.constructor.prototype);
-    this.name = "Error0";
-    this.propsOriginal = this.constructor._getSelfGeneralProps({
-      error0Input: safeInput,
-      message,
-      stack: safeInput.stack || this.stack
-    });
-    const causesProps = this.constructor._getCausesPropsFromError0Props(
-      this.propsOriginal,
-      this.constructor.defaultMaxLevel
-    );
-    const propsFloated = this.constructor._getSelfPropsFloated(causesProps);
-    this.tag = propsFloated.tag;
-    this.code = propsFloated.code;
-    this.httpStatus = propsFloated.httpStatus;
-    this.expected = propsFloated.expected;
-    this.clientMessage = propsFloated.clientMessage;
-    this.cause = propsFloated.cause;
-    this.stack = propsFloated.stack;
-    this.meta = propsFloated.meta;
-    this.zodError = propsFloated.zodError;
-    this.axiosError = propsFloated.axiosError;
-  }
-  // settings
-  static defaultMaxLevel = 10;
-  // props
-  static _safeParseInput(error0Input) {
-    const result = {};
-    result.message = typeof error0Input.message === "string" ? error0Input.message : void 0;
-    result.tag = typeof error0Input.tag === "string" ? error0Input.tag : void 0;
-    result.code = typeof error0Input.code === "string" ? error0Input.code : void 0;
-    result.httpStatus = typeof error0Input.httpStatus === "number" || typeof error0Input.httpStatus === "string" ? error0Input.httpStatus : void 0;
-    result.expected = typeof error0Input.expected === "function" || typeof error0Input.expected === "boolean" ? error0Input.expected : void 0;
-    result.clientMessage = typeof error0Input.clientMessage === "string" ? error0Input.clientMessage : void 0;
-    result.cause = error0Input.cause;
-    result.stack = typeof error0Input.stack === "string" ? error0Input.stack : void 0;
-    result.meta = error0Input.meta instanceof Meta0 ? error0Input.meta : typeof error0Input.meta === "object" && error0Input.meta !== null ? error0Input.meta : void 0;
-    result.zodError = error0Input.zodError instanceof ZodError ? error0Input.zodError : void 0;
-    result.axiosError = isAxiosError(error0Input.axiosError) ? error0Input.axiosError : void 0;
-    return result;
-  }
-  static _getSelfGeneralProps({
-    error0Input,
-    message,
-    stack
-  }) {
-    const meta0 = Meta0.extend(error0Input.meta, this.defaultMeta);
-    const meta = meta0.getValue();
-    const finalTag = meta0.getFinalTag(error0Input.tag);
-    const clientMessage = error0Input.clientMessage || this.defaultClientMessage;
-    const result = {
-      message: error0Input.message || this.defaultMessage,
-      tag: finalTag,
-      code: error0Input.code || meta.code || this.defaultCode,
-      httpStatus: typeof error0Input.httpStatus === "number" ? error0Input.httpStatus : error0Input.httpStatus && typeof error0Input.httpStatus === "string" && error0Input.httpStatus in HttpStatusCode ? HttpStatusCode[error0Input.httpStatus] : meta.httpStatus || this.defaultHttpStatus,
-      expected: void 0,
-      clientMessage,
-      anyMessage: clientMessage || message,
-      cause: error0Input.cause,
-      stack: void 0,
-      meta,
-      zodError: error0Input.zodError,
-      axiosError: error0Input.axiosError
+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';
+class PluginError0 {
+  _plugin;
+  Infer = void 0;
+  constructor(plugin) {
+    this._plugin = {
+      props: { ...plugin?.props ?? {} },
+      methods: { ...plugin?.methods ?? {} },
+      adapt: [...plugin?.adapt ?? []],
+      stack: plugin?.stack,
+      cause: plugin?.cause,
+      message: plugin?.message
     };
-    result.expected = this._normalizeSelfExpected(
-      result,
-      typeof error0Input.expected === "boolean" || typeof error0Input.expected === "function" ? error0Input.expected : meta.expected || this.defaultExpected
-    );
-    result.stack = this._removeConstructorStackPart(stack);
-    return result;
-  }
-  static _getSelfPropsFloated(causesProps) {
-    const cause = this._getClosestPropValue(causesProps, "cause");
-    const stack = this._mergeStack(causesProps[1]?.stack, causesProps[0]?.stack);
-    const closestTag = this._getClosestPropValue(causesProps, "tag");
-    const meta = this._getMergedMetaValue(causesProps);
-    const tag = Meta0.getFinalTag(meta, closestTag);
-    const propsFloated = {
-      message: this._getClosestPropValue(causesProps, "message"),
-      tag,
-      code: this._getClosestPropValue(causesProps, "code"),
-      httpStatus: this._getClosestPropValue(causesProps, "httpStatus"),
-      expected: this._isExpected(causesProps),
-      clientMessage: this._getClosestPropValue(causesProps, "clientMessage"),
-      cause,
-      stack,
-      anyMessage: causesProps[0].anyMessage,
-      meta,
-      zodError: this._getClosestPropValue(causesProps, "zodError"),
-      axiosError: this._getClosestPropValue(causesProps, "axiosError")
-    };
-    return propsFloated;
   }
-  // sepcial
-  static _getExtraError0PropsByZodError(zodError) {
-    return {
-      message: `Zod Validation Error: ${zodError.message}`
-    };
+  prop(key, value) {
+    return this.use("prop", key, value);
   }
-  static _getExtraError0PropsByAxiosError(axiosError) {
-    return {
-      message: "Axios Error",
-      meta: {
-        axiosData: (() => {
-          try {
-            return JSON.stringify(axiosError.response?.data);
-          } catch {
-            return void 0;
-          }
-        })(),
-        axiosStatus: axiosError.response?.status
-      }
-    };
+  method(key, value) {
+    return this.use("method", key, value);
   }
-  static _assignError0Props(error0Props, extraError0Props) {
-    const metaValue = Meta0.mergeValues(error0Props.meta, extraError0Props.meta);
-    Object.assign(error0Props, extraError0Props, { meta: metaValue });
+  adapt(value) {
+    return this.use("adapt", value);
   }
-  // expected
-  static _normalizeSelfExpected(error0Props, expectedProvided) {
-    if (typeof expectedProvided === "function") {
-      return expectedProvided(error0Props);
-    }
-    return expectedProvided;
+  stack(value) {
+    return this.use("stack", value);
   }
-  static _isExpected(causesProps) {
-    let hasExpectedTrue = false;
-    for (const causeProps of causesProps) {
-      if (causeProps.expected === false) {
-        return false;
+  cause(value) {
+    return this.use("cause", value);
+  }
+  message(value) {
+    return this.use("message", value);
+  }
+  use(kind, keyOrValue, value) {
+    const nextProps = { ...this._plugin.props ?? {} };
+    const nextMethods = { ...this._plugin.methods ?? {} };
+    const nextAdapt = [...this._plugin.adapt ?? []];
+    let nextStack = this._plugin.stack;
+    let nextCause = this._plugin.cause;
+    let nextMessage = this._plugin.message;
+    if (kind === "prop") {
+      const key = keyOrValue;
+      if (key === "stack") {
+        throw new Error(RESERVED_STACK_PROP_ERROR);
+      }
+      if (key === "message") {
+        throw new Error(RESERVED_MESSAGE_PROP_ERROR);
       }
-      if (causeProps.expected === true) {
-        hasExpectedTrue = true;
+      if (value === void 0) {
+        throw new Error('PluginError0.use("prop", key, value) requires value');
       }
+      nextProps[key] = value;
+    } else if (kind === "method") {
+      const key = keyOrValue;
+      if (value === void 0) {
+        throw new Error('PluginError0.use("method", key, value) requires value');
+      }
+      nextMethods[key] = value;
+    } else if (kind === "adapt") {
+      nextAdapt.push(keyOrValue);
+    } else if (kind === "stack") {
+      nextStack = keyOrValue;
+    } else if (kind === "cause") {
+      nextCause = keyOrValue;
+    } else {
+      nextMessage = keyOrValue;
     }
-    return hasExpectedTrue;
+    return new PluginError0({
+      props: nextProps,
+      methods: nextMethods,
+      adapt: nextAdapt,
+      stack: nextStack,
+      cause: nextCause,
+      message: nextMessage
+    });
   }
-  // getters
-  static _getPropsFromUnknown(error, defaults) {
-    if (typeof error !== "object" || error === null) {
-      return {
-        message: void 0,
-        tag: void 0,
-        code: void 0,
-        httpStatus: void 0,
-        expected: void 0,
-        clientMessage: void 0,
-        anyMessage: this.defaultMessage,
-        cause: void 0,
-        stack: void 0,
-        zodError: void 0,
-        axiosError: void 0,
-        meta: {}
-      };
-    }
-    const message = "message" in error && typeof error.message === "string" ? error.message : void 0;
-    const clientMessage = "clientMessage" in error && typeof error.clientMessage === "string" ? error.clientMessage : defaults?.clientMessage || void 0;
-    const result = {
-      message,
-      code: "code" in error && typeof error.code === "string" ? error.code : defaults?.code || void 0,
-      clientMessage,
-      anyMessage: clientMessage || message || this.defaultMessage,
-      expected: void 0,
-      stack: "stack" in error && typeof error.stack === "string" ? error.stack : void 0,
-      tag: "tag" in error && typeof error.tag === "string" ? error.tag : defaults?.tag || void 0,
-      cause: "cause" in error ? error.cause : defaults?.cause || void 0,
-      meta: "meta" in error && typeof error.meta === "object" && error.meta !== null ? Meta0.getValue(error.meta) : Meta0.getValue(defaults?.meta) || {},
-      httpStatus: "httpStatus" in error && typeof error.httpStatus === "number" && error.httpStatus in HttpStatusCode ? error.httpStatus : typeof defaults?.httpStatus === "string" ? HttpStatusCode[defaults.httpStatus] : defaults?.httpStatus,
-      zodError: "zodError" in error && error.zodError instanceof ZodError ? error.zodError : error instanceof ZodError ? error : defaults?.zodError,
-      axiosError: "axiosError" in error && isAxiosError(error.axiosError) ? error.axiosError : isAxiosError(error) ? error : defaults?.axiosError
+}
+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,
+    propKeys: [],
+    propEntries: [],
+    methodEntries: []
+  };
+  static _indexResolvedPlugin(resolved) {
+    return {
+      ...resolved,
+      propKeys: Object.keys(resolved.props),
+      propEntries: Object.entries(resolved.props),
+      methodEntries: Object.entries(resolved.methods)
     };
-    result.expected = this._normalizeSelfExpected(
-      result,
-      "expected" in error && (typeof error.expected === "boolean" || typeof error.expected === "function") ? error.expected : defaults?.expected || void 0
-    );
-    if (result.zodError) {
-      this._assignError0Props(result, this._getExtraError0PropsByZodError(result.zodError));
+  }
+  static _applyPlugin(resolved, plugin) {
+    if (plugin.props && "stack" in plugin.props) {
+      throw new Error(RESERVED_STACK_PROP_ERROR);
     }
-    if (result.axiosError) {
-      this._assignError0Props(result, this._getExtraError0PropsByAxiosError(result.axiosError));
+    if (plugin.props && "message" in plugin.props) {
+      throw new Error(RESERVED_MESSAGE_PROP_ERROR);
     }
-    return result;
-  }
-  static _getCausesPropsFromUnknown(error, maxLevel) {
-    if (!error) {
-      return [];
+    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;
     }
-    const causeProps = this._getPropsFromUnknown(error);
-    const causesProps = [causeProps];
-    if (!causeProps.cause) {
-      return causesProps;
+    if (typeof plugin.cause !== "undefined") {
+      resolved.cause = plugin.cause;
     }
-    if (maxLevel > 0) {
-      causesProps.push(...this._getCausesPropsFromUnknown(this._getPropsFromUnknown(causeProps.cause), maxLevel - 1));
+    if (typeof plugin.message !== "undefined") {
+      resolved.message = plugin.message;
     }
-    return causesProps;
   }
-  static _getCausesPropsFromError0Props(error0Props, maxLevel) {
-    return [error0Props, ...this._getCausesPropsFromUnknown(error0Props.cause, maxLevel - 1)];
+  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: [],
+      propKeys: [],
+      propEntries: [],
+      methodEntries: []
+    };
+    for (const plugin of this._plugins) {
+      this._applyPlugin(resolved, plugin);
+    }
+    const indexed = this._indexResolvedPlugin(resolved);
+    Object.defineProperty(this, "_resolvedPlugin", {
+      value: indexed,
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+    return indexed;
   }
-  static _getClosestPropValue(causesProps, propKey) {
-    for (const causeProps of causesProps) {
-      const propValue = causeProps[propKey];
-      if (isFilled(propValue)) {
-        return propValue;
+  constructor(...args) {
+    const [first, second] = args;
+    const input = typeof first === "string" ? { message: first, ...second ?? {} } : first;
+    super(input.message, { cause: input.cause });
+    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
+        }),
+        set: (value) => {
+          ownStore[key] = value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      if (key in input) {
+        const ownValue = input[key];
+        ownStore[key] = typeof prop.init === "function" ? prop.init(ownValue) : ownValue;
       }
     }
+  }
+  static _getOwnStore(object) {
+    const record = object;
+    const existing = record[OWN_SYMBOL];
+    if (existing && typeof existing === "object") {
+      return existing;
+    }
     return void 0;
   }
-  // private static getClosestByGetter<TResult>(
-  //   causesProps: Error0GeneralProps[],
-  //   getter: (props: Error0GeneralProps) => TResult,
-  // ): NonNullable<TResult> | undefined {
-  //   for (const causeProps of causesProps) {
-  //     const result = getter(causeProps)
-  //     if (isFilled(result)) {
-  //       return result
-  //     }
-  //   }
-  //   return undefined
-  // }
-  static _getFilledPropValues(causesProps, propKey) {
-    const values = [];
-    for (const causeProps of causesProps) {
-      const propValue = causeProps[propKey];
-      if (isFilled(propValue)) {
-        values.push(propValue);
-      }
+  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);
     }
     return values;
   }
-  static _getMergedMetaValue(causesProps) {
-    const metas = this._getFilledPropValues(causesProps, "meta");
-    if (metas.length === 0) {
-      return {};
-    } else if (metas.length === 1) {
-      return metas[0];
-    } else {
-      return Meta0.mergeValues(metas[0], ...metas.slice(1));
+  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 this._ownByKey(error0, key);
   }
-  // stack
-  static _removeConstructorStackPart(stack) {
-    if (!stack) {
-      return stack;
+  own(key) {
+    const ctor = this.constructor;
+    if (key === void 0) {
+      return ctor.own(this);
     }
-    let lines = stack.split("\n");
-    const removeAllLinesContains = (search) => {
-      lines = lines.filter((line) => !line.includes(search));
-    };
-    removeAllLinesContains("at new Error0");
-    removeAllLinesContains("at _toError0");
-    removeAllLinesContains("at Error0.from");
-    removeAllLinesContains("at Error0._toError0");
-    return lines.join("\n");
+    return ctor._ownByKey(this, key);
+  }
+  static flow(error, key) {
+    const error0 = this.from(error);
+    return this._flowByKey(error0, key);
   }
-  static _mergeStack(prevStack, nextStack) {
-    return [nextStack, prevStack].filter(Boolean).join("\n\n") || void 0;
+  flow(key) {
+    const ctor = this.constructor;
+    return ctor._flowByKey(this, key);
   }
-  // transformations
-  static isError0(error) {
-    return error instanceof Error0;
+  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 isLikelyError0(error) {
-    if (error instanceof Error0) {
-      return true;
+  static resolve(error) {
+    const error0 = this.from(error);
+    const resolved = {};
+    const plugin = this._getResolvedPlugin();
+    for (const key of plugin.propKeys) {
+      resolved[key] = this._resolveByKey(error0, key, plugin);
     }
-    if (typeof error === "object" && error !== null) {
-      if ("__I_AM_ERROR_0" in error && error.__I_AM_ERROR_0 === true) {
-        return true;
+    return resolved;
+  }
+  resolve() {
+    const ctor = this.constructor;
+    return ctor.resolve(this);
+  }
+  static causes(error, instancesOnly) {
+    const causes = [];
+    let current = error;
+    const seen = /* @__PURE__ */ new Set();
+    let depth = 0;
+    while (depth < this.MAX_CAUSES_DEPTH) {
+      if (seen.has(current)) {
+        break;
+      }
+      seen.add(current);
+      if (!instancesOnly || this.is(current)) {
+        causes.push(current);
       }
+      if (!current || typeof current !== "object") {
+        break;
+      }
+      current = current.cause;
+      depth += 1;
+    }
+    return causes;
+  }
+  causes(instancesOnly) {
+    const ctor = this.constructor;
+    if (instancesOnly) {
+      return ctor.causes(this, true);
     }
-    return false;
+    return ctor.causes(this);
   }
-  static _toError0(error, inputOverride = {}) {
-    if (error instanceof Error0) {
+  static is(error) {
+    return error instanceof this;
+  }
+  static isSerialized(error) {
+    return !this.is(error) && typeof error === "object" && error !== null && "name" in error && error.name === "Error0";
+  }
+  static from(error) {
+    if (this.is(error)) {
       return error;
     }
-    if (typeof error === "string") {
-      return new Error0(error, inputOverride);
+    if (this.isSerialized(error)) {
+      return this._fromSerialized(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) {
+      const adapted = adapt(error);
+      if (adapted && typeof adapted === "object") {
+        Object.assign(error, adapted);
+      }
+    }
+    return error;
+  }
+  static _fromSerialized(error) {
+    const message = this._extractMessage(error);
     if (typeof error !== "object" || error === null) {
-      return new Error0({
-        message: this.defaultMessage,
-        ...inputOverride
-      });
+      return this._applyAdapt(new this(message, { cause: error }));
     }
-    const inputFromData = get(error, "data");
-    if (inputFromData) {
-      if (Error0.isLikelyError0(inputFromData)) {
-        return this._toError0(inputFromData, inputOverride);
+    const errorRecord = error;
+    const recreated = new this(message);
+    const plugin = this._getResolvedPlugin();
+    for (const [key, prop] of plugin.propEntries) {
+      if (prop.deserialize === false) {
+        continue;
+      }
+      if (!(key in errorRecord)) {
+        continue;
+      }
+      try {
+        const value = prop.deserialize({ value: errorRecord[key], record: errorRecord });
+        recreated[key] = value;
+      } catch {
+        console.error(`Error0: failed to deserialize property ${key}`, errorRecord);
       }
     }
-    const inputFromDataError0 = get(error, "data.error0");
-    if (inputFromDataError0) {
-      if (Error0.isLikelyError0(inputFromDataError0)) {
-        return this._toError0(inputFromDataError0, inputOverride);
+    if ("stack" in errorRecord) {
+      try {
+        if (typeof errorRecord.stack === "string") {
+          recreated.stack = errorRecord.stack;
+        }
+      } catch {
+        console.error("Error0: failed to deserialize stack", errorRecord);
       }
     }
-    return new Error0(this._getPropsFromUnknown(error, inputOverride));
+    const causePlugin = plugin.cause;
+    if (causePlugin && "cause" in errorRecord) {
+      try {
+        ;
+        recreated.cause = causePlugin.deserialize({
+          cause: errorRecord.cause,
+          error: errorRecord,
+          isSerialized: (serializedCause) => this.isSerialized(serializedCause),
+          fromSerialized: (serializedCause) => this._fromSerialized(serializedCause)
+        });
+      } catch {
+        console.error("Error0: failed to deserialize cause", errorRecord);
+      }
+    }
+    return recreated;
   }
-  static from(error, inputOverride) {
-    return this._toError0(error, inputOverride);
+  static _fromNonError0(error) {
+    const message = this._extractMessage(error);
+    return this._applyAdapt(new this(message, { cause: error }));
   }
-  static extend(props) {
-    const parent = this;
-    return class Error0 extends parent {
-      static defaultMessage = props.defaultMessage ?? parent.defaultMessage;
-      static defaultCode = props.defaultCode ?? parent.defaultCode;
-      static defaultHttpStatus = props.defaultHttpStatus ?? parent.defaultHttpStatus;
-      static defaultExpected = props.defaultExpected ?? parent.defaultExpected;
-      static defaultClientMessage = props.defaultClientMessage ?? parent.defaultClientMessage;
-      static defaultMeta = Meta0.extend(props.defaultMeta, parent.defaultMeta);
-    };
+  static _extractMessage(error) {
+    return (typeof error === "string" ? error : typeof error === "object" && error !== null && "message" in error && typeof error.message === "string" ? error.message : void 0) || "Unknown error";
   }
-  static extendCollection(classes, props) {
-    return Object.fromEntries(Object.entries(classes).map(([name, Class]) => [name, Class.extend(props)]));
+  static _useWithPlugin(plugin) {
+    const Base = this;
+    const Error0Extended = class Error0 extends Base {
+    };
+    Error0Extended._plugins = [...Base._plugins, plugin];
+    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);
+        },
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(Error0Extended, key, {
+        value: function(error, ...args) {
+          return method(this.from(error), ...args);
+        },
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+    }
+    return Error0Extended;
   }
-  toJSON() {
+  static _pluginFromBuilder(plugin) {
+    const pluginRecord = plugin;
     return {
-      message: this.message,
-      tag: this.tag,
-      code: this.code,
-      httpStatus: this.httpStatus,
-      expected: this.expected,
-      clientMessage: this.clientMessage,
-      anyMessage: this.anyMessage,
-      cause: this.cause,
-      meta: Meta0.getValue(this.meta),
-      stack: this.stack,
-      __I_AM_ERROR_0: this.__I_AM_ERROR_0
+      props: { ...pluginRecord._plugin.props ?? {} },
+      methods: { ...pluginRecord._plugin.methods ?? {} },
+      adapt: [...pluginRecord._plugin.adapt ?? []],
+      stack: pluginRecord._plugin.stack,
+      cause: pluginRecord._plugin.cause,
+      message: pluginRecord._plugin.message
     };
   }
-  static toJSON(error, inputOverride) {
-    const error0 = this.from(error, inputOverride);
-    return error0.toJSON();
+  static use(first, key, value) {
+    if (first instanceof PluginError0) {
+      return this._useWithPlugin(this._pluginFromBuilder(first));
+    }
+    if (first === "stack") {
+      if (typeof key === "undefined") {
+        throw new Error('Error0.use("stack", value) requires stack plugin value');
+      }
+      if (typeof key !== "object" || key === null || typeof key.serialize !== "function") {
+        throw new Error('Error0.use("stack", value) expects { serialize: function }');
+      }
+      return this._useWithPlugin({
+        stack: key
+      });
+    }
+    if (first === "cause") {
+      if (typeof key === "undefined") {
+        throw new Error('Error0.use("cause", value) requires cause plugin value');
+      }
+      if (typeof key !== "object" || key === null || typeof key.serialize !== "function" || typeof key.deserialize !== "function") {
+        throw new Error('Error0.use("cause", value) expects { serialize: function, deserialize: function }');
+      }
+      return this._useWithPlugin({
+        cause: key
+      });
+    }
+    if (first === "message") {
+      if (typeof key === "undefined") {
+        throw new Error('Error0.use("message", value) requires message plugin value');
+      }
+      if (typeof key !== "object" || key === null || typeof key.serialize !== "function") {
+        throw new Error('Error0.use("message", value) expects { serialize: function }');
+      }
+      return this._useWithPlugin({
+        message: key
+      });
+    }
+    if (first === "adapt") {
+      if (typeof key !== "function") {
+        throw new Error('Error0.use("adapt", value) requires adapt function');
+      }
+      return this._useWithPlugin({
+        adapt: [key]
+      });
+    }
+    if (typeof key !== "string" || value === void 0) {
+      throw new Error("Error0.use(kind, key, value) requires key and value");
+    }
+    if (first === "prop") {
+      if (key === "stack") {
+        throw new Error(RESERVED_STACK_PROP_ERROR);
+      }
+      if (key === "message") {
+        throw new Error(RESERVED_MESSAGE_PROP_ERROR);
+      }
+      return this._useWithPlugin({
+        props: { [key]: value }
+      });
+    }
+    return this._useWithPlugin({
+      methods: { [key]: value }
+    });
+  }
+  static plugin() {
+    return new PluginError0();
   }
-  toResponse(data) {
-    return Response.json(
-      {
-        ...this.toJSON(),
-        ...data
-      },
-      {
-        status: this.httpStatus,
-        statusText: this.message
+  static serialize(error, isPublic = true) {
+    const error0 = this.from(error);
+    const plugin = this._getResolvedPlugin();
+    const resolveByKey = (targetError, key, targetPlugin) => this._resolveByKey(targetError, key, targetPlugin);
+    const messagePlugin = plugin.message;
+    let serializedMessage = error0.message;
+    try {
+      if (messagePlugin) {
+        serializedMessage = messagePlugin.serialize({ value: error0.message, error: error0, isPublic });
       }
-    );
+    } catch {
+      console.error("Error0: failed to serialize message", error0);
+      serializedMessage = error0.message;
+    }
+    const json = {
+      name: error0.name
+    };
+    if (serializedMessage !== void 0) {
+      json.message = serializedMessage;
+    }
+    for (const [key, prop] of plugin.propEntries) {
+      if (prop.serialize === false) {
+        continue;
+      }
+      try {
+        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}`, error0);
+      }
+    }
+    const stackPlugin = plugin.stack;
+    try {
+      let serializedStack;
+      if (stackPlugin) {
+        serializedStack = stackPlugin.serialize({ value: error0.stack, error: error0, isPublic });
+      } else {
+        serializedStack = isPublic ? void 0 : error0.stack;
+      }
+      if (serializedStack !== void 0) {
+        json.stack = serializedStack;
+      }
+    } catch {
+      console.error("Error0: failed to serialize stack", error0);
+    }
+    const causePlugin = plugin.cause;
+    if (causePlugin?.serialize) {
+      try {
+        const serializedCause = causePlugin.serialize({
+          cause: error0.cause,
+          error: error0,
+          isPublic,
+          is: (cause) => this.is(cause),
+          serialize: (cause) => this.serialize(cause, isPublic)
+        });
+        if (serializedCause !== void 0) {
+          json.cause = serializedCause;
+        }
+      } catch {
+        console.error("Error0: failed to serialize cause", error0);
+      }
+    }
+    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);
   }
 }
-const e0s = {
-  Default: Error0,
-  Expected: Error0.extend({
-    defaultExpected: true
-  })
-};
 export {
   Error0,
-  e0s
+  PluginError0
 };
 //# sourceMappingURL=index.js.map