wellcrafted 0.32.0 → 0.33.0

package/README.md

@@ -54,19 +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";
 
-// Static error — no fields needed
-const { ValidationError } = createTaggedError("ValidationError")
-  .withMessage(() => "Email is required");
-ValidationError();
-
-// Structured error — fields are spread flat on the error object
-const { ApiError } = createTaggedError("ApiError")
-  .withFields<{ endpoint: string }>()
-  .withMessage(({ endpoint }) => `Request to ${endpoint} failed`);
+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
@@ -109,13 +112,17 @@ npm install wellcrafted
 
 ```typescript
 import { tryAsync } from "wellcrafted/result";
-import { createTaggedError } from "wellcrafted/error";
+import { defineErrors, type InferError } from "wellcrafted/error";
 
-// Define your error with factory function
-const { ApiError, ApiErr } = createTaggedError("ApiError")
-  .withFields<{ endpoint: string }>()
-  .withMessage(({ endpoint }) => `Failed to fetch ${endpoint}`);
-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({
@@ -213,14 +220,20 @@ if (error) {
 ### Wrap Unsafe Operations
 
 ```typescript
-// Define errors with fields and message template
-const { ParseError, ParseErr } = createTaggedError("ParseError")
-  .withFields<{ input: string }>()
-  .withMessage(({ input }) => `Invalid JSON: ${input.slice(0, 50)}`);
+import { defineErrors, type InferError } from "wellcrafted/error";
 
