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

package/dist/cjs/index.d.cts

@@ -34,18 +34,30 @@ type ErrorPluginPropOptions<TInputValue = undefined, TOutputValue = unknown, TEr
 type ErrorPluginMethodFn<TOutputValue, TArgs extends unknown[] = unknown[], TError extends Error0 = Error0> = (error: TError, ...args: TArgs) => TOutputValue;
 type ErrorPluginAdaptResult<TOutputProps extends Record<string, unknown>> = Partial<TOutputProps> | undefined;
 type ErrorPluginAdaptFn<TError extends Error0 = Error0, TOutputProps extends Record<string, unknown> = Record<never, never>> = ((error: TError) => void) | ((error: TError) => ErrorPluginAdaptResult<TOutputProps>);
-type ErrorPluginStackSerialize<TError extends Error0> = ((options: {
+type ErrorPluginStackSerialize<TError extends Error0> = (options: {
     value: string | undefined;
     error: TError;
     isPublic: boolean;
-}) => unknown) | boolean | 'merge';
-type ErrorPluginStack<TError extends Error0 = Error0> = ErrorPluginStackSerialize<TError>;
-type ErrorPluginCauseSerialize<TError extends Error0> = ((options: {
+}) => unknown;
+type ErrorPluginStack<TError extends Error0 = Error0> = {
+    serialize: ErrorPluginStackSerialize<TError>;
+};
+type ErrorPluginCauseSerialize<TError extends Error0> = (options: {
     value: unknown;
     error: TError;
     isPublic: boolean;
-}) => unknown) | boolean;
-type ErrorPluginCause<TError extends Error0 = Error0> = ErrorPluginCauseSerialize<TError>;
+}) => unknown;
+type ErrorPluginCause<TError extends Error0 = Error0> = {
+    serialize: ErrorPluginCauseSerialize<TError>;
+};
+type ErrorPluginMessageSerialize<TError extends Error0> = (options: {
+    value: string;
+    error: TError;
+    isPublic: boolean;
+}) => unknown;
+type ErrorPluginMessage<TError extends Error0 = Error0> = {
+    serialize: ErrorPluginMessageSerialize<TError>;
+};
 type ErrorMethodRecord = {
     args: unknown[];
     output: unknown;
@@ -62,6 +74,7 @@ type ErrorPlugin<TProps extends ErrorPluginProps = Record<never, never>, TMethod
     adapt?: Array<ErrorPluginAdaptFn<Error0, PluginOutputProps<TProps>>>;
     stack?: ErrorPluginStack;
     cause?: ErrorPluginCause;
+    message?: ErrorPluginMessage;
 };
 type AddPropToPluginProps<TProps extends ErrorPluginProps, TKey extends string, TInputValue, TOutputValue, TResolveValue extends TOutputValue | undefined = TOutputValue | undefined> = TProps & Record<TKey, ErrorPluginPropOptions<TInputValue, TOutputValue, Error0, TResolveValue>>;
 type AddMethodToPluginMethods<TMethods extends ErrorPluginMethods, TKey extends string, TArgs extends unknown[], TOutputValue> = TMethods & Record<TKey, ErrorPluginMethodFn<TOutputValue, TArgs>>;
@@ -148,9 +161,7 @@ type PluginsMapOf<TClass> = TClass extends {
     __pluginsMap?: infer TPluginsMap;
 } ? TPluginsMap extends ErrorPluginsMap ? TPluginsMap : EmptyPluginsMap : EmptyPluginsMap;
 type PluginsMapOfInstance<TInstance> = TInstance extends {
-    constructor: {
-        __pluginsMap?: infer TPluginsMap;
-    };
+    __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>;
@@ -168,17 +179,23 @@ declare class PluginError0<TProps extends ErrorPluginProps = Record<never, never
     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, TArgs extends unknown[], TOutputValue>(kind: 'method', key: TKey, value: ErrorPluginMethodFn<TOutputValue, TArgs, BuilderError0<TProps, TMethods>>): PluginError0<TProps, AddMethodToPluginMethods<TMethods, TKey, TArgs, TOutputValue>>;
     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 ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> = {
-    new (message: string, input?: ErrorInput<TPluginsMap>): Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap>;
+    new (message: string, input?: ErrorInput<TPluginsMap>): Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap> & {
+        readonly __pluginsMap?: TPluginsMap;
+    };
     new (input: {
         message: string;
-    } & ErrorInput<TPluginsMap>): Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap>;
+    } & ErrorInput<TPluginsMap>): Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap> & {
+        readonly __pluginsMap?: TPluginsMap;
+    };
     readonly __pluginsMap?: TPluginsMap;
     from: (error: unknown) => Error0 & ErrorResolved<TPluginsMap> & ErrorOwnMethods<TPluginsMap> & ErrorResolveMethods<TPluginsMap>;
     resolve: (error: unknown) => ErrorResolvedProps<TPluginsMap>;
