@classytic/arc 2.11.3 → 2.13.1

package/dist/errorHandler-Bk-AGhkU.mjs

@@ -0,0 +1,174 @@
+import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
+import { m as statusToArcCode, p as isArcError } from "./errors-j4aJm1Wg.mjs";
+import { isHttpError, toErrorContract } from "@classytic/repo-core/errors";
+import fp from "fastify-plugin";
+//#region src/plugins/errorHandler.ts
+var errorHandler_exports = /* @__PURE__ */ __exportAll({
+	defaultIsDuplicateKeyError: () => defaultIsDuplicateKeyError,
+	errorHandlerPlugin: () => errorHandlerPlugin
+});
+/**
+* Default duplicate-key detector. Strict driver-code matching only — never
+* message strings (false positives mask real WriteConflict / NotWritable
+* errors as 409s). Long-tail drivers compose: see jsdoc on
+* {@link ErrorHandlerOptions.isDuplicateKeyError}.
+*/
+function defaultIsDuplicateKeyError(err) {
+	if (!err || typeof err !== "object") return false;
+	const e = err;
+	if (e.code === 11e3 || e.codeName === "DuplicateKey") return true;
+	if (e.code === "P2002") return true;
+	if (e.code === "23505") return true;
+	if (e.code === "ER_DUP_ENTRY" || e.errno === 1062) return true;
+	if (e.code === "SQLITE_CONSTRAINT_UNIQUE" || e.code === "SQLITE_CONSTRAINT_PRIMARYKEY") return true;
+	return false;
+}
+function extractDuplicateFields(err) {
+	if (!err || typeof err !== "object") return null;
+	const e = err;
+	if (e.keyValue && typeof e.keyValue === "object") return Object.keys(e.keyValue);
+	if (e.meta?.target) {
+		if (Array.isArray(e.meta.target)) return e.meta.target.map(String);
+		if (typeof e.meta.target === "string") return [e.meta.target];
+	}
+	if (typeof e.constraint === "string") return [e.constraint];
+	return null;
+}
+/** Map Fastify schema-validation errors → canonical `ErrorDetail[]`. */
+function fastifyValidationDetails(error) {
+	return (error.validation ?? []).map((v) => {
+		const missingProperty = v.params?.missingProperty;
+		const path = v.instancePath?.replace(/^\//, "") || (typeof missingProperty === "string" ? missingProperty : void 0);
+		return {
+			...path ? { path } : {},
+			code: v.keyword ?? "invalid",
+			message: v.message || "Invalid value"
+		};
+	});
+}
+/** Map Mongoose `ValidationError.errors` → canonical `ErrorDetail[]`. */
+function mongooseValidationDetails(errors) {
+	return Object.entries(errors).map(([field, e]) => ({
+		path: e.path || field,
+		code: "validation_error",
+		message: e.message
+	}));
+}
+async function errorHandlerPluginFn(fastify, options = {}) {
+	const isProduction = process.env.NODE_ENV === "production";
+	const { includeStack = !isProduction, onError, errorMap = {}, errorMappers = [], isDuplicateKeyError = defaultIsDuplicateKeyError } = options;
+	fastify.setErrorHandler(async (error, request, reply) => {
+		if (onError) try {
+			await onError(error, request);
+		} catch (callbackError) {
+			request.log.error({ err: callbackError }, "Error in onError callback");
+		}
+		const correlationId = request.id;
+		const contract = classify(error, {
+			errorMappers,
+			errorMap,
+			isDuplicateKeyError
+		});
+		const meta = { ...contract.meta ?? {} };
+		if (includeStack && error.stack) meta.stack = error.stack;
+		const wire = {
+			...contract,
+			...correlationId ? { correlationId } : {},
+			...Object.keys(meta).length > 0 ? { meta } : {}
+		};
+		const status = wire.status ?? 500;
+		if (status >= 500) request.log.error({
+			err: error,
+			status
+		}, "Server error");
+		else if (status >= 400) request.log.warn({
+			err: error,
+			status
+		}, "Client error");
+		if (isArcError(error) && error.cause) request.log.error({ cause: error.cause }, "Error cause chain");
+		return reply.status(status).send(wire);
+	});
+}
+/**
+* Single-pass error → `ErrorContract` classifier. Dispatch order is fixed:
+*
+*   1. Class-based mappers (`instanceof`) — user-registered domain errors
+*   2. `ArcError` / any `HttpError`-shaped throw — flows through `toErrorContract`
+*   3. Fastify schema-validation errors — `error.validation` array
+*   4. Fastify-style errors with a numeric `statusCode`
+*   5. Name-keyed `errorMap` entries
+*   6. Mongoose `ValidationError` / `CastError`
+*   7. Driver-specific duplicate-key classifier
+*   8. Fallback: `arc.internal_error` 500
+*/
+function classify(error, ctx) {
+	for (const mapper of ctx.errorMappers) if (error instanceof mapper.type) {
+		const mapped = mapper.toResponse(error);
+		return {
+			code: mapped.code ?? statusToArcCode(mapped.status),
+			message: mapped.message ?? error.message,
+			status: mapped.status,
+			...mapped.details ? { details: mapped.details } : {},
+			...mapped.meta ? { meta: mapped.meta } : {}
+		};
+	}
+	if (isArcError(error) || isHttpError(error)) return toErrorContract(error);
+	const fastifyErr = error;
+	if (Array.isArray(fastifyErr.validation)) return {
+		code: "arc.validation_error",
+		message: "Validation failed",
+		status: 400,
+		details: fastifyValidationDetails(fastifyErr)
+	};
+	if (typeof fastifyErr.statusCode === "number") return {
+		code: statusToArcCode(fastifyErr.statusCode),
+		message: error.message || "Error",
+		status: fastifyErr.statusCode
+	};
+	if (error.name && ctx.errorMap[error.name]) {
+		const m = ctx.errorMap[error.name];
+		return {
+			code: m.code,
+			message: m.message ?? error.message,
+			status: m.statusCode
+		};
+	}
+	if (error.name === "ValidationError" && "errors" in error) {
+		const errs = error.errors;
+		return {
+			code: "arc.validation_error",
+			message: error.message || "Validation failed",
+			status: 400,
+			details: mongooseValidationDetails(errs)
+		};
+	}
+	if (error.name === "CastError") return {
+		code: "arc.invalid_id",
+		message: "Invalid identifier format",
+		status: 400
+	};
+	if (ctx.isDuplicateKeyError(error)) {
+		const fields = extractDuplicateFields(error);
+		return {
+			code: "arc.conflict",
+			message: "Resource already exists",
+			status: 409,
+			...fields && fields.length > 0 ? { details: fields.map((f) => ({
+				path: f,
+				code: "duplicate_key",
+				message: `Duplicate value for "${f}"`
+			})) } : {}
+		};
+	}
+	return {
+		code: "arc.internal_error",
+		message: error.message || "Internal Server Error",
+		status: 500
+	};
+}
+const errorHandlerPlugin = fp(errorHandlerPluginFn, {
+	name: "arc-error-handler",
+	fastify: "5.x"
+});
+//#endregion
+export { errorHandlerPlugin as n, errorHandler_exports as r, defaultIsDuplicateKeyError as t };

package/dist/errorHandler-DFr45ZG4.d.mts

@@ -0,0 +1,45 @@
+import { ErrorDetail } from "@classytic/repo-core/errors";
+import { FastifyInstance, FastifyRequest } from "fastify";
+
+//#region src/plugins/errorHandler.d.ts
+/**
+ * Class-based error mapper — `instanceof` check converts a thrown class
+ * to a partial `ErrorContract`. Highest-priority dispatch in the handler.
+ */
+interface ErrorMapper<T extends Error = Error> {
+  type: abstract new (...args: any[]) => T;
+  toResponse: (error: T) => {
+    status: number;
+    code?: string;
+    message?: string;
+    details?: ReadonlyArray<ErrorDetail>;
+    meta?: Record<string, unknown>;
+  };
+}
+interface ErrorHandlerOptions {
+  /** Include `meta.stack` on the wire (defaults to `NODE_ENV !== 'production'`). */
+  includeStack?: boolean;
+  /** Custom callback fired for every error — log to Sentry / Datadog / etc. */
+  onError?: (error: Error, request: FastifyRequest) => void | Promise<void>;
+  /** Map by `error.name` string. Lower priority than `errorMappers`. */
+  errorMap?: Record<string, {
+    statusCode: number;
+    code: string;
+    message?: string;
+  }>;
+  /** Map by `instanceof`. Highest priority — checked first. */
+  errorMappers?: ErrorMapper[];
+  /** Driver-aware duplicate-key classifier. Override to add long-tail drivers. */
+  isDuplicateKeyError?: (err: unknown) => boolean;
+}
+/**
+ * Default duplicate-key detector. Strict driver-code matching only — never
+ * message strings (false positives mask real WriteConflict / NotWritable
+ * errors as 409s). Long-tail drivers compose: see jsdoc on
+ * {@link ErrorHandlerOptions.isDuplicateKeyError}.
+ */
+declare function defaultIsDuplicateKeyError(err: unknown): boolean;
+declare function errorHandlerPluginFn(fastify: FastifyInstance, options?: ErrorHandlerOptions): Promise<void>;
+declare const errorHandlerPlugin: typeof errorHandlerPluginFn;
+//#endregion
+export { errorHandlerPlugin as i, ErrorMapper as n, defaultIsDuplicateKeyError as r, ErrorHandlerOptions as t };

package/dist/errors-j4aJm1Wg.mjs

@@ -0,0 +1,184 @@
+//#region src/utils/errors.ts
+/**
+* Base Arc Error. Implements the canonical `HttpError` contract — `status`
+* mirrors `statusCode` and `meta` mirrors `details`, so consumers reading
+* either name see the same value without adapter glue.
+*/
+var ArcError = class extends Error {
+	name = "ArcError";
+	code;
+	statusCode;
+	details;
+	cause;
+	constructor(message, options = {}) {
+		super(message, options.cause ? { cause: options.cause } : void 0);
+		this.code = options.code ?? "arc.error";
+		this.statusCode = options.statusCode ?? 500;
+		this.details = options.details;
+		this.cause = options.cause;
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+	}
+	/** `HttpError.status` mirror — repo-core's `toErrorContract` reads this. */
+	get status() {
+		return this.statusCode;
+	}
+	/** `HttpError.meta` mirror — `details` under the canonical name. */
+	get meta() {
+		return this.details;
+	}
+};
+var NotFoundError = class extends ArcError {
+	constructor(resource, identifier) {
+		const message = identifier ? `${resource} with identifier '${identifier}' not found` : `${resource} not found`;
+		super(message, {
+			code: "arc.not_found",
+			statusCode: 404,
+			details: {
+				resource,
+				...identifier ? { identifier } : {}
+			}
+		});
+		this.name = "NotFoundError";
+	}
+};
+var ValidationError = class extends ArcError {
+	errors;
+	constructor(message, errors = []) {
+		super(message, {
+			code: "arc.validation_error",
+			statusCode: 400,
+			details: { errors }
+		});
+		this.name = "ValidationError";
+		this.errors = errors;
+	}
+};
+var UnauthorizedError = class extends ArcError {
+	constructor(message = "Authentication required") {
+		super(message, {
+			code: "arc.unauthorized",
+			statusCode: 401
+		});
+		this.name = "UnauthorizedError";
+	}
+};
+var ForbiddenError = class extends ArcError {
+	constructor(message = "Access denied") {
+		super(message, {
+			code: "arc.forbidden",
+			statusCode: 403
+		});
+		this.name = "ForbiddenError";
+	}
+};
+var ConflictError = class extends ArcError {
+	constructor(message, field) {
+		super(message, {
+			code: "arc.conflict",
+			statusCode: 409,
+			...field ? { details: { field } } : {}
+		});
+		this.name = "ConflictError";
+	}
+};
+var OrgRequiredError = class extends ArcError {
+	organizations;
+	constructor(message, organizations) {
+		super(message, {
+			code: "arc.org.selection_required",
+			statusCode: 403,
+			...organizations ? { details: { organizations } } : {}
+		});
+		this.name = "OrgRequiredError";
+		this.organizations = organizations;
+	}
+};
+var OrgAccessDeniedError = class extends ArcError {
+	constructor(orgId) {
+		super("Organization access denied", {
+			code: "arc.org.access_denied",
+			statusCode: 403,
+			...orgId ? { details: { organizationId: orgId } } : {}
+		});
+		this.name = "OrgAccessDeniedError";
+	}
+};
+var RateLimitError = class extends ArcError {
+	retryAfter;
+	constructor(message = "Too many requests", retryAfter) {
+		super(message, {
+			code: "arc.rate_limited",
+			statusCode: 429,
+			...retryAfter ? { details: { retryAfter } } : {}
+		});
+		this.name = "RateLimitError";
+		this.retryAfter = retryAfter;
+	}
+};
+var ServiceUnavailableError = class extends ArcError {
+	constructor(message = "Service temporarily unavailable") {
+		super(message, {
+			code: "arc.service_unavailable",
+			statusCode: 503
+		});
+		this.name = "ServiceUnavailableError";
+	}
+};
+/**
+* Status-code → canonical `arc.*` code mapping. Used by {@link createError}
+* and the global error handler when no explicit code is supplied.
+*/
+const STATUS_CODE_MAP = {
+	400: "arc.bad_request",
+	401: "arc.unauthorized",
+	403: "arc.forbidden",
+	404: "arc.not_found",
+	409: "arc.conflict",
+	422: "arc.unprocessable_entity",
+	429: "arc.rate_limited",
+	500: "arc.internal_error",
+	502: "arc.bad_gateway",
+	503: "arc.service_unavailable",
+	504: "arc.gateway_timeout"
+};
+/** Status → canonical arc code, falling back to `arc.error`. */
+function statusToArcCode(status) {
+	return STATUS_CODE_MAP[status] ?? "arc.error";
+}
+/**
+* Quick `ArcError` constructor when the bundled subclasses don't fit.
+*
+* If `details.code` is a string, it's lifted to the top-level `error.code`
+* (the canonical wire slot for business signals — `'ORG_CONTEXT_REQUIRED'`,
+* `'ALL_FIELDS_STRIPPED'`, etc). The same code stays in `details` so
+* in-process consumers reading `error.details.code` still work. Without
+* this lift, business codes get buried in `details` and the wire envelope
+* carries only the status-derived `arc.forbidden` / `arc.bad_request`
+* fallback — `repo-core`'s `toErrorContract` doesn't surface free-form
+* `details` objects (its `details[]` array is reserved for validation /
+* duplicate-key items).
+*/
+function createError(statusCode, message, details) {
+	return new ArcError(message, {
+		code: (typeof details?.code === "string" ? details.code : void 0) ?? statusToArcCode(statusCode),
+		statusCode,
+		...details ? { details } : {}
+	});
+}
+/**
+* Domain-error escape hatch. Use a hierarchical code that scopes the error
+* to your package (`'commerce.cart.locked'`, `'payment.gateway.timeout'`).
+*/
+function createDomainError(code, message, statusCode = 400, details) {
+	return new ArcError(message, {
+		code,
+		statusCode,
+		...details ? { details } : {}
+	});
+}
+/** Type guard. */
+function isArcError(error) {
+	return error instanceof ArcError;
+}
+//#endregion
+export { OrgAccessDeniedError as a, ServiceUnavailableError as c, createDomainError as d, createError as f, NotFoundError as i, UnauthorizedError as l, statusToArcCode as m, ConflictError as n, OrgRequiredError as o, isArcError as p, ForbiddenError as r, RateLimitError as s, ArcError as t, ValidationError as u };

package/dist/{eventPlugin-KrFIQ097.mjs → eventPlugin-CaKTYkYM.mjs}

@@ -1,144 +1,20 @@
 import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
-import { t as requestContext } from "./requestContext-C5XeK3VA.mjs";
+import { arcLog } from "./logger/index.mjs";
+import { d as createDomainError } from "./errors-j4aJm1Wg.mjs";
+import { t as requestContext } from "./requestContext-SSaaTgW8.mjs";
+import { n as createEvent, t as MemoryEventTransport } from "./EventTransport-DLWoUMHy.mjs";
 import fp from "fastify-plugin";
-//#region src/events/EventTransport.ts
-/**
-* In-memory event transport (default)
-* Events are delivered synchronously within the process.
-* Not suitable for multi-instance deployments.
-*/
-var MemoryEventTransport = class {
-	name = "memory";
-	handlers = /* @__PURE__ */ new Map();
-	logger;
-	constructor(options) {
-		this.logger = options?.logger ?? console;
-	}
-	async publish(event) {
-		const exactHandlers = this.handlers.get(event.type) ?? /* @__PURE__ */ new Set();
-		const wildcardHandlers = this.handlers.get("*") ?? /* @__PURE__ */ new Set();
-		const patternHandlers = /* @__PURE__ */ new Set();
-		for (const [pattern, handlers] of this.handlers.entries()) if (pattern.endsWith(".*")) {
-			const prefix = pattern.slice(0, -2);
-			if (event.type.startsWith(`${prefix}.`)) for (const h of handlers) patternHandlers.add(h);
-		}
-		const allHandlers = new Set([
-			...exactHandlers,
-			...wildcardHandlers,
-			...patternHandlers
-		]);
-		for (const handler of allHandlers) try {
-			await handler(event);
-		} catch (err) {
-			this.logger.error(`[EventTransport] Handler error for ${event.type}:`, err);
-		}
-	}
-	/**
-	* Reference `publishMany` implementation — delegates to `publish()` in order.
-	*
-	* Production transports (Kafka, Redis pipeline, SQS batch) should override
-	* this with a single batched network call. Memory transport has nothing to
-	* batch, so we just loop — the loop still returns a proper result map so
-	* `EventOutbox.relay` can exercise the batched code path in tests.
-	*/
-	async publishMany(events) {
-		const results = /* @__PURE__ */ new Map();
-		for (const event of events) try {
-			await this.publish(event);
-			results.set(event.meta.id, null);
-		} catch (err) {
-			results.set(event.meta.id, err instanceof Error ? err : new Error(String(err)));
-		}
-		return results;
-	}
-	async subscribe(pattern, handler) {
-		if (!this.handlers.has(pattern)) this.handlers.set(pattern, /* @__PURE__ */ new Set());
-		this.handlers.get(pattern)?.add(handler);
-		return () => {
-			const set = this.handlers.get(pattern);
-			if (set) {
-				set.delete(handler);
-				if (set.size === 0) this.handlers.delete(pattern);
-			}
-		};
-	}
-	async close() {
-		this.handlers.clear();
-	}
-};
-/**
-* Create a domain event with auto-generated metadata.
-*
-* `id` and `timestamp` are filled in; everything else is caller-controlled.
-* Set `schemaVersion` explicitly for any event type you plan to evolve.
-*/
-function createEvent(type, payload, meta) {
-	return {
-		type,
-		payload,
-		meta: {
-			id: crypto.randomUUID(),
-			timestamp: /* @__PURE__ */ new Date(),
-			...meta
-		}
-	};
-}
-/**
-* Create a child event that chains causation from a parent event.
-*
-* Rules:
-*  - `causationId` is set to the parent's `id` (direct cause)
-*  - `correlationId` is inherited from the parent if set, else falls back
-*    to the parent's `id` (root correlation)
-*  - `userId` / `organizationId` are inherited when not overridden so the
-*    whole chain stays scoped to the originating principal/tenant
-*
-* Caller-supplied `meta` wins over inherited fields — pass `{ userId: newActor }`
-* to override when a subsystem acts on behalf of a different principal.
-*
-* @example
-* ```typescript
-* const orderPlaced = createEvent('order.placed', { orderId: 'o1' }, {
-*   correlationId: req.id, userId: user.id,
-* });
-* await events.publish(orderPlaced);
-*
-* // Downstream handler emits a child event:
-* const reserved = createChildEvent(orderPlaced, 'inventory.reserved', {
-*   orderId: 'o1', skus: ['sku-1', 'sku-2'],
-* });
-* // reserved.meta.causationId   === orderPlaced.meta.id
-* // reserved.meta.correlationId === orderPlaced.meta.correlationId
-* // reserved.meta.userId        === user.id   (inherited)
-* ```
-*/
-function createChildEvent(parent, type, payload, meta) {
-	const inherited = {
-		correlationId: parent.meta.correlationId ?? parent.meta.id,
-		causationId: parent.meta.id
-	};
-	if (parent.meta.userId !== void 0) inherited.userId = parent.meta.userId;
-	if (parent.meta.organizationId !== void 0) inherited.organizationId = parent.meta.organizationId;
-	if (parent.meta.source !== void 0) inherited.source = parent.meta.source;
-	if (parent.meta.idempotencyKey !== void 0) inherited.idempotencyKey = parent.meta.idempotencyKey;
-	return {
-		type,
-		payload,
-		meta: {
-			id: crypto.randomUUID(),
-			timestamp: /* @__PURE__ */ new Date(),
-			...inherited,
-			...meta
-		}
-	};
-}
-//#endregion
 //#region src/events/retry.ts
 /**
 * Wrap an event handler with retry logic and dead letter support.
 *
 * On failure, retries with exponential backoff (with jitter).
 * After all retries exhausted, calls `onDead` callback if provided.
+*
+* Generic in the payload type `T` so composing with `wrapWithSchema<T>` /
+* `subscribeWithSchema<T>` doesn't force a cast at the boundary — the inner
+* `handler: EventHandler<T>` flows through to the returned wrapper. Defaults
+* to `unknown` for raw `subscribe(pattern, withRetry(...))` call sites.
 */
 function withRetry(handler, options = {}) {
 	const { maxRetries = 3, backoffMs = 1e3, maxBackoffMs = 3e4, jitter = .1, transport, onDead, name, logger = console } = options;
@@ -235,8 +111,18 @@ var eventPlugin_exports = /* @__PURE__ */ __exportAll({
 	eventPlugin: () => eventPlugin
 });
 const eventPlugin = async (fastify, opts = {}) => {
-	const { transport = new MemoryEventTransport(), logEvents = false, failOpen = true, retry: retryOpts, deadLetterQueue: dlqOpts, wal, onPublish, onPublishError, registry, validateMode: rawValidateMode } = opts;
+	const { transport = new MemoryEventTransport(), logEvents = false, failOpen = true, retry: retryOpts, deadLetterQueue: dlqOpts, wal, onPublish, onPublishError, registry, validateMode: rawValidateMode, warnOnDuplicate: rawWarnOnDuplicate } = opts;
 	const validateMode = rawValidateMode ?? (registry ? "warn" : "off");
+	const warnOnDuplicate = rawWarnOnDuplicate ?? process.env.NODE_ENV !== "production";
+	const DUP_WINDOW_MS = 5e3;
+	const recentPublishes = warnOnDuplicate ? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Map();
+	const evictExpiredPublishes = (now) => {
+		if (recentPublishes.size === 0) return;
+		for (const [key, timestamp] of recentPublishes) {
+			if (now - timestamp <= DUP_WINDOW_MS) break;
+			recentPublishes.delete(key);
+		}
+	};
 	fastify.decorate("events", {
 		publish: async (type, payload, meta) => {
 			if (!type || typeof type !== "string") throw new Error("[Arc Events] Event type must be a non-empty string");
@@ -247,16 +133,28 @@ const eventPlugin = async (fastify, opts = {}) => {
 				...store?.requestId && !meta?.correlationId ? { correlationId: store.requestId } : {},
 				...meta
 			});
+			if (warnOnDuplicate && event.meta.correlationId) {
+				const now = Date.now();
+				evictExpiredPublishes(now);
+				const dupKey = `${type}::${event.meta.correlationId}`;
+				const previous = recentPublishes.get(dupKey);
+				if (previous !== void 0 && now - previous <= DUP_WINDOW_MS) arcLog("events").warn(`Duplicate publish detected: event type "${type}" published twice within ${DUP_WINDOW_MS}ms with correlationId "${event.meta.correlationId}". Subscribers will fire twice for the same logical event. Common cause: a domain service holds both a publisher and a notification helper that also publishes to the same bus — pick one. Set \`arcPlugins: { events: { warnOnDuplicate: false } }\` to silence.`);
+				recentPublishes.delete(dupKey);
+				recentPublishes.set(dupKey, now);
+			}
 			if (logEvents) fastify.log?.info?.({
 				eventType: type,
 				eventId: event.meta.id,
 				correlationId: event.meta.correlationId
 			}, "Publishing event");
 			if (registry && validateMode !== "off") {
-				const result = registry.validate(type, payload);
+				const result = registry.validate(type, payload, event.meta.schemaVersion);
 				if (!result.valid) {
 					const msg = `[Arc Events] Event '${type}' payload validation failed: ${result.errors?.join("; ")}`;
-					if (validateMode === "reject") throw new Error(msg);
+					if (validateMode === "reject") throw createDomainError("arc.event.validation_error", msg, 400, {
+						event: type,
+						errors: result.errors
+					});
 					fastify.log?.warn?.(msg);
 				}
 			}
@@ -321,4 +219,4 @@ var eventPlugin_default = fp(eventPlugin, {
 	fastify: "5.x"
 });
 //#endregion
-export { MemoryEventTransport as a, withRetry as i, eventPlugin_exports as n, createChildEvent as o, createDeadLetterPublisher as r, createEvent as s, eventPlugin as t };
+export { withRetry as i, eventPlugin_exports as n, createDeadLetterPublisher as r, eventPlugin as t };