wellcrafted 0.25.0 → 0.26.0

package/dist/error/index.d.ts

@@ -1,22 +1,44 @@
-import { Err } from "../result-DRq8PMRe.js";
+import { Err } from "../result-DolxQXIZ.js";
 
 //#region src/error/types.d.ts
-
 /**
- * Helper type that adds a context property only when TContext is not never.
- * When TContext is never, returns an empty object (no context property).
- * When TContext is a real type, returns { context: TContext } (required property).
+ * Base type for any tagged error, used as a constraint for cause parameters.
+ */
+type AnyTaggedError = {
+  name: string;
+  message: string;
+};
+/**
+ * Helper type that adds a context property.
+ * - When TContext is undefined (default): context is OPTIONAL with loose typing
+ * - 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.
  */
-type WithContext<TContext> = [TContext] extends [never] ? {} : {
+type WithContext<TContext> = [TContext] extends [undefined] ? {
+  context?: Record<string, unknown>;
+} : [undefined] extends [TContext] ? {
+  context?: Exclude<TContext, undefined>;
+} : {
   context: TContext;
 };
 /**
- * Helper type that adds a cause property only when TCause is not never.
- * When TCause is never, returns an empty object (no cause property).
- * When TCause is a real type, returns { cause: TCause } (required property).
+ * Helper type that adds a cause property.
+ * - When TCause is undefined (default): cause is OPTIONAL, any tagged error allowed
+ * - 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
+ *
+ * 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.
+ * Using brackets to prevent distributive conditional behavior with union types.
  */
-type WithCause<TCause> = [TCause] extends [never] ? {} : {
-  cause: TCause;
+type WithCause<TCause> = [TCause] extends [undefined] ? {
+  cause?: AnyTaggedError;
+} : [undefined] extends [TCause] ? {
+  cause?: Exclude<TCause, undefined>;
+} : {
+  cause?: TCause;
 };
 /**
  * Creates a tagged error type for type-safe error handling.
@@ -27,41 +49,47 @@ type WithCause<TCause> = [TCause] extends [never] ? {} : {
  * an error propagated through your application layers.
  *
  * **Type Parameter Behavior:**
- * - When `TContext` is `never` (default): No `context` property exists
- * - When `TContext` is specified: `context` is a **required** property
- * - When `TCause` is `never` (default): No `cause` property exists
- * - When `TCause` is specified: `cause` is a **required** property
+ * - 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
  *
  * @template TName - The error name (discriminator for tagged unions)
- * @template TContext - Additional context data for the error (default: never = no context property)
- * @template TCause - The type of error that caused this error (default: never = no cause property)
+ * @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)
  *
  * @example
  * ```ts
- * // Simple error without context or cause (properties don't exist)
+ * // Flexible error (context and cause optional, loosely typed)
  * type ValidationError = TaggedError<"ValidationError">;
  * const validationError: ValidationError = {
  *   name: "ValidationError",
  *   message: "Input is required"
  * };
- * // validationError.context // Property 'context' does not exist
+ * // validationError.context is optional, typed as Record<string, unknown> | undefined
  *
- * // Error with required context
+ * // Error with required context (fixed context mode)
  * 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; // No optional chaining needed
+ * const host = networkError.context.host; // Type-safe, no optional chaining needed
  *
- * // Type-safe error chaining with required cause
+ * // 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
+ *
+ * // Error with fixed context and constrained cause type
  * type DatabaseError = TaggedError<"DatabaseError", { operation: string }, NetworkError>;
  * const dbError: DatabaseError = {
  *   name: "DatabaseError",
  *   message: "Failed to connect to database",
  *   context: { operation: "connect" }, // Required!
- *   cause: networkError // Required!
+ *   cause: networkError // Optional, but must be NetworkError if provided
  * };
  *
  * // Discriminated unions still work
@@ -75,7 +103,7 @@ type WithCause<TCause> = [TCause] extends [never] ? {} : {
  * }
  * ```
  */
-type TaggedError<TName extends string = string, TContext = never, TCause = never> = Readonly<{
+type TaggedError<TName extends string = string, TContext extends Record<string, unknown> | undefined = undefined, TCause extends AnyTaggedError | undefined = undefined> = Readonly<{
   name: TName;
   message: string;
 } & WithContext<TContext> & WithCause<TCause>>;
@@ -117,13 +145,6 @@ type TaggedError<TName extends string = string, TContext = never, TCause = never
  * ```
  */
 declare function extractErrorMessage(error: unknown): string;
-/**
- * Base type for any tagged error, used as a constraint for cause parameters.
- */
-type AnyTaggedError = {
-  name: string;
-  message: string;
-};
 /**
  * Replaces the "Error" suffix with "Err" suffix in error type names.
  *
@@ -138,133 +159,103 @@ type AnyTaggedError = {
  */
 type ReplaceErrorWithErr<T extends `${string}Error`> = T extends `${infer TBase}Error` ? `${TBase}Err` : never;
 /**
- * Return type when neither context nor cause are constrained.
- * Both factory functions accept any context and cause at call time.
+ * Return type when neither context nor cause are constrained (flexible mode).
+ * Context and cause are optional with loose typing.
  */
 type FlexibleFactories<TName extends `${string}Error`> = { [K in TName]: FlexibleErrorConstructor<K> } & { [K in ReplaceErrorWithErr<TName>]: FlexibleErrConstructor<TName> };
 /**
- * Return type when context is fixed but cause is flexible.
- * Context shape is locked, but cause can be any TaggedError at call time.
+ * Return type when context is fixed.
+ * Context is required with exact type; cause is optional.
  */
 type ContextFixedFactories<TName extends `${string}Error`, TContext extends Record<string, unknown>> = { [K in TName]: ContextFixedErrorConstructor<K, TContext> } & { [K in ReplaceErrorWithErr<TName>]: ContextFixedErrConstructor<TName, TContext> };
 /**
  * Return type when both context and cause are fixed.
- * Both shapes are locked at factory creation time.
+ * Context is required; cause is optional but constrained to specific type.
  */
 type BothFixedFactories<TName extends `${string}Error`, TContext extends Record<string, unknown>, TCause extends AnyTaggedError> = { [K in TName]: BothFixedErrorConstructor<K, TContext, TCause> } & { [K in ReplaceErrorWithErr<TName>]: BothFixedErrConstructor<TName, TContext, TCause> };
 /**
  * Creates plain TaggedError objects with flexible context and cause.
- * Uses function overloads to precisely match return types to inputs.
+ * Single signature: context and cause are optional with loose typing.
  */
-type FlexibleErrorConstructor<TName extends string> = {
-  (input: {
-    message: string;
-  }): TaggedError<TName, never, never>;
-  <TContext extends Record<string, unknown>>(input: {
-    message: string;
-    context: TContext;
-  }): TaggedError<TName, TContext, never>;
-  <TCause extends AnyTaggedError>(input: {
-    message: string;
-    cause: TCause;
-  }): TaggedError<TName, never, TCause>;
-  <TContext extends Record<string, unknown>, TCause extends AnyTaggedError>(input: {
-    message: string;
-    context: TContext;
-    cause: TCause;
-  }): TaggedError<TName, TContext, TCause>;
-};
+type FlexibleErrorConstructor<TName extends string> = (input: {
+  message: string;
+  context?: Record<string, unknown>;
+  cause?: AnyTaggedError;
+}) => TaggedError<TName>;
 /**
  * Creates Err-wrapped TaggedError objects with flexible context and cause.
+ * Single signature: context and cause are optional with loose typing.
  */
-type FlexibleErrConstructor<TName extends string> = {
-  (input: {
-    message: string;
-  }): Err<TaggedError<TName, never, never>>;
-  <TContext extends Record<string, unknown>>(input: {
-    message: string;
-    context: TContext;
-  }): Err<TaggedError<TName, TContext, never>>;
-  <TCause extends AnyTaggedError>(input: {
-    message: string;
-    cause: TCause;
-  }): Err<TaggedError<TName, never, TCause>>;
-  <TContext extends Record<string, unknown>, TCause extends AnyTaggedError>(input: {
-    message: string;
-    context: TContext;
-    cause: TCause;
-  }): Err<TaggedError<TName, TContext, TCause>>;
-};
+type FlexibleErrConstructor<TName extends string> = (input: {
+  message: string;
+  context?: Record<string, unknown>;
+  cause?: AnyTaggedError;
+}) => Err<TaggedError<TName>>;
 /**
- * Creates plain TaggedError objects with fixed context but flexible cause.
- * Context is always required. Cause is optional and inferred at call site.
+ * Creates plain TaggedError objects with fixed context.
+ * Single signature: context is required, cause is optional.
  */
-type ContextFixedErrorConstructor<TName extends string, TContext extends Record<string, unknown>> = {
-  (input: {
-    message: string;
-    context: TContext;
-  }): TaggedError<TName, TContext, never>;
-  <TCause extends AnyTaggedError>(input: {
-    message: string;
-    context: TContext;
-    cause: TCause;
-  }): TaggedError<TName, TContext, TCause>;
-};
+type ContextFixedErrorConstructor<TName extends string, TContext extends Record<string, unknown>> = (input: {
+  message: string;
+  context: TContext;
+  cause?: AnyTaggedError;
+}) => TaggedError<TName, TContext>;
 /**
- * Creates Err-wrapped TaggedError objects with fixed context but flexible cause.
+ * Creates Err-wrapped TaggedError objects with fixed context.
+ * Single signature: context is required, cause is optional.
  */
-type ContextFixedErrConstructor<TName extends string, TContext extends Record<string, unknown>> = {
-  (input: {
-    message: string;
-    context: TContext;
-  }): Err<TaggedError<TName, TContext, never>>;
-  <TCause extends AnyTaggedError>(input: {
-    message: string;
-    context: TContext;
-    cause: TCause;
-  }): Err<TaggedError<TName, TContext, TCause>>;
-};
+type ContextFixedErrConstructor<TName extends string, TContext extends Record<string, unknown>> = (input: {
+  message: string;
+  context: TContext;
+  cause?: AnyTaggedError;
+}) => Err<TaggedError<TName, TContext>>;
 /**
  * Creates plain TaggedError objects with both context and cause fixed.
- * Context is required. Cause is optional but must match the specified type.
+ * Single signature: context is required, cause is optional but constrained.
  */
-type BothFixedErrorConstructor<TName extends string, TContext extends Record<string, unknown>, TCause extends AnyTaggedError> = {
-  (input: {
-    message: string;
-    context: TContext;
-  }): TaggedError<TName, TContext, never>;
-  (input: {
-    message: string;
-    context: TContext;
-    cause: TCause;
-  }): TaggedError<TName, TContext, TCause>;
-};
+type BothFixedErrorConstructor<TName extends string, TContext extends Record<string, unknown>, TCause extends AnyTaggedError> = (input: {
+  message: string;
+  context: TContext;
+  cause?: TCause;
+}) => TaggedError<TName, TContext, TCause>;
 /**
  * Creates Err-wrapped TaggedError objects with both context and cause fixed.
+ * Single signature: context is required, cause is optional but constrained.
  */
-type BothFixedErrConstructor<TName extends string, TContext extends Record<string, unknown>, TCause extends AnyTaggedError> = {
-  (input: {
-    message: string;
-    context: TContext;
-  }): Err<TaggedError<TName, TContext, never>>;
-  (input: {
-    message: string;
-    context: TContext;
-    cause: TCause;
-  }): Err<TaggedError<TName, TContext, TCause>>;
-};
+type BothFixedErrConstructor<TName extends string, TContext extends Record<string, unknown>, TCause extends AnyTaggedError> = (input: {
+  message: string;
+  context: TContext;
+  cause?: TCause;
+}) => Err<TaggedError<TName, TContext, TCause>>;
 /**
  * Creates two factory functions for building tagged errors with type-safe error chaining.
  *
+ * @deprecated Use `defineError()` instead for a cleaner fluent API:
+ * ```ts
+ * // Before
+ * const { FileError } = createTaggedError<'FileError', { path: string }>('FileError')
+ *
+ * // After
+ * const { FileError } = defineError('FileError')
+ *   .withContext<{ path: string }>()
+ * ```
+ *
  * Given an error name like "NetworkError", this returns:
  * - `NetworkError`: Creates a plain TaggedError object
  * - `NetworkErr`: Creates a TaggedError object wrapped in an Err result
  *
  * **Three usage modes:**
  *
- * 1. **Flexible mode** (no type params): Context and cause are optional, any shape accepted
- * 2. **Fixed context mode** (TContext specified): Context is required with that exact shape
- * 3. **Both fixed mode** (TContext + TCause): Context required, cause (if provided) must match
+ * 1. **Flexible mode** (no type params): Context and cause are optional, loosely typed
+ * 2. **Fixed context mode** (TContext specified): Context is required with exact shape
+ * 3. **Both fixed mode** (TContext + TCause): Context required, cause constrained
+ *
+ * **ReturnType works correctly in all modes:**
+ * ```ts
+ * const { NetworkError } = createTaggedError('NetworkError');
+ * type NetworkError = ReturnType<typeof NetworkError>;
+ * // = TaggedError<'NetworkError'> with optional context/cause
+ * ```
  *
  * @template TName - The name of the error type (must end with "Error")
  * @template TContext - Optional fixed context shape (makes context required)
@@ -273,10 +264,14 @@ type BothFixedErrConstructor<TName extends string, TContext extends Record<strin
  *
  * @example
  * ```ts
- * // Mode 1: Flexible - context optional, any shape
+ * // Mode 1: Flexible - context and cause optional, loosely typed
  * const { NetworkError, NetworkErr } = createTaggedError('NetworkError');
  * NetworkError({ message: 'Connection failed' });
  * NetworkError({ message: 'Timeout', context: { url: 'https://...' } });
+ * NetworkError({ message: 'Failed', cause: otherError });
+ *
+ * // Type annotation works with ReturnType:
+ * type NetworkError = ReturnType<typeof NetworkError>;
  *
  * // Mode 2: Fixed context - context REQUIRED with exact shape
  * type BlobContext = { filename: string; code: 'INVALID' | 'TOO_LARGE' };
@@ -293,6 +288,149 @@ type BothFixedErrConstructor<TName extends string, TContext extends Record<strin
 declare function createTaggedError<TName extends `${string}Error`>(name: TName): FlexibleFactories<TName>;
 declare function createTaggedError<TName extends `${string}Error`, TContext extends Record<string, unknown>>(name: TName): ContextFixedFactories<TName, TContext>;
 declare function createTaggedError<TName extends `${string}Error`, TContext extends Record<string, unknown>, TCause extends AnyTaggedError>(name: TName): BothFixedFactories<TName, TContext, TCause>;
+/**
+ * Helper type that determines optionality based on whether T includes undefined.
+ * - If T includes undefined → property is optional
+ * - If T does not include undefined → property is required
+ */
+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.
+ */
+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">);
+/**
+ * The factories object returned by defineError and its builder methods.
+ */
+type ErrorFactories<TName extends `${string}Error`, TContext extends Record<string, unknown> | undefined, TCause extends AnyTaggedError | undefined> = { [K in TName]: (input: ErrorInput<TContext, TCause>) => TaggedError<TName, TContext, TCause> } & { [K in ReplaceErrorWithErr<TName>]: (input: ErrorInput<TContext, TCause>) => Err<TaggedError<TName, TContext, TCause>> };
+/**
+ * Builder interface for the fluent defineError API.
+ * Provides chaining methods and the error factories.
+ */
+type ErrorBuilder<TName extends `${string}Error`, TContext extends Record<string, unknown> | undefined = undefined, TCause extends AnyTaggedError | undefined = undefined> = ErrorFactories<TName, TContext, TCause> & {
+  /**
+   * Constrains the context type for this error.
+   *
+   * Optionality is determined by whether the type includes `undefined`:
+   * - `withContext<T>()` where T doesn't include undefined → context is **required**
+   * - `withContext<T | undefined>()` → context is **optional** but typed when provided
+   *
+   * @typeParam T - The shape of the context object. Include `| undefined` to make optional.
+   *
+   * @example Required context
+   * ```ts
+   * const { FileError } = defineError('FileError')
+   *   .withContext<{ path: string }>()
+   *
+   * FileError({ message: 'Not found', context: { path: '/etc/config' } })  // OK
+   * FileError({ message: 'Not found' })  // Type error: context required
+   * ```
+   *
+   * @example Optional but typed context
+   * ```ts
+   * const { LogError } = defineError('LogError')
+   *   .withContext<{ file: string; line: number } | undefined>()
+   *
+   * LogError({ message: 'Parse error' })  // OK
+   * LogError({ message: 'Parse error', context: { file: 'app.ts', line: 42 } })  // OK
+   * ```
+   */
+  withContext<T extends Record<string, unknown> | undefined>(): ErrorBuilder<TName, T, TCause>;
+  /**
+   * Constrains the cause type for this error.
+   *
+   * Optionality is determined by whether the type includes `undefined`:
+   * - `withCause<T>()` where T doesn't include undefined → cause is **required**
+   * - `withCause<T | undefined>()` → cause is **optional** but typed when provided
+   *
+   * Since cause is typically optional, include `| undefined` in most cases.
+   *
+   * @typeParam T - The allowed cause type(s). Include `| undefined` to make optional.
+   *
+   * @example Optional typed cause (common)
+   * ```ts
+   * const { ServiceError } = defineError('ServiceError')
+   *   .withCause<DbError | CacheError | undefined>()
+   *
+   * ServiceError({ message: 'Failed' })  // OK
+   * ServiceError({ message: 'Failed', cause: dbError })  // OK
+   * ```
+   *
+   * @example Required cause (for wrapper errors)
+   * ```ts
+   * const { UnhandledError } = defineError('UnhandledError')
+   *   .withCause<AnyTaggedError>()
+   *
+   * UnhandledError({ message: 'Unexpected', cause: originalError })  // OK
+   * UnhandledError({ message: 'Unexpected' })  // Type error: cause required
+   * ```
+   */
+  withCause<T extends AnyTaggedError | undefined>(): ErrorBuilder<TName, TContext, T>;
+};
+/**
+ * Defines a new tagged error type with a fluent builder API.
+ *
+ * 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
+ *
+ * **Default behavior (no chaining):**
+ * - `context` is optional and accepts any `Record<string, unknown>`
+ * - `cause` is optional and accepts any `AnyTaggedError`
+ *
+ * **Optionality via type unions:**
+ * Both `withContext` and `withCause` determine optionality based on whether
+ * the type includes `undefined`:
+ * - `T` without undefined → property is required
+ * - `T | undefined` → property is optional but typed when provided
+ *
+ * @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)
+ * ```ts
+ * const { NetworkError, NetworkErr } = defineError('NetworkError')
+ *
+ * NetworkError({ message: 'Connection failed' })
+ * NetworkError({ message: 'Timeout', context: { url: 'https://...' } })
+ * ```
+ *
+ * @example Required context
+ * ```ts
+ * const { ApiError, ApiErr } = defineError('ApiError')
+ *   .withContext<{ endpoint: string; status: number }>()
+ *
+ * ApiError({ message: 'Failed', context: { endpoint: '/users', status: 500 } })
+ * // ApiError({ message: 'Failed' })  // Type error: context required
+ * ```
+ *
+ * @example Optional typed cause
+ * ```ts
+ * const { ServiceError } = defineError('ServiceError')
+ *   .withCause<DbError | CacheError | undefined>()
+ *
+ * ServiceError({ message: 'Failed' })  // OK
+ * ServiceError({ message: 'Failed', cause: dbError })  // OK, typed
+ * ```
+ *
+ * @example Full example with both
+ * ```ts
+ * const { UserServiceError } = defineError('UserServiceError')
+ *   .withContext<{ userId: string }>()
+ *   .withCause<RepoError | undefined>()
+ *
+ * // Type extraction works
+ * type UserServiceError = ReturnType<typeof UserServiceError>
+ * ```
+ */
+declare function defineError<TName extends `${string}Error`>(name: TName): ErrorBuilder<TName>;
 //#endregion
-export { TaggedError, createTaggedError, extractErrorMessage };
+export { AnyTaggedError, TaggedError, createTaggedError, defineError, 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/utils.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/error/index.js

@@ -75,7 +75,86 @@ function createTaggedError(name) {
 		[errName]: errConstructor
 	};
 }
+/**
+* Defines a new tagged error type with a fluent builder API.
+*
+* 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
+*
+* **Default behavior (no chaining):**
+* - `context` is optional and accepts any `Record<string, unknown>`
+* - `cause` is optional and accepts any `AnyTaggedError`
+*
+* **Optionality via type unions:**
+* Both `withContext` and `withCause` determine optionality based on whether
+* the type includes `undefined`:
+* - `T` without undefined → property is required
+* - `T | undefined` → property is optional but typed when provided
+*
+* @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)
+* ```ts
+* const { NetworkError, NetworkErr } = defineError('NetworkError')
+*
+* NetworkError({ message: 'Connection failed' })
+* NetworkError({ message: 'Timeout', context: { url: 'https://...' } })
+* ```
+*
+* @example Required context
+* ```ts
+* const { ApiError, ApiErr } = defineError('ApiError')
+*   .withContext<{ endpoint: string; status: number }>()
+*
+* ApiError({ message: 'Failed', context: { endpoint: '/users', status: 500 } })
+* // ApiError({ message: 'Failed' })  // Type error: context required
+* ```
+*
+* @example Optional typed cause
+* ```ts
+* const { ServiceError } = defineError('ServiceError')
+*   .withCause<DbError | CacheError | undefined>()
+*
+* ServiceError({ message: 'Failed' })  // OK
+* ServiceError({ message: 'Failed', cause: dbError })  // OK, typed
+* ```
+*
+* @example Full example with both
+* ```ts
+* const { UserServiceError } = defineError('UserServiceError')
+*   .withContext<{ userId: string }>()
+*   .withCause<RepoError | undefined>()
+*
+* // Type extraction works
+* type UserServiceError = ReturnType<typeof UserServiceError>
+* ```
+*/
+function defineError(name) {
+	const createBuilder = () => {
+		const errorConstructor = (input) => ({
+			name,
+			...input
+		});
+		const errName = name.replace(/Error$/, "Err");
+		const errConstructor = (input) => Err(errorConstructor(input));
+		return {
+			[name]: errorConstructor,
+			[errName]: errConstructor,
+			withContext() {
+				return createBuilder();
+			},
+			withCause() {
+				return createBuilder();
+			}
+		};
+	};
+	return createBuilder();
+}
 
 //#endregion
-export { createTaggedError, extractErrorMessage };
+export { createTaggedError, defineError, extractErrorMessage };
 //# sourceMappingURL=index.js.map