@zudojs/errors 0.1.0 → 1.0.0

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

@@ -2,6 +2,7 @@
  * Event lifecycle error classes — publishing, definitions, registry, serialization.
  */
 import { ErrorCode } from "../../base/types/errorCode.type.js";
+import { assertFiniteNonNegative } from "../shared/domainError.helpers.js";
 import { EventError } from "./eventError.base.js";
 /** Error raised when event publishing fails. */
 export class EventPublishError extends EventError {
@@ -17,7 +18,7 @@ export class EventPublishError extends EventError {
 export class InvalidEventError extends EventError {
     constructor(message, options = {}) {
         super(message, {
-            code: ErrorCode.INVALID_INPUT,
+            code: ErrorCode.EVENT_INVALID,
             eventType: options.eventType,
             eventId: options.eventId,
             cause: options.cause,
@@ -26,36 +27,51 @@ export class InvalidEventError extends EventError {
         });
     }
 }
-/** Error thrown when an event type is not registered. */
+/**
+ * Error thrown when an event type is not registered.
+ *
+ * Event registration is a server-side concern; reported as internal.
+ */
 export class EventTypeNotFoundError extends EventError {
     constructor(eventType) {
         super(`Event type "${eventType}" is not registered.`, {
-            code: ErrorCode.NOT_FOUND,
+            code: ErrorCode.EVENT_TYPE_NOT_FOUND,
             eventType,
-            statusCode: 404,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
     }
 }
-/** Error thrown when an event definition is duplicated. */
+/**
+ * Error thrown when an event definition is duplicated.
+ *
+ * Event registration is a server-side concern; reported as internal.
+ */
 export class DuplicateEventDefinitionError extends EventError {
     constructor(eventType) {
         super(`Event definition "${eventType}" is already registered.`, {
-            code: ErrorCode.CONFLICT,
+            code: ErrorCode.EVENT_DUPLICATE_DEFINITION,
             eventType,
-            statusCode: 409,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
     }
 }
-/** Error thrown when an event definition is missing. */
+/**
+ * Error thrown when an event definition is missing.
+ *
+ * Event registration is a server-side concern; reported as internal.
+ */
 export class EventDefinitionNotFoundError extends EventError {
     constructor(eventType) {
         super(`Event definition "${eventType}" was not found.`, {
-            code: ErrorCode.NOT_FOUND,
+            code: ErrorCode.EVENT_DEFINITION_NOT_FOUND,
             eventType,
-            statusCode: 404,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
     }
 }
@@ -63,7 +79,7 @@ export class EventDefinitionNotFoundError extends EventError {
 export class EventDispatchAbortedError extends EventError {
     constructor(message = "Event dispatch was aborted.", options = {}) {
         super(message, {
-            code: ErrorCode.OPERATION_CANCELLED,
+            code: ErrorCode.EVENT_DISPATCH_ABORTED,
             eventType: options.eventType,
             eventId: options.eventId,
             statusCode: 499,
@@ -75,7 +91,7 @@ export class EventDispatchAbortedError extends EventError {
 export class EventEmitterDisposedError extends EventError {
     constructor() {
         super("Event emitter has already been disposed.", {
-            code: ErrorCode.OPERATION_FAILED,
+            code: ErrorCode.EVENT_EMITTER_DISPOSED,
             statusCode: 500,
             isOperational: false,
         });
@@ -85,7 +101,7 @@ export class EventEmitterDisposedError extends EventError {
 export class EventRegistryDisposedError extends EventError {
     constructor() {
         super("Event registry has already been disposed.", {
-            code: ErrorCode.OPERATION_FAILED,
+            code: ErrorCode.EVENT_REGISTRY_DISPOSED,
             statusCode: 500,
             isOperational: false,
         });
@@ -93,20 +109,34 @@ export class EventRegistryDisposedError extends EventError {
 }
 /** Error thrown when an event subscription has been closed. */
 export class EventSubscriptionClosedError extends EventError {
+    subscriptionId;
     constructor(subscriptionId) {
         super(`Event subscription "${subscriptionId}" is already closed.`, {
-            code: ErrorCode.OPERATION_FAILED,
+            code: ErrorCode.EVENT_SUBSCRIPTION_CLOSED,
+            metadata: { subscriptionId },
             statusCode: 410,
             expose: true,
         });
+        this.subscriptionId = subscriptionId;
+    }
+}
+/** Error thrown when an operation is attempted on a disposed event bus. */
+export class EventBusDisposedError extends EventError {
+    constructor() {
+        super("Event bus has already been disposed.", {
+            code: ErrorCode.EVENT_BUS_DISPOSED,
+            statusCode: 500,
+            isOperational: false,
+        });
     }
 }
 /** Error thrown when an event operation times out. */
 export class EventTimeoutError extends EventError {
     timeoutMs;
     constructor(timeoutMs, options = {}) {
+        assertFiniteNonNegative("timeoutMs", timeoutMs);
         super(`Event processing exceeded the timeout of ${timeoutMs}ms.`, {
-            code: ErrorCode.TIMEOUT,
+            code: ErrorCode.EVENT_TIMEOUT,
             eventType: options.eventType,
             eventId: options.eventId,
             metadata: { timeoutMs },

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

@@ -10,8 +10,16 @@ export declare class EventSerializationError extends EventError {
         cause?: unknown;
     });
 }
-/** Error thrown when event deserialization fails. */
+/**
+ * Error thrown when event deserialization fails.
+ *
+ * Malformed serialized input is a client/input problem, so this is a
+ * 400 that may be exposed.
+ */
 export declare class EventDeserializationError extends EventError {
-    constructor(message: string, cause?: unknown);
+    constructor(message: string, cause?: unknown, options?: {
+        eventType?: string;
+        eventId?: string;
+    });
 }
 //# sourceMappingURL=eventError.serialization.d.ts.map

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

@@ -7,17 +7,29 @@ import { EventError } from "./eventError.base.js";
 export class EventSerializationError extends EventError {
     constructor(message, options = {}) {
         super(message, {
-            code: ErrorCode.INTERNAL_ERROR,
+            code: ErrorCode.EVENT_SERIALIZATION_FAILED,
             eventType: options.eventType,
             eventId: options.eventId,
             cause: options.cause,
         });
     }
 }
-/** Error thrown when event deserialization fails. */
+/**
+ * Error thrown when event deserialization fails.
+ *
+ * Malformed serialized input is a client/input problem, so this is a
+ * 400 that may be exposed.
+ */
 export class EventDeserializationError extends EventError {
-    constructor(message, cause) {
-        super(message, { code: ErrorCode.INVALID_FORMAT, cause });
+    constructor(message, cause, options = {}) {
+        super(message, {
+            code: ErrorCode.EVENT_DESERIALIZATION_FAILED,
+            cause,
+            eventType: options.eventType,
+            eventId: options.eventId,
+            statusCode: 400,
+            expose: true,
+        });
     }
 }
 //# sourceMappingURL=eventError.serialization.js.map

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

@@ -6,4 +6,5 @@ export type { MessageErrorOptions } from "./messageError.base.js";
 export { MessageHandlerError, createMessageHandlerError, MessageHandlerNotFoundError, DuplicateMessageHandlerError, MessageMiddlewareError, } from "./messageError.handler.js";
 export { MessageDispatchError, InvalidMessageError, MessageTypeNotFoundError, MessageDispatchAbortedError, MessageBusDisposedError, MessageTimeoutError, } from "./messageError.lifecycle.js";
 export { MessageValidationError } from "./messageError.validation.js";
+export { MessageSerializationError, MessageDeserializationError, } from "./messageError.serialization.js";
 //# sourceMappingURL=message.error.d.ts.map

package/dist/domain/message/message.error.js

@@ -5,4 +5,5 @@ export { MessageError, createMessageError, isMessageError, toMessageError, } fro
 export { MessageHandlerError, createMessageHandlerError, MessageHandlerNotFoundError, DuplicateMessageHandlerError, MessageMiddlewareError, } from "./messageError.handler.js";
 export { MessageDispatchError, InvalidMessageError, MessageTypeNotFoundError, MessageDispatchAbortedError, MessageBusDisposedError, MessageTimeoutError, } from "./messageError.lifecycle.js";
 export { MessageValidationError } from "./messageError.validation.js";
+export { MessageSerializationError, MessageDeserializationError, } from "./messageError.serialization.js";
 //# sourceMappingURL=message.error.js.map

package/dist/domain/message/messageError.base.d.ts

@@ -4,6 +4,7 @@
 import { BaseError } from "../../base/core/baseError.core.js";
 import type { BaseErrorOptions } from "../../base/types/baseError.type.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";
 /** Options for creating a message error. */
 export interface MessageErrorOptions extends Omit<BaseErrorOptions, "category"> {
@@ -18,6 +19,7 @@ export declare class MessageError extends BaseError {
     readonly messageType?: string;
     readonly messageId?: string;
     readonly handlerId?: string;
+    readonly middlewareId?: string;
     constructor(message: string, options?: MessageErrorOptions);
     toJSON(): {
         name: string;
@@ -34,6 +36,7 @@ export declare class MessageError extends BaseError {
         messageType?: string | undefined;
         messageId?: string | undefined;
         handlerId?: string | undefined;
+        middlewareId?: string | undefined;
     };
 }
 /** Creates a message error. */
@@ -45,6 +48,6 @@ export declare function toMessageError(error: unknown, options?: {
     message?: string;
     messageType?: string;
     messageId?: string;
-    code?: string;
+    code?: ErrorCode | string;
 }): MessageError;
 //# sourceMappingURL=messageError.base.d.ts.map

package/dist/domain/message/messageError.base.js

@@ -5,11 +5,13 @@ 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 { safeErrorMessage } from "../shared/domainError.helpers.js";
 /** Base error for all message subsystem failures. */
 export class MessageError extends BaseError {
     messageType;
     messageId;
     handlerId;
+    middlewareId;
     constructor(message, options = {}) {
         super(message, {
             ...options,
@@ -23,6 +25,7 @@ export class MessageError extends BaseError {
         this.messageType = options.messageType;
         this.messageId = options.messageId;
         this.handlerId = options.handlerId;
+        this.middlewareId = options.middlewareId;
     }
     toJSON() {
         return {
@@ -32,6 +35,9 @@ export class MessageError extends BaseError {
                 : {}),
             ...(this.messageId !== undefined ? { messageId: this.messageId } : {}),
             ...(this.handlerId !== undefined ? { handlerId: this.handlerId } : {}),
+            ...(this.middlewareId !== undefined
+                ? { middlewareId: this.middlewareId }
+                : {}),
         };
     }
 }
@@ -48,15 +54,7 @@ export function toMessageError(error, options = {}) {
     if (error instanceof MessageError) {
         return error;
     }
-    if (error instanceof Error) {
-        return new MessageError(options.message ?? error.message, {
-            code: options.code,
-            messageType: options.messageType,
-            messageId: options.messageId,
-            cause: error,
-        });
-    }
-    return new MessageError(options.message ?? String(error), {
+    return new MessageError(options.message ?? safeErrorMessage(error), {
         code: options.code,
         messageType: options.messageType,
         messageId: options.messageId,

package/dist/domain/message/messageError.handler.d.ts

@@ -13,17 +13,26 @@ export declare class MessageHandlerError extends MessageError {
 }
 /** Creates a message handler error from an unknown failure. */
 export declare function createMessageHandlerError(handlerId: string, messageType: string, messageId: string, cause: unknown): MessageHandlerError;
-/** Error thrown when a message handler cannot be found. */
+/**
+ * Error thrown when a message handler cannot be found.
+ *
+ * Handler registration is a server-side concern, so this is an internal
+ * (non-exposed, non-operational) failure.
+ */
 export declare class MessageHandlerNotFoundError extends MessageError {
     constructor(handlerId: string);
 }
-/** Error thrown when a message handler is already registered. */
+/**
+ * Error thrown when a message handler is already registered.
+ *
+ * Handler registration is a server-side concern, so this is an internal
+ * (non-exposed, non-operational) failure.
+ */
 export declare class DuplicateMessageHandlerError extends MessageError {
     constructor(handlerId: string);
 }
 /** Error thrown when message middleware fails. */
 export declare class MessageMiddlewareError extends MessageError {
-    readonly middlewareId?: string;
     constructor(message: string, options?: {
         middlewareId?: string;
         messageType?: string;

package/dist/domain/message/messageError.handler.js

@@ -7,7 +7,7 @@ import { MessageError } from "./messageError.base.js";
 export class MessageHandlerError extends MessageError {
     constructor(message, options) {
         super(message, {
-            code: ErrorCode.MESSAGE_HANDLER_NOT_FOUND,
+            code: ErrorCode.MESSAGE_HANDLER_FAILED,
             handlerId: options.handlerId,
             messageType: options.messageType,
             messageId: options.messageId,
@@ -19,40 +19,50 @@ export class MessageHandlerError extends MessageError {
 export function createMessageHandlerError(handlerId, messageType, messageId, cause) {
     return new MessageHandlerError(`Message handler "${handlerId}" failed while processing "${messageType}".`, { handlerId, messageType, messageId, cause });
 }
-/** Error thrown when a message handler cannot be found. */
+/**
+ * Error thrown when a message handler cannot be found.
+ *
+ * Handler registration is a server-side concern, so this is an internal
+ * (non-exposed, non-operational) failure.
+ */
 export class MessageHandlerNotFoundError extends MessageError {
     constructor(handlerId) {
         super(`Message handler "${handlerId}" was not found.`, {
-            code: ErrorCode.RESOURCE_NOT_FOUND,
+            code: ErrorCode.MESSAGE_HANDLER_NOT_FOUND,
             handlerId,
-            statusCode: 404,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
     }
 }
-/** Error thrown when a message handler is already registered. */
+/**
+ * Error thrown when a message handler is already registered.
+ *
+ * Handler registration is a server-side concern, so this is an internal
+ * (non-exposed, non-operational) failure.
+ */
 export class DuplicateMessageHandlerError extends MessageError {
     constructor(handlerId) {
         super(`Message handler "${handlerId}" is already registered.`, {
-            code: ErrorCode.CONFLICT,
+            code: ErrorCode.MESSAGE_DUPLICATE_HANDLER,
             handlerId,
-            statusCode: 409,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
     }
 }
 /** Error thrown when message middleware fails. */
 export class MessageMiddlewareError extends MessageError {
-    middlewareId;
     constructor(message, options = {}) {
         super(message, {
-            code: ErrorCode.MIDDLEWARE_EXECUTION,
+            code: ErrorCode.MESSAGE_MIDDLEWARE_FAILED,
             middlewareId: options.middlewareId,
             messageType: options.messageType,
             messageId: options.messageId,
             cause: options.cause,
         });
-        this.middlewareId = options.middlewareId;
     }
 }
 //# sourceMappingURL=messageError.handler.js.map

package/dist/domain/message/messageError.lifecycle.d.ts

@@ -14,7 +14,11 @@ export declare class InvalidMessageError extends MessageError {
         cause?: unknown;
     });
 }
-/** Error thrown when a message type is not registered. */
+/**
+ * Error thrown when a message type is not registered.
+ *
+ * Message registration is a server-side concern; reported as internal.
+ */
 export declare class MessageTypeNotFoundError extends MessageError {
     constructor(messageType: string);
 }

package/dist/domain/message/messageError.lifecycle.js

@@ -2,6 +2,7 @@
  * Message lifecycle error classes — dispatch, timeout, validation.
  */
 import { ErrorCode } from "../../base/types/errorCode.type.js";
+import { assertFiniteNonNegative } from "../shared/domainError.helpers.js";
 import { MessageError } from "./messageError.base.js";
 /** Error raised when message dispatch fails. */
 export class MessageDispatchError extends MessageError {
@@ -17,7 +18,7 @@ export class MessageDispatchError extends MessageError {
 export class InvalidMessageError extends MessageError {
     constructor(message, options = {}) {
         super(message, {
-            code: ErrorCode.INVALID_INPUT,
+            code: ErrorCode.MESSAGE_INVALID,
             messageType: options.messageType,
             messageId: options.messageId,
             cause: options.cause,
@@ -26,14 +27,19 @@ export class InvalidMessageError extends MessageError {
         });
     }
 }
-/** Error thrown when a message type is not registered. */
+/**
+ * Error thrown when a message type is not registered.
+ *
+ * Message registration is a server-side concern; reported as internal.
+ */
 export class MessageTypeNotFoundError extends MessageError {
     constructor(messageType) {
         super(`Message type "${messageType}" is not registered.`, {
-            code: ErrorCode.NOT_FOUND,
+            code: ErrorCode.MESSAGE_TYPE_NOT_FOUND,
             messageType,
-            statusCode: 404,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
     }
 }
@@ -41,7 +47,7 @@ export class MessageTypeNotFoundError extends MessageError {
 export class MessageDispatchAbortedError extends MessageError {
     constructor(message = "Message dispatch was aborted.", options = {}) {
         super(message, {
-            code: ErrorCode.OPERATION_CANCELLED,
+            code: ErrorCode.MESSAGE_ABORTED,
             messageType: options.messageType,
             messageId: options.messageId,
             statusCode: 499,
@@ -53,7 +59,7 @@ export class MessageDispatchAbortedError extends MessageError {
 export class MessageBusDisposedError extends MessageError {
     constructor() {
         super("Message bus has already been disposed.", {
-            code: ErrorCode.OPERATION_FAILED,
+            code: ErrorCode.MESSAGE_BUS_DISPOSED,
             statusCode: 500,
             isOperational: false,
         });
@@ -63,8 +69,9 @@ export class MessageBusDisposedError extends MessageError {
 export class MessageTimeoutError extends MessageError {
     timeoutMs;
     constructor(timeoutMs, options = {}) {
+        assertFiniteNonNegative("timeoutMs", timeoutMs);
         super(`Message processing exceeded the timeout of ${timeoutMs}ms.`, {
-            code: ErrorCode.TIMEOUT,
+            code: ErrorCode.MESSAGE_TIMEOUT,
             messageType: options.messageType,
             messageId: options.messageId,
             metadata: { timeoutMs },

package/dist/domain/message/messageError.serialization.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Message serialization and deserialization error classes.
+ */
+import { MessageError } from "./messageError.base.js";
+/** Error thrown when message serialization fails. */
+export declare class MessageSerializationError extends MessageError {
+    constructor(message: string, options?: {
+        messageType?: string;
+        messageId?: string;
+        cause?: unknown;
+    });
+}
+/**
+ * Error thrown when message deserialization fails.
+ *
+ * Malformed serialized input is a client/input problem, so this is a
+ * 400 that may be exposed.
+ */
+export declare class MessageDeserializationError extends MessageError {
+    constructor(message: string, options?: {
+        messageType?: string;
+        messageId?: string;
+        cause?: unknown;
+    });
+}
+//# sourceMappingURL=messageError.serialization.d.ts.map

package/dist/domain/message/messageError.serialization.js

@@ -0,0 +1,35 @@
+/**
+ * Message serialization and deserialization error classes.
+ */
+import { ErrorCode } from "../../base/types/errorCode.type.js";
+import { MessageError } from "./messageError.base.js";
+/** Error thrown when message serialization fails. */
+export class MessageSerializationError extends MessageError {
+    constructor(message, options = {}) {
+        super(message, {
+            code: ErrorCode.MESSAGE_SERIALIZATION_FAILED,
+            messageType: options.messageType,
+            messageId: options.messageId,
+            cause: options.cause,
+        });
+    }
+}
+/**
+ * Error thrown when message deserialization fails.
+ *
+ * Malformed serialized input is a client/input problem, so this is a
+ * 400 that may be exposed.
+ */
+export class MessageDeserializationError extends MessageError {
+    constructor(message, options = {}) {
+        super(message, {
+            code: ErrorCode.MESSAGE_DESERIALIZATION_FAILED,
+            messageType: options.messageType,
+            messageId: options.messageId,
+            cause: options.cause,
+            statusCode: 400,
+            expose: true,
+        });
+    }
+}
+//# sourceMappingURL=messageError.serialization.js.map

package/dist/domain/plugin/pluginError.lifecycle.js

@@ -3,6 +3,12 @@
  */
 import { ErrorCode } from "../../base/types/errorCode.type.js";
 import { PluginError } from "./pluginError.base.js";
+/*
+ * Plugin registration, lookup, dependency and state errors describe server
+ * configuration problems. They are reported as internal (500, not exposed,
+ * non-operational) so that plugin names and dependency graphs never reach
+ * clients and so that a misconfigured server is not blamed on the request.
+ */
 /** Error thrown when a plugin registration fails. */
 export class PluginRegistrationError extends PluginError {
     constructor(message, pluginName, options = {}) {
@@ -10,10 +16,10 @@ export class PluginRegistrationError extends PluginError {
             ...options,
             code: ErrorCode.PLUGIN_REGISTRATION,
             pluginName,
-            statusCode: 400,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
-        this.name = "PluginRegistrationError";
     }
 }
 /** Error thrown when a plugin is already registered. */
@@ -23,10 +29,10 @@ export class PluginAlreadyRegisteredError extends PluginError {
             ...options,
             code: ErrorCode.PLUGIN_ALREADY_REGISTERED,
             pluginName,
-            statusCode: 409,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
-        this.name = "PluginAlreadyRegisteredError";
     }
 }
 /** Error thrown when a plugin is not found. */
@@ -36,10 +42,10 @@ export class PluginNotFoundError extends PluginError {
             ...options,
             code: ErrorCode.PLUGIN_NOT_FOUND,
             pluginName,
-            statusCode: 404,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
-        this.name = "PluginNotFoundError";
     }
 }
 /** Error thrown when a plugin dependency is missing. */
@@ -49,11 +55,11 @@ export class PluginDependencyError extends PluginError {
             ...options,
             code: ErrorCode.PLUGIN_DEPENDENCY,
             pluginName,
-            statusCode: 400,
-            expose: true,
-            metadata: { dependencyName },
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
+            metadata: { ...options.metadata, dependencyName },
         });
-        this.name = "PluginDependencyError";
     }
 }
 /** Error thrown when a circular plugin dependency is detected. */
@@ -62,11 +68,11 @@ export class PluginDependencyCycleError extends PluginError {
         super(`Circular plugin dependency detected: ${cycle.join(" -> ")}.`, {
             ...options,
             code: ErrorCode.PLUGIN_DEPENDENCY_CYCLE,
-            statusCode: 400,
-            expose: true,
-            metadata: { cycle: [...cycle] },
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
+            metadata: { ...options.metadata, cycle: [...cycle] },
         });
-        this.name = "PluginDependencyCycleError";
     }
 }
 /** Error thrown when a plugin initialization fails. */
@@ -79,7 +85,6 @@ export class PluginInitializationError extends PluginError {
             statusCode: 500,
             expose: false,
         });
-        this.name = "PluginInitializationError";
     }
 }
 /** Error thrown when a plugin start fails. */
@@ -92,7 +97,6 @@ export class PluginStartError extends PluginError {
             statusCode: 500,
             expose: false,
         });
-        this.name = "PluginStartError";
     }
 }
 /** Error thrown when a plugin stop fails. */
@@ -105,7 +109,6 @@ export class PluginStopError extends PluginError {
             statusCode: 500,
             expose: false,
         });
-        this.name = "PluginStopError";
     }
 }
 /** Error thrown when a plugin dispose fails. */
@@ -118,7 +121,6 @@ export class PluginDisposeError extends PluginError {
             statusCode: 500,
             expose: false,
         });
-        this.name = "PluginDisposeError";
     }
 }
 //# sourceMappingURL=pluginError.lifecycle.js.map

package/dist/domain/plugin/pluginError.runtime.d.ts

@@ -6,7 +6,11 @@ import { PluginError, type PluginErrorOptions } from "./pluginError.base.js";
 export declare class PluginTimeoutError extends PluginError {
     constructor(pluginName: string, timeout: number, options?: PluginErrorOptions);
 }
-/** Error thrown when an invalid plugin state transition is attempted. */
+/**
+ * Error thrown when an invalid plugin state transition is attempted.
+ *
+ * Plugin state is server-side; reported as internal (500, not exposed).
+ */
 export declare class PluginStateError extends PluginError {
     constructor(pluginName: string, fromState: string, toState: string, options?: PluginErrorOptions);
 }