-const { NetworkError, NetworkErr } = createTaggedError("NetworkError")
-  .withFields<{ url: string }>()
-  .withMessage(({ url }) => `Request to ${url} failed`);
+// 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({
@@ -239,16 +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")
-  .withFields<{ currentState?: string; permissions?: string }>()
-  .withMessage(({ permissions, currentState }) => {
-    if (permissions) return `Missing ${permissions} permission`;
-    return `Invalid recorder state: ${currentState}`;
-  });
-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;
@@ -367,8 +383,12 @@ const { data: parsed } = trySync({
 
 ### Propagation Pattern (May Fail)
 ```typescript
-const { ParseError, ParseErr } = createTaggedError("ParseError")
-  .withMessage(() => "Invalid JSON");
+const parseErrors = defineErrors({
+  ParseError: () => ({
+    message: "Invalid JSON",
+  }),
+});
+const { ParseErr } = parseErrors;
 
 // When catch can return Err<E>, function returns Result<T, E>
 const mayFail = trySync({
@@ -421,16 +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 fields and message
-const { RecorderServiceError, RecorderServiceErr } = createTaggedError("RecorderServiceError")
-  .withFields<{ isRecording: boolean }>()
-  .withMessage(({ isRecording }) =>
-    isRecording ? "Already recording" : "Not currently recording"
-  );
-type RecorderServiceError = ReturnType<typeof RecorderServiceError>;
+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() {
@@ -534,12 +556,16 @@ export async function GET(request: Request) {
 <summary><b>Form Validation</b></summary>
 
 ```typescript
-const { FormError, FormErr } = createTaggedError("FormError")
-  .withFields<{ fields: Record<string, string[]> }>()
-  .withMessage(({ fields }) => {
-    const fieldNames = Object.keys(fields).join(", ");
-    return `Validation failed for: ${fieldNames}`;
-  });
+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[]> = {};
@@ -617,20 +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)
-  - Chain `.withFields<T>()` to add typed fields (spread flat on the error object)
-  - Chain `.withMessage(fn)` *(optional)* to seal the message with a template — `message` is not in the factory input type when present
-  - Without `.withMessage()`, `message` is required at the call site
-  - `name` is a reserved key — prevented at compile time by `NoReservedKeys`
-  - Factory input is flat (e.g., `{ endpoint: '/api' }`), not nested
+- **`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

@@ -21,111 +21,76 @@ type AnyTaggedError = {
   message: string;
 };
 /**
- * A tagged error type for type-safe error handling.
- * Uses the `name` property as a discriminator for tagged unions.
- * Additional fields are spread flat on the error object.
- *
- * @template TName - The error name (discriminator for tagged unions)
- * @template TFields - Additional fields spread flat on the error (default: none)
+ * 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 TaggedError<TName extends string = string, TFields extends JsonObject = Record<never, never>> = Readonly<{
-  name: TName;
+type ErrorBody = {
   message: string;
-} & TFields>;
-//# sourceMappingURL=types.d.ts.map
-//#endregion
-//#region src/error/utils.d.ts
-/**
- * Extracts a readable error message from an unknown error value
- *
- * @param error - The unknown error to extract a message from
- * @returns A string representation of the error
- */
-declare function extractErrorMessage(error: unknown): string;
-/**
- * Constraint that prevents the reserved key `name` from appearing in fields.
- * `message` is not reserved — when `.withMessage()` seals it, `message` is
- * simply absent from the input type. When `.withMessage()` is not used,
- * `message` is a built-in input handled separately from TFields.
- */
-type NoReservedKeys = {
-  name?: never;
 };
 /**
- * Replaces the "Error" suffix with "Err" suffix in error type names.
+ * 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 ReplaceErrorWithErr<T extends `${string}Error`> = T extends `${infer TBase}Error` ? `${TBase}Err` : never;
-/**
- * Message template function type.
- * Receives the fields (without name/message) and returns a message string.
- */
-type MessageFn<TFields extends JsonObject> = (input: TFields) => string;
-/** Factory input when message is required (no `.withMessage()`). */
-type RequiredMessageInput<TFields extends JsonObject> = {
+type ValidateErrorBody<K extends string> = {
   message: string;
-} & TFields;
-/**
- * Whether the entire input parameter can be omitted (called with no args).
- * True when TFields is empty or all-optional (and message is sealed via withMessage).
- */
-type IsInputOptional<TFields extends JsonObject> = Partial<TFields> extends TFields ? true : false;
-/**
- * Factories returned by `.withMessage()` — message is sealed by the template.
- * `message` is NOT in the input type. Only has factory functions, no chain methods.
- */
-type SealedFactories<TName extends `${string}Error`, TFields extends JsonObject> = { [K in TName]: IsInputOptional<TFields> extends true ? (input?: TFields) => TaggedError<TName, TFields> : (input: TFields) => TaggedError<TName, TFields> } & { [K in ReplaceErrorWithErr<TName>]: IsInputOptional<TFields> extends true ? (input?: TFields) => Err<TaggedError<TName, TFields>> : (input: TFields) => Err<TaggedError<TName, TFields>> };
-/**
- * Builder object returned by createTaggedError (and .withFields()).
- * Has factory functions (message required) AND chain methods.
- */
-type ErrorBuilder<TName extends `${string}Error`, TFields extends JsonObject = Record<never, never>> = { [K in TName]: (input: RequiredMessageInput<TFields>) => TaggedError<TName, TFields> } & { [K in ReplaceErrorWithErr<TName>]: (input: RequiredMessageInput<TFields>) => Err<TaggedError<TName, TFields>> } & {
-  /** Defines additional fields spread flat on the error object. */
-  withFields<T extends JsonObject & NoReservedKeys>(): ErrorBuilder<TName, T>;
-  /**
-   * Seals the message — the template owns it entirely.
-   * `message` is NOT in the returned factory's input type.
-   */
-  withMessage(fn: MessageFn<TFields>): SealedFactories<TName, TFields>;
+  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
 /**
- * Creates a new tagged error type with a fluent builder API.
+ * Defines a set of typed error factories using Rust-style namespaced variants.
  *
- * Returns an object with factory functions immediately available (message required),
- * plus `.withFields<T>()` and `.withMessage(fn)` for further configuration.
+ * 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.
  *
- * Two mutually exclusive modes:
- * 1. **No `.withMessage()`**: `message` is required at the call site
- * 2. **With `.withMessage()`**: message is sealed — NOT in the input type
- *
- * @example No fields, message required at call site
+ * @example
  * ```ts
- * const { SimpleError, SimpleErr } = createTaggedError('SimpleError');
- * SimpleErr({ message: 'Something went wrong' });
- * ```
+ * const HttpError = defineErrors({
+ *   Connection: ({ cause }: { cause: string }) => ({
+ *     message: `Failed to connect: ${cause}`,
+ *     cause,
+ *   }),
+ *   Parse: ({ cause }: { cause: string }) => ({
+ *     message: `Failed to parse: ${cause}`,
+ *     cause,
+ *   }),
+ * });
  *
- * @example No fields, with sealed message
- * ```ts
- * const { RecorderBusyError } = createTaggedError('RecorderBusyError')
- *   .withMessage(() => 'A recording is already in progress');
- * RecorderBusyError();  // message always: 'A recording is already in progress'
- * ```
+ * type HttpError = InferErrors<typeof HttpError>;
  *
- * @example With fields, message required
- * ```ts
- * const { FsReadError } = createTaggedError('FsReadError')
- *   .withFields<{ path: string }>();
- * FsReadError({ message: 'Failed to read', path: '/etc/config' });
+ * const result = HttpError.Connection({ cause: 'timeout' }); // Err<...>
  * ```
+ */
+declare function defineErrors<const TConfig extends ErrorsConfig>(config: TConfig & ValidatedConfig<TConfig>): DefineErrorsReturn<TConfig>;
+//# sourceMappingURL=defineErrors.d.ts.map
+//#endregion
+//#region src/error/extractErrorMessage.d.ts
+/**
+ * Extracts a readable error message from an unknown error value
  *
- * @example With fields + sealed message (template computes from fields)
- * ```ts
- * const { ResponseError } = createTaggedError('ResponseError')
- *   .withFields<{ status: number }>()
- *   .withMessage(({ status }) => `HTTP ${status}`);
- * ResponseError({ status: 404 });  // message: "HTTP 404"
- * ```
+ * @param error - The unknown error to extract a message from
+ * @returns A string representation of the error
  */
-declare function createTaggedError<TName extends `${string}Error`>(name: TName): ErrorBuilder<TName>;
+declare function extractErrorMessage(error: unknown): string;
+//# 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,83 +73,7 @@ function extractErrorMessage(error) {
 	}
 	return String(error);
 }
-/**
-* Creates a new tagged error type with a fluent builder API.
-*
-* Returns an object with factory functions immediately available (message required),
-* plus `.withFields<T>()` and `.withMessage(fn)` for further configuration.
-*
-* Two mutually exclusive modes:
-* 1. **No `.withMessage()`**: `message` is required at the call site
-* 2. **With `.withMessage()`**: message is sealed — NOT in the input type
-*
-* @example No fields, message required at call site
-* ```ts
-* const { SimpleError, SimpleErr } = createTaggedError('SimpleError');
-* SimpleErr({ message: 'Something went wrong' });
-* ```
-*
-* @example No fields, with sealed message
-* ```ts
-* const { RecorderBusyError } = createTaggedError('RecorderBusyError')
-*   .withMessage(() => 'A recording is already in progress');
-* RecorderBusyError();  // message always: 'A recording is already in progress'
-* ```
-*
-* @example With fields, message required
-* ```ts
-* const { FsReadError } = createTaggedError('FsReadError')
-*   .withFields<{ path: string }>();
-* FsReadError({ message: 'Failed to read', path: '/etc/config' });
-* ```
-*
-* @example With fields + sealed message (template computes from fields)
-* ```ts
-* const { ResponseError } = createTaggedError('ResponseError')
-*   .withFields<{ status: number }>()
-*   .withMessage(({ status }) => `HTTP ${status}`);
-* ResponseError({ status: 404 });  // message: "HTTP 404"
-* ```
-*/
-function createTaggedError(name) {
-	const errName = name.replace(/Error$/, "Err");
-	const createBuilder = () => {
-		const errorConstructor = (input) => {
-			const { message,...fields } = input;
-			return {
-				name,
-				message,
-				...fields
-			};
-		};
-		const errConstructor = (input) => Err(errorConstructor(input));
-		return {
-			[name]: errorConstructor,
-			[errName]: errConstructor,
-			withFields() {
-				return createBuilder();
-			},
-			withMessage(fn) {
-				const sealedErrorConstructor = (input) => {
-					const fields = input ?? {};
-					const message = fn(fields);
-					return {
-						name,
-						message,
-						...fields
-					};
-				};
-				const sealedErrConstructor = (input) => Err(sealedErrorConstructor(input));
-				return {
-					[name]: sealedErrorConstructor,
-					[errName]: sealedErrConstructor
-				};
-			}
-		};
-	};
-	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","input: { message: string } & TFields","fn: MessageFn<TFields>","input?: TFields"],"sources":["../../src/error/utils.ts"],"sourcesContent":["import type { TaggedError, JsonObject } 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 * Constraint that prevents the reserved key `name` from appearing in fields.\n * `message` is not reserved — when `.withMessage()` seals it, `message` is\n * simply absent from the input type. When `.withMessage()` is not used,\n * `message` is a built-in input handled separately from TFields.\n */\ntype NoReservedKeys = { name?: never };\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 template function type.\n * Receives the fields (without name/message) and returns a message string.\n */\ntype MessageFn<TFields extends JsonObject> = (input: TFields) => string;\n\n// =============================================================================\n// Factory Input Types\n// =============================================================================\n\n/** Factory input when message is required (no `.withMessage()`). */\ntype RequiredMessageInput<TFields extends JsonObject> = { message: string } &\n\tTFields;\n\n/**\n * Whether the entire input parameter can be omitted (called with no args).\n * True when TFields is empty or all-optional (and message is sealed via withMessage).\n */\ntype IsInputOptional<TFields extends JsonObject> =\n\tPartial<TFields> extends TFields ? true : false;\n\n// =============================================================================\n// Builder & Factory Types\n// =============================================================================\n\n/**\n * Factories returned by `.withMessage()` — message is sealed by the template.\n * `message` is NOT in the input type. Only has factory functions, no chain methods.\n */\ntype SealedFactories<\n\tTName extends `${string}Error`,\n\tTFields extends JsonObject,\n> = {\n\t[K in TName]: IsInputOptional<TFields> extends true\n\t\t? (input?: TFields) => TaggedError<TName, TFields>\n\t\t: (input: TFields) => TaggedError<TName, TFields>;\n} & {\n\t[K in ReplaceErrorWithErr<TName>]: IsInputOptional<TFields> extends true\n\t\t? (input?: TFields) => Err<TaggedError<TName, TFields>>\n\t\t: (input: TFields) => Err<TaggedError<TName, TFields>>;\n};\n\n/**\n * Builder object returned by createTaggedError (and .withFields()).\n * Has factory functions (message required) AND chain methods.\n */\ntype ErrorBuilder<\n\tTName extends `${string}Error`,\n\tTFields extends JsonObject = Record<never, never>,\n> = {\n\t[K in TName]: (\n\t\tinput: RequiredMessageInput<TFields>,\n\t) => TaggedError<TName, TFields>;\n} & {\n\t[K in ReplaceErrorWithErr<TName>]: (\n\t\tinput: RequiredMessageInput<TFields>,\n\t) => Err<TaggedError<TName, TFields>>;\n} & {\n\t/** Defines additional fields spread flat on the error object. */\n\twithFields<T extends JsonObject & NoReservedKeys>(): ErrorBuilder<TName, T>;\n\n\t/**\n\t * Seals the message — the template owns it entirely.\n\t * `message` is NOT in the returned factory's input type.\n\t */\n\twithMessage(fn: MessageFn<TFields>): SealedFactories<TName, TFields>;\n};\n\n// =============================================================================\n// Implementation\n// =============================================================================\n\n/**\n * Creates a new tagged error type with a fluent builder API.\n *\n * Returns an object with factory functions immediately available (message required),\n * plus `.withFields<T>()` and `.withMessage(fn)` for further configuration.\n *\n * Two mutually exclusive modes:\n * 1. **No `.withMessage()`**: `message` is required at the call site\n * 2. **With `.withMessage()`**: message is sealed — NOT in the input type\n *\n * @example No fields, message required at call site\n * ```ts\n * const { SimpleError, SimpleErr } = createTaggedError('SimpleError');\n * SimpleErr({ message: 'Something went wrong' });\n * ```\n *\n * @example No fields, with sealed message\n * ```ts\n * const { RecorderBusyError } = createTaggedError('RecorderBusyError')\n *   .withMessage(() => 'A recording is already in progress');\n * RecorderBusyError();  // message always: 'A recording is already in progress'\n * ```\n *\n * @example With fields, message required\n * ```ts\n * const { FsReadError } = createTaggedError('FsReadError')\n *   .withFields<{ path: string }>();\n * FsReadError({ message: 'Failed to read', path: '/etc/config' });\n * ```\n *\n * @example With fields + sealed message (template computes from fields)\n * ```ts\n * const { ResponseError } = createTaggedError('ResponseError')\n *   .withFields<{ status: number }>()\n *   .withMessage(({ status }) => `HTTP ${status}`);\n * ResponseError({ status: 404 });  // message: \"HTTP 404\"\n * ```\n */\nexport function createTaggedError<TName extends `${string}Error`>(\n\tname: TName,\n): ErrorBuilder<TName> {\n\tconst errName = name.replace(\n\t\t/Error$/,\n\t\t\"Err\",\n\t) as ReplaceErrorWithErr<TName>;\n\n\tconst createBuilder = <\n\t\tTFields extends JsonObject = Record<never, never>,\n\t>(): ErrorBuilder<TName, TFields> => {\n\t\tconst errorConstructor = (\n\t\t\tinput: { message: string } & TFields,\n\t\t) => {\n\t\t\tconst { message, ...fields } = input;\n\t\t\treturn {\n\t\t\t\tname,\n\t\t\t\tmessage,\n\t\t\t\t...fields,\n\t\t\t} as unknown as TaggedError<TName, TFields>;\n\t\t};\n\n\t\tconst errConstructor = (\n\t\t\tinput: { message: string } & TFields,\n\t\t) => Err(errorConstructor(input));\n\n\t\treturn {\n\t\t\t[name]: errorConstructor,\n\t\t\t[errName]: errConstructor,\n\n\t\t\twithFields<T extends JsonObject & NoReservedKeys>() {\n\t\t\t\treturn createBuilder<T>();\n\t\t\t},\n\n\t\t\twithMessage(\n\t\t\t\tfn: MessageFn<TFields>,\n\t\t\t): SealedFactories<TName, TFields> {\n\t\t\t\tconst sealedErrorConstructor = (input?: TFields) => {\n\t\t\t\t\tconst fields = (input ?? {}) as TFields;\n\t\t\t\t\tconst message = fn(fields);\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...fields,\n\t\t\t\t\t} as unknown as TaggedError<TName, TFields>;\n\t\t\t\t};\n\n\t\t\t\tconst sealedErrConstructor = (input?: TFields) =>\n\t\t\t\t\tErr(sealedErrorConstructor(input));\n\n\t\t\t\treturn {\n\t\t\t\t\t[name]: sealedErrorConstructor,\n\t\t\t\t\t[errName]: sealedErrConstructor,\n\t\t\t\t} as SealedFactories<TName, TFields>;\n\t\t\t},\n\t\t} as ErrorBuilder<TName, TFields>;\n\t};\n\n\treturn createBuilder();\n}\n"],"mappings":";;;;;;;;;AASA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8HD,SAAgB,kBACfC,MACsB;CACtB,MAAM,UAAU,KAAK,QACpB,UACA,MACA;CAED,MAAM,gBAAgB,MAEe;EACpC,MAAM,mBAAmB,CACxBC,UACI;GACJ,MAAM,EAAE,QAAS,GAAG,QAAQ,GAAG;AAC/B,UAAO;IACN;IACA;IACA,GAAG;GACH;EACD;EAED,MAAM,iBAAiB,CACtBA,UACI,IAAI,iBAAiB,MAAM,CAAC;AAEjC,SAAO;IACL,OAAO;IACP,UAAU;GAEX,aAAoD;AACnD,WAAO,eAAkB;GACzB;GAED,YACCC,IACkC;IAClC,MAAM,yBAAyB,CAACC,UAAoB;KACnD,MAAM,SAAU,SAAS,CAAE;KAC3B,MAAM,UAAU,GAAG,OAAO;AAC1B,YAAO;MACN;MACA;MACA,GAAG;KACH;IACD;IAED,MAAM,uBAAuB,CAACA,UAC7B,IAAI,uBAAuB,MAAM,CAAC;AAEnC,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.32.0",
+	"version": "0.33.0",
 	"description": "Delightful TypeScript patterns for elegant, type-safe applications",
 	"type": "module",
 	"files": [