@@ -188,11 +205,6 @@ type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> = {
         <TKey extends keyof TPluginsMap['props'] & string>(error: object, key: TKey): ErrorOwnProps<TPluginsMap>[TKey];
     };
     flow: <TKey extends keyof TPluginsMap['props'] & string>(error: object, key: TKey) => Array<ErrorOwnProps<TPluginsMap>[TKey]>;
-    prop: <TKey extends string, TInputValue = undefined, TOutputValue = unknown, TResolveValue extends TOutputValue | undefined = TOutputValue | undefined>(key: TKey, value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TPluginsMap>, TResolveValue>) => ClassError0<ExtendErrorPluginsMapWithProp<TPluginsMap, TKey, TInputValue, TOutputValue, TResolveValue>>;
-    method: <TKey extends string, TArgs extends unknown[], TOutputValue>(key: TKey, value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<TPluginsMap>>) => ClassError0<ExtendErrorPluginsMapWithMethod<TPluginsMap, TKey, TArgs, TOutputValue>>;
-    adapt: (value: ErrorPluginAdaptFn<ErrorInstanceOfMap<TPluginsMap>, ErrorResolvedProps<TPluginsMap>>) => ClassError0<TPluginsMap>;
-    stack: (value: ErrorPluginStack<ErrorInstanceOfMap<TPluginsMap>>) => ClassError0<TPluginsMap>;
-    cause: (value: ErrorPluginCause<ErrorInstanceOfMap<TPluginsMap>>) => ClassError0<TPluginsMap>;
     use: {
         <TBuilder extends PluginError0>(plugin: TBuilder): ClassError0<ExtendErrorPluginsMap<TPluginsMap, PluginOfBuilder<TBuilder>>>;
         <TKey extends string, TInputValue = undefined, TOutputValue = unknown, TResolveValue extends TOutputValue | undefined = TOutputValue | undefined>(kind: 'prop', key: TKey, value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TPluginsMap>, TResolveValue>): ClassError0<ExtendErrorPluginsMapWithProp<TPluginsMap, TKey, TInputValue, TOutputValue, TResolveValue>>;
@@ -200,11 +212,13 @@ type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> = {
         (kind: 'adapt', value: ErrorPluginAdaptFn<ErrorInstanceOfMap<TPluginsMap>, ErrorResolvedProps<TPluginsMap>>): ClassError0<TPluginsMap>;
         (kind: 'stack', value: ErrorPluginStack<ErrorInstanceOfMap<TPluginsMap>>): ClassError0<TPluginsMap>;
         (kind: 'cause', value: ErrorPluginCause<ErrorInstanceOfMap<TPluginsMap>>): ClassError0<TPluginsMap>;
+        (kind: 'message', value: ErrorPluginMessage<ErrorInstanceOfMap<TPluginsMap>>): ClassError0<TPluginsMap>;
     };
     plugin: () => PluginError0;
 } & ErrorStaticMethods<TPluginsMap>;
 declare class Error0 extends Error {
     static readonly __pluginsMap?: EmptyPluginsMap;
+    readonly __pluginsMap?: EmptyPluginsMap;
     protected static _plugins: ErrorPlugin[];
     private static readonly _emptyPlugin;
     private static _getResolvedPlugin;
@@ -240,20 +254,16 @@ declare class Error0 extends Error {
     private static _extractMessage;
     private static _useWithPlugin;
     private static _pluginFromBuilder;
-    static prop<TThis extends typeof Error0, TKey extends string, TInputValue = undefined, TOutputValue = unknown, TResolveValue extends TOutputValue | undefined = TOutputValue | undefined>(this: TThis, key: TKey, value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<PluginsMapOf<TThis>>, TResolveValue>): ClassError0<ExtendErrorPluginsMapWithProp<PluginsMapOf<TThis>, TKey, TInputValue, TOutputValue, TResolveValue>>;
-    static method<TThis extends typeof Error0, TKey extends string, TArgs extends unknown[], TOutputValue>(this: TThis, key: TKey, value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<PluginsMapOf<TThis>>>): ClassError0<ExtendErrorPluginsMapWithMethod<PluginsMapOf<TThis>, TKey, TArgs, TOutputValue>>;
-    static adapt<TThis extends typeof Error0>(this: TThis, value: ErrorPluginAdaptFn<ErrorInstanceOfMap<PluginsMapOf<TThis>>, ErrorResolvedProps<PluginsMapOf<TThis>>>): ClassError0<PluginsMapOf<TThis>>;
-    static stack<TThis extends typeof Error0>(this: TThis, value: ErrorPluginStack<ErrorInstanceOfMap<PluginsMapOf<TThis>>>): ClassError0<PluginsMapOf<TThis>>;
-    static cause<TThis extends typeof Error0>(this: TThis, value: ErrorPluginCause<ErrorInstanceOfMap<PluginsMapOf<TThis>>>): ClassError0<PluginsMapOf<TThis>>;
     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, TArgs extends unknown[], TOutputValue>(this: TThis, kind: 'method', key: TKey, value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<PluginsMapOf<TThis>>>): ClassError0<ExtendErrorPluginsMapWithMethod<PluginsMapOf<TThis>, TKey, TArgs, TOutputValue>>;
     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>>;
     static use<TThis extends typeof Error0>(this: TThis, kind: 'cause', value: ErrorPluginCause<ErrorInstanceOfMap<PluginsMapOf<TThis>>>): ClassError0<PluginsMapOf<TThis>>;
+    static use<TThis extends typeof Error0>(this: TThis, kind: 'message', value: ErrorPluginMessage<ErrorInstanceOfMap<PluginsMapOf<TThis>>>): ClassError0<PluginsMapOf<TThis>>;
     static plugin(): PluginError0;
     static serialize(error: unknown, isPublic?: boolean): Record<string, unknown>;
     serialize(isPublic?: boolean): Record<string, unknown>;
 }
 
-export { type ClassError0, Error0, type ErrorInput, type ErrorInputBase, type ErrorPlugin, type ErrorPluginAdaptFn, type ErrorPluginAdaptResult, type ErrorPluginCause, type ErrorPluginCauseSerialize, type ErrorPluginMethodFn, type ErrorPluginMethods, type ErrorPluginPropOptions, type ErrorPluginProps, type ErrorPluginStack, type ErrorPluginStackSerialize, type ErrorPluginsMap, type ErrorResolved, type IsEmptyObject, PluginError0 };
+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/cjs/plugins/cause-serialize.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cause_serialize_exports = {};
+__export(cause_serialize_exports, {
+  causeSerializePlugin: () => causeSerializePlugin
+});
+module.exports = __toCommonJS(cause_serialize_exports);
+var import__ = require('../index.cjs');
+const causeSerializePlugin = import__.Error0.plugin().use("cause", {
+  serialize: ({ value, error, isPublic }) => {
+    const ctor = error.constructor;
+    if (ctor.is(value)) {
+      return ctor.serialize(value, isPublic);
+    }
+    return void 0;
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  causeSerializePlugin
+});
+//# sourceMappingURL=cause-serialize.cjs.map

package/dist/cjs/plugins/cause-serialize.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/plugins/cause-serialize.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const causeSerializePlugin = Error0.plugin().use('cause', {\n  serialize: ({ value, error, isPublic }) => {\n    const ctor = error.constructor as typeof Error0\n    if (ctor.is(value)) {\n      return ctor.serialize(value, isPublic)\n    }\n    return undefined\n  },\n})\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAuB;AAEhB,MAAM,uBAAuB,gBAAO,OAAO,EAAE,IAAI,SAAS;AAAA,EAC/D,WAAW,CAAC,EAAE,OAAO,OAAO,SAAS,MAAM;AACzC,UAAM,OAAO,MAAM;AACnB,QAAI,KAAK,GAAG,KAAK,GAAG;AAClB,aAAO,KAAK,UAAU,OAAO,QAAQ;AAAA,IACvC;AACA,WAAO;AAAA,EACT;AACF,CAAC;","names":[]}

package/dist/cjs/plugins/cause-serialize.d.cts

@@ -0,0 +1,5 @@
+import { PluginError0 } from '../index.cjs';
+
+declare const causeSerializePlugin: PluginError0<Record<never, never>, Record<never, never>>;
+
+export { causeSerializePlugin };

package/dist/cjs/plugins/expected.cjs

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var expected_exports = {};
+__export(expected_exports, {
+  expectedPlugin: () => expectedPlugin
+});
+module.exports = __toCommonJS(expected_exports);
+var import__ = require('../index.cjs');
+const isExpected = (flow) => {
+  let expected = false;
+  for (const value of flow) {
+    if (value === false) {
+      return false;
+    }
+    if (value === true) {
+      expected = true;
+    }
+  }
+  return expected;
+};
+const expectedPlugin = import__.Error0.plugin().use("prop", "expected", {
+  init: (input) => input,
+  resolve: ({ flow }) => isExpected(flow),
+  serialize: ({ value }) => value,
+  deserialize: ({ value }) => typeof value === "boolean" ? value : void 0
+}).use("method", "isExpected", (error) => {
+  return isExpected(error.flow("expected"));
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  expectedPlugin
+});
+//# sourceMappingURL=expected.cjs.map

package/dist/cjs/plugins/expected.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/plugins/expected.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nconst isExpected = (flow: unknown[]) => {\n  let expected = false\n  for (const value of flow) {\n    if (value === false) {\n      return false\n    }\n    if (value === true) {\n      expected = true\n    }\n  }\n  return expected\n}\n\nexport const expectedPlugin = Error0.plugin()\n  .use('prop', 'expected', {\n    init: (input: boolean) => input,\n    resolve: ({ flow }) => isExpected(flow),\n    serialize: ({ value }) => value,\n    deserialize: ({ value }) => (typeof value === 'boolean' ? value : undefined),\n  })\n  .use('method', 'isExpected', (error) => {\n    return isExpected(error.flow('expected'))\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAuB;AAEvB,MAAM,aAAa,CAAC,SAAoB;AACtC,MAAI,WAAW;AACf,aAAW,SAAS,MAAM;AACxB,QAAI,UAAU,OAAO;AACnB,aAAO;AAAA,IACT;AACA,QAAI,UAAU,MAAM;AAClB,iBAAW;AAAA,IACb;AAAA,EACF;AACA,SAAO;AACT;AAEO,MAAM,iBAAiB,gBAAO,OAAO,EACzC,IAAI,QAAQ,YAAY;AAAA,EACvB,MAAM,CAAC,UAAmB;AAAA,EAC1B,SAAS,CAAC,EAAE,KAAK,MAAM,WAAW,IAAI;AAAA,EACtC,WAAW,CAAC,EAAE,MAAM,MAAM;AAAA,EAC1B,aAAa,CAAC,EAAE,MAAM,MAAO,OAAO,UAAU,YAAY,QAAQ;AACpE,CAAC,EACA,IAAI,UAAU,cAAc,CAAC,UAAU;AACtC,SAAO,WAAW,MAAM,KAAK,UAAU,CAAC;AAC1C,CAAC;","names":[]}

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

@@ -0,0 +1,5 @@
+import { PluginError0, ErrorPluginPropOptions, Error0, ErrorPluginMethodFn } from '../index.cjs';
+
+declare const expectedPlugin: PluginError0<Record<never, never> & Record<"expected", ErrorPluginPropOptions<boolean, boolean, Error0, boolean>>, Record<never, never> & Record<"isExpected", ErrorPluginMethodFn<boolean, [], Error0>>>;
+
+export { expectedPlugin };

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

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var message_merge_exports = {};
+__export(message_merge_exports, {
+  messageMergePlugin: () => messageMergePlugin
+});
+module.exports = __toCommonJS(message_merge_exports);
+var import__ = require('../index.cjs');
+const messageMergePlugin = import__.Error0.plugin().use("message", {
+  serialize: ({ error }) => {
+    return error.causes().map((cause) => {
+      return cause instanceof Error ? cause.message : void 0;
+    }).filter((value) => typeof value === "string").join(": ") || "Unknown error";
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  messageMergePlugin
+});
+//# sourceMappingURL=message-merge.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/plugins/message-merge.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const messageMergePlugin = Error0.plugin().use('message', {\n  serialize: ({ error }) => {\n    return (\n      error\n        .causes()\n        .map((cause) => {\n          return cause instanceof Error ? cause.message : undefined\n        })\n        .filter((value): value is string => typeof value === 'string')\n        .join(': ') || 'Unknown error'\n    )\n  },\n})\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAuB;AAEhB,MAAM,qBAAqB,gBAAO,OAAO,EAAE,IAAI,WAAW;AAAA,EAC/D,WAAW,CAAC,EAAE,MAAM,MAAM;AACxB,WACE,MACG,OAAO,EACP,IAAI,CAAC,UAAU;AACd,aAAO,iBAAiB,QAAQ,MAAM,UAAU;AAAA,IAClD,CAAC,EACA,OAAO,CAAC,UAA2B,OAAO,UAAU,QAAQ,EAC5D,KAAK,IAAI,KAAK;AAAA,EAErB;AACF,CAAC;","names":[]}

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

@@ -0,0 +1,5 @@
+import { PluginError0 } from '../index.cjs';
+
+declare const messageMergePlugin: PluginError0<Record<never, never>, Record<never, never>>;
+
+export { messageMergePlugin };

package/dist/cjs/plugins/meta.cjs

@@ -0,0 +1,73 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var meta_exports = {};
+__export(meta_exports, {
+  metaPlugin: () => metaPlugin
+});
+module.exports = __toCommonJS(meta_exports);
+var import__ = require('../index.cjs');
+const toJsonSafe = (input) => {
+  if (input === null) {
+    return null;
+  }
+  if (typeof input === "string" || typeof input === "number" || typeof input === "boolean") {
+    return input;
+  }
+  if (Array.isArray(input)) {
+    return input.map((value) => toJsonSafe(value));
+  }
+  if (typeof input === "object") {
+    const output = {};
+    for (const [key, value] of Object.entries(input)) {
+      const jsonValue = toJsonSafe(value);
+      if (jsonValue !== void 0) {
+        output[key] = jsonValue;
+      }
+    }
+    return output;
+  }
+  return void 0;
+};
+const isMetaRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const metaPlugin = import__.Error0.plugin().use("prop", "meta", {
+  init: (input) => input,
+  resolve: ({ flow }) => {
+    const values = flow.filter(isMetaRecord);
+    if (values.length === 0) {
+      return void 0;
+    }
+    const merged = {};
+    for (const value of [...values].reverse()) {
+      Object.assign(merged, value);
+    }
+    return merged;
+  },
+  serialize: ({ value, isPublic }) => isPublic ? void 0 : toJsonSafe(value),
+  deserialize: ({ value }) => {
+    if (!isMetaRecord(value)) {
+      return void 0;
+    }
+    return value;
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  metaPlugin
+});
+//# sourceMappingURL=meta.cjs.map

package/dist/cjs/plugins/meta.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/plugins/meta.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\ntype Json = null | boolean | number | string | Json[] | { [key: string]: Json }\n\nconst toJsonSafe = (input: unknown): Json | undefined => {\n  if (input === null) {\n    return null\n  }\n  if (typeof input === 'string' || typeof input === 'number' || typeof input === 'boolean') {\n    return input\n  }\n  if (Array.isArray(input)) {\n    return input.map((value) => toJsonSafe(value)) as Json[]\n  }\n  if (typeof input === 'object') {\n    const output: Record<string, Json> = {}\n    for (const [key, value] of Object.entries(input as Record<string, unknown>)) {\n      const jsonValue = toJsonSafe(value)\n      if (jsonValue !== undefined) {\n        output[key] = jsonValue\n      }\n    }\n    return output\n  }\n  return undefined\n}\n\nconst isMetaRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value)\n\nexport const metaPlugin = Error0.plugin().use('prop', 'meta', {\n  init: (input: Record<string, unknown>) => input,\n  resolve: ({ flow }) => {\n    const values = flow.filter(isMetaRecord)\n    if (values.length === 0) {\n      return undefined\n    }\n\n    // Merge cause meta into the current error; nearer errors win on conflicts.\n    const merged: Record<string, unknown> = {}\n    for (const value of [...values].reverse()) {\n      Object.assign(merged, value)\n    }\n    return merged\n  },\n  serialize: ({ value, isPublic }) => (isPublic ? undefined : toJsonSafe(value)),\n  deserialize: ({ value }) => {\n    if (!isMetaRecord(value)) {\n      return undefined\n    }\n    return value\n  },\n})\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAuB;AAIvB,MAAM,aAAa,CAAC,UAAqC;AACvD,MAAI,UAAU,MAAM;AAClB,WAAO;AAAA,EACT;AACA,MAAI,OAAO,UAAU,YAAY,OAAO,UAAU,YAAY,OAAO,UAAU,WAAW;AACxF,WAAO;AAAA,EACT;AACA,MAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,WAAO,MAAM,IAAI,CAAC,UAAU,WAAW,KAAK,CAAC;AAAA,EAC/C;AACA,MAAI,OAAO,UAAU,UAAU;AAC7B,UAAM,SAA+B,CAAC;AACtC,eAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,KAAgC,GAAG;AAC3E,YAAM,YAAY,WAAW,KAAK;AAClC,UAAI,cAAc,QAAW;AAC3B,eAAO,GAAG,IAAI;AAAA,MAChB;AAAA,IACF;AACA,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAEA,MAAM,eAAe,CAAC,UACpB,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAE9D,MAAM,aAAa,gBAAO,OAAO,EAAE,IAAI,QAAQ,QAAQ;AAAA,EAC5D,MAAM,CAAC,UAAmC;AAAA,EAC1C,SAAS,CAAC,EAAE,KAAK,MAAM;AACrB,UAAM,SAAS,KAAK,OAAO,YAAY;AACvC,QAAI,OAAO,WAAW,GAAG;AACvB,aAAO;AAAA,IACT;AAGA,UAAM,SAAkC,CAAC;AACzC,eAAW,SAAS,CAAC,GAAG,MAAM,EAAE,QAAQ,GAAG;AACzC,aAAO,OAAO,QAAQ,KAAK;AAAA,IAC7B;AACA,WAAO;AAAA,EACT;AAAA,EACA,WAAW,CAAC,EAAE,OAAO,SAAS,MAAO,WAAW,SAAY,WAAW,KAAK;AAAA,EAC5E,aAAa,CAAC,EAAE,MAAM,MAAM;AAC1B,QAAI,CAAC,aAAa,KAAK,GAAG;AACxB,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AACF,CAAC;","names":[]}

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

@@ -0,0 +1,5 @@
+import { PluginError0, ErrorPluginPropOptions, Error0 } from '../index.cjs';
+
+declare const metaPlugin: PluginError0<Record<never, never> & Record<"meta", ErrorPluginPropOptions<Record<string, unknown>, Record<string, unknown>, Error0, Record<string, unknown> | undefined>>, Record<never, never>>;
+
+export { metaPlugin };

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

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stack_merge_exports = {};
+__export(stack_merge_exports, {
+  stackMergePlugin: () => stackMergePlugin
+});
+module.exports = __toCommonJS(stack_merge_exports);
+var import__ = require('../index.cjs');
+const stackMergePlugin = import__.Error0.plugin().use("stack", {
+  serialize: ({ error, isPublic }) => {
+    if (isPublic) {
+      return void 0;
+    }
+    return error.causes().map((cause) => {
+      return cause instanceof Error ? cause.stack : void 0;
+    }).filter((value) => typeof value === "string").join("\n");
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  stackMergePlugin
+});
+//# sourceMappingURL=stack-merge.cjs.map

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

@@ -0,0 +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":[]}

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

@@ -0,0 +1,5 @@
+import { PluginError0 } from '../index.cjs';
+
+declare const stackMergePlugin: PluginError0<Record<never, never>, Record<never, never>>;
+
+export { stackMergePlugin };

package/dist/cjs/plugins/tags.cjs

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tags_exports = {};
+__export(tags_exports, {
+  tagsPlugin: () => tagsPlugin
+});
+module.exports = __toCommonJS(tags_exports);
+var import__ = require('../index.cjs');
+const tagsPlugin = import__.Error0.plugin().use("prop", "tags", {
+  init: (input) => input,
+  resolve: ({ flow }) => {
+    const merged = [];
+    for (const value of flow) {
+      if (Array.isArray(value)) {
+        merged.push(...value.filter((item) => typeof item === "string"));
+      }
+    }
+    return merged.length > 0 ? Array.from(new Set(merged)) : void 0;
+  },
+  serialize: ({ value, isPublic }) => isPublic ? void 0 : value,
+  deserialize: ({ value }) => {
+    if (!Array.isArray(value)) {
+      return void 0;
+    }
+    return value.filter((item) => typeof item === "string");
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  tagsPlugin
+});
+//# sourceMappingURL=tags.cjs.map

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

@@ -0,0 +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":[]}

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

@@ -0,0 +1,5 @@
+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>>;
+
+export { tagsPlugin };