@classytic/arc 1.1.0 → 2.1.3

package/dist/eventPlugin-BEOvaDqo.mjs

@@ -0,0 +1,229 @@
+import { t as __exportAll } from "./chunk-C7Uep-_p.mjs";
+import { t as requestContext } from "./requestContext-xi6OKBL-.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 + ".")) handlers.forEach((h) => 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);
+		}
+	}
+	async subscribe(pattern, handler) {
+		if (!this.handlers.has(pattern)) this.handlers.set(pattern, /* @__PURE__ */ new Set());
+		this.handlers.get(pattern).add(handler);
+		return () => {
+			this.handlers.get(pattern)?.delete(handler);
+		};
+	}
+	async close() {
+		this.handlers.clear();
+	}
+};
+/**
+* Create a domain event with auto-generated metadata
+*/
+function createEvent(type, payload, meta) {
+	return {
+		type,
+		payload,
+		meta: {
+			id: crypto.randomUUID(),
+			timestamp: /* @__PURE__ */ new Date(),
+			...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.
+*/
+function withRetry(handler, options = {}) {
+	const { maxRetries = 3, backoffMs = 1e3, maxBackoffMs = 3e4, jitter = .1, onDead, name, logger = console } = options;
+	const label = name ?? handler.name ?? "anonymous";
+	return async (event) => {
+		const errors = [];
+		for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+			await handler(event);
+			return;
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			errors.push(error);
+			if (attempt < maxRetries) {
+				const baseDelay = Math.min(backoffMs * 2 ** attempt, maxBackoffMs);
+				const delay = baseDelay + jitter * baseDelay * Math.random();
+				logger.warn(`[Arc Events] Handler '${label}' failed for ${event.type} (attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${Math.round(delay)}ms: ${error.message}`);
+				await sleep(delay);
+			}
+		}
+		logger.error(`[Arc Events] Handler '${label}' permanently failed for ${event.type} after ${maxRetries + 1} attempts. ${errors.length} errors.`);
+		if (onDead) try {
+			await onDead(event, errors);
+		} catch (dlqErr) {
+			logger.error("[Arc Events] Dead letter callback failed:", dlqErr);
+		}
+	};
+}
+/**
+* Create a dead letter publisher that sends failed events to a `$deadLetter` channel.
+*
+* @example
+* ```typescript
+* import { withRetry, createDeadLetterPublisher } from '@classytic/arc/events';
+*
+* const toDlq = createDeadLetterPublisher(fastify.events);
+*
+* await fastify.events.subscribe('order.created', withRetry(handler, {
+*   maxRetries: 3,
+*   onDead: toDlq,
+* }));
+*
+* // Monitor dead letters
+* await fastify.events.subscribe('$deadLetter', async (event) => {
+*   console.error('Dead letter:', event.payload);
+*   await alertOps(event.payload);
+* });
+* ```
+*/
+function createDeadLetterPublisher(events) {
+	return async (event, errors) => {
+		await events.publish("$deadLetter", {
+			originalEvent: event,
+			errors: errors.map((e) => ({
+				message: e.message,
+				stack: e.stack
+			})),
+			failedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	};
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+//#endregion
+//#region src/events/eventPlugin.ts
+/**
+* Event Plugin
+*
+* Integrates event transport with Fastify.
+* Defaults to in-memory transport; configure durable transport for production.
+*
+* @example
+* // Development (in-memory)
+* await fastify.register(eventPlugin);
+*
+* // Production (Redis)
+* await fastify.register(eventPlugin, {
+*   transport: new RedisEventTransport({ url: process.env.REDIS_URL }),
+* });
+*/
+var eventPlugin_exports = /* @__PURE__ */ __exportAll({
+	default: () => eventPlugin_default,
+	eventPlugin: () => eventPlugin
+});
+const eventPlugin = async (fastify, opts = {}) => {
+	const { transport = new MemoryEventTransport(), logEvents = false, failOpen = true, retry: retryOpts, deadLetterQueue: dlqOpts, wal, onPublish, onPublishError } = opts;
+	fastify.decorate("events", {
+		publish: async (type, payload, meta) => {
+			const store = requestContext.get();
+			const event = createEvent(type, payload, {
+				...store?.requestId && !meta?.correlationId ? { correlationId: store.requestId } : {},
+				...meta
+			});
+			if (logEvents) fastify.log?.info?.({
+				eventType: type,
+				eventId: event.meta.id,
+				correlationId: event.meta.correlationId
+			}, "Publishing event");
+			try {
+				if (wal) await wal.save(event);
+				await transport.publish(event);
+				if (wal?.acknowledge) await wal.acknowledge(event.meta.id);
+				onPublish?.(event);
+			} catch (error) {
+				fastify.log?.error?.({
+					transport: transport.name,
+					eventType: type,
+					error
+				}, "[Arc Events] Failed to publish event");
+				onPublishError?.(event, error);
+				if (!failOpen) throw error;
+			}
+		},
+		subscribe: async (pattern, handler) => {
+			let wrappedHandler = handler;
+			if (retryOpts && pattern !== "$deadLetter") wrappedHandler = withRetry(handler, {
+				...retryOpts,
+				onDead: dlqOpts?.store ?? createDeadLetterPublisher(fastify.events),
+				logger: fastify.log
+			});
+			if (logEvents) fastify.log?.info?.({
+				pattern,
+				retry: !!retryOpts
+			}, "Subscribing to events");
+			try {
+				return await transport.subscribe(pattern, wrappedHandler);
+			} catch (error) {
+				fastify.log?.error?.({
+					transport: transport.name,
+					pattern,
+					error
+				}, "[Arc Events] Failed to subscribe to events");
+				if (!failOpen) throw error;
+				return () => {};
+			}
+		},
+		transportName: transport.name
+	});
+	fastify.addHook("onClose", async () => {
+		try {
+			await transport.close?.();
+		} catch (error) {
+			fastify.log?.warn?.({
+				transport: transport.name,
+				error
+			}, "[Arc Events] Transport close failed");
+			if (!failOpen) throw error;
+		}
+	});
+	if (transport.name === "memory") fastify.log?.warn?.("[Arc Events] Using in-memory transport. Events will not persist or scale across instances. For production, configure a durable transport (Redis, RabbitMQ, etc.)");
+	else fastify.log?.debug?.(`[Arc Events] Using ${transport.name} transport`);
+};
+var eventPlugin_default = fp(eventPlugin, {
+	name: "arc-events",
+	fastify: "5.x"
+});
+
+//#endregion
+export { MemoryEventTransport as a, withRetry as i, eventPlugin_exports as n, createEvent as o, createDeadLetterPublisher as r, eventPlugin as t };

package/dist/eventPlugin-H6wDDjGO.d.mts

@@ -0,0 +1,124 @@
+import { i as EventTransport, n as EventHandler, r as EventLogger, t as DomainEvent } from "./EventTransport-BkUDYZEb.mjs";
+import { FastifyPluginAsync } from "fastify";
+
+//#region src/events/retry.d.ts
+interface RetryOptions {
+  /**
+   * Max retry attempts (not counting the initial attempt).
+   * @default 3
+   */
+  maxRetries?: number;
+  /**
+   * Initial backoff delay in ms. Doubles on each retry (exponential backoff).
+   * @default 1000
+   */
+  backoffMs?: number;
+  /**
+   * Maximum backoff delay in ms (caps exponential growth).
+   * @default 30000
+   */
+  maxBackoffMs?: number;
+  /**
+   * Jitter factor (0-1). Adds randomness to prevent thundering herd.
+   * 0 = no jitter, 1 = full jitter (delay ∈ [0, calculated]).
+   * @default 0.1
+   */
+  jitter?: number;
+  /**
+   * Callback when all retries are exhausted. The event is "dead".
+   * Use this to publish to a `$deadLetter` channel, log, alert, etc.
+   */
+  onDead?: (event: DomainEvent, errors: Error[]) => void | Promise<void>;
+  /**
+   * Optional name for logging/debugging.
+   */
+  name?: string;
+  /**
+   * Logger for retry warnings and error messages (default: console).
+   * Pass `fastify.log` to integrate with your application logger.
+   */
+  logger?: EventLogger;
+}
+/**
+ * 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.
+ */
+declare function withRetry(handler: EventHandler, options?: RetryOptions): EventHandler;
+/**
+ * Create a dead letter publisher that sends failed events to a `$deadLetter` channel.
+ *
+ * @example
+ * ```typescript
+ * import { withRetry, createDeadLetterPublisher } from '@classytic/arc/events';
+ *
+ * const toDlq = createDeadLetterPublisher(fastify.events);
+ *
+ * await fastify.events.subscribe('order.created', withRetry(handler, {
+ *   maxRetries: 3,
+ *   onDead: toDlq,
+ * }));
+ *
+ * // Monitor dead letters
+ * await fastify.events.subscribe('$deadLetter', async (event) => {
+ *   console.error('Dead letter:', event.payload);
+ *   await alertOps(event.payload);
+ * });
+ * ```
+ */
+declare function createDeadLetterPublisher(events: {
+  publish: <T>(type: string, payload: T, meta?: Record<string, unknown>) => Promise<void>;
+}): (event: DomainEvent, errors: Error[]) => Promise<void>;
+//#endregion
+//#region src/events/eventPlugin.d.ts
+interface EventPluginOptions {
+  /** Event transport (default: MemoryEventTransport) */
+  transport?: EventTransport;
+  /** Enable event logging (default: false) */
+  logEvents?: boolean;
+  /**
+   * Fail-open mode for runtime resilience (default: true).
+   * - true: publish/subscribe/close errors are logged and suppressed
+   * - false: errors are thrown to caller
+   */
+  failOpen?: boolean;
+  /**
+   * Write-Ahead Log (WAL) configuration for at-least-once delivery guarantees.
+   * If provided, events will be saved to the WAL *before* passing to the transport.
+   * After a successful publish, they are acknowledged.
+   */
+  wal?: {
+    save: (event: DomainEvent) => Promise<void>;
+    acknowledge?: (eventId: string) => Promise<void>;
+  };
+  /**
+   * Auto-wrap all subscribed handlers with retry logic.
+   * When enabled, failed handler invocations are retried with exponential backoff.
+   */
+  retry?: Pick<RetryOptions, "maxRetries" | "backoffMs" | "maxBackoffMs" | "jitter">;
+  /**
+   * Dead letter queue for events that exhaust all retries.
+   * Requires `retry` to be enabled. If `retry` is set but no custom `store`,
+   * failed events are published to the `$deadLetter` event type by default.
+   */
+  deadLetterQueue?: {
+    /** Custom store function. If omitted, publishes to '$deadLetter' event type. */store?: (event: DomainEvent, errors: Error[]) => void | Promise<void>;
+  };
+  /** Callback after successful publish (for metrics/tracking) */
+  onPublish?: (event: DomainEvent) => void;
+  /** Callback on publish failure (for metrics/alerting) */
+  onPublishError?: (event: DomainEvent, error: Error) => void;
+}
+declare module "fastify" {
+  interface FastifyInstance {
+    events: {
+      /** Publish an event */publish: <T>(type: string, payload: T, meta?: Partial<DomainEvent["meta"]>) => Promise<void>; /** Subscribe to events */
+      subscribe: (pattern: string, handler: EventHandler) => Promise<() => void>; /** Get transport name */
+      transportName: string;
+    };
+  }
+}
+declare const eventPlugin: FastifyPluginAsync<EventPluginOptions>;
+//#endregion
+export { withRetry as a, createDeadLetterPublisher as i, eventPlugin as n, RetryOptions as r, EventPluginOptions as t };

package/dist/events/index.d.mts

@@ -0,0 +1,53 @@
+import { a as MemoryEventTransport, i as EventTransport, n as EventHandler, o as MemoryEventTransportOptions, r as EventLogger, s as createEvent, t as DomainEvent } from "../EventTransport-BkUDYZEb.mjs";
+import { a as withRetry, i as createDeadLetterPublisher, n as eventPlugin, r as RetryOptions, t as EventPluginOptions } from "../eventPlugin-H6wDDjGO.mjs";
+import { RedisEventTransportOptions, RedisLike } from "./transports/redis.mjs";
+import { r as RedisStreamTransportOptions, t as RedisStreamLike } from "../redis-stream-CBg0upHI.mjs";
+
+//#region src/events/eventTypes.d.ts
+/**
+ * Event Type Constants and Helpers
+ *
+ * Provides well-typed event names for CRUD operations and lifecycle events.
+ * Use these instead of hand-typing event strings to prevent typos.
+ *
+ * @example
+ * ```typescript
+ * import { crudEventType, ARC_LIFECYCLE_EVENTS } from '@classytic/arc/events';
+ *
+ * // Subscribe to product creation events
+ * events.subscribe(crudEventType('product', 'created'), handler);
+ *
+ * // Subscribe to Arc lifecycle events
+ * events.subscribe(ARC_LIFECYCLE_EVENTS.READY, handler);
+ * ```
+ */
+/** Suffixes for auto-emitted CRUD events */
+declare const CRUD_EVENT_SUFFIXES: readonly ["created", "updated", "deleted"];
+/** Type for CRUD event suffixes */
+type CrudEventSuffix = typeof CRUD_EVENT_SUFFIXES[number];
+/**
+ * Build a CRUD event type string.
+ *
+ * @example
+ * ```typescript
+ * crudEventType('product', 'created')  // 'product.created'
+ * crudEventType('order', 'deleted')    // 'order.deleted'
+ * ```
+ */
+declare function crudEventType(resource: string, suffix: CrudEventSuffix): string;
+/** Arc framework lifecycle events — emitted automatically by the framework */
+declare const ARC_LIFECYCLE_EVENTS: Readonly<{
+  /** Emitted when a resource plugin is registered */readonly RESOURCE_REGISTERED: "arc.resource.registered"; /** Emitted when Arc is fully ready (all resources registered, onReady fired) */
+  readonly READY: "arc.ready";
+}>;
+/** Type for Arc lifecycle event names */
+type ArcLifecycleEvent = typeof ARC_LIFECYCLE_EVENTS[keyof typeof ARC_LIFECYCLE_EVENTS];
+/** Cache-specific event types for observability and external triggers */
+declare const CACHE_EVENTS: Readonly<{
+  /** Emitted when a resource's cache version is bumped */readonly VERSION_BUMPED: "arc.cache.version.bumped"; /** Emitted when a tag version is bumped */
+  readonly TAG_VERSION_BUMPED: "arc.cache.tag.bumped";
+}>;
+/** Type for cache event names */
+type CacheEvent = typeof CACHE_EVENTS[keyof typeof CACHE_EVENTS];
+//#endregion
+export { ARC_LIFECYCLE_EVENTS, type ArcLifecycleEvent, CACHE_EVENTS, CRUD_EVENT_SUFFIXES, type CacheEvent, type CrudEventSuffix, type DomainEvent, type EventHandler, type EventLogger, type EventPluginOptions, type EventTransport, MemoryEventTransport, type MemoryEventTransportOptions, type RedisEventTransportOptions, type RedisLike, type RedisStreamLike, type RedisStreamTransportOptions, type RetryOptions, createDeadLetterPublisher, createEvent, crudEventType, eventPlugin, withRetry };

package/dist/events/index.mjs

@@ -0,0 +1,51 @@
+import { a as MemoryEventTransport, i as withRetry, o as createEvent, r as createDeadLetterPublisher, t as eventPlugin } from "../eventPlugin-BEOvaDqo.mjs";
+
+//#region src/events/eventTypes.ts
+/**
+* Event Type Constants and Helpers
+*
+* Provides well-typed event names for CRUD operations and lifecycle events.
+* Use these instead of hand-typing event strings to prevent typos.
+*
+* @example
+* ```typescript
+* import { crudEventType, ARC_LIFECYCLE_EVENTS } from '@classytic/arc/events';
+*
+* // Subscribe to product creation events
+* events.subscribe(crudEventType('product', 'created'), handler);
+*
+* // Subscribe to Arc lifecycle events
+* events.subscribe(ARC_LIFECYCLE_EVENTS.READY, handler);
+* ```
+*/
+/** Suffixes for auto-emitted CRUD events */
+const CRUD_EVENT_SUFFIXES = Object.freeze([
+	"created",
+	"updated",
+	"deleted"
+]);
+/**
+* Build a CRUD event type string.
+*
+* @example
+* ```typescript
+* crudEventType('product', 'created')  // 'product.created'
+* crudEventType('order', 'deleted')    // 'order.deleted'
+* ```
+*/
+function crudEventType(resource, suffix) {
+	return `${resource}.${suffix}`;
+}
+/** Arc framework lifecycle events — emitted automatically by the framework */
+const ARC_LIFECYCLE_EVENTS = Object.freeze({
+	RESOURCE_REGISTERED: "arc.resource.registered",
+	READY: "arc.ready"
+});
+/** Cache-specific event types for observability and external triggers */
+const CACHE_EVENTS = Object.freeze({
+	VERSION_BUMPED: "arc.cache.version.bumped",
+	TAG_VERSION_BUMPED: "arc.cache.tag.bumped"
+});
+
+//#endregion
+export { ARC_LIFECYCLE_EVENTS, CACHE_EVENTS, CRUD_EVENT_SUFFIXES, MemoryEventTransport, createDeadLetterPublisher, createEvent, crudEventType, eventPlugin, withRetry };

package/dist/events/transports/redis-stream-entry.d.mts

@@ -0,0 +1,2 @@
+import { n as RedisStreamTransport, r as RedisStreamTransportOptions, t as RedisStreamLike } from "../../redis-stream-CBg0upHI.mjs";
+export { type RedisStreamLike, RedisStreamTransport, type RedisStreamTransportOptions };

package/dist/events/transports/redis-stream-entry.mjs

@@ -0,0 +1,177 @@
+//#region src/events/transports/redis-stream.ts
+var RedisStreamTransport = class {
+	name = "redis-stream";
+	redis;
+	stream;
+	group;
+	consumer;
+	blockTimeMs;
+	batchSize;
+	maxRetries;
+	claimTimeoutMs;
+	deadLetterStream;
+	maxLen;
+	logger;
+	handlers = /* @__PURE__ */ new Map();
+	running = false;
+	pollPromise = null;
+	groupCreated = false;
+	constructor(redis, options = {}) {
+		this.redis = redis;
+		this.stream = options.stream ?? "arc:events";
+		this.group = options.group ?? "default";
+		this.consumer = options.consumer ?? `consumer-${crypto.randomUUID().slice(0, 8)}`;
+		this.blockTimeMs = options.blockTimeMs ?? 5e3;
+		this.batchSize = options.batchSize ?? 10;
+		this.maxRetries = options.maxRetries ?? 5;
+		this.claimTimeoutMs = options.claimTimeoutMs ?? 3e4;
+		this.deadLetterStream = options.deadLetterStream ?? "arc:events:dlq";
+		this.maxLen = options.maxLen ?? 1e4;
+		this.logger = options.logger ?? console;
+	}
+	async publish(event) {
+		const args = [
+			this.stream,
+			...this.maxLen > 0 ? [
+				"MAXLEN",
+				"~",
+				String(this.maxLen)
+			] : [],
+			"*",
+			"type",
+			event.type,
+			"data",
+			JSON.stringify(event)
+		];
+		await this.redis.xadd(...args);
+	}
+	async subscribe(pattern, handler) {
+		if (!this.handlers.has(pattern)) this.handlers.set(pattern, /* @__PURE__ */ new Set());
+		this.handlers.get(pattern).add(handler);
+		if (!this.running) {
+			await this.ensureGroup();
+			this.running = true;
+			this.pollPromise = this.pollLoop();
+		}
+		return () => {
+			const set = this.handlers.get(pattern);
+			if (set) {
+				set.delete(handler);
+				if (set.size === 0) this.handlers.delete(pattern);
+			}
+			if (this.handlers.size === 0 && this.running) this.running = false;
+		};
+	}
+	async close() {
+		this.running = false;
+		this.handlers.clear();
+		if (this.pollPromise) {
+			await this.pollPromise;
+			this.pollPromise = null;
+		}
+	}
+	async ensureGroup() {
+		if (this.groupCreated) return;
+		try {
+			await this.redis.xgroup("CREATE", this.stream, this.group, "$", "MKSTREAM");
+		} catch (err) {
+			if (err instanceof Error && !err.message.includes("BUSYGROUP")) throw err;
+		}
+		this.groupCreated = true;
+	}
+	async pollLoop() {
+		while (this.running) try {
+			await this.claimPending();
+			await this.readNewMessages();
+		} catch (err) {
+			if (this.running) {
+				this.logger.error("[RedisStreamTransport] Poll error:", err);
+				await this.sleep(1e3);
+			}
+		}
+	}
+	async readNewMessages() {
+		const result = await this.redis.xreadgroup("GROUP", this.group, this.consumer, "COUNT", this.batchSize, "BLOCK", this.blockTimeMs, "STREAMS", this.stream, ">");
+		if (!result) return;
+		for (const [, entries] of result) for (const [messageId, fields] of entries) await this.processEntry(messageId, fields);
+	}
+	async claimPending() {
+		try {
+			const pending = await this.redis.xpending(this.stream, this.group, "-", "+", 10);
+			if (!pending || pending.length === 0) return;
+			const staleIds = [];
+			const overRetryIds = [];
+			for (const entry of pending) {
+				const [id, , idleTime, deliveryCount] = entry;
+				if (idleTime > this.claimTimeoutMs) if (deliveryCount >= this.maxRetries) overRetryIds.push(id);
+				else staleIds.push(id);
+			}
+			if (overRetryIds.length > 0) await this.moveToDlq(overRetryIds);
+			if (staleIds.length > 0) {
+				const claimed = await this.redis.xclaim(this.stream, this.group, this.consumer, this.claimTimeoutMs, ...staleIds);
+				for (const [messageId, fields] of claimed) await this.processEntry(messageId, fields);
+			}
+		} catch {}
+	}
+	async processEntry(messageId, fields) {
+		const fieldMap = /* @__PURE__ */ new Map();
+		for (let i = 0; i < fields.length; i += 2) fieldMap.set(fields[i], fields[i + 1]);
+		const eventType = fieldMap.get("type");
+		const rawData = fieldMap.get("data");
+		if (!eventType || !rawData) {
+			await this.redis.xack(this.stream, this.group, messageId);
+			return;
+		}
+		let event;
+		try {
+			event = JSON.parse(rawData, (key, value) => {
+				if (key === "timestamp" && typeof value === "string") return new Date(value);
+				return value;
+			});
+		} catch {
+			await this.redis.xack(this.stream, this.group, messageId);
+			return;
+		}
+		const matchingHandlers = this.getMatchingHandlers(event.type);
+		let allSucceeded = true;
+		for (const handler of matchingHandlers) try {
+			await handler(event);
+		} catch (err) {
+			allSucceeded = false;
+			this.logger.error(`[RedisStreamTransport] Handler error for ${event.type}:`, err);
+		}
+		if (allSucceeded) await this.redis.xack(this.stream, this.group, messageId);
+	}
+	getMatchingHandlers(eventType) {
+		const matched = [];
+		for (const [pattern, handlers] of this.handlers) if (this.matchesPattern(pattern, eventType)) for (const h of handlers) matched.push(h);
+		return matched;
+	}
+	matchesPattern(pattern, eventType) {
+		if (pattern === "*") return true;
+		if (pattern === eventType) return true;
+		if (pattern.endsWith(".*")) {
+			const prefix = pattern.slice(0, -2);
+			return eventType.startsWith(prefix + ".");
+		}
+		return false;
+	}
+	async moveToDlq(ids) {
+		if (this.deadLetterStream === false) {
+			for (const id of ids) await this.redis.xack(this.stream, this.group, id);
+			return;
+		}
+		for (const id of ids) try {
+			await this.redis.xadd(this.deadLetterStream, "*", "originalStream", this.stream, "originalId", id, "group", this.group, "failedAt", (/* @__PURE__ */ new Date()).toISOString());
+			await this.redis.xack(this.stream, this.group, id);
+		} catch (err) {
+			this.logger.error(`[RedisStreamTransport] DLQ write failed for ${id}:`, err);
+		}
+	}
+	sleep(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+};
+
+//#endregion
+export { RedisStreamTransport };