@zudojs/errors 1.1.0 → 1.2.0

package/dist/base/core/errorCause.redact.d.ts

@@ -10,11 +10,16 @@
  * Redacts sensitive keys inside a record without changing its shape:
  * primitives, dates and class instances are kept, plain objects and arrays
  * are walked, cycles stop at `"[Circular]"`, prototype keys are dropped.
+ *
+ * The walk is depth-bounded exactly as metadata cloning is: a subtree past
+ * {@link MAX_METADATA_DEPTH} becomes `"[MaxDepth]"`. Without that bound a
+ * parsed request body attached as a cause could overflow the stack *inside*
+ * the serializer, turning a logged error into an uncaught `RangeError`.
  */
-export declare function redactCauseFields(fields: Record<string, unknown>, pattern: RegExp | undefined, seen?: WeakSet<object>): Record<string, unknown>;
+export declare function redactCauseFields(fields: Record<string, unknown>, pattern: RegExp | undefined, seen?: WeakSet<object>, depth?: number): Record<string, unknown>;
 /**
  * Redacts one cause value: arrays and plain objects are walked, every other
- * value is returned unchanged.
+ * value is returned unchanged. Walking stops at {@link MAX_METADATA_DEPTH}.
  */
-export declare function redactCauseValue(value: unknown, pattern: RegExp | undefined, seen?: WeakSet<object>): unknown;
+export declare function redactCauseValue(value: unknown, pattern: RegExp | undefined, seen?: WeakSet<object>, depth?: number): unknown;
 //# sourceMappingURL=errorCause.redact.d.ts.map

package/dist/base/core/errorCause.redact.js

@@ -6,7 +6,9 @@
  *
  * @module base/core/errorCause.redact
  */
