@zudojs/errors 1.0.0 → 1.1.0

package/dist/domain/transaction/transactionError.types.js

@@ -0,0 +1,62 @@
+/**
+ * Specific transaction error subclasses. Constructor signatures and codes
+ * match the classes `@zudojs/transactions` defined locally.
+ */
+import { ErrorCode } from "../../base/types/errorCode.type.js";
+import { TransactionError } from "./transactionError.base.js";
+/** Transaction is in an invalid state for the requested operation. */
+export class TransactionStateError extends TransactionError {
+    constructor(state, operation) {
+        super(`Cannot ${operation} transaction in state "${state}"`, {
+            code: ErrorCode.LIFECYCLE_STATE,
+            metadata: { state, operation },
+        });
+    }
+}
+/** Transaction exceeded its timeout. */
+export class TransactionTimeoutError extends TransactionError {
+    constructor(transactionId, timeoutMs) {
+        super(`Transaction "${transactionId}" timed out after ${timeoutMs}ms`, {
+            code: ErrorCode.TIMEOUT,
+            metadata: { transactionId, timeoutMs },
+        });
+    }
+}
+/** Transaction commit failed. */
+export class TransactionCommitError extends TransactionError {
+    constructor(transactionId, cause) {
+        super(`Transaction "${transactionId}" commit failed`, {
+            code: ErrorCode.DATABASE_TRANSACTION,
+            cause,
+            metadata: { transactionId },
+        });
+    }
+}
+/** Transaction rollback failed. */
+export class TransactionRollbackError extends TransactionError {
+    constructor(transactionId, options) {
+        super(`Transaction "${transactionId}" rollback failed`, {
+            code: ErrorCode.DATABASE_TRANSACTION,
+            cause: options?.cause,
+            metadata: {
+                transactionId,
+                originalError: options?.originalError instanceof Error
+                    ? options.originalError.message
+                    : String(options?.originalError ?? "unknown"),
+            },
+        });
+    }
+}
+/** The underlying adapter threw an error. */
+export class TransactionAdapterError extends TransactionError {
+    constructor(message, cause) {
+        super(message, { code: ErrorCode.ADAPTER_OPERATION_FAILED, cause });
+    }
+}
+/** Propagation strategy violation. */
+export class TransactionPropagationError extends TransactionError {
+    constructor(message) {
+        super(message, { code: ErrorCode.VALIDATION_FAILED });
+    }
+}
+//# sourceMappingURL=transactionError.types.js.map

package/dist/domain/traversal/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @zudojs/errors/domain/traversal
+ *
+ * Bounded-traversal limit errors (depth, budget, cycle).
+ */
+export * from "./traversalLimit.error.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/traversal/index.js

@@ -0,0 +1,7 @@
+/**
+ * @zudojs/errors/domain/traversal
+ *
+ * Bounded-traversal limit errors (depth, budget, cycle).
+ */
+export * from "./traversalLimit.error.js";
+//# sourceMappingURL=index.js.map

package/dist/domain/traversal/traversalLimit.error.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Error raised when a bounded object-graph traversal stops early.
+ */
+import { BaseError } from "../../base/core/baseError.core.js";
+import { ErrorCategory } from "../../base/types/errorCategory.type.js";
+import { ErrorSeverity } from "../../base/types/errorSeverity.type.js";
+import type { ErrorMetadata } from "../../base/core/errorMetadata.type.js";
+/** Why a traversal stopped early. */
+export type TraversalHalt = "depth" | "budget" | "cycle";
+/**
+ * Signals that a traversal hit one of its bounds (depth, cost budget or a
+ * cycle). Constructor matches the class `@zudojs/validation` defined
+ * locally; not exposed, because `path` can contain submitted keys.
+ */
+export declare class TraversalLimitError extends BaseError {
+    readonly halt: TraversalHalt;
+    readonly path: string;
+    readonly observed: number;
+    constructor(halt: TraversalHalt, path: string, observed: number);
+    toJSON(): {
+        name: string;
+        message: string;
+        code: string;
+        category: ErrorCategory;
+        severity: ErrorSeverity;
+        statusCode: number;
+        expose: boolean;
+        isOperational: boolean;
+        metadata: Readonly<ErrorMetadata>;
+        stack?: string;
+        cause?: import("../../index.js").SerializedBaseError | unknown;
+        halt: TraversalHalt;
+        path: string;
+        observed: number;
+    };
+}
+//# sourceMappingURL=traversalLimit.error.d.ts.map

