@classytic/arc 1.1.0 → 2.1.2

package/dist/eventPlugin-DGR_B2on.mjs

@@ -0,0 +1,230 @@
+import { t as __exportAll } from "./chunk-C7Uep-_p.mjs";
+import { t as requestContext } from "./requestContext-QQD6ROJc.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 };
+//# sourceMappingURL=eventPlugin-DGR_B2on.mjs.map

package/dist/eventPlugin-DGR_B2on.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventPlugin-DGR_B2on.mjs","names":[],"sources":["../src/events/EventTransport.ts","../src/events/retry.ts","../src/events/eventPlugin.ts"],"sourcesContent":["/**\n * Event Transport Interface\n *\n * Defines contract for event delivery backends.\n * Implement for durable transports (Redis, RabbitMQ, Kafka, etc.)\n *\n * @example\n * // Redis Pub/Sub implementation\n * class RedisEventTransport implements EventTransport {\n *   async publish(event) {\n *     await redis.publish(event.type, JSON.stringify(event));\n *   }\n *   async subscribe(pattern, handler) {\n *     redis.psubscribe(pattern);\n *     redis.on('pmessage', (p, channel, msg) => handler(JSON.parse(msg)));\n *   }\n * }\n */\n\nexport interface DomainEvent<T = unknown> {\n  /** Event type (e.g., 'product.created', 'order.shipped') */\n  type: string;\n  /** Event payload */\n  payload: T;\n  /** Event metadata */\n  meta: {\n    /** Unique event ID */\n    id: string;\n    /** Event timestamp */\n    timestamp: Date;\n    /** Source resource */\n    resource?: string;\n    /** Resource ID */\n    resourceId?: string;\n    /** User who triggered the event */\n    userId?: string;\n    /** Organization context */\n    organizationId?: string;\n    /** Correlation ID for tracing */\n    correlationId?: string;\n  };\n}\n\nexport type EventHandler<T = unknown> = (event: DomainEvent<T>) => void | Promise<void>;\n\n/**\n * Minimal logger interface for event transports.\n * Compatible with `console`, `pino`, `fastify.log`, and any custom logger.\n *\n * @example\n * ```typescript\n * // Use Fastify's logger\n * new MemoryEventTransport({ logger: fastify.log });\n *\n * // Use a custom logger\n * new MemoryEventTransport({ logger: { warn: myWarn, error: myError } });\n *\n * // Default: console (no logger option needed)\n * new MemoryEventTransport();\n * ```\n */\nexport interface EventLogger {\n  warn(message: string, ...args: unknown[]): void;\n  error(message: string, ...args: unknown[]): void;\n}\n\nexport interface EventTransport {\n  /** Transport name for logging */\n  readonly name: string;\n\n  /**\n   * Publish an event to the transport\n   */\n  publish(event: DomainEvent): Promise<void>;\n\n  /**\n   * Subscribe to events matching a pattern\n   * @param pattern - Event type pattern (e.g., 'product.*', '*')\n   * @param handler - Handler function\n   * @returns Unsubscribe function\n   */\n  subscribe(pattern: string, handler: EventHandler): Promise<() => void>;\n\n  /**\n   * Close transport connections\n   */\n  close?(): Promise<void>;\n}\n\nexport interface MemoryEventTransportOptions {\n  /** Logger for error/warning messages (default: console) */\n  logger?: EventLogger;\n}\n\n/**\n * In-memory event transport (default)\n * Events are delivered synchronously within the process.\n * Not suitable for multi-instance deployments.\n */\nexport class MemoryEventTransport implements EventTransport {\n  readonly name = 'memory';\n  private handlers = new Map<string, Set<EventHandler>>();\n  private logger: EventLogger;\n\n  constructor(options?: MemoryEventTransportOptions) {\n    this.logger = options?.logger ?? console;\n  }\n\n  async publish(event: DomainEvent): Promise<void> {\n    // Exact match handlers\n    const exactHandlers = this.handlers.get(event.type) ?? new Set();\n\n    // Wildcard handlers\n    const wildcardHandlers = this.handlers.get('*') ?? new Set();\n\n    // Pattern match handlers (e.g., 'product.*' matches 'product.created')\n    const patternHandlers = new Set<EventHandler>();\n    for (const [pattern, handlers] of this.handlers.entries()) {\n      if (pattern.endsWith('.*')) {\n        const prefix = pattern.slice(0, -2);\n        if (event.type.startsWith(prefix + '.')) {\n          handlers.forEach((h) => patternHandlers.add(h));\n        }\n      }\n    }\n\n    const allHandlers = new Set([...exactHandlers, ...wildcardHandlers, ...patternHandlers]);\n\n    // Execute handlers (catch errors to prevent one handler from blocking others)\n    for (const handler of allHandlers) {\n      try {\n        await handler(event);\n      } catch (err) {\n        this.logger.error(`[EventTransport] Handler error for ${event.type}:`, err);\n      }\n    }\n  }\n\n  async subscribe(pattern: string, handler: EventHandler): Promise<() => void> {\n    if (!this.handlers.has(pattern)) {\n      this.handlers.set(pattern, new Set());\n    }\n    this.handlers.get(pattern)!.add(handler);\n\n    return () => {\n      this.handlers.get(pattern)?.delete(handler);\n    };\n  }\n\n  async close(): Promise<void> {\n    this.handlers.clear();\n  }\n}\n\n/**\n * Create a domain event with auto-generated metadata\n */\nexport function createEvent<T>(\n  type: string,\n  payload: T,\n  meta?: Partial<DomainEvent['meta']>\n): DomainEvent<T> {\n  return {\n    type,\n    payload,\n    meta: {\n      id: crypto.randomUUID(),\n      timestamp: new Date(),\n      ...meta,\n    },\n  };\n}\n\nexport default MemoryEventTransport;\n","/**\n * Event Handler Retry with Dead Letter Queue\n *\n * Transport-agnostic retry wrapper for event handlers.\n * Works with any EventTransport (Memory, Redis Pub/Sub, Redis Streams).\n *\n * @example\n * ```typescript\n * import { withRetry } from '@classytic/arc/events';\n *\n * // Retry up to 3 times with exponential backoff\n * await fastify.events.subscribe('order.created', withRetry(\n *   async (event) => {\n *     await sendConfirmationEmail(event.payload);\n *   },\n *   { maxRetries: 3, backoffMs: 1000 }\n * ));\n *\n * // With dead letter callback\n * await fastify.events.subscribe('order.created', withRetry(\n *   async (event) => { ... },\n *   {\n *     maxRetries: 3,\n *     onDead: async (event, errors) => {\n *       await fastify.events.publish('$deadLetter', { event, errors });\n *     },\n *   }\n * ));\n * ```\n */\n\nimport type { DomainEvent, EventHandler, EventLogger } from './EventTransport.js';\n\nexport interface RetryOptions {\n  /**\n   * Max retry attempts (not counting the initial attempt).\n   * @default 3\n   */\n  maxRetries?: number;\n\n  /**\n   * Initial backoff delay in ms. Doubles on each retry (exponential backoff).\n   * @default 1000\n   */\n  backoffMs?: number;\n\n  /**\n   * Maximum backoff delay in ms (caps exponential growth).\n   * @default 30000\n   */\n  maxBackoffMs?: number;\n\n  /**\n   * Jitter factor (0-1). Adds randomness to prevent thundering herd.\n   * 0 = no jitter, 1 = full jitter (delay ∈ [0, calculated]).\n   * @default 0.1\n   */\n  jitter?: number;\n\n  /**\n   * Callback when all retries are exhausted. The event is \"dead\".\n   * Use this to publish to a `$deadLetter` channel, log, alert, etc.\n   */\n  onDead?: (event: DomainEvent, errors: Error[]) => void | Promise<void>;\n\n  /**\n   * Optional name for logging/debugging.\n   */\n  name?: string;\n\n  /**\n   * Logger for retry warnings and error messages (default: console).\n   * Pass `fastify.log` to integrate with your application logger.\n   */\n  logger?: EventLogger;\n}\n\n/**\n * Wrap an event handler with retry logic and dead letter support.\n *\n * On failure, retries with exponential backoff (with jitter).\n * After all retries exhausted, calls `onDead` callback if provided.\n */\nexport function withRetry(\n  handler: EventHandler,\n  options: RetryOptions = {},\n): EventHandler {\n  const {\n    maxRetries = 3,\n    backoffMs = 1000,\n    maxBackoffMs = 30_000,\n    jitter = 0.1,\n    onDead,\n    name,\n    logger = console,\n  } = options;\n\n  const label = name ?? handler.name ?? 'anonymous';\n\n  return async (event: DomainEvent): Promise<void> => {\n    const errors: Error[] = [];\n\n    for (let attempt = 0; attempt <= maxRetries; attempt++) {\n      try {\n        await handler(event);\n        return; // Success\n      } catch (err) {\n        const error = err instanceof Error ? err : new Error(String(err));\n        errors.push(error);\n\n        if (attempt < maxRetries) {\n          // Calculate delay with exponential backoff + jitter\n          const baseDelay = Math.min(backoffMs * 2 ** attempt, maxBackoffMs);\n          const jitterAmount = jitter * baseDelay * Math.random();\n          const delay = baseDelay + jitterAmount;\n\n          logger.warn(\n            `[Arc Events] Handler '${label}' failed for ${event.type} ` +\n            `(attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${Math.round(delay)}ms: ${error.message}`,\n          );\n\n          await sleep(delay);\n        }\n      }\n    }\n\n    // All retries exhausted — event is dead\n    logger.error(\n      `[Arc Events] Handler '${label}' permanently failed for ${event.type} ` +\n      `after ${maxRetries + 1} attempts. ${errors.length} errors.`,\n    );\n\n    if (onDead) {\n      try {\n        await onDead(event, errors);\n      } catch (dlqErr) {\n        logger.error('[Arc Events] Dead letter callback failed:', dlqErr);\n      }\n    }\n  };\n}\n\n/**\n * Create a dead letter publisher that sends failed events to a `$deadLetter` channel.\n *\n * @example\n * ```typescript\n * import { withRetry, createDeadLetterPublisher } from '@classytic/arc/events';\n *\n * const toDlq = createDeadLetterPublisher(fastify.events);\n *\n * await fastify.events.subscribe('order.created', withRetry(handler, {\n *   maxRetries: 3,\n *   onDead: toDlq,\n * }));\n *\n * // Monitor dead letters\n * await fastify.events.subscribe('$deadLetter', async (event) => {\n *   console.error('Dead letter:', event.payload);\n *   await alertOps(event.payload);\n * });\n * ```\n */\nexport function createDeadLetterPublisher(\n  events: { publish: <T>(type: string, payload: T, meta?: Record<string, unknown>) => Promise<void> },\n): (event: DomainEvent, errors: Error[]) => Promise<void> {\n  return async (event: DomainEvent, errors: Error[]) => {\n    await events.publish('$deadLetter', {\n      originalEvent: event,\n      errors: errors.map((e) => ({\n        message: e.message,\n        stack: e.stack,\n      })),\n      failedAt: new Date().toISOString(),\n    });\n  };\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n","/**\n * Event Plugin\n *\n * Integrates event transport with Fastify.\n * Defaults to in-memory transport; configure durable transport for production.\n *\n * @example\n * // Development (in-memory)\n * await fastify.register(eventPlugin);\n *\n * // Production (Redis)\n * await fastify.register(eventPlugin, {\n *   transport: new RedisEventTransport({ url: process.env.REDIS_URL }),\n * });\n */\n\nimport fp from \"fastify-plugin\";\nimport type { FastifyInstance, FastifyPluginAsync } from \"fastify\";\nimport {\n  MemoryEventTransport,\n  createEvent,\n  type EventTransport,\n  type DomainEvent,\n  type EventHandler,\n} from \"./EventTransport.js\";\nimport {\n  withRetry,\n  createDeadLetterPublisher,\n  type RetryOptions,\n} from \"./retry.js\";\nimport { requestContext } from \"../context/requestContext.js\";\n\nexport interface EventPluginOptions {\n  /** Event transport (default: MemoryEventTransport) */\n  transport?: EventTransport;\n  /** Enable event logging (default: false) */\n  logEvents?: boolean;\n  /**\n   * Fail-open mode for runtime resilience (default: true).\n   * - true: publish/subscribe/close errors are logged and suppressed\n   * - false: errors are thrown to caller\n   */\n  failOpen?: boolean;\n  /**\n   * Write-Ahead Log (WAL) configuration for at-least-once delivery guarantees.\n   * If provided, events will be saved to the WAL *before* passing to the transport.\n   * After a successful publish, they are acknowledged.\n   */\n  wal?: {\n    save: (event: DomainEvent) => Promise<void>;\n    acknowledge?: (eventId: string) => Promise<void>;\n  };\n  /**\n   * Auto-wrap all subscribed handlers with retry logic.\n   * When enabled, failed handler invocations are retried with exponential backoff.\n   */\n  retry?: Pick<\n    RetryOptions,\n    \"maxRetries\" | \"backoffMs\" | \"maxBackoffMs\" | \"jitter\"\n  >;\n  /**\n   * Dead letter queue for events that exhaust all retries.\n   * Requires `retry` to be enabled. If `retry` is set but no custom `store`,\n   * failed events are published to the `$deadLetter` event type by default.\n   */\n  deadLetterQueue?: {\n    /** Custom store function. If omitted, publishes to '$deadLetter' event type. */\n    store?: (event: DomainEvent, errors: Error[]) => void | Promise<void>;\n  };\n  /** Callback after successful publish (for metrics/tracking) */\n  onPublish?: (event: DomainEvent) => void;\n  /** Callback on publish failure (for metrics/alerting) */\n  onPublishError?: (event: DomainEvent, error: Error) => void;\n}\n\ndeclare module \"fastify\" {\n  interface FastifyInstance {\n    events: {\n      /** Publish an event */\n      publish: <T>(\n        type: string,\n        payload: T,\n        meta?: Partial<DomainEvent[\"meta\"]>,\n      ) => Promise<void>;\n      /** Subscribe to events */\n      subscribe: (\n        pattern: string,\n        handler: EventHandler,\n      ) => Promise<() => void>;\n      /** Get transport name */\n      transportName: string;\n    };\n  }\n}\n\nconst eventPlugin: FastifyPluginAsync<EventPluginOptions> = async (\n  fastify: FastifyInstance,\n  opts: EventPluginOptions = {},\n) => {\n  const {\n    transport = new MemoryEventTransport(),\n    logEvents = false,\n    failOpen = true,\n    retry: retryOpts,\n    deadLetterQueue: dlqOpts,\n    wal,\n    onPublish,\n    onPublishError,\n  } = opts;\n\n  // Decorate fastify with event utilities\n  fastify.decorate(\"events\", {\n    publish: async <T>(\n      type: string,\n      payload: T,\n      meta?: Partial<DomainEvent[\"meta\"]>,\n    ): Promise<void> => {\n      // Auto-inject correlationId from request context if not already set\n      const store = requestContext.get();\n      const enrichedMeta: Partial<DomainEvent[\"meta\"]> = {\n        ...(store?.requestId && !meta?.correlationId\n          ? { correlationId: store.requestId }\n          : {}),\n        ...meta,\n      };\n      const event = createEvent(type, payload, enrichedMeta);\n\n      if (logEvents) {\n        fastify.log?.info?.(\n          {\n            eventType: type,\n            eventId: event.meta.id,\n            correlationId: event.meta.correlationId,\n          },\n          \"Publishing event\",\n        );\n      }\n\n      try {\n        if (wal) {\n          await wal.save(event);\n        }\n        await transport.publish(event);\n        if (wal?.acknowledge) {\n          await wal.acknowledge(event.meta.id);\n        }\n        onPublish?.(event);\n      } catch (error) {\n        fastify.log?.error?.(\n          { transport: transport.name, eventType: type, error },\n          \"[Arc Events] Failed to publish event\",\n        );\n        onPublishError?.(event, error as Error);\n        if (!failOpen) throw error;\n      }\n    },\n\n    subscribe: async (\n      pattern: string,\n      handler: EventHandler,\n    ): Promise<() => void> => {\n      // Auto-wrap handler with retry if configured (skip for DLQ subscriptions)\n      let wrappedHandler = handler;\n      if (retryOpts && pattern !== \"$deadLetter\") {\n        wrappedHandler = withRetry(handler, {\n          ...retryOpts,\n          onDead: dlqOpts?.store ?? createDeadLetterPublisher(fastify.events),\n          logger: fastify.log as import(\"./EventTransport.js\").EventLogger,\n        });\n      }\n\n      if (logEvents) {\n        fastify.log?.info?.(\n          { pattern, retry: !!retryOpts },\n          \"Subscribing to events\",\n        );\n      }\n      try {\n        return await transport.subscribe(pattern, wrappedHandler);\n      } catch (error) {\n        fastify.log?.error?.(\n          { transport: transport.name, pattern, error },\n          \"[Arc Events] Failed to subscribe to events\",\n        );\n        if (!failOpen) throw error;\n        return () => {};\n      }\n    },\n\n    transportName: transport.name,\n  });\n\n  // Cleanup on close\n  fastify.addHook(\"onClose\", async () => {\n    try {\n      await transport.close?.();\n    } catch (error) {\n      fastify.log?.warn?.(\n        { transport: transport.name, error },\n        \"[Arc Events] Transport close failed\",\n      );\n      if (!failOpen) throw error;\n    }\n  });\n\n  // Log transport type\n  if (transport.name === \"memory\") {\n    fastify.log?.warn?.(\n      \"[Arc Events] Using in-memory transport. Events will not persist or scale across instances. \" +\n        \"For production, configure a durable transport (Redis, RabbitMQ, etc.)\",\n    );\n  } else {\n    fastify.log?.debug?.(`[Arc Events] Using ${transport.name} transport`);\n  }\n};\n\nexport default fp(eventPlugin, {\n  name: \"arc-events\",\n  fastify: \"5.x\",\n});\n\nexport { eventPlugin };\n"],"mappings":"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"}

package/dist/events/index.d.mts

@@ -0,0 +1,54 @@
+import { a as MemoryEventTransport, i as EventTransport, n as EventHandler, o as MemoryEventTransportOptions, r as EventLogger, s as createEvent, t as DomainEvent } from "../EventTransport-BD2U0BTc.mjs";
+import { a as withRetry, i as createDeadLetterPublisher, n as eventPlugin, r as RetryOptions, t as EventPluginOptions } from "../eventPlugin-CTrLH3mt.mjs";
+import { RedisEventTransportOptions, RedisLike } from "./transports/redis.mjs";
+import { r as RedisStreamTransportOptions, t as RedisStreamLike } from "../redis-stream-Bdh_vUU8.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 };
+//# sourceMappingURL=index.d.mts.map

package/dist/events/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/events/eventTypes.ts"],"mappings":";;;;;;;;;;;;AAmBA;;;;;AAGA;;;;;AAWA;;cAda,mBAAA;;KAGD,eAAA,UAAyB,mBAAA;;;;;AAgBrC;;;;;iBALgB,aAAA,CAAc,QAAA,UAAkB,MAAA,EAAQ,eAAA;;cAK3C,oBAAA,EAAoB,QAAA;8GAQJ;EAAA;;;KAAjB,iBAAA,UAA2B,oBAAA,cAAkC,oBAAA;;cAG5D,YAAA,EAAY,QAAA;EAAA;;;;KAQb,UAAA,UAAoB,YAAA,cAA0B,YAAA"}

package/dist/events/index.mjs

@@ -0,0 +1,52 @@
+import { a as MemoryEventTransport, i as withRetry, o as createEvent, r as createDeadLetterPublisher, t as eventPlugin } from "../eventPlugin-DGR_B2on.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 };
+//# sourceMappingURL=index.mjs.map

package/dist/events/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/events/eventTypes.ts"],"sourcesContent":["/**\r\n * Event Type Constants and Helpers\r\n *\r\n * Provides well-typed event names for CRUD operations and lifecycle events.\r\n * Use these instead of hand-typing event strings to prevent typos.\r\n *\r\n * @example\r\n * ```typescript\r\n * import { crudEventType, ARC_LIFECYCLE_EVENTS } from '@classytic/arc/events';\r\n *\r\n * // Subscribe to product creation events\r\n * events.subscribe(crudEventType('product', 'created'), handler);\r\n *\r\n * // Subscribe to Arc lifecycle events\r\n * events.subscribe(ARC_LIFECYCLE_EVENTS.READY, handler);\r\n * ```\r\n */\r\n\r\n/** Suffixes for auto-emitted CRUD events */\r\nexport const CRUD_EVENT_SUFFIXES = Object.freeze(['created', 'updated', 'deleted'] as const);\r\n\r\n/** Type for CRUD event suffixes */\r\nexport type CrudEventSuffix = typeof CRUD_EVENT_SUFFIXES[number];\r\n\r\n/**\r\n * Build a CRUD event type string.\r\n *\r\n * @example\r\n * ```typescript\r\n * crudEventType('product', 'created')  // 'product.created'\r\n * crudEventType('order', 'deleted')    // 'order.deleted'\r\n * ```\r\n */\r\nexport function crudEventType(resource: string, suffix: CrudEventSuffix): string {\r\n  return `${resource}.${suffix}`;\r\n}\r\n\r\n/** Arc framework lifecycle events — emitted automatically by the framework */\r\nexport const ARC_LIFECYCLE_EVENTS = Object.freeze({\r\n  /** Emitted when a resource plugin is registered */\r\n  RESOURCE_REGISTERED: 'arc.resource.registered',\r\n  /** Emitted when Arc is fully ready (all resources registered, onReady fired) */\r\n  READY: 'arc.ready',\r\n} as const);\r\n\r\n/** Type for Arc lifecycle event names */\r\nexport type ArcLifecycleEvent = typeof ARC_LIFECYCLE_EVENTS[keyof typeof ARC_LIFECYCLE_EVENTS];\r\n\r\n/** Cache-specific event types for observability and external triggers */\r\nexport const CACHE_EVENTS = Object.freeze({\r\n  /** Emitted when a resource's cache version is bumped */\r\n  VERSION_BUMPED: 'arc.cache.version.bumped',\r\n  /** Emitted when a tag version is bumped */\r\n  TAG_VERSION_BUMPED: 'arc.cache.tag.bumped',\r\n} as const);\r\n\r\n/** Type for cache event names */\r\nexport type CacheEvent = typeof CACHE_EVENTS[keyof typeof CACHE_EVENTS];\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAmBA,MAAa,sBAAsB,OAAO,OAAO;CAAC;CAAW;CAAW;CAAU,CAAU;;;;;;;;;;AAc5F,SAAgB,cAAc,UAAkB,QAAiC;AAC/E,QAAO,GAAG,SAAS,GAAG;;;AAIxB,MAAa,uBAAuB,OAAO,OAAO;CAEhD,qBAAqB;CAErB,OAAO;CACR,CAAU;;AAMX,MAAa,eAAe,OAAO,OAAO;CAExC,gBAAgB;CAEhB,oBAAoB;CACrB,CAAU"}

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-Bdh_vUU8.mjs";
+export { type RedisStreamLike, RedisStreamTransport, type RedisStreamTransportOptions };

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

@@ -0,0 +1,178 @@
+//#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 };
+//# sourceMappingURL=redis-stream-entry.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"redis-stream-entry.mjs","names":[],"sources":["../../../src/events/transports/redis-stream.ts"],"sourcesContent":["/**\n * Redis Stream Event Transport — Durable Event Delivery\n *\n * Uses Redis Streams (`XADD`/`XREADGROUP`) for persistent, exactly-once event\n * delivery across multiple service instances. Unlike Pub/Sub, events are stored\n * in Redis and survive crashes/restarts.\n *\n * Key features:\n * - Consumer groups: each event processed by exactly one consumer per group\n * - Crash recovery: pending entries are auto-claimed after `claimTimeoutMs`\n * - Dead letter stream: events exceeding `maxRetries` are moved to a DLQ\n * - Backpressure: configurable block time and batch size\n *\n * @example\n * ```typescript\n * import { RedisStreamTransport } from '@classytic/arc/events';\n * import Redis from 'ioredis';\n *\n * const transport = new RedisStreamTransport(new Redis(), {\n *   stream: 'arc-events',\n *   group: 'api-service',\n *   consumer: 'worker-1',\n * });\n *\n * await app.register(eventPlugin, { transport });\n * ```\n */\n\nimport type { EventTransport, DomainEvent, EventHandler, EventLogger } from '../EventTransport.js';\n\n// ---------------------------------------------------------------------------\n// Minimal Redis-like interface for Streams support\n// ---------------------------------------------------------------------------\n\nexport interface RedisStreamLike {\n  xadd(key: string, id: string, ...fieldValues: string[]): Promise<string | null>;\n  xreadgroup(\n    command: 'GROUP',\n    group: string,\n    consumer: string,\n    ...args: (string | number)[]\n  ): Promise<Array<[string, Array<[string, string[]]>]> | null>;\n  xack(key: string, group: string, ...ids: string[]): Promise<number>;\n  xgroup(command: string, key: string, group: string, ...args: string[]): Promise<unknown>;\n  xpending(\n    key: string,\n    group: string,\n    ...args: (string | number)[]\n  ): Promise<Array<[string, string, number, number]>>;\n  xclaim(\n    key: string,\n    group: string,\n    consumer: string,\n    minIdleTime: number,\n    ...ids: string[]\n  ): Promise<Array<[string, string[]]>>;\n  xlen(key: string): Promise<number>;\n  quit(): Promise<unknown>;\n}\n\n// ---------------------------------------------------------------------------\n// Options\n// ---------------------------------------------------------------------------\n\nexport interface RedisStreamTransportOptions {\n  /**\n   * Redis stream key name.\n   * @default 'arc:events'\n   */\n  stream?: string;\n\n  /**\n   * Consumer group name. Each group receives every event independently.\n   * Multiple instances of the same service should share a group name.\n   * @default 'default'\n   */\n  group?: string;\n\n  /**\n   * Consumer name within the group. Must be unique per instance.\n   * @default 'consumer-<random>'\n   */\n  consumer?: string;\n\n  /**\n   * Block time in ms when waiting for new events.\n   * @default 5000\n   */\n  blockTimeMs?: number;\n\n  /**\n   * Max events to read per batch.\n   * @default 10\n   */\n  batchSize?: number;\n\n  /**\n   * Max delivery attempts before moving to dead letter stream.\n   * @default 5\n   */\n  maxRetries?: number;\n\n  /**\n   * Idle time in ms before pending entries are claimed by this consumer.\n   * Handles crash recovery — if a consumer dies mid-processing, another\n   * consumer will claim its pending entries after this timeout.\n   * @default 30000\n   */\n  claimTimeoutMs?: number;\n\n  /**\n   * Dead letter stream name. Failed events are moved here after maxRetries.\n   * Set to `false` to disable DLQ (failed events are acked and dropped).\n   * @default 'arc:events:dlq'\n   */\n  deadLetterStream?: string | false;\n\n  /**\n   * Max stream length (approximate). Uses XADD MAXLEN ~ to trim old entries.\n   * Set to 0 to disable trimming.\n   * @default 10000\n   */\n  maxLen?: number;\n\n  /**\n   * Logger for error messages (default: console).\n   * Pass `fastify.log` to integrate with your application logger.\n   */\n  logger?: EventLogger;\n}\n\n// ---------------------------------------------------------------------------\n// Transport\n// ---------------------------------------------------------------------------\n\nexport class RedisStreamTransport implements EventTransport {\n  readonly name = 'redis-stream';\n\n  private redis: RedisStreamLike;\n  private stream: string;\n  private group: string;\n  private consumer: string;\n  private blockTimeMs: number;\n  private batchSize: number;\n  private maxRetries: number;\n  private claimTimeoutMs: number;\n  private deadLetterStream: string | false;\n  private maxLen: number;\n\n  private logger: EventLogger;\n\n  private handlers = new Map<string, Set<EventHandler>>();\n  private running = false;\n  private pollPromise: Promise<void> | null = null;\n  private groupCreated = false;\n\n  constructor(redis: RedisStreamLike, options: RedisStreamTransportOptions = {}) {\n    this.redis = redis;\n    this.stream = options.stream ?? 'arc:events';\n    this.group = options.group ?? 'default';\n    this.consumer = options.consumer ?? `consumer-${crypto.randomUUID().slice(0, 8)}`;\n    this.blockTimeMs = options.blockTimeMs ?? 5000;\n    this.batchSize = options.batchSize ?? 10;\n    this.maxRetries = options.maxRetries ?? 5;\n    this.claimTimeoutMs = options.claimTimeoutMs ?? 30_000;\n    this.deadLetterStream = options.deadLetterStream ?? 'arc:events:dlq';\n    this.maxLen = options.maxLen ?? 10_000;\n    this.logger = options.logger ?? console;\n  }\n\n  // -----------------------------------------------------------------------\n  // EventTransport.publish\n  // -----------------------------------------------------------------------\n\n  async publish(event: DomainEvent): Promise<void> {\n    const args: string[] = [\n      this.stream,\n      ...(this.maxLen > 0 ? ['MAXLEN', '~', String(this.maxLen)] : []),\n      '*',\n      'type', event.type,\n      'data', JSON.stringify(event),\n    ];\n\n    // Use spread to call xadd with dynamic args\n    await (this.redis as any).xadd(...args);\n  }\n\n  // -----------------------------------------------------------------------\n  // EventTransport.subscribe\n  // -----------------------------------------------------------------------\n\n  async subscribe(pattern: string, handler: EventHandler): Promise<() => void> {\n    if (!this.handlers.has(pattern)) {\n      this.handlers.set(pattern, new Set());\n    }\n    this.handlers.get(pattern)!.add(handler);\n\n    // Start the consumer loop if not already running\n    if (!this.running) {\n      await this.ensureGroup();\n      this.running = true;\n      this.pollPromise = this.pollLoop();\n    }\n\n    return () => {\n      const set = this.handlers.get(pattern);\n      if (set) {\n        set.delete(handler);\n        if (set.size === 0) this.handlers.delete(pattern);\n      }\n      // Stop polling when no handlers remain — prevents CPU/network waste\n      if (this.handlers.size === 0 && this.running) {\n        this.running = false;\n      }\n    };\n  }\n\n  // -----------------------------------------------------------------------\n  // EventTransport.close\n  // -----------------------------------------------------------------------\n\n  async close(): Promise<void> {\n    this.running = false;\n    this.handlers.clear();\n\n    // Wait for the poll loop to finish its current iteration\n    if (this.pollPromise) {\n      await this.pollPromise;\n      this.pollPromise = null;\n    }\n  }\n\n  // -----------------------------------------------------------------------\n  // Consumer group management\n  // -----------------------------------------------------------------------\n\n  private async ensureGroup(): Promise<void> {\n    if (this.groupCreated) return;\n\n    try {\n      // Create the consumer group, starting from new messages ('$')\n      // Use MKSTREAM to auto-create the stream if it doesn't exist\n      await this.redis.xgroup('CREATE', this.stream, this.group, '$', 'MKSTREAM');\n    } catch (err: unknown) {\n      // BUSYGROUP = group already exists, which is fine\n      if (err instanceof Error && !err.message.includes('BUSYGROUP')) {\n        throw err;\n      }\n    }\n\n    this.groupCreated = true;\n  }\n\n  // -----------------------------------------------------------------------\n  // Poll loop — reads new messages + claims pending (crash recovery)\n  // -----------------------------------------------------------------------\n\n  private async pollLoop(): Promise<void> {\n    while (this.running) {\n      try {\n        // Phase 1: Claim pending entries from dead consumers (crash recovery)\n        await this.claimPending();\n\n        // Phase 2: Read new messages\n        await this.readNewMessages();\n      } catch (err) {\n        if (this.running) {\n          this.logger.error('[RedisStreamTransport] Poll error:', err);\n          // Brief pause before retrying on error\n          await this.sleep(1000);\n        }\n      }\n    }\n  }\n\n  private async readNewMessages(): Promise<void> {\n    // XREADGROUP GROUP <group> <consumer> COUNT <n> BLOCK <ms> STREAMS <key> >\n    const result = await this.redis.xreadgroup(\n      'GROUP', this.group, this.consumer,\n      'COUNT', this.batchSize,\n      'BLOCK', this.blockTimeMs,\n      'STREAMS', this.stream, '>',\n    );\n\n    if (!result) return; // Timeout, no new messages\n\n    for (const [, entries] of result) {\n      for (const [messageId, fields] of entries) {\n        await this.processEntry(messageId, fields);\n      }\n    }\n  }\n\n  private async claimPending(): Promise<void> {\n    try {\n      // Check for pending entries across all consumers that have been idle\n      const pending = await this.redis.xpending(\n        this.stream, this.group,\n        '-', '+', 10, // Check up to 10 pending entries\n      );\n\n      if (!pending || pending.length === 0) return;\n\n      const staleIds: string[] = [];\n      const overRetryIds: string[] = [];\n\n      for (const entry of pending) {\n        const [id, , idleTime, deliveryCount] = entry;\n        if (idleTime > this.claimTimeoutMs) {\n          if (deliveryCount >= this.maxRetries) {\n            overRetryIds.push(id);\n          } else {\n            staleIds.push(id);\n          }\n        }\n      }\n\n      // Move over-retry entries to DLQ\n      if (overRetryIds.length > 0) {\n        await this.moveToDlq(overRetryIds);\n      }\n\n      // Claim stale entries\n      if (staleIds.length > 0) {\n        const claimed = await this.redis.xclaim(\n          this.stream, this.group, this.consumer,\n          this.claimTimeoutMs, ...staleIds,\n        );\n\n        for (const [messageId, fields] of claimed) {\n          await this.processEntry(messageId, fields);\n        }\n      }\n    } catch {\n      // Pending check failures are non-fatal — will retry next iteration\n    }\n  }\n\n  // -----------------------------------------------------------------------\n  // Message processing\n  // -----------------------------------------------------------------------\n\n  private async processEntry(messageId: string, fields: string[]): Promise<void> {\n    // Parse fields array into key-value pairs\n    const fieldMap = new Map<string, string>();\n    for (let i = 0; i < fields.length; i += 2) {\n      fieldMap.set(fields[i]!, fields[i + 1]!);\n    }\n\n    const eventType = fieldMap.get('type');\n    const rawData = fieldMap.get('data');\n    if (!eventType || !rawData) {\n      // Malformed entry — ack and skip\n      await this.redis.xack(this.stream, this.group, messageId);\n      return;\n    }\n\n    let event: DomainEvent;\n    try {\n      event = JSON.parse(rawData, (key, value) => {\n        if (key === 'timestamp' && typeof value === 'string') return new Date(value);\n        return value;\n      }) as DomainEvent;\n    } catch {\n      // Unparseable — ack and skip\n      await this.redis.xack(this.stream, this.group, messageId);\n      return;\n    }\n\n    // Dispatch to matching handlers\n    const matchingHandlers = this.getMatchingHandlers(event.type);\n    let allSucceeded = true;\n\n    for (const handler of matchingHandlers) {\n      try {\n        await handler(event);\n      } catch (err) {\n        allSucceeded = false;\n        this.logger.error(`[RedisStreamTransport] Handler error for ${event.type}:`, err);\n      }\n    }\n\n    if (allSucceeded) {\n      await this.redis.xack(this.stream, this.group, messageId);\n    }\n    // If not all succeeded, leave unacked — will be retried via pending claim\n  }\n\n  private getMatchingHandlers(eventType: string): EventHandler[] {\n    const matched: EventHandler[] = [];\n\n    for (const [pattern, handlers] of this.handlers) {\n      if (this.matchesPattern(pattern, eventType)) {\n        for (const h of handlers) {\n          matched.push(h);\n        }\n      }\n    }\n\n    return matched;\n  }\n\n  private matchesPattern(pattern: string, eventType: string): boolean {\n    if (pattern === '*') return true;\n    if (pattern === eventType) return true;\n    if (pattern.endsWith('.*')) {\n      const prefix = pattern.slice(0, -2);\n      return eventType.startsWith(prefix + '.');\n    }\n    return false;\n  }\n\n  // -----------------------------------------------------------------------\n  // Dead letter queue\n  // -----------------------------------------------------------------------\n\n  private async moveToDlq(ids: string[]): Promise<void> {\n    if (this.deadLetterStream === false) {\n      // DLQ disabled — just ack and drop\n      for (const id of ids) {\n        await this.redis.xack(this.stream, this.group, id);\n      }\n      return;\n    }\n\n    // Read the entries, write to DLQ stream, then ack\n    for (const id of ids) {\n      try {\n        await (this.redis as any).xadd(\n          this.deadLetterStream,\n          '*',\n          'originalStream', this.stream,\n          'originalId', id,\n          'group', this.group,\n          'failedAt', new Date().toISOString(),\n        );\n        await this.redis.xack(this.stream, this.group, id);\n      } catch (err) {\n        this.logger.error(`[RedisStreamTransport] DLQ write failed for ${id}:`, err);\n      }\n    }\n  }\n\n  // -----------------------------------------------------------------------\n  // Utility\n  // -----------------------------------------------------------------------\n\n  private sleep(ms: number): Promise<void> {\n    return new Promise((resolve) => setTimeout(resolve, ms));\n  }\n}\n\nexport default RedisStreamTransport;\n"],"mappings":"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"}