@zudojs/errors 0.1.1 → 1.0.1

package/dist/base/utils/baseError.utils.js

@@ -1,33 +1,84 @@
+import { ErrorCategory } from "../types/errorCategory.type.js";
 import { ErrorCode } from "../types/errorCode.type.js";
-import { BaseError } from "../core/baseError.core.js";
+import { ErrorSeverity } from "../types/errorSeverity.type.js";
+import { BaseError, BASE_ERROR_BRAND } from "../core/baseError.core.js";
 /**
  * Determines whether an unknown value is a BaseError.
+ *
+ * Uses `instanceof` as the fast path and falls back to the package brand plus
+ * a structural check, so errors produced by another installed copy of
+ * `@zudojs/errors` are still recognised.
  */
 export function isBaseError(value) {
-    return value instanceof BaseError;
+    if (value instanceof BaseError)
+        return true;
+    if (value === null || typeof value !== "object")
+        return false;
+    if (!(value instanceof Error))
+        return false;
+    const candidate = value;
+    return (candidate[BASE_ERROR_BRAND] === true &&
+        typeof candidate.code === "string" &&
+        typeof candidate.category === "string" &&
+        typeof candidate.severity === "string" &&
+        typeof candidate.statusCode === "number" &&
+        typeof candidate.expose === "boolean" &&
+        typeof candidate.isOperational === "boolean" &&
+        typeof candidate.metadata === "object" &&
+        candidate.metadata !== null &&
+        typeof candidate.toJSON === "function");
 }
+/** Default message used when an unknown value is converted into a BaseError. */
+export const UNKNOWN_ERROR_MESSAGE = "An unexpected error occurred.";
 /**
  * Converts an unknown thrown value into a BaseError.
+ *
+ * This is the single normalization routine shared by `toBaseError`,
+ * `normalizeToBaseError`, `normalizeUnknownError` and `ErrorHandler.normalize`.
+ * Unknown values are classified as non-operational internal errors
+ * (`ERR_INTERNAL_ERROR`, 500, not exposed) and the original value is kept as
+ * `cause`; a plain string is used as the message.
  */