package/dist/domain/traversal/traversalLimit.error.js

@@ -0,0 +1,39 @@
+/**
+ * Error raised when a bounded object-graph traversal stops early.
+ */
+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";
+/**
+ * Signals that a traversal hit one of its bounds (depth, cost budget or a
+ * cycle). Constructor matches the class `@zudojs/validation` defined
+ * locally; not exposed, because `path` can contain submitted keys.
+ */
+export class TraversalLimitError extends BaseError {
+    halt;
+    path;
+    observed;
+    constructor(halt, path, observed) {
+        super(`Traversal halted (${halt}) at ${path}`, {
+            code: ErrorCode.VALIDATION_FAILED,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.WARNING,
+            statusCode: 400,
+            expose: false,
+            metadata: { halt, observed },
+        });
+        this.halt = halt;
+        this.path = path;
+        this.observed = observed;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            halt: this.halt,
+            path: this.path,
+            observed: this.observed,
+        };
+    }
+}
+//# sourceMappingURL=traversalLimit.error.js.map

package/dist/infrastructure/httpPipeline/httpMiddleware.error.d.ts

@@ -0,0 +1,26 @@
+/**
+ * HTTP middleware pipeline errors. Names, codes and constructors match the
+ * classes `@zudojs/http` defined locally.
+ */
+import { BaseError } from "../../base/core/baseError.core.js";
+/** Options accepted by {@link HttpMiddlewareError}. */
+export interface HttpMiddlewareErrorOptions {
+    readonly middlewareId?: string;
+    readonly middlewareName?: string;
+    readonly cause?: unknown;
+}
+/** Error raised by an HTTP middleware function (500, not exposed). */
+export declare class HttpMiddlewareError extends BaseError {
+    /** The unique identifier of the middleware. */
+    readonly middlewareId: string | undefined;
+    /** The name of the middleware. */
+    readonly middlewareName: string | undefined;
+    constructor(message: string, options?: HttpMiddlewareErrorOptions);
+}
+/** Error raised when the HTTP middleware pipeline fails. */
+export declare class HttpMiddlewarePipelineError extends BaseError {
+    /** The errors that occurred during pipeline execution. */
+    readonly errors: readonly HttpMiddlewareError[];
+    constructor(errors: readonly HttpMiddlewareError[]);
+}
+//# sourceMappingURL=httpMiddleware.error.d.ts.map

package/dist/infrastructure/httpPipeline/httpMiddleware.error.js

@@ -0,0 +1,43 @@
+/**
+ * HTTP middleware pipeline errors. Names, codes and constructors match the
+ * classes `@zudojs/http` defined locally.
+ */
+import { BaseError } from "../../base/core/baseError.core.js";
+/** Error raised by an HTTP middleware function (500, not exposed). */
+export class HttpMiddlewareError extends BaseError {
+    /** The unique identifier of the middleware. */
+    middlewareId;
+    /** The name of the middleware. */
+    middlewareName;
+    constructor(message, options = {}) {
+        super(message, {
+            code: "HTTP_MIDDLEWARE_ERROR",
+            statusCode: 500,
+            expose: false,
+            cause: options.cause,
+        });
+        this.name = "HttpMiddlewareError";
+        this.middlewareId = options.middlewareId;
+        this.middlewareName = options.middlewareName;
+    }
+}
+/** Error raised when the HTTP middleware pipeline fails. */
+export class HttpMiddlewarePipelineError extends BaseError {
+    /** The errors that occurred during pipeline execution. */
+    errors;
+    constructor(errors) {
+        const message = errors.length === 1
+            ? `HTTP middleware pipeline failed: ${errors[0]?.message ?? "Unknown error"}`
+            : `HTTP middleware pipeline failed with ${errors.length} errors: ${errors
+                .map((e) => e.message)
+                .join(", ")}`;
+        super(message, {
+            code: "MIDDLEWARE_PIPELINE_ERROR",
+            statusCode: 500,
+            expose: false,
+        });
+        this.name = "HttpMiddlewarePipelineError";
+        this.errors = Object.freeze([...errors]);
+    }
+}
+//# sourceMappingURL=httpMiddleware.error.js.map