-import { isForbiddenMetadataKey, isSensitiveMetadataKey, REDACTED_METADATA_VALUE, } from "./errorMetadata.core.js";
+import { isForbiddenMetadataKey, isSensitiveMetadataKey, MAX_METADATA_DEPTH, REDACTED_METADATA_VALUE, } from "./errorMetadata.core.js";
+/** Marker substituted for a cause subtree deeper than {@link MAX_METADATA_DEPTH}. */
+const MAX_DEPTH_VALUE = "[MaxDepth]";
 /** Plain objects (Object.prototype or null prototype) are walked; anything else is kept as-is. */
 function isPlainRecord(value) {
     if (value === null || typeof value !== "object")
@@ -18,8 +20,13 @@ function isPlainRecord(value) {
  * Redacts sensitive keys inside a record without changing its shape:
  * primitives, dates and class instances are kept, plain objects and arrays
  * are walked, cycles stop at `"[Circular]"`, prototype keys are dropped.
+ *
+ * The walk is depth-bounded exactly as metadata cloning is: a subtree past
+ * {@link MAX_METADATA_DEPTH} becomes `"[MaxDepth]"`. Without that bound a
+ * parsed request body attached as a cause could overflow the stack *inside*
+ * the serializer, turning a logged error into an uncaught `RangeError`.
  */
-export function redactCauseFields(fields, pattern, seen = new WeakSet()) {
+export function redactCauseFields(fields, pattern, seen = new WeakSet(), depth = 0) {
     const result = {};
     for (const key of Object.keys(fields)) {
         if (isForbiddenMetadataKey(key))
@@ -29,21 +36,23 @@ export function redactCauseFields(fields, pattern, seen = new WeakSet()) {
             : isSensitiveMetadataKey(key, pattern);
         result[key] = sensitive
             ? REDACTED_METADATA_VALUE
-            : redactCauseValue(fields[key], pattern, seen);
+            : redactCauseValue(fields[key], pattern, seen, depth + 1);
     }
     return result;
 }
 /**
  * Redacts one cause value: arrays and plain objects are walked, every other
- * value is returned unchanged.
+ * value is returned unchanged. Walking stops at {@link MAX_METADATA_DEPTH}.
  */
-export function redactCauseValue(value, pattern, seen = new WeakSet()) {
+export function redactCauseValue(value, pattern, seen = new WeakSet(), depth = 0) {
     if (Array.isArray(value)) {
+        if (depth > MAX_METADATA_DEPTH)
+            return MAX_DEPTH_VALUE;
         if (seen.has(value))
             return "[Circular]";
         seen.add(value);
         try {
-            return value.map((entry) => redactCauseValue(entry, pattern, seen));
+            return value.map((entry) => redactCauseValue(entry, pattern, seen, depth + 1));
         }
         finally {
             seen.delete(value);
@@ -51,11 +60,13 @@ export function redactCauseValue(value, pattern, seen = new WeakSet()) {
     }
     if (!isPlainRecord(value))
         return value;
+    if (depth > MAX_METADATA_DEPTH)
+        return MAX_DEPTH_VALUE;
     if (seen.has(value))
         return "[Circular]";
     seen.add(value);
     try {
-        return redactCauseFields(value, pattern, seen);
+        return redactCauseFields(value, pattern, seen, depth);
     }
     finally {
         seen.delete(value);

package/dist/base/types/errorCode.type.d.ts

@@ -114,6 +114,7 @@ export declare enum ErrorCode {
     EVENT_REGISTRY_DISPOSED = "ERR_EVENT_REGISTRY_DISPOSED",
     EVENT_BUS_DISPOSED = "ERR_EVENT_BUS_DISPOSED",
     EVENT_SUBSCRIPTION_CLOSED = "ERR_EVENT_SUBSCRIPTION_CLOSED",
+    EVENT_LISTENER_LIMIT_EXCEEDED = "ERR_EVENT_LISTENER_LIMIT_EXCEEDED",
     EVENT_TIMEOUT = "ERR_EVENT_TIMEOUT",
     EVENT_SERIALIZATION_FAILED = "ERR_EVENT_SERIALIZATION_FAILED",
     EVENT_DESERIALIZATION_FAILED = "ERR_EVENT_DESERIALIZATION_FAILED",

package/dist/base/types/errorCode.type.js

@@ -120,6 +120,7 @@ export var ErrorCode;
     ErrorCode["EVENT_REGISTRY_DISPOSED"] = "ERR_EVENT_REGISTRY_DISPOSED";
     ErrorCode["EVENT_BUS_DISPOSED"] = "ERR_EVENT_BUS_DISPOSED";
     ErrorCode["EVENT_SUBSCRIPTION_CLOSED"] = "ERR_EVENT_SUBSCRIPTION_CLOSED";
+    ErrorCode["EVENT_LISTENER_LIMIT_EXCEEDED"] = "ERR_EVENT_LISTENER_LIMIT_EXCEEDED";
     ErrorCode["EVENT_TIMEOUT"] = "ERR_EVENT_TIMEOUT";
     ErrorCode["EVENT_SERIALIZATION_FAILED"] = "ERR_EVENT_SERIALIZATION_FAILED";
     ErrorCode["EVENT_DESERIALIZATION_FAILED"] = "ERR_EVENT_DESERIALIZATION_FAILED";

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

@@ -4,6 +4,6 @@
 export { EventError, createEventError, isEventError, toEventError, } from "./eventError.base.js";
 export type { EventErrorOptions } from "./eventError.base.js";
 export { EventHandlerError, createEventHandlerError, EventHandlerNotFoundError, DuplicateEventHandlerError, EventMiddlewareError, } from "./eventError.handler.js";
-export { EventPublishError, InvalidEventError, EventTypeNotFoundError, DuplicateEventDefinitionError, EventDefinitionNotFoundError, EventDispatchAbortedError, EventEmitterDisposedError, EventRegistryDisposedError, EventSubscriptionClosedError, EventBusDisposedError, EventTimeoutError, } from "./eventError.lifecycle.js";
+export { EventPublishError, InvalidEventError, EventTypeNotFoundError, DuplicateEventDefinitionError, EventDefinitionNotFoundError, EventDispatchAbortedError, EventEmitterDisposedError, EventRegistryDisposedError, EventSubscriptionClosedError, EventBusDisposedError, EventListenerLimitExceededError, EventTimeoutError, } from "./eventError.lifecycle.js";
 export { EventSerializationError, EventDeserializationError, } from "./eventError.serialization.js";
 //# sourceMappingURL=event.error.d.ts.map

package/dist/domain/event/event.error.js

@@ -3,6 +3,6 @@
  */
 export { EventError, createEventError, isEventError, toEventError, } from "./eventError.base.js";
 export { EventHandlerError, createEventHandlerError, EventHandlerNotFoundError, DuplicateEventHandlerError, EventMiddlewareError, } from "./eventError.handler.js";
-export { EventPublishError, InvalidEventError, EventTypeNotFoundError, DuplicateEventDefinitionError, EventDefinitionNotFoundError, EventDispatchAbortedError, EventEmitterDisposedError, EventRegistryDisposedError, EventSubscriptionClosedError, EventBusDisposedError, EventTimeoutError, } from "./eventError.lifecycle.js";
+export { EventPublishError, InvalidEventError, EventTypeNotFoundError, DuplicateEventDefinitionError, EventDefinitionNotFoundError, EventDispatchAbortedError, EventEmitterDisposedError, EventRegistryDisposedError, EventSubscriptionClosedError, EventBusDisposedError, EventListenerLimitExceededError, EventTimeoutError, } from "./eventError.lifecycle.js";
 export { EventSerializationError, EventDeserializationError, } from "./eventError.serialization.js";
 //# sourceMappingURL=event.error.js.map

package/dist/domain/event/eventError.lifecycle.d.ts

@@ -62,6 +62,22 @@ export declare class EventSubscriptionClosedError extends EventError {
 export declare class EventBusDisposedError extends EventError {
     constructor();
 }
+/**
+ * Error thrown when a pattern exceeds its configured handler limit.
+ *
+ * The limit exists to catch a subscribe-without-unsubscribe leak. Registering
+ * past it is a programming fault rather than bad input, so this is reported as
+ * internal and is never exposed to a caller.
+ *
+ * A registry only raises this when it is configured to enforce the limit;
+ * the default is a one-shot warning, which does not interrupt registration.
+ */
+export declare class EventListenerLimitExceededError extends EventError {
+    readonly pattern: string;
+    readonly count: number;
+    readonly limit: number;
+    constructor(pattern: string, count: number, limit: number);
+}
 /** Error thrown when an event operation times out. */
 export declare class EventTimeoutError extends EventError {
     readonly timeoutMs: number;

package/dist/domain/event/eventError.lifecycle.js

@@ -130,6 +130,37 @@ export class EventBusDisposedError extends EventError {
         });
     }
 }
+/**
+ * Error thrown when a pattern exceeds its configured handler limit.
+ *
+ * The limit exists to catch a subscribe-without-unsubscribe leak. Registering
+ * past it is a programming fault rather than bad input, so this is reported as
+ * internal and is never exposed to a caller.
+ *
+ * A registry only raises this when it is configured to enforce the limit;
+ * the default is a one-shot warning, which does not interrupt registration.
+ */
+export class EventListenerLimitExceededError extends EventError {
+    pattern;
+    count;
+    limit;
+    constructor(pattern, count, limit) {
+        assertFiniteNonNegative("count", count);
+        assertFiniteNonNegative("limit", limit);
+        super(`Possible event handler leak: ${count} handlers registered for ` +
+            `"${pattern}" (limit ${limit}). Unsubscribe handlers you no longer ` +
+            "need or raise maxHandlersPerPattern / maxListeners.", {
+            code: ErrorCode.EVENT_LISTENER_LIMIT_EXCEEDED,
+            metadata: { pattern, count, limit },
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
+        });
+        this.pattern = pattern;
+        this.count = count;
+        this.limit = limit;
+    }
+}
 /** Error thrown when an event operation times out. */
 export class EventTimeoutError extends EventError {
     timeoutMs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/errors",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Shared error base class, error codes, and error handling utilities for the Zudojs framework.",
   "type": "module",
   "main": "./dist/index.js",