-export function toBaseError(error, options = {}) {
-    if (error instanceof BaseError)
-        return error;
-    if (error instanceof Error) {
-        return new BaseError(options.message ?? error.message, {
+export function normalizeUnknownToBaseError(value, options = {}) {
+    if (isBaseError(value))
+        return value;
+    const defaults = {
+        code: ErrorCode.INTERNAL_ERROR,
+        category: ErrorCategory.SYSTEM,
+        severity: ErrorSeverity.ERROR,
+        statusCode: 500,
+        expose: false,
+        isOperational: false,
+    };
+    if (value instanceof Error) {
+        return new BaseError(options.message ?? (value.message || UNKNOWN_ERROR_MESSAGE), {
+            ...defaults,
             ...options,
-            cause: options.cause ?? error,
+            cause: options.cause ?? value,
         });
     }
-    return new BaseError(options.message ?? "An unknown error occurred.", {
+    const message = options.message ??
+        (typeof value === "string" && value.length > 0
+            ? value
+            : UNKNOWN_ERROR_MESSAGE);
+    return new BaseError(message, {
+        ...defaults,
         ...options,
-        cause: options.cause ?? error,
+        metadata: { originalType: typeof value, ...options.metadata },
+        cause: options.cause ?? value,
     });
 }
+/**
+ * Converts an unknown thrown value into a BaseError.
+ */
+export function toBaseError(error, options = {}) {
+    return normalizeUnknownToBaseError(error, options);
+}
 /**
  * Extracts an error code from an unknown error.
  */
 export function getErrorCode(error) {
-    if (error instanceof BaseError)
+    if (isBaseError(error))
         return error.code;
     return ErrorCode.UNKNOWN;
 }
@@ -35,23 +86,23 @@ export function getErrorCode(error) {
  * Extracts an error category from an unknown error.
  */
 export function getErrorCategory(error) {
-    if (error instanceof BaseError)
+    if (isBaseError(error))
         return error.category;
-    return "UNKNOWN";
+    return ErrorCategory.UNKNOWN;
 }
 /**
  * Extracts an error severity from an unknown error.
  */
 export function getErrorSeverity(error) {
-    if (error instanceof BaseError)
+    if (isBaseError(error))
         return error.severity;
-    return "ERROR";
+    return ErrorSeverity.ERROR;
 }
 /**
  * Extracts a status code from an unknown error.
  */
 export function getErrorStatusCode(error) {
-    if (error instanceof BaseError)
+    if (isBaseError(error))
         return error.statusCode;
     return 500;
 }
@@ -59,7 +110,7 @@ export function getErrorStatusCode(error) {
  * Determines whether an unknown error is safe to expose.
  */
 export function isErrorExposable(error) {
-    if (error instanceof BaseError)
+    if (isBaseError(error))
         return error.expose;
     return false;
 }

package/dist/domain/access/rateLimit.error.d.ts

@@ -7,7 +7,12 @@ import { ErrorSeverity } from "../../base/types/errorSeverity.type.js";
  */
 export interface RateLimitErrorOptions extends Omit<BaseErrorOptions, "category"> {
     readonly category?: ErrorCategory;
-    /** Number of seconds the client should wait before retrying. */
+    /**
+     * Number of seconds the client should wait before retrying.
+     *
+     * Must be a finite non-negative number; fractional values are rounded up
+     * because the HTTP `Retry-After` header requires an integer.
+     */
     readonly retryAfterSeconds?: number;
 }
 /**

package/dist/domain/access/rateLimit.error.js

@@ -2,12 +2,16 @@ import { BaseError } from "../../base/core/baseError.core.js";
 import { ErrorCategory } from "../../base/types/errorCategory.type.js";
 import { ErrorCode } from "../../base/types/errorCode.type.js";
 import { ErrorSeverity } from "../../base/types/errorSeverity.type.js";
+import { normalizeRetryAfterSeconds } from "../shared/domainError.helpers.js";
 /**
  * Error raised when a client exceeds an allowed request or operation rate.
  */
 export class RateLimitError extends BaseError {
     retryAfterSeconds;
     constructor(message = "Too many requests. Please try again later.", options = {}) {
+        const retryAfterSeconds = options.retryAfterSeconds !== undefined
+            ? normalizeRetryAfterSeconds(options.retryAfterSeconds)
+            : undefined;
         super(message, {
             ...options,
             code: options.code ?? ErrorCode.RATE_LIMITED,
@@ -18,17 +22,11 @@ export class RateLimitError extends BaseError {
             isOperational: options.isOperational ?? true,
             metadata: {
                 ...options.metadata,
-                ...(options.retryAfterSeconds !== undefined
-                    ? { retryAfterSeconds: options.retryAfterSeconds }
-                    : {}),
+                ...(retryAfterSeconds !== undefined ? { retryAfterSeconds } : {}),
             },
         });
-        if (options.retryAfterSeconds !== undefined) {
-            if (!Number.isFinite(options.retryAfterSeconds) ||
-                options.retryAfterSeconds < 0) {
-                throw new RangeError("retryAfterSeconds must be a finite non-negative number.");
-            }
-            this.retryAfterSeconds = options.retryAfterSeconds;
+        if (retryAfterSeconds !== undefined) {
+            this.retryAfterSeconds = retryAfterSeconds;
         }
     }
     /** Returns the retry-after value in seconds. */

package/dist/domain/api/apiError.base.js

@@ -58,7 +58,7 @@ export class APIValidationError extends APIError {
 export class APIAuthenticationError extends APIError {
     constructor(message = "API authentication is required.", options = {}) {
         super(message, {
-            code: ErrorCode.UNAUTHORIZED,
+            code: ErrorCode.API_AUTHENTICATION,
             endpoint: options.endpoint,
             method: options.method,
             cause: options.cause,
@@ -71,7 +71,7 @@ export class APIAuthenticationError extends APIError {
 export class APIAuthorizationError extends APIError {
     constructor(message = "You do not have permission to perform this operation.", options = {}) {
         super(message, {
-            code: ErrorCode.FORBIDDEN,
+            code: ErrorCode.API_AUTHORIZATION,
             endpoint: options.endpoint,
             method: options.method,
             cause: options.cause,

package/dist/domain/api/apiError.lifecycle.d.ts

@@ -2,8 +2,17 @@
  * API lifecycle error classes — rate limit, timeout, availability.
  */
 import { APIError } from "./apiError.base.js";
-/** Error thrown when an API rate limit is exceeded. */
+/**
+ * Error thrown when an API rate limit is exceeded.
+ *
+ * `retryAfter` is expressed in seconds (as the HTTP `Retry-After` header);
+ * fractional values are rounded up and the value is only recorded in
+ * metadata (as `retryAfterSeconds`) when provided.
+ */
 export declare class APIRateLimitError extends APIError {
+    /** Seconds to wait before retrying, if known. */
+    readonly retryAfterSeconds?: number;
+    /** @deprecated Use `retryAfterSeconds`. */
     readonly retryAfter?: number;
     constructor(message?: string, retryAfter?: number, options?: {
         endpoint?: string;

package/dist/domain/api/apiError.lifecycle.js

@@ -2,29 +2,44 @@
  * API lifecycle error classes — rate limit, timeout, availability.
  */
 import { ErrorCode } from "../../base/types/errorCode.type.js";
+import { assertFiniteNonNegative, normalizeRetryAfterSeconds, } from "../shared/domainError.helpers.js";
 import { APIError } from "./apiError.base.js";
-/** Error thrown when an API rate limit is exceeded. */
+/**
+ * Error thrown when an API rate limit is exceeded.
+ *
+ * `retryAfter` is expressed in seconds (as the HTTP `Retry-After` header);
+ * fractional values are rounded up and the value is only recorded in
+ * metadata (as `retryAfterSeconds`) when provided.
+ */
 export class APIRateLimitError extends APIError {
+    /** Seconds to wait before retrying, if known. */
+    retryAfterSeconds;
+    /** @deprecated Use `retryAfterSeconds`. */
     retryAfter;
     constructor(message = "API rate limit exceeded.", retryAfter, options = {}) {
+        const retryAfterSeconds = retryAfter !== undefined
+            ? normalizeRetryAfterSeconds(retryAfter, "retryAfter")
+            : undefined;
         super(message, {
-            code: ErrorCode.RATE_LIMITED,
+            code: ErrorCode.API_RATE_LIMIT,
             endpoint: options.endpoint,
             method: options.method,
             cause: options.cause,
-            metadata: { retryAfter },
+            metadata: retryAfterSeconds !== undefined ? { retryAfterSeconds } : {},
             statusCode: 429,
             expose: true,
         });
-        this.retryAfter = retryAfter;
+        this.retryAfterSeconds = retryAfterSeconds;
+        this.retryAfter = retryAfterSeconds;
     }
 }
 /** Error thrown when an API operation times out. */
 export class APITimeoutError extends APIError {
     timeoutMs;
     constructor(timeoutMs, options = {}) {
+        assertFiniteNonNegative("timeoutMs", timeoutMs);
         super(`API operation timed out after ${timeoutMs}ms.`, {
-            code: ErrorCode.TIMEOUT,
+            code: ErrorCode.API_TIMEOUT,
             endpoint: options.endpoint,
             method: options.method,
             cause: options.cause,
@@ -39,7 +54,7 @@ export class APITimeoutError extends APIError {
 export class APIUnavailableError extends APIError {
     constructor(message = "API service is temporarily unavailable.", options = {}) {
         super(message, {
-            code: ErrorCode.SERVICE_UNAVAILABLE,
+            code: ErrorCode.API_UNAVAILABLE,
             endpoint: options.endpoint,
             method: options.method,
             cause: options.cause,
@@ -52,7 +67,7 @@ export class APIUnavailableError extends APIError {
 export class APIInternalError extends APIError {
     constructor(message = "An unexpected internal API error occurred.", options = {}) {
         super(message, {
-            code: ErrorCode.INTERNAL_ERROR,
+            code: ErrorCode.API_INTERNAL,
             endpoint: options.endpoint,
             method: options.method,
             cause: options.cause,

package/dist/domain/api/apiError.routing.js

@@ -7,7 +7,7 @@ import { APIError } from "./apiError.base.js";
 export class APINotFoundError extends APIError {
     constructor(endpoint, method = "GET", options = {}) {
         super(`Endpoint "${method} ${endpoint}" was not found.`, {
-            code: ErrorCode.NOT_FOUND,
+            code: ErrorCode.API_NOT_FOUND,
             endpoint,
             method,
             cause: options.cause,
@@ -20,7 +20,7 @@ export class APINotFoundError extends APIError {
 export class APIConflictError extends APIError {
     constructor(message, options = {}) {
         super(message, {
-            code: ErrorCode.CONFLICT,
+            code: ErrorCode.API_CONFLICT,
             endpoint: options.endpoint,
             method: options.method,
             cause: options.cause,
@@ -33,7 +33,7 @@ export class APIConflictError extends APIError {
 export class APIOperationNotFoundError extends APIError {
     constructor(operation, options = {}) {
         super(`API operation "${operation}" was not found.`, {
-            code: ErrorCode.NOT_FOUND,
+            code: ErrorCode.API_OPERATION_NOT_FOUND,
             endpoint: operation,
             cause: options.cause,
             statusCode: 404,
@@ -45,7 +45,7 @@ export class APIOperationNotFoundError extends APIError {
 export class APIDuplicateOperationError extends APIError {
     constructor(operation, options = {}) {
         super(`API operation "${operation}" is already registered.`, {
-            code: ErrorCode.CONFLICT,
+            code: ErrorCode.API_DUPLICATE_OPERATION,
             endpoint: operation,
             cause: options.cause,
             statusCode: 409,

package/dist/domain/app/domain.error.d.ts

@@ -27,6 +27,8 @@ export declare function createDomainError(message: string, options?: DomainError
 export declare function isDomainError(value: unknown): value is DomainError;
 /**
  * Creates a domain error for an invalid domain state.
+ *
+ * Uses `PRECONDITION_FAILED` with HTTP 412, the status that matches the code.
  */
 export declare function invalidDomainState(message: string, metadata?: DomainErrorOptions["metadata"]): DomainError;
 /**

package/dist/domain/app/domain.error.js

@@ -36,12 +36,14 @@ export function isDomainError(value) {
 }
 /**
  * Creates a domain error for an invalid domain state.
+ *
+ * Uses `PRECONDITION_FAILED` with HTTP 412, the status that matches the code.
  */
 export function invalidDomainState(message, metadata) {
     return new DomainError(message, {
         code: ErrorCode.PRECONDITION_FAILED,
         category: ErrorCategory.BUSINESS,
-        statusCode: 409,
+        statusCode: 412,
         metadata,
     });
 }

package/dist/domain/app/lifecycleError.types.js

@@ -2,6 +2,7 @@
  * Specific lifecycle error classes.
  */
 import { ErrorCode } from "../../base/types/errorCode.type.js";
+import { assertFiniteNonNegative } from "../shared/domainError.helpers.js";
 import { LifecycleError } from "./lifecycleError.base.js";
 /** Error thrown when a lifecycle state transition is invalid. */
 export class LifecycleStateError extends LifecycleError {
@@ -13,7 +14,6 @@ export class LifecycleStateError extends LifecycleError {
             componentId,
             metadata: { fromState, toState },
         });
-        this.name = "LifecycleStateError";
         this.fromState = fromState;
         this.toState = toState;
     }
@@ -22,6 +22,7 @@ export class LifecycleStateError extends LifecycleError {
 export class LifecycleTimeoutError extends LifecycleError {
     timeout;
     constructor(componentId, phase, timeout, cause) {
+        assertFiniteNonNegative("timeout", timeout);
         super(`Lifecycle operation timed out for component "${componentId}" during ${phase} after ${timeout}ms.`, {
             code: ErrorCode.LIFECYCLE_TIMEOUT,
             componentId,
@@ -29,7 +30,6 @@ export class LifecycleTimeoutError extends LifecycleError {
             cause,
             metadata: { timeout },
         });
-        this.name = "LifecycleTimeoutError";
         this.timeout = timeout;
     }
 }
@@ -41,7 +41,6 @@ export class LifecycleDependencyError extends LifecycleError {
             code: ErrorCode.LIFECYCLE_DEPENDENCY,
             metadata: { cycle },
         });
-        this.name = "LifecycleDependencyError";
         this.cycle = Object.freeze([...cycle]);
     }
 }
@@ -54,7 +53,6 @@ export class LifecycleComponentError extends LifecycleError {
             phase,
             cause,
         });
-        this.name = "LifecycleComponentError";
     }
 }
 /** Error thrown when a lifecycle start operation fails. */
@@ -66,7 +64,6 @@ export class LifecycleStartError extends LifecycleError {
             phase: "start",
             cause,
         });
-        this.name = "LifecycleStartError";
     }
 }
 /** Error thrown when a lifecycle stop operation fails. */
@@ -78,7 +75,6 @@ export class LifecycleStopError extends LifecycleError {
             phase: "stop",
             cause,
         });
-        this.name = "LifecycleStopError";
     }
 }
 /** Error thrown when a lifecycle rollback operation fails. */
@@ -89,7 +85,6 @@ export class LifecycleRollbackError extends LifecycleError {
             componentId,
             cause,
         });
-        this.name = "LifecycleRollbackError";
     }
 }
 /** Error thrown when an operation is attempted on a disposed lifecycle manager. */
@@ -99,7 +94,6 @@ export class LifecycleDisposedError extends LifecycleError {
             code: ErrorCode.LIFECYCLE_DISPOSED,
             statusCode: 500,
         });
-        this.name = "LifecycleDisposedError";
     }
 }
 //# sourceMappingURL=lifecycleError.types.js.map

package/dist/domain/app/moduleError.types.d.ts

@@ -1,6 +1,9 @@
 import { ModuleError } from "./moduleError.base.js";
 /**
  * Error thrown when a module is not found.
+ *
+ * Module registration is a server-side concern, so this is reported as an
+ * internal (500, non-exposed, non-operational) failure.
  */
 export declare class ModuleNotFoundError extends ModuleError {
     constructor(moduleId: string, message?: string);

package/dist/domain/app/moduleError.types.js

@@ -2,13 +2,17 @@ import { ErrorCode } from "../../base/types/errorCode.type.js";
 import { ModuleError } from "./moduleError.base.js";
 /**
  * Error thrown when a module is not found.
+ *
+ * Module registration is a server-side concern, so this is reported as an
+ * internal (500, non-exposed, non-operational) failure.
  */
 export class ModuleNotFoundError extends ModuleError {
     constructor(moduleId, message) {
         super(message ?? `Module "${moduleId}" was not found.`, {
             code: ErrorCode.MODULE_NOT_FOUND,
-            statusCode: 404,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
             moduleId,
         });
     }

package/dist/domain/body/bodyParser.error.d.ts

@@ -15,20 +15,27 @@ export declare class BodyParserError extends BaseError {
 }
 /**
  * Error thrown when an unsupported body type is encountered.
+ *
+ * Responds with 415 Unsupported Media Type. The header value is untrusted
+ * input: it is stripped of control characters and truncated before being
+ * embedded in the message or metadata.
  */
 export declare class UnsupportedBodyTypeError extends BodyParserError {
     /**
-     * The unsupported content type.
+     * The unsupported content type (sanitized and truncated).
      */
     readonly contentType: string;
     constructor(contentType: string);
 }
 /**
  * Error thrown when the Content-Length header is invalid.
+ *
+ * The header value is untrusted input: it is stripped of control characters
+ * and truncated before being embedded in the message or metadata.
  */
 export declare class InvalidContentLengthError extends BodyParserError {
     /**
-     * The invalid Content-Length value.
+     * The invalid Content-Length value (sanitized and truncated).
      */
     readonly value: string;
     constructor(value: string);

package/dist/domain/body/bodyParser.error.js

@@ -2,6 +2,7 @@ import { BaseError } from "../../base/core/baseError.core.js";
 import { ErrorCode } from "../../base/types/errorCode.type.js";
 import { ErrorCategory } from "../../base/types/errorCategory.type.js";
 import { ErrorSeverity } from "../../base/types/errorSeverity.type.js";
+import { MAX_METADATA_FRAGMENT_LENGTH, sanitizeFragment, } from "../shared/domainError.helpers.js";
 /**
  * Base error class for body parser errors.
  */
@@ -11,49 +12,56 @@ export class BodyParserError extends BaseError {
             ...options,
             code: options.code ?? ErrorCode.HTTP_BODY_PARSER,
             category: options.category ?? ErrorCategory.INPUT,
-            severity: options.severity ?? ErrorSeverity.ERROR,
+            severity: options.severity ?? ErrorSeverity.WARNING,
             statusCode: options.statusCode ?? 400,
             expose: options.expose ?? true,
         });
-        this.name = "BodyParserError";
     }
 }
 /**
  * Error thrown when an unsupported body type is encountered.
+ *
+ * Responds with 415 Unsupported Media Type. The header value is untrusted
+ * input: it is stripped of control characters and truncated before being
+ * embedded in the message or metadata.
  */
 export class UnsupportedBodyTypeError extends BodyParserError {
     /**
-     * The unsupported content type.
+     * The unsupported content type (sanitized and truncated).
      */
     contentType;
     constructor(contentType) {
-        super(`Unsupported request content type: ${contentType}`, {
+        const safeContentType = sanitizeFragment(contentType, MAX_METADATA_FRAGMENT_LENGTH);
+        super(`Unsupported request content type: ${sanitizeFragment(contentType)}`, {
             code: ErrorCode.HTTP_UNSUPPORTED_BODY_TYPE,
+            statusCode: 415,
             metadata: {
-                contentType,
+                contentType: safeContentType,
             },
         });
-        this.name = "UnsupportedBodyTypeError";
-        this.contentType = contentType;
+        this.contentType = safeContentType;
     }
 }
 /**
  * Error thrown when the Content-Length header is invalid.
+ *
+ * The header value is untrusted input: it is stripped of control characters
+ * and truncated before being embedded in the message or metadata.
  */
 export class InvalidContentLengthError extends BodyParserError {
     /**
-     * The invalid Content-Length value.
+     * The invalid Content-Length value (sanitized and truncated).
      */
     value;
     constructor(value) {
-        super(`Invalid Content-Length header: ${value}`, {
+        const safeValue = sanitizeFragment(value, MAX_METADATA_FRAGMENT_LENGTH);
+        super(`Invalid Content-Length header: ${sanitizeFragment(value)}`, {
             code: ErrorCode.HTTP_INVALID_CONTENT_LENGTH,
             metadata: {
-                value,
+                value: safeValue,
             },
         });
-        this.name = "InvalidContentLengthError";
-        this.value = value;
+        this.value = safeValue;
     }
 }
 /**

package/dist/domain/body/httpBodyError.base.js

@@ -11,11 +11,10 @@ export class HttpBodyError extends BaseError {
             ...options,
             code: options.code ?? ErrorCode.HTTP_BODY,
             category: options.category ?? ErrorCategory.INPUT,
-            severity: options.severity ?? ErrorSeverity.ERROR,
+            severity: options.severity ?? ErrorSeverity.WARNING,
             statusCode: options.statusCode ?? 400,
             expose: options.expose ?? true,
         });
-        this.name = "HttpBodyError";
     }
 }
 /** Creates an HTTP body error. */

package/dist/domain/body/httpBodyError.types.js

@@ -11,9 +11,9 @@ export class HttpBodyLimitError extends HttpBodyError {
     constructor(limit, received) {
         super("Request body exceeds the configured size limit.", {
             code: ErrorCode.HTTP_BODY_LIMIT,
+            statusCode: 413,
             metadata: { limit, received },
         });
-        this.name = "HttpBodyLimitError";
         this.limit = limit;
         this.received = received;
     }
@@ -27,7 +27,6 @@ export class HttpBodyAbortedError extends HttpBodyError {
             code: ErrorCode.HTTP_BODY_ABORTED,
             statusCode: 408,
         });
-        this.name = "HttpBodyAbortedError";
     }
 }
 /**
@@ -39,7 +38,6 @@ export class HttpBodyParseError extends HttpBodyError {
             code: ErrorCode.HTTP_BODY_PARSE,
             cause,
         });
-        this.name = "HttpBodyParseError";
     }
 }
 //# sourceMappingURL=httpBodyError.types.js.map

package/dist/domain/body/httpFormData.error.js

@@ -11,11 +11,10 @@ export class HttpFormDataError extends BaseError {
             ...options,
             code: options.code ?? ErrorCode.HTTP_FORM_DATA,
             category: options.category ?? ErrorCategory.INPUT,
-            severity: options.severity ?? ErrorSeverity.ERROR,
+            severity: options.severity ?? ErrorSeverity.WARNING,
             statusCode: options.statusCode ?? 400,
             expose: options.expose ?? true,
         });
-        this.name = "HttpFormDataError";
     }
 }
 /**
@@ -25,8 +24,8 @@ export class HttpFormDataLimitError extends HttpFormDataError {
     constructor(message) {
         super(message, {
             code: ErrorCode.HTTP_FORM_DATA_LIMIT,
+            statusCode: 413,
         });
-        this.name = "HttpFormDataLimitError";
     }
 }
 /**
@@ -37,7 +36,6 @@ export class HttpFormDataParseError extends HttpFormDataError {
         super(message, {
             code: ErrorCode.HTTP_FORM_DATA_PARSE,
         });
-        this.name = "HttpFormDataParseError";
     }
 }
 /**