package/dist/infrastructure/httpPipeline/httpRequestGuard.error.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Error thrown when an HTTP request security guard rejects a request.
+ */
+import { BaseError } from "../../base/core/baseError.core.js";
+/** The parts of a guard verdict this error records. */
+export interface HttpRequestGuardRejection {
+    /** Status the response should use (400-499). */
+    readonly statusCode: number;
+    /** Individual validation failures, for logs only. */
+    readonly errors: readonly string[];
+}
+/**
+ * Carries the status the response should use and the individual failures, so
+ * a caller can log the detail without returning it to the client (not
+ * exposed). Matches `@zudojs/http`'s local class, which extended `Error`.
+ */
+export declare class HttpRequestGuardError extends BaseError {
+    readonly errors: readonly string[];
+    constructor(result: HttpRequestGuardRejection);
+}
+//# sourceMappingURL=httpRequestGuard.error.d.ts.map

package/dist/infrastructure/httpPipeline/httpRequestGuard.error.js

@@ -0,0 +1,28 @@
+/**
+ * Error thrown when an HTTP request security guard rejects a request.
+ */
+import { BaseError } from "../../base/core/baseError.core.js";
+import { ErrorCategory } from "../../base/types/errorCategory.type.js";
+/**
+ * Carries the status the response should use and the individual failures, so
+ * a caller can log the detail without returning it to the client (not
+ * exposed). Matches `@zudojs/http`'s local class, which extended `Error`.
+ */
+export class HttpRequestGuardError extends BaseError {
+    errors;
+    constructor(result) {
+        const errors = Array.isArray(result?.errors) ? [...result.errors] : [];
+        const status = result?.statusCode;
+        super(`Request rejected by security guard: ${errors.join("; ")}`, {
+            code: "HTTP_REQUEST_REJECTED",
+            category: ErrorCategory.VALIDATION,
+            statusCode: Number.isInteger(status) && status >= 400 && status <= 499
+                ? status
+                : 400,
+            expose: false,
+        });
+        this.name = "HttpRequestGuardError";
+        this.errors = Object.freeze(errors);
+    }
+}
+//# sourceMappingURL=httpRequestGuard.error.js.map

package/dist/infrastructure/httpPipeline/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @zudojs/errors/infrastructure/httpPipeline
+ *
+ * HTTP middleware pipeline and request-guard errors.
+ */
+export * from "./httpMiddleware.error.js";
+export * from "./httpRequestGuard.error.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/infrastructure/httpPipeline/index.js

@@ -0,0 +1,8 @@
+/**
+ * @zudojs/errors/infrastructure/httpPipeline
+ *
+ * HTTP middleware pipeline and request-guard errors.
+ */
+export * from "./httpMiddleware.error.js";
+export * from "./httpRequestGuard.error.js";
+//# sourceMappingURL=index.js.map

package/dist/infrastructure/index.d.ts

@@ -10,4 +10,5 @@ export * from "./container/index.js";
 export * from "./cache/index.js";
 export * from "./middleware/index.js";
 export * from "./adapter/index.js";
+export * from "./httpPipeline/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/infrastructure/index.js

@@ -10,4 +10,5 @@ export * from "./container/index.js";
 export * from "./cache/index.js";
 export * from "./middleware/index.js";
 export * from "./adapter/index.js";
+export * from "./httpPipeline/index.js";
 //# sourceMappingURL=index.js.map

package/dist/infrastructure/middleware/index.d.ts

@@ -4,4 +4,5 @@
  * Middleware error types.
  */
 export * from "./middleware.error.js";
+export * from "./middlewareError.types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/infrastructure/middleware/index.js

@@ -4,4 +4,5 @@
  * Middleware error types.
  */
 export * from "./middleware.error.js";
+export * from "./middlewareError.types.js";
 //# sourceMappingURL=index.js.map

