wellcrafted 0.31.0 → 0.33.0

package/README.md

@@ -21,8 +21,8 @@ try {
 const { data, error } = await saveUser(user);
 if (error) {
   switch (error.name) {
-    case "ValidationError": 
-      showToast(`Invalid ${error.context.field}`);
+    case "ValidationError":
+      showToast(`Invalid ${error.field}`);
       break;
     case "AuthError":
       redirectToLogin();
@@ -54,18 +54,22 @@ function getUser(id: UserId) { /* ... */ }
 ```
 
 ### 📋 Tagged Errors
-Structured, serializable errors with a fluent API
+Structured, serializable errors with a declarative API
 ```typescript
-import { createTaggedError } from "wellcrafted/error";
+import { defineErrors, type InferError } from "wellcrafted/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>();
+const errors = defineErrors({
+  // Static error — no fields needed
+  ValidationError: () => ({
+    message: "Email is required",
+  }),
+  // Structured error — fields are spread flat on the error object
+  ApiError: (fields: { endpoint: string }) => ({
+    ...fields,
+    message: `Request to ${fields.endpoint} failed`,
+  }),
+});
+const { ValidationError, ApiError } = errors;
 ```
 
 ### 🔄 Query Integration
@@ -108,22 +112,22 @@ npm install wellcrafted
 
 ```typescript
 import { tryAsync } from "wellcrafted/result";
-import { createTaggedError, type AnyTaggedError } from "wellcrafted/error";
+import { defineErrors, type InferError } from "wellcrafted/error";
 
-// Define your error with factory function
-const { ApiError, ApiErr } = createTaggedError("ApiError")
-  .withContext<{ endpoint: string }>()
-  .withCause<AnyTaggedError | undefined>();
-type ApiError = ReturnType<typeof ApiError>;
+// Define your errors declaratively
+const errors = defineErrors({
+  ApiError: (fields: { endpoint: string }) => ({
+    ...fields,
+    message: `Failed to fetch ${fields.endpoint}`,
+  }),
+});
+const { ApiError, ApiErr } = errors;
+type ApiError = InferError<typeof errors, "ApiError">;
 
 // Wrap any throwing operation
 const { data, error } = await tryAsync({
   try: () => fetch('/api/user').then(r => r.json()),
-  catch: (e) => ApiErr({
-    message: "Failed to fetch user",
-    context: { endpoint: '/api/user' },
-    cause: { name: "FetchError", message: String(e) }
-  })
+  catch: (e) => ApiErr({ endpoint: '/api/user' })
 });
 
 if (error) {
@@ -216,29 +220,31 @@ if (error) {
 ### Wrap Unsafe Operations
 
 ```typescript
-// Define errors with context and cause
-const { ParseError, ParseErr } = createTaggedError("ParseError")
-  .withContext<{ input: string }>();
+import { defineErrors, type InferError } from "wellcrafted/error";
 
-const { NetworkError, NetworkErr } = createTaggedError("NetworkError")
-  .withContext<{ url: string }>();
+// Define errors declaratively
+const errors = defineErrors({
+  ParseError: (fields: { input: string }) => ({
+    ...fields,
+    message: `Invalid JSON: ${fields.input.slice(0, 50)}`,
+  }),
+  NetworkError: (fields: { url: string }) => ({
+    ...fields,
+    message: `Request to ${fields.url} failed`,
+  }),
+});
+const { ParseErr, NetworkErr } = errors;
 
 // Synchronous
 const result = trySync({
   try: () => JSON.parse(jsonString),
-  catch: () => ParseErr({
-    message: "Invalid JSON",
-    context: { input: jsonString }
-  })
+  catch: () => ParseErr({ input: jsonString })
 });
 
 // Asynchronous
 const result = await tryAsync({
   try: () => fetch(url),
-  catch: () => NetworkErr({
-    message: "Request failed",
-    context: { url }
-  })
+  catch: () => NetworkErr({ url })
 });
 ```
 
@@ -246,12 +252,19 @@ const result = await tryAsync({
 
 ```typescript
 // 1. Service Layer - Pure business logic
-import { createTaggedError } from "wellcrafted/error";
+import { defineErrors, type InferError } from "wellcrafted/error";
 import { tryAsync, Result, Ok } from "wellcrafted/result";
 
-const { RecorderServiceError, RecorderServiceErr } = createTaggedError("RecorderServiceError")
-  .withContext<{ currentState?: string; permissions?: string }>();
-type RecorderServiceError = ReturnType<typeof RecorderServiceError>;
+const recorderErrors = defineErrors({
+  RecorderServiceError: (fields: { currentState?: string; permissions?: string }) => ({
+    ...fields,
+    message: fields.permissions
+      ? `Missing ${fields.permissions} permission`
+      : `Invalid recorder state: ${fields.currentState}`,
+  }),
+});
+const { RecorderServiceError, RecorderServiceErr } = recorderErrors;
+type RecorderServiceError = InferError<typeof recorderErrors, "RecorderServiceError">;
 
 export function createRecorderService() {
   let isRecording = false;
@@ -260,10 +273,7 @@ export function createRecorderService() {
   return {
     async startRecording(): Promise<Result<void, RecorderServiceError>> {
       if (isRecording) {
-        return RecorderServiceErr({
-          message: "Already recording",
-          context: { currentState: 'recording' }
-        });
+        return RecorderServiceErr({ currentState: 'recording' });
       }
 
       return tryAsync({
@@ -273,19 +283,13 @@ export function createRecorderService() {
           // ... recording setup
           isRecording = true;
         },
-        catch: () => RecorderServiceErr({
-          message: "Failed to start recording",
-          context: { permissions: 'microphone' }
-        })
+        catch: () => RecorderServiceErr({ permissions: 'microphone' })
       });
     },
 
     async stopRecording(): Promise<Result<Blob, RecorderServiceError>> {
       if (!isRecording) {
-        return RecorderServiceErr({
-          message: "Not currently recording",
-          context: { currentState: 'idle' }
-        });
+        return RecorderServiceErr({ currentState: 'idle' });
       }
 
       // Stop recording and return blob...
@@ -379,12 +383,17 @@ const { data: parsed } = trySync({
 
 ### Propagation Pattern (May Fail)
 ```typescript
-const { ParseError, ParseErr } = createTaggedError("ParseError");
+const parseErrors = defineErrors({
+  ParseError: () => ({
+    message: "Invalid JSON",
+  }),
+});
+const { ParseErr } = parseErrors;
 
 // When catch can return Err<E>, function returns Result<T, E>
 const mayFail = trySync({
   try: () => JSON.parse(riskyJson),
-  catch: () => ParseErr({ message: "Invalid JSON" })
+  catch: () => ParseErr()
 });
 // mayFail: Result<object, ParseError> - Must check for errors
 if (isOk(mayFail)) {
@@ -402,7 +411,7 @@ const smartParse = trySync({
       return Ok({}); // Return Ok<T> for fallback
     }
     // Propagate other errors
-    return ParseErr({ message: "Parse failed" });
+    return ParseErr();
   }
 });
 // smartParse: Result<object, ParseError> - Mixed handling = Result type
@@ -432,13 +441,18 @@ Based on real-world usage, here's the recommended pattern for creating services
 ### Factory Function Pattern
 
 ```typescript
-import { createTaggedError } from "wellcrafted/error";
+import { defineErrors, type InferError } from "wellcrafted/error";
 import { Result, Ok } from "wellcrafted/result";
 
-// 1. Define service-specific errors with typed context
-const { RecorderServiceError, RecorderServiceErr } = createTaggedError("RecorderServiceError")
-  .withContext<{ isRecording: boolean }>();
-type RecorderServiceError = ReturnType<typeof RecorderServiceError>;
+// 1. Define service-specific errors with typed fields and message
+const recorderErrors = defineErrors({
+  RecorderServiceError: (fields: { isRecording: boolean }) => ({
+    ...fields,
+    message: fields.isRecording ? "Already recording" : "Not currently recording",
+  }),
+});
+const { RecorderServiceError, RecorderServiceErr } = recorderErrors;
+type RecorderServiceError = InferError<typeof recorderErrors, "RecorderServiceError">;
 
 // 2. Create service with factory function
 export function createRecorderService() {
@@ -449,10 +463,7 @@ export function createRecorderService() {
   return {
     startRecording(): Result<void, RecorderServiceError> {
       if (isRecording) {
-        return RecorderServiceErr({
-          message: "Already recording",
-          context: { isRecording }
-        });
+        return RecorderServiceErr({ isRecording });
       }
 
       isRecording = true;
@@ -461,10 +472,7 @@ export function createRecorderService() {
 
     stopRecording(): Result<Blob, RecorderServiceError> {
       if (!isRecording) {
-        return RecorderServiceErr({
-          message: "Not currently recording",
-          context: { isRecording }
-        });
+        return RecorderServiceErr({ isRecording });
       }
 
       isRecording = false;
@@ -548,8 +556,16 @@ export async function GET(request: Request) {
 <summary><b>Form Validation</b></summary>
 
 ```typescript
-const { FormError, FormErr } = createTaggedError("FormError")
-  .withContext<{ fields: Record<string, string[]> }>();
+import { defineErrors, type InferError } from "wellcrafted/error";
+
+const formErrors = defineErrors({
+  FormError: (fields: { fields: Record<string, string[]> }) => ({
+    ...fields,
+    message: `Validation failed for: ${Object.keys(fields.fields).join(", ")}`,
+  }),
+});
+const { FormErr } = formErrors;
+type FormError = InferError<typeof formErrors, "FormError">;
 
 function validateLoginForm(data: unknown): Result<LoginData, FormError> {
   const errors: Record<string, string[]> = {};
@@ -559,10 +575,7 @@ function validateLoginForm(data: unknown): Result<LoginData, FormError> {
   }
 
   if (Object.keys(errors).length > 0) {
-    return FormErr({
-      message: "Validation failed",
-      context: { fields: errors }
-    });
+    return FormErr({ fields: errors });
   }
 
   return Ok(data as LoginData);
@@ -630,19 +643,19 @@ For comprehensive examples, service layer patterns, framework integrations, and
 - **`defineMutation(options)`** - Define a mutation with dual interface (`.options` + callable/`.execute()`)
 
 ### Error Functions
-- **`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
+- **`defineErrors(definitions)`** - Define multiple error factories in a single declaration
+  - Each key becomes an error name; the value is a factory function returning fields + `message`
+  - Returns `{ErrorName}` (plain error) and `{ErrorName}Err` (Err-wrapped) for each key
+  - Factory functions receive typed fields and return `{ ...fields, message }`
+  - No-field errors use `() => ({ message: '...' })`
+  - `name` is a reserved key — prevented at compile time
 - **`extractErrorMessage(error)`** - Extract readable message from unknown error
 
 ### Types
 - **`Result<T, E>`** - Union of Ok<T> | Err<E>
 - **`Ok<T>`** - Success result type
 - **`Err<E>`** - Error result type
-- **`TaggedError<T>`** - Structured error type
+- **`InferError<TErrors, TName>`** - Extract error type from `defineErrors` result
 - **`Brand<T, B>`** - Branded type wrapper
 - **`ExtractOkFromResult<R>`** - Extract Ok variant from Result union
 - **`ExtractErrFromResult<R>`** - Extract Err variant from Result union

package/dist/error/index.d.ts

@@ -14,48 +14,74 @@ type JsonValue = string | number | boolean | null | JsonValue[] | {
  */
 type JsonObject = Record<string, JsonValue>;
 /**
- * Base type for any tagged error, used as a constraint for cause parameters.
+ * Base type for any tagged error, used as a minimum constraint.
  */
 type AnyTaggedError = {
   name: string;
   message: string;
 };
 /**
- * Helper type that adds a context property.
- * - 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
+ * Constructor return must include `message: string`.
+ * JSON serializability is a convention, not enforced at the type level
+ * (optional fields produce `T | undefined` which breaks `JsonObject`).
  */
-type WithContext<TContext> = [TContext] extends [undefined] ? Record<never, never> : [undefined] extends [TContext] ? {
-  context?: Exclude<TContext, undefined>;
-} : {
-  context: TContext;
+type ErrorBody = {
+  message: string;
 };
 /**
- * Helper type that adds a cause property.
- * - 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 without undefined: cause is REQUIRED
+ * Per-key validation: tells the user exactly what `name` will be stamped as.
+ * If a user provides `name` in the return object, they see a descriptive error.
  */
-type WithCause<TCause> = [TCause] extends [undefined] ? Record<never, never> : [undefined] extends [TCause] ? {
-  cause?: Exclude<TCause, undefined>;
-} : {
-  cause: TCause;
+type ValidateErrorBody<K extends string> = {
+  message: string;
+  name?: `The 'name' key is reserved as '${K}'. Remove it.`;
 };
+/** The config: each key is a variant name, each value is a constructor function. */
+type ErrorsConfig = Record<string, (...args: any[]) => ErrorBody>;
+/** Validates each config entry, injecting the key-specific `name` reservation message. */
+type ValidatedConfig<T extends ErrorsConfig> = { [K in keyof T & string]: T[K] extends ((...args: infer A) => infer R) ? (...args: A) => R & ValidateErrorBody<K> : T[K] };
+/** Single factory: takes constructor args, returns Err-wrapped error. */
+type ErrorFactory<TName extends string, TFn extends (...args: any[]) => ErrorBody> = { [K in TName]: (...args: Parameters<TFn>) => Err<Readonly<{
+  name: TName;
+} & ReturnType<TFn>>> };
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+/** Return type of `defineErrors`. Maps each config key to its factory. */
+type DefineErrorsReturn<TConfig extends ErrorsConfig> = UnionToIntersection<{ [K in keyof TConfig & string]: ErrorFactory<K, TConfig[K]> }[keyof TConfig & string]>;
+/** Extract the error type from a single factory. */
+type InferError<T> = T extends ((...args: any[]) => Err<infer R>) ? R : never;
+/** Extract union of ALL error types from a defineErrors return. */
+type InferErrors<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => Err<infer R>) ? R : never }[keyof T];
+//#endregion
+//#region src/error/defineErrors.d.ts
 /**
- * A tagged error type for type-safe error handling.
- * Uses the `name` property as a discriminator for tagged unions.
+ * Defines a set of typed error factories using Rust-style namespaced variants.
+ *
+ * Each key is a short variant name (the namespace provides context). Every
+ * factory returns `Err<...>` directly — ready for `trySync`/`tryAsync` catch
+ * handlers. The variant name is stamped as `name` on the error object.
  *
- * @template TName - The error name (discriminator for tagged unions)
- * @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
+ * const HttpError = defineErrors({
+ *   Connection: ({ cause }: { cause: string }) => ({
+ *     message: `Failed to connect: ${cause}`,
+ *     cause,
+ *   }),
+ *   Parse: ({ cause }: { cause: string }) => ({
+ *     message: `Failed to parse: ${cause}`,
+ *     cause,
+ *   }),
+ * });
+ *
+ * type HttpError = InferErrors<typeof HttpError>;
+ *
+ * const result = HttpError.Connection({ cause: 'timeout' }); // Err<...>
+ * ```
  */
-type TaggedError<TName extends string = string, TContext extends JsonObject | undefined = undefined, TCause extends AnyTaggedError | undefined = undefined> = Readonly<{
-  name: TName;
-  message: string;
-} & WithContext<TContext> & WithCause<TCause>>;
+declare function defineErrors<const TConfig extends ErrorsConfig>(config: TConfig & ValidatedConfig<TConfig>): DefineErrorsReturn<TConfig>;
+//# sourceMappingURL=defineErrors.d.ts.map
 //#endregion
-//#region src/error/utils.d.ts
+//#region src/error/extractErrorMessage.d.ts
 /**
  * Extracts a readable error message from an unknown error value
  *
@@ -63,98 +89,8 @@ type TaggedError<TName extends string = string, TContext extends JsonObject | un
  * @returns A string representation of the error
  */
 declare function extractErrorMessage(error: unknown): string;
-/**
- * Replaces the "Error" suffix with "Err" suffix in error type names.
- */
-type ReplaceErrorWithErr<T extends `${string}Error`> = T extends `${infer TBase}Error` ? `${TBase}Err` : never;
-/**
- * Input provided to the message template function.
- * Contains everything the error will have except `message` (since that's what it computes).
- */
-type MessageInput<TName extends string, TContext extends JsonObject | undefined, TCause extends AnyTaggedError | undefined> = {
-  name: TName;
-} & ([TContext] extends [undefined] ? Record<never, never> : {
-  context: Exclude<TContext, undefined>;
-}) & ([TCause] extends [undefined] ? Record<never, never> : {
-  cause: Exclude<TCause, undefined>;
-});
-/**
- * Message template function type.
- */
-type MessageFn<TName extends string, TContext extends JsonObject | undefined, TCause extends AnyTaggedError | undefined> = (input: MessageInput<TName, TContext, TCause>) => string;
-/**
- * Helper type that determines optionality based on whether T includes undefined.
- */
-type OptionalIfUndefined<T, TKey extends string> = undefined extends T ? { [K in TKey]?: Exclude<T, undefined> } : { [K in TKey]: T };
-/**
- * Input type for error factory functions.
- * `message` is optional (computed from template when omitted).
- * `context` and `cause` follow the same optionality rules as before.
- */
-type ErrorCallInput<TContext extends JsonObject | undefined, TCause extends AnyTaggedError | undefined> = {
-  message?: string;
-} & (TContext extends undefined ? Record<never, never> : OptionalIfUndefined<TContext, "context">) & (TCause extends undefined ? Record<never, never> : OptionalIfUndefined<TCause, "cause">);
-/**
- * The final factories object returned by `.withMessage()`.
- * Has factory functions, NO chain methods.
- */
-type FinalFactories<TName extends `${string}Error`, TContext extends JsonObject | undefined, TCause extends AnyTaggedError | undefined> = { [K in TName]: (input: ErrorCallInput<TContext, TCause>) => TaggedError<TName, TContext, TCause> } & { [K in ReplaceErrorWithErr<TName>]: (input: ErrorCallInput<TContext, TCause>) => Err<TaggedError<TName, TContext, TCause>> };
-/**
- * Builder interface for the fluent createTaggedError API.
- * Has chain methods only, NO factory functions.
- * Must call `.withMessage(fn)` to get factories.
- */
-type ErrorBuilder<TName extends `${string}Error`, TContext extends JsonObject | undefined = undefined, TCause extends AnyTaggedError | undefined = undefined> = {
-  /**
-   * Constrains the context type for this error.
-   * `.withContext<T>()` where T doesn't include undefined → context is **required**
-   * `.withContext<T | undefined>()` → context is **optional** but typed when provided
-   */
-  withContext<T extends JsonObject | undefined = JsonObject | undefined>(): ErrorBuilder<TName, T, TCause>;
-  /**
-   * Constrains the cause type for this error.
-   * `.withCause<T>()` where T doesn't include undefined → cause is **required**
-   * `.withCause<T | undefined>()` → cause is **optional** but typed when provided
-   */
-  withCause<T extends AnyTaggedError | undefined = AnyTaggedError | undefined>(): ErrorBuilder<TName, TContext, T>;
-  /**
-   * Terminal method that defines how the error message is computed from its data.
-   * Returns the factory functions — this is the only way to get them.
-   *
-   * @param fn - Template function that receives `{ name, context?, cause? }` and returns a message string
-   */
-  withMessage(fn: MessageFn<TName, TContext, TCause>): FinalFactories<TName, TContext, TCause>;
-};
-/**
- * Creates a new tagged error type with a fluent builder API.
- *
- * The builder provides `.withContext<T>()`, `.withCause<T>()`, and `.withMessage(fn)`.
- * `.withMessage(fn)` is **required** and **terminal** — it returns the factory functions.
- *
- * @example Simple error
- * ```ts
- * const { RecorderBusyError, RecorderBusyErr } = createTaggedError('RecorderBusyError')
- *   .withMessage(() => 'A recording is already in progress');
- * ```
- *
- * @example Error with context
- * ```ts
- * const { DbNotFoundError, DbNotFoundErr } = createTaggedError('DbNotFoundError')
- *   .withContext<{ table: string; id: string }>()
- *   .withMessage(({ context }) => `${context.table} '${context.id}' not found`);
- * ```
- *
- * @example Error with context and cause
- * ```ts
- * const { ServiceError, ServiceErr } = createTaggedError('ServiceError')
- *   .withContext<{ operation: string }>()
- *   .withCause<DbServiceError>()
- *   .withMessage(({ context, cause }) =>
- *     `Operation '${context.operation}' failed: ${cause.message}`
- *   );
- * ```
- */
-declare function createTaggedError<TName extends `${string}Error`>(name: TName): ErrorBuilder<TName>;
+//# sourceMappingURL=extractErrorMessage.d.ts.map
+
 //#endregion
-export { AnyTaggedError, JsonObject, JsonValue, TaggedError, createTaggedError, extractErrorMessage };
+export { AnyTaggedError, DefineErrorsReturn, ErrorBody, ErrorsConfig, InferError, InferErrors, JsonObject, JsonValue, ValidatedConfig, defineErrors, extractErrorMessage };
 //# sourceMappingURL=index.d.ts.map

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/defineErrors.ts","../../src/error/extractErrorMessage.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/error/index.js

@@ -1,6 +1,45 @@
 import { Err } from "../result-DnOm5ds5.js";
 
-//#region src/error/utils.ts
+//#region src/error/defineErrors.ts
+/**
+* Defines a set of typed error factories using Rust-style namespaced variants.
+*
+* Each key is a short variant name (the namespace provides context). Every
+* factory returns `Err<...>` directly — ready for `trySync`/`tryAsync` catch
+* handlers. The variant name is stamped as `name` on the error object.
+*
+* @example
+* ```ts
+* const HttpError = defineErrors({
+*   Connection: ({ cause }: { cause: string }) => ({
+*     message: `Failed to connect: ${cause}`,
+*     cause,
+*   }),
+*   Parse: ({ cause }: { cause: string }) => ({
+*     message: `Failed to parse: ${cause}`,
+*     cause,
+*   }),
+* });
+*
+* type HttpError = InferErrors<typeof HttpError>;
+*
+* const result = HttpError.Connection({ cause: 'timeout' }); // Err<...>
+* ```
+*/
+function defineErrors(config) {
+	const result = {};
+	for (const [name, ctor] of Object.entries(config)) result[name] = (...args) => {
+		const body = ctor(...args);
+		return Err(Object.freeze({
+			...body,
+			name
+		}));
+	};
+	return result;
+}
+
+//#endregion
+//#region src/error/extractErrorMessage.ts
 /**
 * Extracts a readable error message from an unknown error value
 *
@@ -34,70 +73,7 @@ function extractErrorMessage(error) {
 	}
 	return String(error);
 }
-/**
-* Creates a new tagged error type with a fluent builder API.
-*
-* The builder provides `.withContext<T>()`, `.withCause<T>()`, and `.withMessage(fn)`.
-* `.withMessage(fn)` is **required** and **terminal** — it returns the factory functions.
-*
-* @example Simple error
-* ```ts
-* const { RecorderBusyError, RecorderBusyErr } = createTaggedError('RecorderBusyError')
-*   .withMessage(() => 'A recording is already in progress');
-* ```
-*
-* @example Error with context
-* ```ts
-* const { DbNotFoundError, DbNotFoundErr } = createTaggedError('DbNotFoundError')
-*   .withContext<{ table: string; id: string }>()
-*   .withMessage(({ context }) => `${context.table} '${context.id}' not found`);
-* ```
-*
-* @example Error with context and cause
-* ```ts
-* const { ServiceError, ServiceErr } = createTaggedError('ServiceError')
-*   .withContext<{ operation: string }>()
-*   .withCause<DbServiceError>()
-*   .withMessage(({ context, cause }) =>
-*     `Operation '${context.operation}' failed: ${cause.message}`
-*   );
-* ```
-*/
-function createTaggedError(name) {
-	const createBuilder = () => {
-		return {
-			withContext() {
-				return createBuilder();
-			},
-			withCause() {
-				return createBuilder();
-			},
-			withMessage(fn) {
-				const errorConstructor = (input) => {
-					const messageInput = {
-						name,
-						..."context" in input ? { context: input.context } : {},
-						..."cause" in input ? { cause: input.cause } : {}
-					};
-					return {
-						name,
-						message: input.message ?? fn(messageInput),
-						..."context" in input ? { context: input.context } : {},
-						..."cause" in input ? { cause: input.cause } : {}
-					};
-				};
-				const errName = name.replace(/Error$/, "Err");
-				const errConstructor = (input) => Err(errorConstructor(input));
-				return {
-					[name]: errorConstructor,
-					[errName]: errConstructor
-				};
-			}
-		};
-	};
-	return createBuilder();
-}
 
 //#endregion
-export { createTaggedError, extractErrorMessage };
+export { defineErrors, extractErrorMessage };
 //# sourceMappingURL=index.js.map

package/dist/error/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["error: unknown","name: TName","fn: MessageFn<TName, TContext, TCause>","input: ErrorCallInput<TContext, TCause>"],"sources":["../../src/error/utils.ts"],"sourcesContent":["import type {\n\tTaggedError,\n\tAnyTaggedError,\n\tJsonObject,\n} from \"./types.js\";\nimport { Err } from \"../result/result.js\";\n\n/**\n * Extracts a readable error message from an unknown error value\n *\n * @param error - The unknown error to extract a message from\n * @returns A string representation of the error\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 */\ntype ReplaceErrorWithErr<T extends `${string}Error`> =\n\tT extends `${infer TBase}Error` ? `${TBase}Err` : never;\n\n// =============================================================================\n// Message Function Types\n// =============================================================================\n\n/**\n * Input provided to the message template function.\n * Contains everything the error will have except `message` (since that's what it computes).\n */\ntype MessageInput<\n\tTName extends string,\n\tTContext extends JsonObject | undefined,\n\tTCause extends AnyTaggedError | undefined,\n> = { name: TName } & ([TContext] extends [undefined]\n\t? Record<never, never>\n\t: { context: Exclude<TContext, undefined> }) &\n\t([TCause] extends [undefined]\n\t\t? Record<never, never>\n\t\t: { cause: Exclude<TCause, undefined> });\n\n/**\n * Message template function type.\n */\ntype MessageFn<\n\tTName extends string,\n\tTContext extends JsonObject | undefined,\n\tTCause extends AnyTaggedError | undefined,\n> = (input: MessageInput<TName, TContext, TCause>) => string;\n\n// =============================================================================\n// Factory Input Types\n// =============================================================================\n\n/**\n * Helper type that determines optionality based on whether T includes undefined.\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 factory functions.\n * `message` is optional (computed from template when omitted).\n * `context` and `cause` follow the same optionality rules as before.\n */\ntype ErrorCallInput<\n\tTContext extends JsonObject | undefined,\n\tTCause extends AnyTaggedError | undefined,\n> = { message?: string } & (TContext extends undefined\n\t? Record<never, never>\n\t: OptionalIfUndefined<TContext, \"context\">) &\n\t(TCause extends undefined\n\t\t? Record<never, never>\n\t\t: OptionalIfUndefined<TCause, \"cause\">);\n\n// =============================================================================\n// Builder & Factory Types\n// =============================================================================\n\n/**\n * The final factories object returned by `.withMessage()`.\n * Has factory functions, NO chain methods.\n */\ntype FinalFactories<\n\tTName extends `${string}Error`,\n\tTContext extends JsonObject | undefined,\n\tTCause extends AnyTaggedError | undefined,\n> = {\n\t[K in TName]: (\n\t\tinput: ErrorCallInput<TContext, TCause>,\n\t) => TaggedError<TName, TContext, TCause>;\n} & {\n\t[K in ReplaceErrorWithErr<TName>]: (\n\t\tinput: ErrorCallInput<TContext, TCause>,\n\t) => Err<TaggedError<TName, TContext, TCause>>;\n};\n\n/**\n * Builder interface for the fluent createTaggedError API.\n * Has chain methods only, NO factory functions.\n * Must call `.withMessage(fn)` to get factories.\n */\ntype ErrorBuilder<\n\tTName extends `${string}Error`,\n\tTContext extends JsonObject | undefined = undefined,\n\tTCause extends AnyTaggedError | undefined = undefined,\n> = {\n\t/**\n\t * Constrains the context type for this error.\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\twithContext<\n\t\tT extends JsonObject | undefined = JsonObject | undefined,\n\t>(): ErrorBuilder<TName, T, TCause>;\n\n\t/**\n\t * Constrains the cause type for this error.\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\twithCause<\n\t\tT extends AnyTaggedError | undefined = AnyTaggedError | undefined,\n\t>(): ErrorBuilder<TName, TContext, T>;\n\n\t/**\n\t * Terminal method that defines how the error message is computed from its data.\n\t * Returns the factory functions — this is the only way to get them.\n\t *\n\t * @param fn - Template function that receives `{ name, context?, cause? }` and returns a message string\n\t */\n\twithMessage(\n\t\tfn: MessageFn<TName, TContext, TCause>,\n\t): FinalFactories<TName, TContext, TCause>;\n};\n\n// =============================================================================\n// Implementation\n// =============================================================================\n\n/**\n * Creates a new tagged error type with a fluent builder API.\n *\n * The builder provides `.withContext<T>()`, `.withCause<T>()`, and `.withMessage(fn)`.\n * `.withMessage(fn)` is **required** and **terminal** — it returns the factory functions.\n *\n * @example Simple error\n * ```ts\n * const { RecorderBusyError, RecorderBusyErr } = createTaggedError('RecorderBusyError')\n *   .withMessage(() => 'A recording is already in progress');\n * ```\n *\n * @example Error with context\n * ```ts\n * const { DbNotFoundError, DbNotFoundErr } = createTaggedError('DbNotFoundError')\n *   .withContext<{ table: string; id: string }>()\n *   .withMessage(({ context }) => `${context.table} '${context.id}' not found`);\n * ```\n *\n * @example Error with context and cause\n * ```ts\n * const { ServiceError, ServiceErr } = createTaggedError('ServiceError')\n *   .withContext<{ operation: string }>()\n *   .withCause<DbServiceError>()\n *   .withMessage(({ context, cause }) =>\n *     `Operation '${context.operation}' failed: ${cause.message}`\n *   );\n * ```\n */\nexport function createTaggedError<TName extends `${string}Error`>(\n\tname: TName,\n): ErrorBuilder<TName> {\n\tconst createBuilder = <\n\t\tTContext extends JsonObject | undefined = undefined,\n\t\tTCause extends AnyTaggedError | undefined = undefined,\n\t>(): ErrorBuilder<TName, TContext, TCause> => {\n\t\treturn {\n\t\t\twithContext<\n\t\t\t\tT extends JsonObject | undefined = JsonObject | 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\twithMessage(\n\t\t\t\tfn: MessageFn<TName, TContext, TCause>,\n\t\t\t): FinalFactories<TName, TContext, TCause> {\n\t\t\t\tconst errorConstructor = (\n\t\t\t\t\tinput: ErrorCallInput<TContext, TCause>,\n\t\t\t\t) => {\n\t\t\t\t\tconst messageInput = {\n\t\t\t\t\t\tname,\n\t\t\t\t\t\t...(\"context\" in input ? { context: input.context } : {}),\n\t\t\t\t\t\t...(\"cause\" in input ? { cause: input.cause } : {}),\n\t\t\t\t\t} as MessageInput<TName, TContext, TCause>;\n\n\t\t\t\t\treturn {\n\t\t\t\t\t\tname,\n\t\t\t\t\t\tmessage:\n\t\t\t\t\t\t\tinput.message ?? fn(messageInput),\n\t\t\t\t\t\t...(\"context\" in input ? { context: input.context } : {}),\n\t\t\t\t\t\t...(\"cause\" in input ? { cause: input.cause } : {}),\n\t\t\t\t\t} as unknown as TaggedError<TName, TContext, TCause>;\n\t\t\t\t};\n\n\t\t\t\tconst errName = name.replace(\n\t\t\t\t\t/Error$/,\n\t\t\t\t\t\"Err\",\n\t\t\t\t) as ReplaceErrorWithErr<TName>;\n\t\t\t\tconst errConstructor = (\n\t\t\t\t\tinput: ErrorCallInput<TContext, TCause>,\n\t\t\t\t) => Err(errorConstructor(input));\n\n\t\t\t\treturn {\n\t\t\t\t\t[name]: errorConstructor,\n\t\t\t\t\t[errName]: errConstructor,\n\t\t\t\t} as FinalFactories<TName, TContext, TCause>;\n\t\t\t},\n\t\t} as ErrorBuilder<TName, TContext, TCause>;\n\t};\n\n\treturn createBuilder();\n}\n"],"mappings":";;;;;;;;;AAaA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4JD,SAAgB,kBACfC,MACsB;CACtB,MAAM,gBAAgB,MAGwB;AAC7C,SAAO;GACN,cAEI;AACH,WAAO,eAA0B;GACjC;GACD,YAEI;AACH,WAAO,eAA4B;GACnC;GACD,YACCC,IAC0C;IAC1C,MAAM,mBAAmB,CACxBC,UACI;KACJ,MAAM,eAAe;MACpB;MACA,GAAI,aAAa,QAAQ,EAAE,SAAS,MAAM,QAAS,IAAG,CAAE;MACxD,GAAI,WAAW,QAAQ,EAAE,OAAO,MAAM,MAAO,IAAG,CAAE;KAClD;AAED,YAAO;MACN;MACA,SACC,MAAM,WAAW,GAAG,aAAa;MAClC,GAAI,aAAa,QAAQ,EAAE,SAAS,MAAM,QAAS,IAAG,CAAE;MACxD,GAAI,WAAW,QAAQ,EAAE,OAAO,MAAM,MAAO,IAAG,CAAE;KAClD;IACD;IAED,MAAM,UAAU,KAAK,QACpB,UACA,MACA;IACD,MAAM,iBAAiB,CACtBA,UACI,IAAI,iBAAiB,MAAM,CAAC;AAEjC,WAAO;MACL,OAAO;MACP,UAAU;IACX;GACD;EACD;CACD;AAED,QAAO,eAAe;AACtB"}
+{"version":3,"file":"index.js","names":["config: TConfig & ValidatedConfig<TConfig>","result: Record<string, unknown>","error: unknown"],"sources":["../../src/error/defineErrors.ts","../../src/error/extractErrorMessage.ts"],"sourcesContent":["import { Err } from \"../result/result.js\";\nimport type {\n\tDefineErrorsReturn,\n\tErrorsConfig,\n\tValidatedConfig,\n} from \"./types.js\";\n\n/**\n * Defines a set of typed error factories using Rust-style namespaced variants.\n *\n * Each key is a short variant name (the namespace provides context). Every\n * factory returns `Err<...>` directly — ready for `trySync`/`tryAsync` catch\n * handlers. The variant name is stamped as `name` on the error object.\n *\n * @example\n * ```ts\n * const HttpError = defineErrors({\n *   Connection: ({ cause }: { cause: string }) => ({\n *     message: `Failed to connect: ${cause}`,\n *     cause,\n *   }),\n *   Parse: ({ cause }: { cause: string }) => ({\n *     message: `Failed to parse: ${cause}`,\n *     cause,\n *   }),\n * });\n *\n * type HttpError = InferErrors<typeof HttpError>;\n *\n * const result = HttpError.Connection({ cause: 'timeout' }); // Err<...>\n * ```\n */\nexport function defineErrors<const TConfig extends ErrorsConfig>(\n\tconfig: TConfig & ValidatedConfig<TConfig>,\n): DefineErrorsReturn<TConfig> {\n\tconst result: Record<string, unknown> = {};\n\n\tfor (const [name, ctor] of Object.entries(config)) {\n\t\tresult[name] = (...args: unknown[]) => {\n\t\t\tconst body = (ctor as (...a: unknown[]) => Record<string, unknown>)(\n\t\t\t\t...args,\n\t\t\t);\n\t\t\treturn Err(Object.freeze({ ...body, name }));\n\t\t};\n\t}\n\n\treturn result as DefineErrorsReturn<TConfig>;\n}\n","/**\n * Extracts a readable error message from an unknown error value\n *\n * @param error - The unknown error to extract a message from\n * @returns A string representation of the error\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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,aACfA,QAC8B;CAC9B,MAAMC,SAAkC,CAAE;AAE1C,MAAK,MAAM,CAAC,MAAM,KAAK,IAAI,OAAO,QAAQ,OAAO,CAChD,QAAO,QAAQ,CAAC,GAAG,SAAoB;EACtC,MAAM,OAAO,AAAC,KACb,GAAG,KACH;AACD,SAAO,IAAI,OAAO,OAAO;GAAE,GAAG;GAAM;EAAM,EAAC,CAAC;CAC5C;AAGF,QAAO;AACP;;;;;;;;;;ACzCD,SAAgB,oBAAoBC,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"}

package/package.json

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