wellcrafted 0.27.0 → 0.28.0

package/README.md

@@ -54,12 +54,18 @@ function getUser(id: UserId) { /* ... */ }
 ```
 
 ### 📋 Tagged Errors
-Structured, serializable errors with convenient factory functions
+Structured, serializable errors with a fluent API
 ```typescript
 import { createTaggedError } from "wellcrafted/error";
 
-const { ApiError, ApiErr } = createTaggedError("ApiError");
-// ApiError() creates error object, ApiErr() creates Err-wrapped error
+// Minimal by default - only name and message
+const { ValidationError } = createTaggedError("ValidationError");
+ValidationError({ message: "Email is required" });
+
+// Chain to add context and cause when needed
+const { ApiError } = createTaggedError("ApiError")
+  .withContext<{ endpoint: string }>()
+  .withCause<NetworkError | undefined>();
 ```
 
 ### 🔄 Query Integration
@@ -100,19 +106,21 @@ npm install wellcrafted
 
 ```typescript
 import { tryAsync } from "wellcrafted/result";
-import { createTaggedError } from "wellcrafted/error";
+import { createTaggedError, type AnyTaggedError } from "wellcrafted/error";
 
 // Define your error with factory function
-const { ApiError, ApiErr } = createTaggedError("ApiError");
+const { ApiError, ApiErr } = createTaggedError("ApiError")
+  .withContext<{ endpoint: string }>()
+  .withCause<AnyTaggedError | undefined>();
 type ApiError = ReturnType<typeof ApiError>;
 
 // Wrap any throwing operation
 const { data, error } = await tryAsync({
   try: () => fetch('/api/user').then(r => r.json()),
-  catch: (error) => ApiErr({
+  catch: (e) => ApiErr({
     message: "Failed to fetch user",
     context: { endpoint: '/api/user' },
-    cause: error
+    cause: { name: "FetchError", message: String(e) }
   })
 });
 
@@ -206,25 +214,28 @@ if (error) {
 ### Wrap Unsafe Operations
 
 ```typescript
+// Define errors with context and cause
+const { ParseError, ParseErr } = createTaggedError("ParseError")
+  .withContext<{ input: string }>();
+
+const { NetworkError, NetworkErr } = createTaggedError("NetworkError")
+  .withContext<{ url: string }>();
+
 // Synchronous
 const result = trySync({
   try: () => JSON.parse(jsonString),
-  catch: (error) => Err({
-    name: "ParseError",
+  catch: () => ParseErr({
     message: "Invalid JSON",
-    context: { input: jsonString },
-    cause: error
+    context: { input: jsonString }
   })
 });
 
-// Asynchronous  
+// Asynchronous
 const result = await tryAsync({
   try: () => fetch(url),
-  catch: (error) => Err({
-    name: "NetworkError",
+  catch: () => NetworkErr({
     message: "Request failed",
-    context: { url },
-    cause: error
+    context: { url }
   })
 });
 ```
@@ -234,9 +245,10 @@ const result = await tryAsync({
 ```typescript
 // 1. Service Layer - Pure business logic
 import { createTaggedError } from "wellcrafted/error";
-import { tryAsync, Result } from "wellcrafted/result";
+import { tryAsync, Result, Ok } from "wellcrafted/result";
 
-const { RecorderServiceError, RecorderServiceErr } = createTaggedError("RecorderServiceError");
+const { RecorderServiceError, RecorderServiceErr } = createTaggedError("RecorderServiceError")
+  .withContext<{ currentState?: string; permissions?: string }>();
 type RecorderServiceError = ReturnType<typeof RecorderServiceError>;
 
 export function createRecorderService() {
@@ -248,8 +260,7 @@ export function createRecorderService() {
       if (isRecording) {
         return RecorderServiceErr({
           message: "Already recording",
-          context: { currentState: 'recording' },
-          cause: undefined
+          context: { currentState: 'recording' }
         });
       }
 
@@ -260,10 +271,9 @@ export function createRecorderService() {
           // ... recording setup
           isRecording = true;
         },
-        catch: (error) => RecorderServiceErr({
+        catch: () => RecorderServiceErr({
           message: "Failed to start recording",
-          context: { permissions: 'microphone' },
-          cause: error
+          context: { permissions: 'microphone' }
         })
       });
     },
@@ -272,11 +282,10 @@ export function createRecorderService() {
       if (!isRecording) {
         return RecorderServiceErr({
           message: "Not currently recording",
-          context: { currentState: 'idle' },
-          cause: undefined
+          context: { currentState: 'idle' }
         });
       }
-      
+
       // Stop recording and return blob...
       isRecording = false;
       return Ok(currentBlob!);
@@ -367,10 +376,12 @@ const { data: parsed } = trySync({
 
 ### Propagation Pattern (May Fail)
 ```typescript
-// When catch can return Err<E>, function returns Result<T, E>  
+const { ParseError, ParseErr } = createTaggedError("ParseError");
+
+// When catch can return Err<E>, function returns Result<T, E>
 const mayFail = trySync({
   try: () => JSON.parse(riskyJson),
-  catch: (error) => ParseErr({ message: "Invalid JSON", cause: error })
+  catch: () => ParseErr({ message: "Invalid JSON" })
 });
 // mayFail: Result<object, ParseError> - Must check for errors
 if (isOk(mayFail)) {
@@ -382,13 +393,13 @@ if (isOk(mayFail)) {
 ```typescript
 const smartParse = trySync({
   try: () => JSON.parse(input),
-  catch: (error) => {
+  catch: () => {
     // Recover from empty input
     if (input.trim() === "") {
       return Ok({}); // Return Ok<T> for fallback
     }
-    // Propagate other errors  
-    return ParseErr({ message: "Parse failed", cause: error });
+    // Propagate other errors
+    return ParseErr({ message: "Parse failed" });
   }
 });
 // smartParse: Result<object, ParseError> - Mixed handling = Result type
@@ -419,40 +430,40 @@ Based on real-world usage, here's the recommended pattern for creating services
 
 ```typescript
 import { createTaggedError } from "wellcrafted/error";
+import { Result, Ok } from "wellcrafted/result";
 
-// 1. Define service-specific errors
-const { RecorderServiceError, RecorderServiceErr } = createTaggedError("RecorderServiceError");
+// 1. Define service-specific errors with typed context
+const { RecorderServiceError, RecorderServiceErr } = createTaggedError("RecorderServiceError")
+  .withContext<{ isRecording: boolean }>();
 type RecorderServiceError = ReturnType<typeof RecorderServiceError>;
 
 // 2. Create service with factory function
 export function createRecorderService() {
   // Private state in closure
   let isRecording = false;
-  
+
   // Return object with methods
   return {
     startRecording(): Result<void, RecorderServiceError> {
       if (isRecording) {
         return RecorderServiceErr({
           message: "Already recording",
-          context: { isRecording },
-          cause: undefined
+          context: { isRecording }
         });
       }
-      
+
       isRecording = true;
       return Ok(undefined);
     },
-    
+
     stopRecording(): Result<Blob, RecorderServiceError> {
       if (!isRecording) {
         return RecorderServiceErr({
-          message: "Not currently recording", 
-          context: { isRecording },
-          cause: undefined
+          message: "Not currently recording",
+          context: { isRecording }
         });
       }
-      
+
       isRecording = false;
       return Ok(new Blob(["audio data"]));
     }
@@ -534,22 +545,23 @@ export async function GET(request: Request) {
 <summary><b>Form Validation</b></summary>
 
 ```typescript
+const { FormError, FormErr } = createTaggedError("FormError")
+  .withContext<{ fields: Record<string, string[]> }>();
+
 function validateLoginForm(data: unknown): Result<LoginData, FormError> {
   const errors: Record<string, string[]> = {};
-  
+
   if (!isValidEmail(data?.email)) {
     errors.email = ["Invalid email format"];
   }
-  
+
   if (Object.keys(errors).length > 0) {
-    return Err({
-      name: "FormError",
+    return FormErr({
       message: "Validation failed",
-      context: { fields: errors },
-      cause: undefined
+      context: { fields: errors }
     });
   }
-  
+
   return Ok(data as LoginData);
 }
 ```
@@ -615,10 +627,12 @@ For comprehensive examples, service layer patterns, framework integrations, and
 - **`defineMutation(options)`** - Define a mutation with dual interface (`.options()` + `.execute()`)
 
 ### Error Functions
-- **`createTaggedError(name)`** - Creates error factory functions
-  - Returns two functions: `{ErrorName}` and `{ErrorName}Err`
-  - The first creates plain error objects
-  - The second creates Err-wrapped errors
+- **`createTaggedError(name)`** - Creates error factory functions with fluent API
+  - Returns `{ErrorName}` (plain error) and `{ErrorName}Err` (Err-wrapped)
+  - **Default**: minimal errors with only `name` and `message`
+  - Chain `.withContext<T>()` to add typed context
+  - Chain `.withCause<T>()` to add typed cause
+  - Include `| undefined` in type to make property optional but typed
 - **`extractErrorMessage(error)`** - Extract readable message from unknown error
 
 ### Types

package/dist/error/index.d.ts

@@ -10,81 +10,77 @@ type AnyTaggedError = {
 };
 /**
  * Helper type that adds a context property.
- * - When TContext is undefined (default): context is OPTIONAL with loose typing
+ * - When TContext is undefined (default): NO context property (explicit opt-in)
  * - When TContext includes undefined (e.g., `{ foo: string } | undefined`): context is OPTIONAL but typed
  * - When TContext is a specific type without undefined: context is REQUIRED with that exact type
  *
- * This allows users to specify "optional but typed" context by passing a union with undefined.
+ * This follows Rust's explicit error philosophy: context must be explicitly added via .withContext<T>().
  */
-type WithContext<TContext> = [TContext] extends [undefined] ? {
-  context?: Record<string, unknown>;
-} : [undefined] extends [TContext] ? {
+type WithContext<TContext> = [TContext] extends [undefined] ? {} : [undefined] extends [TContext] ? {
   context?: Exclude<TContext, undefined>;
 } : {
   context: TContext;
 };
 /**
  * Helper type that adds a cause property.
- * - When TCause is undefined (default): cause is OPTIONAL, any tagged error allowed
+ * - When TCause is undefined (default): NO cause property (explicit opt-in)
  * - When TCause includes undefined (e.g., `NetworkError | undefined`): cause is OPTIONAL, constrained
- * - When TCause is a specific type: cause is OPTIONAL but constrained to that type
+ * - When TCause is a specific type without undefined: cause is REQUIRED
  *
- * Note: cause is always optional at runtime (errors can be created without causes),
- * but when TCause is specified, it constrains what cause types are allowed.
+ * This follows Rust's explicit error philosophy: cause must be explicitly added via .withCause<T>().
  * Using brackets to prevent distributive conditional behavior with union types.
  */
-type WithCause<TCause> = [TCause] extends [undefined] ? {
-  cause?: AnyTaggedError;
-} : [undefined] extends [TCause] ? {
+type WithCause<TCause> = [TCause] extends [undefined] ? {} : [undefined] extends [TCause] ? {
   cause?: Exclude<TCause, undefined>;
 } : {
-  cause?: TCause;
+  cause: TCause;
 };
 /**
  * Creates a tagged error type for type-safe error handling.
  * Uses the `name` property as a discriminator for tagged unions.
  *
- * The `cause` property enables error chaining, creating a JSON-serializable
- * call stack. Each error wraps its cause, building a complete trace of how
- * an error propagated through your application layers.
+ * **Explicit Opt-In Philosophy (Rust-inspired):**
+ * By default, errors only have `name` and `message`. Context and cause must be
+ * explicitly added via type parameters. This follows Rust's thiserror pattern
+ * where error properties are intentional architectural decisions.
  *
  * **Type Parameter Behavior:**
- * - When `TContext` is `undefined` (default): `context` is OPTIONAL with type `Record<string, unknown>`
- * - When `TContext` is `{ ... } | undefined`: `context` is OPTIONAL but typed (use union for optional typed context)
- * - When `TContext` is specified without undefined: `context` is REQUIRED with that exact type
- * - When `TCause` is `undefined` (default): `cause` is OPTIONAL, any `AnyTaggedError` allowed
- * - When `TCause` is specified: `cause` is OPTIONAL but constrained to that type
+ * - When `TContext` is `undefined` (default): NO context property
+ * - When `TContext` is `{ ... } | undefined`: `context` is OPTIONAL but typed
+ * - When `TContext` is specified without undefined: `context` is REQUIRED
+ * - When `TCause` is `undefined` (default): NO cause property
+ * - When `TCause` is `{ ... } | undefined`: `cause` is OPTIONAL but typed
+ * - When `TCause` is specified without undefined: `cause` is REQUIRED
  *
  * @template TName - The error name (discriminator for tagged unions)
- * @template TContext - Additional context data for the error (default: undefined = optional loose context)
- * @template TCause - The type of error that caused this error (default: undefined = optional any cause)
+ * @template TContext - Additional context data for the error (default: undefined = no context)
+ * @template TCause - The type of error that caused this error (default: undefined = no cause)
  *
  * @example
  * ```ts
- * // Flexible error (context and cause optional, loosely typed)
+ * // Minimal error (no context, no cause)
  * type ValidationError = TaggedError<"ValidationError">;
  * const validationError: ValidationError = {
  *   name: "ValidationError",
  *   message: "Input is required"
  * };
- * // validationError.context is optional, typed as Record<string, unknown> | undefined
+ * // validationError only has name and message
  *
- * // Error with required context (fixed context mode)
+ * // Error with required context
  * type NetworkError = TaggedError<"NetworkError", { host: string; port: number }>;
  * const networkError: NetworkError = {
  *   name: "NetworkError",
  *   message: "Socket timeout",
  *   context: { host: "db.example.com", port: 5432 } // Required!
  * };
- * const host = networkError.context.host; // Type-safe, no optional chaining needed
  *
  * // Error with OPTIONAL but TYPED context (union with undefined)
  * type LogError = TaggedError<"LogError", { file: string; line: number } | undefined>;
- * const logError1: LogError = { name: "LogError", message: "Parse failed" }; // OK - no context
- * const logError2: LogError = { name: "LogError", message: "Parse failed", context: { file: "app.ts", line: 42 } }; // OK - typed context
+ * const logError1: LogError = { name: "LogError", message: "Parse failed" }; // OK
+ * const logError2: LogError = { name: "LogError", message: "Parse failed", context: { file: "app.ts", line: 42 } }; // OK
  *
- * // Error with fixed context and constrained cause type
- * type DatabaseError = TaggedError<"DatabaseError", { operation: string }, NetworkError>;
+ * // Error with required context and optional cause
+ * type DatabaseError = TaggedError<"DatabaseError", { operation: string }, NetworkError | undefined>;
  * const dbError: DatabaseError = {
  *   name: "DatabaseError",
  *   message: "Failed to connect to database",
@@ -166,14 +162,15 @@ type ReplaceErrorWithErr<T extends `${string}Error`> = T extends `${infer TBase}
 type OptionalIfUndefined<T, TKey extends string> = undefined extends T ? { [K in TKey]?: Exclude<T, undefined> } : { [K in TKey]: T };
 /**
  * Input type for error constructors with fluent API context/cause handling.
+ *
+ * Follows explicit opt-in philosophy:
+ * - When TContext/TCause is undefined: property doesn't exist
+ * - When TContext/TCause includes undefined: property is optional but typed
+ * - When TContext/TCause is a specific type: property is required
  */
 type ErrorInput<TContext extends Record<string, unknown> | undefined, TCause extends AnyTaggedError | undefined> = {
   message: string;
-} & (TContext extends undefined ? {
-  context?: Record<string, unknown>;
-} : OptionalIfUndefined<TContext, "context">) & (TCause extends undefined ? {
-  cause?: AnyTaggedError;
-} : OptionalIfUndefined<TCause, "cause">);
+} & (TContext extends undefined ? {} : OptionalIfUndefined<TContext, "context">) & (TCause extends undefined ? {} : OptionalIfUndefined<TCause, "cause">);
 /**
  * The factories object returned by createTaggedError and its builder methods.
  */
@@ -209,8 +206,17 @@ type ErrorBuilder<TName extends `${string}Error`, TContext extends Record<string
    * LogError({ message: 'Parse error' })  // OK
    * LogError({ message: 'Parse error', context: { file: 'app.ts', line: 42 } })  // OK
    * ```
+   *
+   * @example Default (no generic): permissive optional context
+   * ```ts
+   * const { FlexError } = createTaggedError('FlexError')
+   *   .withContext()  // Defaults to Record<string, unknown> | undefined
+   *
+   * FlexError({ message: 'Error' })  // OK - context is optional
+   * FlexError({ message: 'Error', context: { anything: 'works' } })  // OK
+   * ```
    */
-  withContext<T extends Record<string, unknown> | undefined>(): ErrorBuilder<TName, T, TCause>;
+  withContext<T extends Record<string, unknown> | undefined = Record<string, unknown> | undefined>(): ErrorBuilder<TName, T, TCause>;
   /**
    * Constrains the cause type for this error.
    *
@@ -239,8 +245,17 @@ type ErrorBuilder<TName extends `${string}Error`, TContext extends Record<string
    * UnhandledError({ message: 'Unexpected', cause: originalError })  // OK
    * UnhandledError({ message: 'Unexpected' })  // Type error: cause required
    * ```
+   *
+   * @example Default (no generic): permissive optional cause
+   * ```ts
+   * const { FlexError } = createTaggedError('FlexError')
+   *   .withCause()  // Defaults to AnyTaggedError | undefined
+   *
+   * FlexError({ message: 'Error' })  // OK - cause is optional
+   * FlexError({ message: 'Error', cause: anyTaggedError })  // OK
+   * ```
    */
-  withCause<T extends AnyTaggedError | undefined>(): ErrorBuilder<TName, TContext, T>;
+  withCause<T extends AnyTaggedError | undefined = AnyTaggedError | undefined>(): ErrorBuilder<TName, TContext, T>;
 };
 /**
  * Creates a new tagged error type with a fluent builder API.
@@ -248,12 +263,13 @@ type ErrorBuilder<TName extends `${string}Error`, TContext extends Record<string
  * Returns an object containing:
  * - `{Name}Error`: Factory function that creates plain TaggedError objects
  * - `{Name}Err`: Factory function that creates Err-wrapped TaggedError objects
- * - `withContext<T>()`: Chain method to constrain context type
- * - `withCause<T>()`: Chain method to constrain cause type
+ * - `withContext<T>()`: Chain method to add context type
+ * - `withCause<T>()`: Chain method to add cause type
  *
- * **Default behavior (no chaining):**
- * - `context` is optional and accepts any `Record<string, unknown>`
- * - `cause` is optional and accepts any `AnyTaggedError`
+ * **Explicit Opt-In (Rust-inspired):**
+ * By default, errors only have `{ name, message }`. Context and cause must be
+ * explicitly added via `.withContext<T>()` and `.withCause<T>()`. This follows
+ * Rust's thiserror pattern where error properties are intentional decisions.
  *
  * **Optionality via type unions:**
  * Both `withContext` and `withCause` determine optionality based on whether
@@ -264,12 +280,12 @@ type ErrorBuilder<TName extends `${string}Error`, TContext extends Record<string
  * @template TName - The name of the error type (must end with "Error")
  * @param name - The name of the error type
  *
- * @example Simple error (flexible mode)
+ * @example Minimal error (no context, no cause)
  * ```ts
  * const { NetworkError, NetworkErr } = createTaggedError('NetworkError')
  *
  * NetworkError({ message: 'Connection failed' })
- * NetworkError({ message: 'Timeout', context: { url: 'https://...' } })
+ * // Error only has { name: 'NetworkError', message: 'Connection failed' }
  * ```
  *
  * @example Required context
@@ -299,6 +315,13 @@ type ErrorBuilder<TName extends `${string}Error`, TContext extends Record<string
  * // Type extraction works
  * type UserServiceError = ReturnType<typeof UserServiceError>
  * ```
+ *
+ * @example Permissive mode (if you want the old behavior)
+ * ```ts
+ * const { FlexibleError } = createTaggedError('FlexibleError')
+ *   .withContext<Record<string, unknown> | undefined>()
+ *   .withCause<AnyTaggedError | undefined>()
+ * ```
  */
 declare function createTaggedError<TName extends `${string}Error`>(name: TName): ErrorBuilder<TName>;
 //#endregion

package/dist/error/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/error/types.ts","../../src/error/utils.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/error/types.ts","../../src/error/utils.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/error/index.js

@@ -69,12 +69,13 @@ function extractErrorMessage(error) {
 * Returns an object containing:
 * - `{Name}Error`: Factory function that creates plain TaggedError objects
 * - `{Name}Err`: Factory function that creates Err-wrapped TaggedError objects
-* - `withContext<T>()`: Chain method to constrain context type
-* - `withCause<T>()`: Chain method to constrain cause type
+* - `withContext<T>()`: Chain method to add context type
+* - `withCause<T>()`: Chain method to add cause type
 *
-* **Default behavior (no chaining):**
-* - `context` is optional and accepts any `Record<string, unknown>`
-* - `cause` is optional and accepts any `AnyTaggedError`
+* **Explicit Opt-In (Rust-inspired):**
+* By default, errors only have `{ name, message }`. Context and cause must be
+* explicitly added via `.withContext<T>()` and `.withCause<T>()`. This follows
+* Rust's thiserror pattern where error properties are intentional decisions.
 *
 * **Optionality via type unions:**
 * Both `withContext` and `withCause` determine optionality based on whether
@@ -85,12 +86,12 @@ function extractErrorMessage(error) {
 * @template TName - The name of the error type (must end with "Error")
 * @param name - The name of the error type
 *
-* @example Simple error (flexible mode)
+* @example Minimal error (no context, no cause)
 * ```ts
 * const { NetworkError, NetworkErr } = createTaggedError('NetworkError')
 *
 * NetworkError({ message: 'Connection failed' })
-* NetworkError({ message: 'Timeout', context: { url: 'https://...' } })
+* // Error only has { name: 'NetworkError', message: 'Connection failed' }
 * ```
 *
 * @example Required context
@@ -120,6 +121,13 @@ function extractErrorMessage(error) {
 * // Type extraction works
 * type UserServiceError = ReturnType<typeof UserServiceError>
 * ```
+*
+* @example Permissive mode (if you want the old behavior)
+* ```ts
+* const { FlexibleError } = createTaggedError('FlexibleError')
+*   .withContext<Record<string, unknown> | undefined>()
+*   .withCause<AnyTaggedError | undefined>()
+* ```
 */
 function createTaggedError(name) {
 	const createBuilder = () => {

package/dist/error/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["error: unknown","name: TName","input: ErrorInput<TContext, TCause>"],"sources":["../../src/error/utils.ts"],"sourcesContent":["import type { TaggedError, AnyTaggedError } from \"./types.js\";\nimport { Err } from \"../result/result.js\";\n\n/**\n * Extracts a readable error message from an unknown error value\n *\n * This utility is commonly used in mapErr functions when converting\n * unknown errors to typed error objects in the Result system.\n *\n * @param error - The unknown error to extract a message from\n * @returns A string representation of the error\n *\n * @example\n * ```ts\n * // With native Error\n * const error = new Error(\"Something went wrong\");\n * const message = extractErrorMessage(error); // \"Something went wrong\"\n *\n * // With string error\n * const stringError = \"String error\";\n * const message2 = extractErrorMessage(stringError); // \"String error\"\n *\n * // With object error\n * const unknownError = { code: 500, details: \"Server error\" };\n * const message3 = extractErrorMessage(unknownError); // '{\"code\":500,\"details\":\"Server error\"}'\n *\n * // Used in mapErr function\n * const result = await tryAsync({\n *   try: () => riskyOperation(),\n *   mapErr: (error) => Err({\n *     name: \"NetworkError\",\n *     message: extractErrorMessage(error),\n *     context: { operation: \"riskyOperation\" },\n *     cause: error,\n *   }),\n * });\n * ```\n */\nexport function extractErrorMessage(error: unknown): string {\n\t// Handle Error instances\n\tif (error instanceof Error) {\n\t\treturn error.message;\n\t}\n\n\t// Handle primitives\n\tif (typeof error === \"string\") return error;\n\tif (\n\t\ttypeof error === \"number\" ||\n\t\ttypeof error === \"boolean\" ||\n\t\ttypeof error === \"bigint\"\n\t)\n\t\treturn String(error);\n\tif (typeof error === \"symbol\") return error.toString();\n\tif (error === null) return \"null\";\n\tif (error === undefined) return \"undefined\";\n\n\t// Handle arrays\n\tif (Array.isArray(error)) return JSON.stringify(error);\n\n\t// Handle plain objects\n\tif (typeof error === \"object\") {\n\t\tconst errorObj = error as Record<string, unknown>;\n\n\t\t// Check common error properties\n\t\tconst messageProps = [\n\t\t\t\"message\",\n\t\t\t\"error\",\n\t\t\t\"description\",\n\t\t\t\"title\",\n\t\t\t\"reason\",\n\t\t\t\"details\",\n\t\t] as const;\n\t\tfor (const prop of messageProps) {\n\t\t\tif (prop in errorObj && typeof errorObj[prop] === \"string\") {\n\t\t\t\treturn errorObj[prop];\n\t\t\t}\n\t\t}\n\n\t\t// Fallback to JSON stringification\n\t\ttry {\n\t\t\treturn JSON.stringify(error);\n\t\t} catch {\n\t\t\treturn String(error);\n\t\t}\n\t}\n\n\t// Final fallback\n\treturn String(error);\n}\n\n/**\n * Replaces the \"Error\" suffix with \"Err\" suffix in error type names.\n *\n * @template T - An error type name that must end with \"Error\"\n * @returns The type name with \"Error\" replaced by \"Err\"\n *\n * @example\n * ```ts\n * type NetworkErr = ReplaceErrorWithErr<\"NetworkError\">; // \"NetworkErr\"\n * type ValidationErr = ReplaceErrorWithErr<\"ValidationError\">; // \"ValidationErr\"\n * ```\n */\ntype ReplaceErrorWithErr<T extends `${string}Error`> =\n\tT extends `${infer TBase}Error` ? `${TBase}Err` : never;\n\n// =============================================================================\n// Fluent API Types\n// =============================================================================\n\n/**\n * Helper type that determines optionality based on whether T includes undefined.\n * - If T includes undefined → property is optional\n * - If T does not include undefined → property is required\n */\ntype OptionalIfUndefined<T, TKey extends string> = undefined extends T\n\t? { [K in TKey]?: Exclude<T, undefined> }\n\t: { [K in TKey]: T };\n\n/**\n * Input type for error constructors with fluent API context/cause handling.\n */\ntype ErrorInput<\n\tTContext extends Record<string, unknown> | undefined,\n\tTCause extends AnyTaggedError | undefined,\n> = { message: string } & (TContext extends undefined\n\t? { context?: Record<string, unknown> }\n\t: OptionalIfUndefined<TContext, \"context\">) &\n\t(TCause extends undefined\n\t\t? { cause?: AnyTaggedError }\n\t\t: OptionalIfUndefined<TCause, \"cause\">);\n\n/**\n * The factories object returned by createTaggedError and its builder methods.\n */\ntype ErrorFactories<\n\tTName extends `${string}Error`,\n\tTContext extends Record<string, unknown> | undefined,\n\tTCause extends AnyTaggedError | undefined,\n> = {\n\t[K in TName]: (\n\t\tinput: ErrorInput<TContext, TCause>,\n\t) => TaggedError<TName, TContext, TCause>;\n} & {\n\t[K in ReplaceErrorWithErr<TName>]: (\n\t\tinput: ErrorInput<TContext, TCause>,\n\t) => Err<TaggedError<TName, TContext, TCause>>;\n};\n\n/**\n * Builder interface for the fluent createTaggedError API.\n * Provides chaining methods and the error factories.\n */\ntype ErrorBuilder<\n\tTName extends `${string}Error`,\n\tTContext extends Record<string, unknown> | undefined = undefined,\n\tTCause extends AnyTaggedError | undefined = undefined,\n> = ErrorFactories<TName, TContext, TCause> & {\n\t/**\n\t * Constrains the context type for this error.\n\t *\n\t * Optionality is determined by whether the type includes `undefined`:\n\t * - `withContext<T>()` where T doesn't include undefined → context is **required**\n\t * - `withContext<T | undefined>()` → context is **optional** but typed when provided\n\t *\n\t * @typeParam T - The shape of the context object. Include `| undefined` to make optional.\n\t *\n\t * @example Required context\n\t * ```ts\n\t * const { FileError } = createTaggedError('FileError')\n\t *   .withContext<{ path: string }>()\n\t *\n\t * FileError({ message: 'Not found', context: { path: '/etc/config' } })  // OK\n\t * FileError({ message: 'Not found' })  // Type error: context required\n\t * ```\n\t *\n\t * @example Optional but typed context\n\t * ```ts\n\t * const { LogError } = createTaggedError('LogError')\n\t *   .withContext<{ file: string; line: number } | undefined>()\n\t *\n\t * LogError({ message: 'Parse error' })  // OK\n\t * LogError({ message: 'Parse error', context: { file: 'app.ts', line: 42 } })  // OK\n\t * ```\n\t */\n\twithContext<T extends Record<string, unknown> | undefined>(): ErrorBuilder<\n\t\tTName,\n\t\tT,\n\t\tTCause\n\t>;\n\n\t/**\n\t * Constrains the cause type for this error.\n\t *\n\t * Optionality is determined by whether the type includes `undefined`:\n\t * - `withCause<T>()` where T doesn't include undefined → cause is **required**\n\t * - `withCause<T | undefined>()` → cause is **optional** but typed when provided\n\t *\n\t * Since cause is typically optional, include `| undefined` in most cases.\n\t *\n\t * @typeParam T - The allowed cause type(s). Include `| undefined` to make optional.\n\t *\n\t * @example Optional typed cause (common)\n\t * ```ts\n\t * const { ServiceError } = createTaggedError('ServiceError')\n\t *   .withCause<DbError | CacheError | undefined>()\n\t *\n\t * ServiceError({ message: 'Failed' })  // OK\n\t * ServiceError({ message: 'Failed', cause: dbError })  // OK\n\t * ```\n\t *\n\t * @example Required cause (for wrapper errors)\n\t * ```ts\n\t * const { UnhandledError } = createTaggedError('UnhandledError')\n\t *   .withCause<AnyTaggedError>()\n\t *\n\t * UnhandledError({ message: 'Unexpected', cause: originalError })  // OK\n\t * UnhandledError({ message: 'Unexpected' })  // Type error: cause required\n\t * ```\n\t */\n\twithCause<T extends AnyTaggedError | undefined>(): ErrorBuilder<\n\t\tTName,\n\t\tTContext,\n\t\tT\n\t>;\n};\n\n// =============================================================================\n// Fluent API Implementation\n// =============================================================================\n\n/**\n * Creates a new tagged error type with a fluent builder API.\n *\n * Returns an object containing:\n * - `{Name}Error`: Factory function that creates plain TaggedError objects\n * - `{Name}Err`: Factory function that creates Err-wrapped TaggedError objects\n * - `withContext<T>()`: Chain method to constrain context type\n * - `withCause<T>()`: Chain method to constrain cause type\n *\n * **Default behavior (no chaining):**\n * - `context` is optional and accepts any `Record<string, unknown>`\n * - `cause` is optional and accepts any `AnyTaggedError`\n *\n * **Optionality via type unions:**\n * Both `withContext` and `withCause` determine optionality based on whether\n * the type includes `undefined`:\n * - `T` without undefined → property is required\n * - `T | undefined` → property is optional but typed when provided\n *\n * @template TName - The name of the error type (must end with \"Error\")\n * @param name - The name of the error type\n *\n * @example Simple error (flexible mode)\n * ```ts\n * const { NetworkError, NetworkErr } = createTaggedError('NetworkError')\n *\n * NetworkError({ message: 'Connection failed' })\n * NetworkError({ message: 'Timeout', context: { url: 'https://...' } })\n * ```\n *\n * @example Required context\n * ```ts\n * const { ApiError, ApiErr } = createTaggedError('ApiError')\n *   .withContext<{ endpoint: string; status: number }>()\n *\n * ApiError({ message: 'Failed', context: { endpoint: '/users', status: 500 } })\n * // ApiError({ message: 'Failed' })  // Type error: context required\n * ```\n *\n * @example Optional typed cause\n * ```ts\n * const { ServiceError } = createTaggedError('ServiceError')\n *   .withCause<DbError | CacheError | undefined>()\n *\n * ServiceError({ message: 'Failed' })  // OK\n * ServiceError({ message: 'Failed', cause: dbError })  // OK, typed\n * ```\n *\n * @example Full example with both\n * ```ts\n * const { UserServiceError } = createTaggedError('UserServiceError')\n *   .withContext<{ userId: string }>()\n *   .withCause<RepoError | undefined>()\n *\n * // Type extraction works\n * type UserServiceError = ReturnType<typeof UserServiceError>\n * ```\n */\nexport function createTaggedError<TName extends `${string}Error`>(\n\tname: TName,\n): ErrorBuilder<TName> {\n\tconst createBuilder = <\n\t\tTContext extends Record<string, unknown> | undefined = undefined,\n\t\tTCause extends AnyTaggedError | undefined = undefined,\n\t>(): ErrorBuilder<TName, TContext, TCause> => {\n\t\tconst errorConstructor = (input: ErrorInput<TContext, TCause>) =>\n\t\t\t({ name, ...input }) as unknown as TaggedError<TName, TContext, TCause>;\n\n\t\tconst errName = name.replace(\n\t\t\t/Error$/,\n\t\t\t\"Err\",\n\t\t) as ReplaceErrorWithErr<TName>;\n\t\tconst errConstructor = (input: ErrorInput<TContext, TCause>) =>\n\t\t\tErr(errorConstructor(input));\n\n\t\treturn {\n\t\t\t[name]: errorConstructor,\n\t\t\t[errName]: errConstructor,\n\t\t\twithContext<T extends Record<string, unknown> | undefined>() {\n\t\t\t\treturn createBuilder<T, TCause>();\n\t\t\t},\n\t\t\twithCause<T extends AnyTaggedError | undefined>() {\n\t\t\t\treturn createBuilder<TContext, T>();\n\t\t\t},\n\t\t} as ErrorBuilder<TName, TContext, TCause>;\n\t};\n\n\treturn createBuilder();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,oBAAoBA,OAAwB;AAE3D,KAAI,iBAAiB,MACpB,QAAO,MAAM;AAId,YAAW,UAAU,SAAU,QAAO;AACtC,YACQ,UAAU,mBACV,UAAU,oBACV,UAAU,SAEjB,QAAO,OAAO,MAAM;AACrB,YAAW,UAAU,SAAU,QAAO,MAAM,UAAU;AACtD,KAAI,UAAU,KAAM,QAAO;AAC3B,KAAI,iBAAqB,QAAO;AAGhC,KAAI,MAAM,QAAQ,MAAM,CAAE,QAAO,KAAK,UAAU,MAAM;AAGtD,YAAW,UAAU,UAAU;EAC9B,MAAM,WAAW;EAGjB,MAAM,eAAe;GACpB;GACA;GACA;GACA;GACA;GACA;EACA;AACD,OAAK,MAAM,QAAQ,aAClB,KAAI,QAAQ,mBAAmB,SAAS,UAAU,SACjD,QAAO,SAAS;AAKlB,MAAI;AACH,UAAO,KAAK,UAAU,MAAM;EAC5B,QAAO;AACP,UAAO,OAAO,MAAM;EACpB;CACD;AAGD,QAAO,OAAO,MAAM;AACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwMD,SAAgB,kBACfC,MACsB;CACtB,MAAM,gBAAgB,MAGwB;EAC7C,MAAM,mBAAmB,CAACC,WACxB;GAAE;GAAM,GAAG;EAAO;EAEpB,MAAM,UAAU,KAAK,QACpB,UACA,MACA;EACD,MAAM,iBAAiB,CAACA,UACvB,IAAI,iBAAiB,MAAM,CAAC;AAE7B,SAAO;IACL,OAAO;IACP,UAAU;GACX,cAA6D;AAC5D,WAAO,eAA0B;GACjC;GACD,YAAkD;AACjD,WAAO,eAA4B;GACnC;EACD;CACD;AAED,QAAO,eAAe;AACtB"}
+{"version":3,"file":"index.js","names":["error: unknown","name: TName","input: ErrorInput<TContext, TCause>"],"sources":["../../src/error/utils.ts"],"sourcesContent":["import type { TaggedError, AnyTaggedError } from \"./types.js\";\nimport { Err } from \"../result/result.js\";\n\n/**\n * Extracts a readable error message from an unknown error value\n *\n * This utility is commonly used in mapErr functions when converting\n * unknown errors to typed error objects in the Result system.\n *\n * @param error - The unknown error to extract a message from\n * @returns A string representation of the error\n *\n * @example\n * ```ts\n * // With native Error\n * const error = new Error(\"Something went wrong\");\n * const message = extractErrorMessage(error); // \"Something went wrong\"\n *\n * // With string error\n * const stringError = \"String error\";\n * const message2 = extractErrorMessage(stringError); // \"String error\"\n *\n * // With object error\n * const unknownError = { code: 500, details: \"Server error\" };\n * const message3 = extractErrorMessage(unknownError); // '{\"code\":500,\"details\":\"Server error\"}'\n *\n * // Used in mapErr function\n * const result = await tryAsync({\n *   try: () => riskyOperation(),\n *   mapErr: (error) => Err({\n *     name: \"NetworkError\",\n *     message: extractErrorMessage(error),\n *     context: { operation: \"riskyOperation\" },\n *     cause: error,\n *   }),\n * });\n * ```\n */\nexport function extractErrorMessage(error: unknown): string {\n\t// Handle Error instances\n\tif (error instanceof Error) {\n\t\treturn error.message;\n\t}\n\n\t// Handle primitives\n\tif (typeof error === \"string\") return error;\n\tif (\n\t\ttypeof error === \"number\" ||\n\t\ttypeof error === \"boolean\" ||\n\t\ttypeof error === \"bigint\"\n\t)\n\t\treturn String(error);\n\tif (typeof error === \"symbol\") return error.toString();\n\tif (error === null) return \"null\";\n\tif (error === undefined) return \"undefined\";\n\n\t// Handle arrays\n\tif (Array.isArray(error)) return JSON.stringify(error);\n\n\t// Handle plain objects\n\tif (typeof error === \"object\") {\n\t\tconst errorObj = error as Record<string, unknown>;\n\n\t\t// Check common error properties\n\t\tconst messageProps = [\n\t\t\t\"message\",\n\t\t\t\"error\",\n\t\t\t\"description\",\n\t\t\t\"title\",\n\t\t\t\"reason\",\n\t\t\t\"details\",\n\t\t] as const;\n\t\tfor (const prop of messageProps) {\n\t\t\tif (prop in errorObj && typeof errorObj[prop] === \"string\") {\n\t\t\t\treturn errorObj[prop];\n\t\t\t}\n\t\t}\n\n\t\t// Fallback to JSON stringification\n\t\ttry {\n\t\t\treturn JSON.stringify(error);\n\t\t} catch {\n\t\t\treturn String(error);\n\t\t}\n\t}\n\n\t// Final fallback\n\treturn String(error);\n}\n\n/**\n * Replaces the \"Error\" suffix with \"Err\" suffix in error type names.\n *\n * @template T - An error type name that must end with \"Error\"\n * @returns The type name with \"Error\" replaced by \"Err\"\n *\n * @example\n * ```ts\n * type NetworkErr = ReplaceErrorWithErr<\"NetworkError\">; // \"NetworkErr\"\n * type ValidationErr = ReplaceErrorWithErr<\"ValidationError\">; // \"ValidationErr\"\n * ```\n */\ntype ReplaceErrorWithErr<T extends `${string}Error`> =\n\tT extends `${infer TBase}Error` ? `${TBase}Err` : never;\n\n// =============================================================================\n// Fluent API Types\n// =============================================================================\n\n/**\n * Helper type that determines optionality based on whether T includes undefined.\n * - If T includes undefined → property is optional\n * - If T does not include undefined → property is required\n */\ntype OptionalIfUndefined<T, TKey extends string> = undefined extends T\n\t? { [K in TKey]?: Exclude<T, undefined> }\n\t: { [K in TKey]: T };\n\n/**\n * Input type for error constructors with fluent API context/cause handling.\n *\n * Follows explicit opt-in philosophy:\n * - When TContext/TCause is undefined: property doesn't exist\n * - When TContext/TCause includes undefined: property is optional but typed\n * - When TContext/TCause is a specific type: property is required\n */\ntype ErrorInput<\n\tTContext extends Record<string, unknown> | undefined,\n\tTCause extends AnyTaggedError | undefined,\n> = { message: string } & (TContext extends undefined\n\t? {}\n\t: OptionalIfUndefined<TContext, \"context\">) &\n\t(TCause extends undefined\n\t\t? {}\n\t\t: OptionalIfUndefined<TCause, \"cause\">);\n\n/**\n * The factories object returned by createTaggedError and its builder methods.\n */\ntype ErrorFactories<\n\tTName extends `${string}Error`,\n\tTContext extends Record<string, unknown> | undefined,\n\tTCause extends AnyTaggedError | undefined,\n> = {\n\t[K in TName]: (\n\t\tinput: ErrorInput<TContext, TCause>,\n\t) => TaggedError<TName, TContext, TCause>;\n} & {\n\t[K in ReplaceErrorWithErr<TName>]: (\n\t\tinput: ErrorInput<TContext, TCause>,\n\t) => Err<TaggedError<TName, TContext, TCause>>;\n};\n\n/**\n * Builder interface for the fluent createTaggedError API.\n * Provides chaining methods and the error factories.\n */\ntype ErrorBuilder<\n\tTName extends `${string}Error`,\n\tTContext extends Record<string, unknown> | undefined = undefined,\n\tTCause extends AnyTaggedError | undefined = undefined,\n> = ErrorFactories<TName, TContext, TCause> & {\n\t/**\n\t * Constrains the context type for this error.\n\t *\n\t * Optionality is determined by whether the type includes `undefined`:\n\t * - `withContext<T>()` where T doesn't include undefined → context is **required**\n\t * - `withContext<T | undefined>()` → context is **optional** but typed when provided\n\t *\n\t * @typeParam T - The shape of the context object. Include `| undefined` to make optional.\n\t *\n\t * @example Required context\n\t * ```ts\n\t * const { FileError } = createTaggedError('FileError')\n\t *   .withContext<{ path: string }>()\n\t *\n\t * FileError({ message: 'Not found', context: { path: '/etc/config' } })  // OK\n\t * FileError({ message: 'Not found' })  // Type error: context required\n\t * ```\n\t *\n\t * @example Optional but typed context\n\t * ```ts\n\t * const { LogError } = createTaggedError('LogError')\n\t *   .withContext<{ file: string; line: number } | undefined>()\n\t *\n\t * LogError({ message: 'Parse error' })  // OK\n\t * LogError({ message: 'Parse error', context: { file: 'app.ts', line: 42 } })  // OK\n\t * ```\n\t *\n\t * @example Default (no generic): permissive optional context\n\t * ```ts\n\t * const { FlexError } = createTaggedError('FlexError')\n\t *   .withContext()  // Defaults to Record<string, unknown> | undefined\n\t *\n\t * FlexError({ message: 'Error' })  // OK - context is optional\n\t * FlexError({ message: 'Error', context: { anything: 'works' } })  // OK\n\t * ```\n\t */\n\twithContext<\n\t\tT extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,\n\t>(): ErrorBuilder<TName, T, TCause>;\n\n\t/**\n\t * Constrains the cause type for this error.\n\t *\n\t * Optionality is determined by whether the type includes `undefined`:\n\t * - `withCause<T>()` where T doesn't include undefined → cause is **required**\n\t * - `withCause<T | undefined>()` → cause is **optional** but typed when provided\n\t *\n\t * Since cause is typically optional, include `| undefined` in most cases.\n\t *\n\t * @typeParam T - The allowed cause type(s). Include `| undefined` to make optional.\n\t *\n\t * @example Optional typed cause (common)\n\t * ```ts\n\t * const { ServiceError } = createTaggedError('ServiceError')\n\t *   .withCause<DbError | CacheError | undefined>()\n\t *\n\t * ServiceError({ message: 'Failed' })  // OK\n\t * ServiceError({ message: 'Failed', cause: dbError })  // OK\n\t * ```\n\t *\n\t * @example Required cause (for wrapper errors)\n\t * ```ts\n\t * const { UnhandledError } = createTaggedError('UnhandledError')\n\t *   .withCause<AnyTaggedError>()\n\t *\n\t * UnhandledError({ message: 'Unexpected', cause: originalError })  // OK\n\t * UnhandledError({ message: 'Unexpected' })  // Type error: cause required\n\t * ```\n\t *\n\t * @example Default (no generic): permissive optional cause\n\t * ```ts\n\t * const { FlexError } = createTaggedError('FlexError')\n\t *   .withCause()  // Defaults to AnyTaggedError | undefined\n\t *\n\t * FlexError({ message: 'Error' })  // OK - cause is optional\n\t * FlexError({ message: 'Error', cause: anyTaggedError })  // OK\n\t * ```\n\t */\n\twithCause<\n\t\tT extends AnyTaggedError | undefined = AnyTaggedError | undefined,\n\t>(): ErrorBuilder<TName, TContext, T>;\n};\n\n// =============================================================================\n// Fluent API Implementation\n// =============================================================================\n\n/**\n * Creates a new tagged error type with a fluent builder API.\n *\n * Returns an object containing:\n * - `{Name}Error`: Factory function that creates plain TaggedError objects\n * - `{Name}Err`: Factory function that creates Err-wrapped TaggedError objects\n * - `withContext<T>()`: Chain method to add context type\n * - `withCause<T>()`: Chain method to add cause type\n *\n * **Explicit Opt-In (Rust-inspired):**\n * By default, errors only have `{ name, message }`. Context and cause must be\n * explicitly added via `.withContext<T>()` and `.withCause<T>()`. This follows\n * Rust's thiserror pattern where error properties are intentional decisions.\n *\n * **Optionality via type unions:**\n * Both `withContext` and `withCause` determine optionality based on whether\n * the type includes `undefined`:\n * - `T` without undefined → property is required\n * - `T | undefined` → property is optional but typed when provided\n *\n * @template TName - The name of the error type (must end with \"Error\")\n * @param name - The name of the error type\n *\n * @example Minimal error (no context, no cause)\n * ```ts\n * const { NetworkError, NetworkErr } = createTaggedError('NetworkError')\n *\n * NetworkError({ message: 'Connection failed' })\n * // Error only has { name: 'NetworkError', message: 'Connection failed' }\n * ```\n *\n * @example Required context\n * ```ts\n * const { ApiError, ApiErr } = createTaggedError('ApiError')\n *   .withContext<{ endpoint: string; status: number }>()\n *\n * ApiError({ message: 'Failed', context: { endpoint: '/users', status: 500 } })\n * // ApiError({ message: 'Failed' })  // Type error: context required\n * ```\n *\n * @example Optional typed cause\n * ```ts\n * const { ServiceError } = createTaggedError('ServiceError')\n *   .withCause<DbError | CacheError | undefined>()\n *\n * ServiceError({ message: 'Failed' })  // OK\n * ServiceError({ message: 'Failed', cause: dbError })  // OK, typed\n * ```\n *\n * @example Full example with both\n * ```ts\n * const { UserServiceError } = createTaggedError('UserServiceError')\n *   .withContext<{ userId: string }>()\n *   .withCause<RepoError | undefined>()\n *\n * // Type extraction works\n * type UserServiceError = ReturnType<typeof UserServiceError>\n * ```\n *\n * @example Permissive mode (if you want the old behavior)\n * ```ts\n * const { FlexibleError } = createTaggedError('FlexibleError')\n *   .withContext<Record<string, unknown> | undefined>()\n *   .withCause<AnyTaggedError | undefined>()\n * ```\n */\nexport function createTaggedError<TName extends `${string}Error`>(\n\tname: TName,\n): ErrorBuilder<TName> {\n\tconst createBuilder = <\n\t\tTContext extends Record<string, unknown> | undefined = undefined,\n\t\tTCause extends AnyTaggedError | undefined = undefined,\n\t>(): ErrorBuilder<TName, TContext, TCause> => {\n\t\tconst errorConstructor = (input: ErrorInput<TContext, TCause>) =>\n\t\t\t({ name, ...input }) as unknown as TaggedError<TName, TContext, TCause>;\n\n\t\tconst errName = name.replace(\n\t\t\t/Error$/,\n\t\t\t\"Err\",\n\t\t) as ReplaceErrorWithErr<TName>;\n\t\tconst errConstructor = (input: ErrorInput<TContext, TCause>) =>\n\t\t\tErr(errorConstructor(input));\n\n\t\treturn {\n\t\t\t[name]: errorConstructor,\n\t\t\t[errName]: errConstructor,\n\t\t\twithContext<\n\t\t\t\tT extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,\n\t\t\t>() {\n\t\t\t\treturn createBuilder<T, TCause>();\n\t\t\t},\n\t\t\twithCause<\n\t\t\t\tT extends AnyTaggedError | undefined = AnyTaggedError | undefined,\n\t\t\t>() {\n\t\t\t\treturn createBuilder<TContext, T>();\n\t\t\t},\n\t\t} as ErrorBuilder<TName, TContext, TCause>;\n\t};\n\n\treturn createBuilder();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,oBAAoBA,OAAwB;AAE3D,KAAI,iBAAiB,MACpB,QAAO,MAAM;AAId,YAAW,UAAU,SAAU,QAAO;AACtC,YACQ,UAAU,mBACV,UAAU,oBACV,UAAU,SAEjB,QAAO,OAAO,MAAM;AACrB,YAAW,UAAU,SAAU,QAAO,MAAM,UAAU;AACtD,KAAI,UAAU,KAAM,QAAO;AAC3B,KAAI,iBAAqB,QAAO;AAGhC,KAAI,MAAM,QAAQ,MAAM,CAAE,QAAO,KAAK,UAAU,MAAM;AAGtD,YAAW,UAAU,UAAU;EAC9B,MAAM,WAAW;EAGjB,MAAM,eAAe;GACpB;GACA;GACA;GACA;GACA;GACA;EACA;AACD,OAAK,MAAM,QAAQ,aAClB,KAAI,QAAQ,mBAAmB,SAAS,UAAU,SACjD,QAAO,SAAS;AAKlB,MAAI;AACH,UAAO,KAAK,UAAU,MAAM;EAC5B,QAAO;AACP,UAAO,OAAO,MAAM;EACpB;CACD;AAGD,QAAO,OAAO,MAAM;AACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmOD,SAAgB,kBACfC,MACsB;CACtB,MAAM,gBAAgB,MAGwB;EAC7C,MAAM,mBAAmB,CAACC,WACxB;GAAE;GAAM,GAAG;EAAO;EAEpB,MAAM,UAAU,KAAK,QACpB,UACA,MACA;EACD,MAAM,iBAAiB,CAACA,UACvB,IAAI,iBAAiB,MAAM,CAAC;AAE7B,SAAO;IACL,OAAO;IACP,UAAU;GACX,cAEI;AACH,WAAO,eAA0B;GACjC;GACD,YAEI;AACH,WAAO,eAA4B;GACnC;EACD;CACD;AAED,QAAO,eAAe;AACtB"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wellcrafted",
-	"version": "0.27.0",
+	"version": "0.28.0",
 	"description": "Delightful TypeScript patterns for elegant, type-safe applications",
 	"type": "module",
 	"files": [