package/dist/infrastructure/middleware/middlewareError.types.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Pipeline-guard middleware errors. Constructors and defaults match the
+ * wrappers `@zudojs/middleware` defines over the shared `MiddlewareError`.
+ */
+import { MiddlewareError } from "./middleware.error.js";
+/** Error thrown when a pipeline is configured with more middleware than allowed. */
+export declare class MiddlewareLimitExceededError extends MiddlewareError {
+    constructor(count: number, maximum: number);
+}
+/** Error thrown when the middleware chain nests deeper than the allowed limit. */
+export declare class MiddlewareDepthExceededError extends MiddlewareError {
+    constructor(maxDepth: number);
+}
+/**
+ * Error thrown when a rate limit is exceeded. `retryAfterMs` feeds a
+ * `Retry-After` header.
+ */
+export declare class MiddlewareRateLimitError extends MiddlewareError {
+    readonly retryAfterMs: number;
+    readonly limit: number;
+    readonly windowMs: number;
+    constructor(limit: number, windowMs: number, retryAfterMs: number);
+}
+/** Error thrown when a pipeline is aborted through its `AbortSignal`. */
+export declare class MiddlewareAbortedError extends MiddlewareError {
+    constructor(reason?: unknown);
+}
+//# sourceMappingURL=middlewareError.types.d.ts.map

package/dist/infrastructure/middleware/middlewareError.types.js

@@ -0,0 +1,44 @@
+/**
+ * Pipeline-guard middleware errors. Constructors and defaults match the
+ * wrappers `@zudojs/middleware` defines over the shared `MiddlewareError`.
+ */
+import { MiddlewareError } from "./middleware.error.js";
+/** Error thrown when a pipeline is configured with more middleware than allowed. */
+export class MiddlewareLimitExceededError extends MiddlewareError {
+    constructor(count, maximum) {
+        super(`Pipeline has ${count} middleware, exceeding the maximum of ${maximum}`, { metadata: { count, maximum } });
+    }
+}
+/** Error thrown when the middleware chain nests deeper than the allowed limit. */
+export class MiddlewareDepthExceededError extends MiddlewareError {
+    constructor(maxDepth) {
+        super(`Middleware chain exceeded the maximum depth of ${maxDepth}`, {
+            metadata: { maxDepth },
+        });
+    }
+}
+/**
+ * Error thrown when a rate limit is exceeded. `retryAfterMs` feeds a
+ * `Retry-After` header.
+ */
+export class MiddlewareRateLimitError extends MiddlewareError {
+    retryAfterMs;
+    limit;
+    windowMs;
+    constructor(limit, windowMs, retryAfterMs) {
+        super(`Rate limit exceeded: ${limit} requests per ${windowMs}ms`, {
+            middlewareName: "rate-limit",
+            metadata: { middlewareName: "rate-limit" },
+        });
+        this.retryAfterMs = retryAfterMs;
+        this.limit = limit;
+        this.windowMs = windowMs;
+    }
+}
+/** Error thrown when a pipeline is aborted through its `AbortSignal`. */
+export class MiddlewareAbortedError extends MiddlewareError {
+    constructor(reason) {
+        super("Middleware pipeline aborted", { cause: reason });
+    }
+}
+//# sourceMappingURL=middlewareError.types.js.map

package/dist/system/index.d.ts

@@ -7,4 +7,5 @@ export * from "./crypto.error.js";
 export * from "./system.error.js";
 export * from "./runtime.error.js";
 export * from "./logging/index.js";
+export * from "./observability/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/system/index.js

@@ -7,4 +7,5 @@ export * from "./crypto.error.js";
 export * from "./system.error.js";
 export * from "./runtime.error.js";
 export * from "./logging/index.js";
+export * from "./observability/index.js";
 //# sourceMappingURL=index.js.map

package/dist/system/observability/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @zudojs/errors/system/observability
+ *
+ * Telemetry (metrics, tracing, exporter) errors.
+ */
+export * from "./observabilityError.base.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/system/observability/index.js

@@ -0,0 +1,7 @@
+/**
+ * @zudojs/errors/system/observability
+ *
+ * Telemetry (metrics, tracing, exporter) errors.
+ */
+export * from "./observabilityError.base.js";
+//# sourceMappingURL=index.js.map

package/dist/system/observability/observabilityError.base.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Base observability error: telemetry throws only for programmer errors.
+ */
+import { BaseError } from "../../base/core/baseError.core.js";
+import { ErrorCode } from "../../base/types/errorCode.type.js";
+/** Options accepted by {@link ObservabilityError}. */
+export interface ObservabilityErrorOptions {
+    readonly code?: ErrorCode;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly cause?: unknown;
+}
+/** Base error for all observability failures (500, not exposed). */
+export declare class ObservabilityError extends BaseError {
+    constructor(message: string, options?: ObservabilityErrorOptions);
+}
+//# sourceMappingURL=observabilityError.base.d.ts.map

package/dist/system/observability/observabilityError.base.js

@@ -0,0 +1,23 @@
+/**
+ * Base observability error: telemetry throws only for programmer errors.
+ */
+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";
+/** Base error for all observability failures (500, not exposed). */
+export class ObservabilityError extends BaseError {
+    constructor(message, options) {
+        super(message, {
+            code: options?.code ?? ErrorCode.OPERATION_FAILED,
+            category: ErrorCategory.INTERNAL,
+            severity: ErrorSeverity.ERROR,
+            statusCode: 500,
+            expose: false,
+            metadata: options?.metadata,
+            cause: options?.cause,
+        });
+        this.name = "ObservabilityError";
+    }
+}
+//# sourceMappingURL=observabilityError.base.js.map

package/dist/utils/errorMapper.mappers.d.ts

@@ -16,7 +16,7 @@ export declare function mapNativeError(error: unknown): BaseError | undefined;
 /** Maps an error using a registry and falls back to native error mapping. */
 export declare function mapError(error: unknown, registry?: ErrorMapperRegistry, context?: ErrorMapperContext): BaseError;
 /** Any constructor whose instances are `T` (parameters are not constrained). */
-export type ErrorConstructor<T extends Error> = abstract new (...args: any[]) => T;
+export type ErrorConstructor<T extends Error> = abstract new (...args: never[]) => T;
 /**
  * Creates a mapping rule for a specific error constructor.
  *

package/dist/utils/errorSerializer.core.d.ts

@@ -19,7 +19,8 @@ export declare class ErrorSerializer {
      * Serializes an error for internal logging or monitoring.
      *
      * `includeStack`, `includeCause` and `redactSensitiveData` are applied at
-     * every level of the cause chain.
+     * every level of the cause chain, including array causes and plain-object
+     * causes that merely look like a serialized BaseError.
      */
     serialize(error: BaseError): InternalErrorResponse;
     /**
@@ -36,7 +37,14 @@ export declare class ErrorSerializer {
     serializeUnknownPublic(value: unknown): PublicErrorResponse;
     /** Applies the serializer options to one level of a serialized error. */
     private serializeLevel;
-    /** Applies the serializer options recursively to a serialized cause. */
+    /**
+     * Applies the serializer options recursively to a serialized cause.
+     *
+     * Only objects that a BaseError's `toJSON` really produced are treated as
+     * serialized BaseErrors (whose `metadata` alone needs redacting). Anything
+     * else, including a plain object carrying the same field names and any
+     * array, has every field walked and redacted.
+     */
     private serializeCause;
     /** Computes the metadata allowed in a public response. */
     private publicMetadata;

package/dist/utils/errorSerializer.core.js

@@ -3,6 +3,8 @@
  */
 import { BaseError } from "../base/core/baseError.core.js";
 import { pickErrorMetadata, redactErrorMetadata, } from "../base/core/errorMetadata.core.js";
+import { isGenuineSerializedBaseError, MAX_CAUSE_DEPTH, toJSONWithFrame, } from "../base/core/baseError.serialize.js";
+import { redactCauseFields, redactCauseValue, } from "../base/core/errorCause.redact.js";
 import { normalizeUnknownError } from "./errorSerializer.factory.js";
 export { createErrorSerializer, serializeError, serializePublicError, normalizeUnknownError, } from "./errorSerializer.factory.js";
 /** Converts errors into safe, predictable serialized structures. */
@@ -27,10 +29,12 @@ export class ErrorSerializer {
      * Serializes an error for internal logging or monitoring.
      *
      * `includeStack`, `includeCause` and `redactSensitiveData` are applied at
-     * every level of the cause chain.
+     * every level of the cause chain, including array causes and plain-object
+     * causes that merely look like a serialized BaseError.
      */
     serialize(error) {
-        return this.serializeLevel(error.toJSON());
+        const raw = toJSONWithFrame(error, { depth: 0, redact: false });
+        return this.serializeLevel(raw, 0);
     }
     /**
      * Serializes an error for an untrusted API client.
@@ -58,7 +62,7 @@ export class ErrorSerializer {
         return this.serializePublic(normalizeUnknownError(value));
     }
     /** Applies the serializer options to one level of a serialized error. */
-    serializeLevel(serialized) {
+    serializeLevel(serialized, depth) {
         const { stack, cause, metadata, ...rest } = serialized;
         const result = {
             ...rest,
@@ -69,27 +73,43 @@ export class ErrorSerializer {
                 : {},
             ...(this.includeStack && stack !== undefined ? { stack } : {}),
             ...(this.includeCause && cause !== undefined
-                ? { cause: this.serializeCause(cause) }
+                ? { cause: this.serializeCause(cause, depth + 1) }
                 : {}),
         };
         return result;
     }
-    /** Applies the serializer options recursively to a serialized cause. */
-    serializeCause(cause) {
+    /**
+     * Applies the serializer options recursively to a serialized cause.
+     *
+     * Only objects that a BaseError's `toJSON` really produced are treated as
+     * serialized BaseErrors (whose `metadata` alone needs redacting). Anything
+     * else, including a plain object carrying the same field names and any
+     * array, has every field walked and redacted.
+     */
+    serializeCause(cause, depth) {
+        if (depth > MAX_CAUSE_DEPTH)
+            return "[MaxDepth]";
         if (cause === null || typeof cause !== "object")
             return cause;
-        if (Array.isArray(cause))
-            return cause;
+        if (Array.isArray(cause)) {
+            return this.redactSensitiveData
+                ? redactCauseValue(cause, this.sensitiveKeyPattern)
+                : cause;
+        }
         const record = cause;
-        if (isSerializedBaseError(record)) {
-            return this.serializeLevel(record);
+        if (isGenuineSerializedBaseError(record)) {
+            return this.serializeLevel(record, depth);
         }
-        // Native error shape: { name, message, stack?, cause? }
         const { stack, cause: nested, ...rest } = record;
+        const fields = this.redactSensitiveData
+            ? redactCauseFields(rest, this.sensitiveKeyPattern, new WeakSet([record]))
+            : rest;
         return {
-            ...rest,
+            ...fields,
             ...(this.includeStack && stack !== undefined ? { stack } : {}),
-            ...(nested !== undefined ? { cause: this.serializeCause(nested) } : {}),
+            ...(nested !== undefined
+                ? { cause: this.serializeCause(nested, depth + 1) }
+                : {}),
         };
     }
     /** Computes the metadata allowed in a public response. */
@@ -118,13 +138,4 @@ export class ErrorSerializer {
         });
     }
 }
-/** Structural check for a serialized BaseError (used on nested causes). */
-function isSerializedBaseError(value) {
-    return (typeof value.code === "string" &&
-        typeof value.category === "string" &&
-        typeof value.severity === "string" &&
-        typeof value.statusCode === "number" &&
-        typeof value.metadata === "object" &&
-        value.metadata !== null);
-}
 //# sourceMappingURL=errorSerializer.core.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/errors",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Shared error base class, error codes, and error handling utilities for the Zudojs framework.",
   "type": "module",
   "main": "./dist/index.js",
@@ -28,6 +28,10 @@
     "node": ">=24.0.0"
   },
   "license": "MIT",
+  "author": {
+    "name": "Oluwayemi Oyinlola",
+    "url": "https://github.com/oyinlola-tech"
+  },
   "publishConfig": {
     "access": "public"
   },