@k-msg/webhook 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -1,3068 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  BatchDispatcher: () => BatchDispatcher,
-  DeliveryStore: () => DeliveryStore,
-  EndpointManager: () => EndpointManager,
-  EventStore: () => EventStore,
-  LoadBalancer: () => LoadBalancer,
-  QueueManager: () => QueueManager,
-  RetryManager: () => RetryManager,
-  SecurityManager: () => SecurityManager,
-  WebhookDispatcher: () => WebhookDispatcher,
-  WebhookEventType: () => WebhookEventType,
-  WebhookRegistry: () => WebhookRegistry,
-  WebhookService: () => WebhookService
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/types/webhook.types.ts
-var import_zod = require("zod");
-var WebhookEventType = /* @__PURE__ */ ((WebhookEventType2) => {
-  WebhookEventType2["MESSAGE_SENT"] = "message.sent";
-  WebhookEventType2["MESSAGE_DELIVERED"] = "message.delivered";
-  WebhookEventType2["MESSAGE_FAILED"] = "message.failed";
-  WebhookEventType2["MESSAGE_CLICKED"] = "message.clicked";
-  WebhookEventType2["MESSAGE_READ"] = "message.read";
-  WebhookEventType2["TEMPLATE_CREATED"] = "template.created";
-  WebhookEventType2["TEMPLATE_APPROVED"] = "template.approved";
-  WebhookEventType2["TEMPLATE_REJECTED"] = "template.rejected";
-  WebhookEventType2["TEMPLATE_UPDATED"] = "template.updated";
-  WebhookEventType2["TEMPLATE_DELETED"] = "template.deleted";
-  WebhookEventType2["CHANNEL_CREATED"] = "channel.created";
-  WebhookEventType2["CHANNEL_VERIFIED"] = "channel.verified";
-  WebhookEventType2["SENDER_NUMBER_ADDED"] = "sender_number.added";
-  WebhookEventType2["SENDER_NUMBER_VERIFIED"] = "sender_number.verified";
-  WebhookEventType2["QUOTA_WARNING"] = "system.quota_warning";
-  WebhookEventType2["QUOTA_EXCEEDED"] = "system.quota_exceeded";
-  WebhookEventType2["PROVIDER_ERROR"] = "system.provider_error";
-  WebhookEventType2["SYSTEM_MAINTENANCE"] = "system.maintenance";
-  WebhookEventType2["ANOMALY_DETECTED"] = "analytics.anomaly_detected";
-  WebhookEventType2["THRESHOLD_EXCEEDED"] = "analytics.threshold_exceeded";
-  return WebhookEventType2;
-})(WebhookEventType || {});
-var WebhookEventSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  type: import_zod.z.string(),
-  timestamp: import_zod.z.date(),
-  data: import_zod.z.any(),
-  metadata: import_zod.z.object({
-    providerId: import_zod.z.string().optional(),
-    channelId: import_zod.z.string().optional(),
-    templateId: import_zod.z.string().optional(),
-    messageId: import_zod.z.string().optional(),
-    userId: import_zod.z.string().optional(),
-    organizationId: import_zod.z.string().optional(),
-    correlationId: import_zod.z.string().optional(),
-    retryCount: import_zod.z.number().optional()
-  }),
-  version: import_zod.z.string()
-});
-var WebhookEndpointSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  url: import_zod.z.string().url(),
-  name: import_zod.z.string().optional(),
-  description: import_zod.z.string().optional(),
-  active: import_zod.z.boolean(),
-  events: import_zod.z.array(import_zod.z.string()),
-  headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
-  secret: import_zod.z.string().optional(),
-  retryConfig: import_zod.z.object({
-    maxRetries: import_zod.z.number().min(0).max(10),
-    retryDelayMs: import_zod.z.number().min(1e3),
-    backoffMultiplier: import_zod.z.number().min(1).max(5)
-  }).optional(),
-  filters: import_zod.z.object({
-    providerId: import_zod.z.array(import_zod.z.string()).optional(),
-    channelId: import_zod.z.array(import_zod.z.string()).optional(),
-    templateId: import_zod.z.array(import_zod.z.string()).optional()
-  }).optional(),
-  createdAt: import_zod.z.date(),
-  updatedAt: import_zod.z.date(),
-  lastTriggeredAt: import_zod.z.date().optional(),
-  status: import_zod.z.enum(["active", "inactive", "error", "suspended"])
-});
-var WebhookDeliverySchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  endpointId: import_zod.z.string(),
-  eventId: import_zod.z.string(),
-  url: import_zod.z.string().url(),
-  httpMethod: import_zod.z.enum(["POST", "PUT", "PATCH"]),
-  headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()),
-  payload: import_zod.z.string(),
-  attempts: import_zod.z.array(import_zod.z.object({
-    attemptNumber: import_zod.z.number(),
-    timestamp: import_zod.z.date(),
-    httpStatus: import_zod.z.number().optional(),
-    responseBody: import_zod.z.string().optional(),
-    responseHeaders: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
-    error: import_zod.z.string().optional(),
-    latencyMs: import_zod.z.number()
-  })),
-  status: import_zod.z.enum(["pending", "success", "failed", "exhausted"]),
-  createdAt: import_zod.z.date(),
-  completedAt: import_zod.z.date().optional(),
-  nextRetryAt: import_zod.z.date().optional()
-});
-
-// src/services/webhook.dispatcher.ts
-var WebhookDispatcher = class {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  async dispatch(event, endpoint) {
-    const delivery = {
-      id: this.generateDeliveryId(),
-      endpointId: endpoint.id,
-      eventId: event.id,
-      url: endpoint.url,
-      httpMethod: "POST",
-      headers: this.buildHeaders(endpoint, event),
-      payload: JSON.stringify(event),
-      attempts: [],
-      status: "pending",
-      createdAt: /* @__PURE__ */ new Date()
-    };
-    await this.executeDelivery(delivery, endpoint);
-    return delivery;
-  }
-  async executeDelivery(delivery, endpoint) {
-    const maxRetries = endpoint.retryConfig?.maxRetries || this.config.maxRetries;
-    for (let attempt = 1; attempt <= maxRetries + 1; attempt++) {
-      const attemptResult = await this.makeHttpRequest(delivery, endpoint, attempt);
-      delivery.attempts.push(attemptResult);
-      if (attemptResult.httpStatus && attemptResult.httpStatus >= 200 && attemptResult.httpStatus < 300) {
-        delivery.status = "success";
-        delivery.completedAt = /* @__PURE__ */ new Date();
-        return;
-      }
-      if (attempt <= maxRetries) {
-        const delay = this.calculateRetryDelay(attempt, endpoint);
-        await this.sleep(delay);
-      }
-    }
-    delivery.status = "exhausted";
-    delivery.completedAt = /* @__PURE__ */ new Date();
-  }
-  async makeHttpRequest(delivery, endpoint, attemptNumber) {
-    const startTime = Date.now();
-    const attempt = {
-      attemptNumber,
-      timestamp: /* @__PURE__ */ new Date(),
-      latencyMs: 0
-    };
-    try {
-      const response = await fetch(delivery.url, {
-        method: delivery.httpMethod,
-        headers: delivery.headers,
-        body: delivery.payload,
-        signal: AbortSignal.timeout(this.config.timeoutMs)
-      });
-      attempt.httpStatus = response.status;
-      attempt.responseBody = await response.text();
-      const responseHeaders = {};
-      response.headers.forEach((value, key) => {
-        responseHeaders[key] = value;
-      });
-      attempt.responseHeaders = responseHeaders;
-      attempt.latencyMs = Date.now() - startTime;
-      if (!response.ok) {
-        attempt.error = `HTTP ${response.status}: ${response.statusText}`;
-      }
-    } catch (error) {
-      attempt.latencyMs = Date.now() - startTime;
-      attempt.error = error instanceof Error ? error.message : "Unknown error";
-    }
-    return attempt;
-  }
-  buildHeaders(endpoint, event) {
-    const headers = {
-      "Content-Type": "application/json",
-      "X-Webhook-ID": event.id,
-      "X-Webhook-Event": event.type,
-      "X-Webhook-Timestamp": event.timestamp.toISOString(),
-      "User-Agent": "K-Message-Webhook/1.0"
-    };
-    if (endpoint.headers) {
-      Object.assign(headers, endpoint.headers);
-    }
-    if (endpoint.secret) {
-      const signature = this.generateSignature(JSON.stringify(event), endpoint.secret);
-      headers["X-Webhook-Signature"] = signature;
-    }
-    return headers;
-  }
-  generateSignature(payload, secret) {
-    return `sha256=${Buffer.from(payload + secret).toString("base64")}`;
-  }
-  calculateRetryDelay(attempt, endpoint) {
-    const baseDelay = endpoint.retryConfig?.retryDelayMs || this.config.retryDelayMs;
-    const multiplier = endpoint.retryConfig?.backoffMultiplier || 2;
-    return baseDelay * Math.pow(multiplier, attempt - 1);
-  }
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-  generateDeliveryId() {
-    return `delivery_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
-  }
-  async shutdown() {
-  }
-};
-
-// src/services/webhook.registry.ts
-var WebhookRegistry = class {
-  endpoints = /* @__PURE__ */ new Map();
-  deliveries = /* @__PURE__ */ new Map();
-  async addEndpoint(endpoint) {
-    this.endpoints.set(endpoint.id, endpoint);
-  }
-  async updateEndpoint(endpointId, endpoint) {
-    if (!this.endpoints.has(endpointId)) {
-      throw new Error(`Endpoint ${endpointId} not found`);
-    }
-    this.endpoints.set(endpointId, endpoint);
-  }
-  async removeEndpoint(endpointId) {
-    this.endpoints.delete(endpointId);
-  }
-  async getEndpoint(endpointId) {
-    return this.endpoints.get(endpointId) || null;
-  }
-  async listEndpoints() {
-    return Array.from(this.endpoints.values());
-  }
-  async addDelivery(delivery) {
-    this.deliveries.set(delivery.id, delivery);
-  }
-  async getDeliveries(endpointId, timeRange, eventType, status, limit = 100) {
-    let deliveries = Array.from(this.deliveries.values());
-    if (endpointId) {
-      deliveries = deliveries.filter((d) => d.endpointId === endpointId);
-    }
-    if (timeRange) {
-      deliveries = deliveries.filter(
-        (d) => d.createdAt >= timeRange.start && d.createdAt <= timeRange.end
-      );
-    }
-    if (status) {
-      deliveries = deliveries.filter((d) => d.status === status);
-    }
-    return deliveries.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime()).slice(0, limit);
-  }
-  async getFailedDeliveries(endpointId, eventType) {
-    return this.getDeliveries(endpointId, void 0, eventType, "failed");
-  }
-};
-
-// src/security/security.manager.ts
-var crypto = __toESM(require("crypto"), 1);
-var SecurityManager = class {
-  config;
-  constructor(webhookConfig) {
-    this.config = {
-      algorithm: webhookConfig.algorithm || "sha256",
-      header: webhookConfig.signatureHeader || "X-Webhook-Signature",
-      prefix: webhookConfig.signaturePrefix || "sha256="
-    };
-  }
-  /**
-   * Webhook 페이로드에 대한 서명 생성
-   */
-  generateSignature(payload, secret) {
-    const hmac = crypto.createHmac(this.config.algorithm, secret);
-    hmac.update(payload, "utf8");
-    const signature = hmac.digest("hex");
-    return this.config.prefix ? `${this.config.prefix}${signature}` : signature;
-  }
-  /**
-   * Webhook 서명 검증
-   */
-  verifySignature(payload, signature, secret) {
-    try {
-      const expectedSignature = this.generateSignature(payload, secret);
-      return this.constantTimeCompare(signature, expectedSignature);
-    } catch (error) {
-      console.error("Signature verification failed:", error);
-      return false;
-    }
-  }
-  /**
-   * HTTP 헤더에서 서명 추출
-   */
-  extractSignature(headers) {
-    const headerName = this.config.header.toLowerCase();
-    for (const [key, value] of Object.entries(headers)) {
-      if (key.toLowerCase() === headerName) {
-        return value;
-      }
-    }
-    return null;
-  }
-  /**
-   * Webhook 전송을 위한 보안 헤더 생성
-   */
-  createSecurityHeaders(payload, secret) {
-    const signature = this.generateSignature(payload, secret);
-    const timestamp = Math.floor(Date.now() / 1e3).toString();
-    return {
-      [this.config.header]: signature,
-      "X-Webhook-Timestamp": timestamp,
-      "X-Webhook-ID": this.generateWebhookId(),
-      "User-Agent": "K-Message-Webhook/1.0"
-    };
-  }
-  /**
-   * 타임스탬프 기반 재생 공격 방지 검증
-   */
-  verifyTimestamp(timestamp, toleranceSeconds = 300) {
-    try {
-      const webhookTime = parseInt(timestamp, 10);
-      const currentTime = Math.floor(Date.now() / 1e3);
-      const timeDiff = Math.abs(currentTime - webhookTime);
-      return timeDiff <= toleranceSeconds;
-    } catch (error) {
-      return false;
-    }
-  }
-  /**
-   * Webhook ID 생성 (추적용)
-   */
-  generateWebhookId() {
-    return `wh_${crypto.randomBytes(16).toString("hex")}`;
-  }
-  /**
-   * Constant-time 문자열 비교 (타이밍 공격 방지)
-   */
-  constantTimeCompare(a, b) {
-    if (a.length !== b.length) {
-      return false;
-    }
-    let result = 0;
-    for (let i = 0; i < a.length; i++) {
-      result |= a.charCodeAt(i) ^ b.charCodeAt(i);
-    }
-    return result === 0;
-  }
-  /**
-   * 보안 설정 업데이트
-   */
-  updateConfig(config) {
-    this.config = { ...this.config, ...config };
-  }
-  /**
-   * 현재 보안 설정 반환
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-};
-
-// src/retry/retry.manager.ts
-var RetryManager = class {
-  config;
-  constructor(webhookConfig) {
-    this.config = {
-      maxRetries: webhookConfig.maxRetries,
-      baseDelayMs: webhookConfig.retryDelayMs,
-      maxDelayMs: webhookConfig.maxDelayMs || 3e5,
-      // 5분
-      backoffMultiplier: webhookConfig.backoffMultiplier || 2,
-      jitter: webhookConfig.jitter !== false
-      // 기본값 true
-    };
-  }
-  /**
-   * 다음 재시도 시간 계산
-   */
-  calculateNextRetry(attemptNumber) {
-    if (attemptNumber >= this.config.maxRetries) {
-      throw new Error(`Maximum retry attempts (${this.config.maxRetries}) exceeded`);
-    }
-    let delay = this.config.baseDelayMs * Math.pow(this.config.backoffMultiplier, attemptNumber);
-    delay = Math.min(delay, this.config.maxDelayMs);
-    if (this.config.jitter) {
-      delay = delay * (0.5 + Math.random() * 0.5);
-    }
-    return new Date(Date.now() + delay);
-  }
-  /**
-   * 재시도 가능 여부 확인
-   */
-  shouldRetry(attemptNumber, error) {
-    if (attemptNumber >= this.config.maxRetries) {
-      return false;
-    }
-    if (error) {
-      return this.isRetryableError(error);
-    }
-    return true;
-  }
-  /**
-   * 재시도 가능한 에러인지 판단
-   */
-  isRetryableError(error) {
-    const message = error.message.toLowerCase();
-    const retryableErrors = [
-      "timeout",
-      "network",
-      "connection",
-      "econnreset",
-      "enotfound",
-      "econnrefused",
-      "socket hang up"
-    ];
-    return retryableErrors.some((keyword) => message.includes(keyword));
-  }
-  /**
-   * HTTP 상태 코드별 재시도 정책
-   */
-  shouldRetryStatus(statusCode) {
-    if (statusCode >= 400 && statusCode < 500) {
-      const retryable4xx = [408, 429];
-      return retryable4xx.includes(statusCode);
-    }
-    if (statusCode >= 500) {
-      return true;
-    }
-    return false;
-  }
-  /**
-   * 재시도 통계 계산
-   */
-  calculateRetryStats(attempts) {
-    if (attempts.length === 0) {
-      return {
-        totalAttempts: 0,
-        successfulAttempts: 0,
-        failedAttempts: 0,
-        averageDelayMs: 0,
-        totalTimeMs: 0
-      };
-    }
-    const successful = attempts.filter((a) => a.success).length;
-    const failed = attempts.length - successful;
-    let totalDelay = 0;
-    for (let i = 1; i < attempts.length; i++) {
-      totalDelay += attempts[i].timestamp.getTime() - attempts[i - 1].timestamp.getTime();
-    }
-    const averageDelay = attempts.length > 1 ? totalDelay / (attempts.length - 1) : 0;
-    const totalTime = attempts.length > 0 ? attempts[attempts.length - 1].timestamp.getTime() - attempts[0].timestamp.getTime() : 0;
-    return {
-      totalAttempts: attempts.length,
-      successfulAttempts: successful,
-      failedAttempts: failed,
-      averageDelayMs: averageDelay,
-      totalTimeMs: totalTime
-    };
-  }
-  /**
-   * 재시도 설정 업데이트
-   */
-  updateConfig(config) {
-    this.config = { ...this.config, ...config };
-  }
-  /**
-   * 현재 재시도 설정 반환
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-  /**
-   * 백오프 지연 시간 계산 (테스트용)
-   */
-  getBackoffDelay(attemptNumber) {
-    let delay = this.config.baseDelayMs * Math.pow(this.config.backoffMultiplier, attemptNumber);
-    return Math.min(delay, this.config.maxDelayMs);
-  }
-};
-
-// src/services/webhook.service.ts
-var WebhookService = class {
-  config;
-  dispatcher;
-  registry;
-  securityManager;
-  retryManager;
-  eventQueue = [];
-  batchProcessor = null;
-  constructor(config) {
-    this.config = config;
-    this.dispatcher = new WebhookDispatcher(config);
-    this.registry = new WebhookRegistry();
-    this.securityManager = new SecurityManager(config);
-    this.retryManager = new RetryManager(config);
-    this.startBatchProcessor();
-  }
-  /**
-   * 웹훅 엔드포인트 등록
-   */
-  async registerEndpoint(endpoint) {
-    await this.validateEndpointUrl(endpoint.url);
-    const newEndpoint = {
-      ...endpoint,
-      id: this.generateEndpointId(),
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date(),
-      status: "active"
-    };
-    await this.registry.addEndpoint(newEndpoint);
-    await this.testEndpoint(newEndpoint.id);
-    return newEndpoint;
-  }
-  /**
-   * 웹훅 엔드포인트 수정
-   */
-  async updateEndpoint(endpointId, updates) {
-    const endpoint = await this.registry.getEndpoint(endpointId);
-    if (!endpoint) {
-      throw new Error(`Webhook endpoint ${endpointId} not found`);
-    }
-    if (updates.url && updates.url !== endpoint.url) {
-      await this.validateEndpointUrl(updates.url);
-    }
-    const updatedEndpoint = {
-      ...endpoint,
-      ...updates,
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    await this.registry.updateEndpoint(endpointId, updatedEndpoint);
-    return updatedEndpoint;
-  }
-  /**
-   * 웹훅 엔드포인트 삭제
-   */
-  async deleteEndpoint(endpointId) {
-    await this.registry.removeEndpoint(endpointId);
-  }
-  /**
-   * 웹훅 엔드포인트 조회
-   */
-  async getEndpoint(endpointId) {
-    return this.registry.getEndpoint(endpointId);
-  }
-  /**
-   * 모든 웹훅 엔드포인트 조회
-   */
-  async listEndpoints() {
-    return this.registry.listEndpoints();
-  }
-  /**
-   * 이벤트 발생 (비동기 처리)
-   */
-  async emit(event) {
-    if (!this.config.enabledEvents.includes(event.type)) {
-      return;
-    }
-    this.validateEvent(event);
-    this.eventQueue.push(event);
-    if (this.eventQueue.length >= this.config.batchSize) {
-      await this.processBatch();
-    }
-  }
-  /**
-   * 이벤트 발생 (동기 처리)
-   */
-  async emitSync(event) {
-    this.validateEvent(event);
-    const endpoints = await this.getMatchingEndpoints(event);
-    const deliveries = [];
-    for (const endpoint of endpoints) {
-      const delivery = await this.dispatcher.dispatch(event, endpoint);
-      deliveries.push(delivery);
-    }
-    return deliveries;
-  }
-  /**
-   * 웹훅 엔드포인트 테스트
-   */
-  async testEndpoint(endpointId) {
-    const endpoint = await this.registry.getEndpoint(endpointId);
-    if (!endpoint) {
-      throw new Error(`Webhook endpoint ${endpointId} not found`);
-    }
-    const testEvent = {
-      id: `test_${Date.now()}`,
-      type: "system.maintenance" /* SYSTEM_MAINTENANCE */,
-      // 테스트용 이벤트
-      timestamp: /* @__PURE__ */ new Date(),
-      data: {
-        test: true,
-        message: "This is a test webhook"
-      },
-      metadata: {
-        correlationId: `test_${endpointId}`
-      },
-      version: "1.0"
-    };
-    const startTime = Date.now();
-    try {
-      const delivery = await this.dispatcher.dispatch(testEvent, endpoint);
-      const endTime = Date.now();
-      return {
-        endpointId,
-        url: endpoint.url,
-        success: delivery.status === "success",
-        httpStatus: delivery.attempts[0]?.httpStatus,
-        responseTime: endTime - startTime,
-        testedAt: /* @__PURE__ */ new Date()
-      };
-    } catch (error) {
-      const endTime = Date.now();
-      return {
-        endpointId,
-        url: endpoint.url,
-        success: false,
-        responseTime: endTime - startTime,
-        error: error instanceof Error ? error.message : "Unknown error",
-        testedAt: /* @__PURE__ */ new Date()
-      };
-    }
-  }
-  /**
-   * 웹훅 통계 조회
-   */
-  async getStats(endpointId, timeRange) {
-    const deliveries = await this.registry.getDeliveries(endpointId, timeRange);
-    const successful = deliveries.filter((d) => d.status === "success");
-    const failed = deliveries.filter((d) => d.status === "failed" || d.status === "exhausted");
-    const totalLatency = deliveries.reduce((sum, d) => {
-      const lastAttempt = d.attempts[d.attempts.length - 1];
-      return sum + (lastAttempt?.latencyMs || 0);
-    }, 0);
-    const eventBreakdown = {};
-    const errorBreakdown = {};
-    for (const delivery of deliveries) {
-      if (delivery.status === "failed" || delivery.status === "exhausted") {
-        const lastAttempt = delivery.attempts[delivery.attempts.length - 1];
-        const errorKey = lastAttempt?.error || `HTTP ${lastAttempt?.httpStatus || "Unknown"}`;
-        errorBreakdown[errorKey] = (errorBreakdown[errorKey] || 0) + 1;
-      }
-    }
-    return {
-      endpointId,
-      timeRange,
-      totalDeliveries: deliveries.length,
-      successfulDeliveries: successful.length,
-      failedDeliveries: failed.length,
-      averageLatencyMs: deliveries.length > 0 ? totalLatency / deliveries.length : 0,
-      successRate: deliveries.length > 0 ? successful.length / deliveries.length * 100 : 0,
-      eventBreakdown,
-      errorBreakdown
-    };
-  }
-  /**
-   * 실패한 웹훅 재시도
-   */
-  async retryFailed(endpointId, eventType) {
-    const failedDeliveries = await this.registry.getFailedDeliveries(endpointId, eventType);
-    let retriedCount = 0;
-    for (const delivery of failedDeliveries) {
-      const attemptCount = delivery.attempts.length;
-      if (this.retryManager.shouldRetry(attemptCount)) {
-        setTimeout(async () => {
-          const endpoint = await this.registry.getEndpoint(delivery.endpointId);
-          if (endpoint) {
-            await this.dispatcher.dispatch(
-              JSON.parse(delivery.payload),
-              endpoint
-            );
-          }
-        }, this.retryManager.getBackoffDelay(attemptCount));
-        retriedCount++;
-      }
-    }
-    return retriedCount;
-  }
-  /**
-   * 웹훅 일시 중단
-   */
-  async pauseEndpoint(endpointId) {
-    await this.updateEndpoint(endpointId, { status: "suspended" });
-  }
-  /**
-   * 웹훅 재개
-   */
-  async resumeEndpoint(endpointId) {
-    await this.updateEndpoint(endpointId, { status: "active" });
-  }
-  /**
-   * 웹훅 전달 내역 조회
-   */
-  async getDeliveries(endpointId, eventType, status, limit = 100) {
-    return this.registry.getDeliveries(endpointId, void 0, eventType, status, limit);
-  }
-  async processBatch() {
-    if (this.eventQueue.length === 0) {
-      return;
-    }
-    const batch = this.eventQueue.splice(0, this.config.batchSize);
-    try {
-      for (const event of batch) {
-        const endpoints = await this.getMatchingEndpoints(event);
-        for (const endpoint of endpoints) {
-          this.dispatcher.dispatch(event, endpoint).catch((error) => {
-            console.error(`Failed to dispatch webhook to ${endpoint.url}:`, error);
-          });
-        }
-      }
-    } catch (error) {
-      console.error("Batch processing failed:", error);
-      this.eventQueue.unshift(...batch);
-    }
-  }
-  async getMatchingEndpoints(event) {
-    const allEndpoints = await this.registry.listEndpoints();
-    return allEndpoints.filter((endpoint) => {
-      if (endpoint.status !== "active") {
-        return false;
-      }
-      if (!endpoint.events.includes(event.type)) {
-        return false;
-      }
-      if (endpoint.filters) {
-        if (endpoint.filters.providerId && event.metadata.providerId) {
-          if (!endpoint.filters.providerId.includes(event.metadata.providerId)) {
-            return false;
-          }
-        }
-        if (endpoint.filters.channelId && event.metadata.channelId) {
-          if (!endpoint.filters.channelId.includes(event.metadata.channelId)) {
-            return false;
-          }
-        }
-        if (endpoint.filters.templateId && event.metadata.templateId) {
-          if (!endpoint.filters.templateId.includes(event.metadata.templateId)) {
-            return false;
-          }
-        }
-      }
-      return true;
-    });
-  }
-  validateEvent(event) {
-    if (!event.id) {
-      throw new Error("Event ID is required");
-    }
-    if (!event.type) {
-      throw new Error("Event type is required");
-    }
-    if (!event.timestamp) {
-      throw new Error("Event timestamp is required");
-    }
-    if (!event.version) {
-      throw new Error("Event version is required");
-    }
-  }
-  async validateEndpointUrl(url) {
-    try {
-      const parsedUrl = new URL(url);
-      if (parsedUrl.protocol !== "https:" && !url.includes("localhost") && !url.includes("127.0.0.1")) {
-        throw new Error("Webhook URL must use HTTPS");
-      }
-      if (process.env.NODE_ENV === "production") {
-        const hostname = parsedUrl.hostname;
-        if (hostname === "localhost" || hostname === "127.0.0.1" || hostname.startsWith("192.168.") || hostname.startsWith("10.")) {
-          throw new Error("Private IP addresses are not allowed in production");
-        }
-      }
-    } catch (error) {
-      if (error instanceof Error) {
-        throw error;
-      }
-      throw new Error("Invalid webhook URL");
-    }
-  }
-  generateEndpointId() {
-    return `webhook_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
-  }
-  startBatchProcessor() {
-    this.batchProcessor = setInterval(async () => {
-      try {
-        await this.processBatch();
-      } catch (error) {
-        console.error("Batch processor error:", error);
-      }
-    }, this.config.batchTimeoutMs);
-  }
-  /**
-   * 서비스 종료 시 정리
-   */
-  async shutdown() {
-    if (this.batchProcessor) {
-      clearInterval(this.batchProcessor);
-      this.batchProcessor = null;
-    }
-    if (this.eventQueue.length > 0) {
-      await this.processBatch();
-    }
-    await this.dispatcher.shutdown();
-  }
-};
-
-// src/dispatcher/batch.dispatcher.ts
-var import_events = require("events");
-var BatchDispatcher = class extends import_events.EventEmitter {
-  config;
-  pendingJobs = /* @__PURE__ */ new Map();
-  // endpointId -> jobs
-  activeBatches = /* @__PURE__ */ new Map();
-  batchProcessor = null;
-  defaultConfig = {
-    maxBatchSize: 100,
-    batchTimeoutMs: 5e3,
-    maxConcurrentBatches: 10,
-    enablePrioritization: true,
-    priorityLevels: 3
-  };
-  constructor(config = {}) {
-    super();
-    this.config = { ...this.defaultConfig, ...config };
-    this.startBatchProcessor();
-  }
-  /**
-   * 배치 작업 추가
-   */
-  async addJob(job) {
-    const endpointId = job.endpoint.id;
-    if (!this.pendingJobs.has(endpointId)) {
-      this.pendingJobs.set(endpointId, []);
-    }
-    const jobs = this.pendingJobs.get(endpointId);
-    if (this.config.enablePrioritization) {
-      this.insertJobByPriority(jobs, job);
-    } else {
-      jobs.push(job);
-    }
-    if (jobs.length >= this.config.maxBatchSize) {
-      await this.processBatchForEndpoint(endpointId);
-    }
-    this.emit("jobAdded", { endpointId, jobId: job.id, queueSize: jobs.length });
-  }
-  /**
-   * 특정 엔드포인트의 배치 처리
-   */
-  async processBatchForEndpoint(endpointId) {
-    const jobs = this.pendingJobs.get(endpointId);
-    if (!jobs || jobs.length === 0) {
-      return null;
-    }
-    if (this.activeBatches.size >= this.config.maxConcurrentBatches) {
-      this.emit("batchSkipped", { endpointId, reason: "max_concurrent_batches" });
-      return null;
-    }
-    const batchJobs = jobs.splice(0, this.config.maxBatchSize);
-    const batch = this.createBatch(endpointId, batchJobs);
-    this.activeBatches.set(batch.id, batch);
-    try {
-      this.emit("batchStarted", { batchId: batch.id, endpointId, jobCount: batchJobs.length });
-      await this.executeBatch(batch, batchJobs);
-      batch.status = "completed";
-      this.emit("batchCompleted", { batchId: batch.id, endpointId, success: true });
-    } catch (error) {
-      batch.status = "failed";
-      this.emit("batchFailed", { batchId: batch.id, endpointId, error: error instanceof Error ? error.message : "Unknown error" });
-      this.requeueFailedJobs(batchJobs);
-    } finally {
-      this.activeBatches.delete(batch.id);
-    }
-    return batch;
-  }
-  /**
-   * 모든 대기 중인 배치 처리
-   */
-  async processAllBatches() {
-    const processedBatches = [];
-    const endpointIds = Array.from(this.pendingJobs.keys());
-    for (const endpointId of endpointIds) {
-      const batch = await this.processBatchForEndpoint(endpointId);
-      if (batch) {
-        processedBatches.push(batch);
-      }
-    }
-    return processedBatches;
-  }
-  /**
-   * 배치 통계 조회
-   */
-  getBatchStats() {
-    const endpointIds = Array.from(this.pendingJobs.keys());
-    const totalPendingJobs = endpointIds.reduce((sum, id) => {
-      return sum + (this.pendingJobs.get(id)?.length || 0);
-    }, 0);
-    return {
-      pendingJobsCount: totalPendingJobs,
-      activeBatchesCount: this.activeBatches.size,
-      endpointsWithPendingJobs: endpointIds.length,
-      averageQueueSize: endpointIds.length > 0 ? totalPendingJobs / endpointIds.length : 0
-    };
-  }
-  /**
-   * 특정 엔드포인트의 대기 중인 작업 수 조회
-   */
-  getPendingJobCount(endpointId) {
-    return this.pendingJobs.get(endpointId)?.length || 0;
-  }
-  /**
-   * 배치 처리기 시작
-   */
-  startBatchProcessor() {
-    this.batchProcessor = setInterval(async () => {
-      try {
-        await this.processAllBatches();
-      } catch (error) {
-        this.emit("processorError", error);
-      }
-    }, this.config.batchTimeoutMs);
-  }
-  /**
-   * 우선순위 기반 작업 삽입
-   */
-  insertJobByPriority(jobs, newJob) {
-    let insertIndex = 0;
-    for (let i = 0; i < jobs.length; i++) {
-      if (jobs[i].priority <= newJob.priority) {
-        insertIndex = i;
-        break;
-      }
-      insertIndex = i + 1;
-    }
-    jobs.splice(insertIndex, 0, newJob);
-  }
-  /**
-   * 배치 생성
-   */
-  createBatch(endpointId, jobs) {
-    return {
-      id: `batch_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-      endpointId,
-      events: jobs.map((job) => job.event),
-      createdAt: /* @__PURE__ */ new Date(),
-      scheduledAt: /* @__PURE__ */ new Date(),
-      status: "processing"
-    };
-  }
-  /**
-   * 배치 실행
-   */
-  async executeBatch(batch, jobs) {
-    const endpoint = jobs[0]?.endpoint;
-    if (!endpoint) {
-      throw new Error("No endpoint found for batch");
-    }
-    const deliveryPromises = jobs.map((job) => this.executeJob(job));
-    try {
-      const deliveries = await Promise.allSettled(deliveryPromises);
-      const successful = deliveries.filter((result) => result.status === "fulfilled").length;
-      const failed = deliveries.length - successful;
-      this.emit("batchExecuted", {
-        batchId: batch.id,
-        endpointId: batch.endpointId,
-        total: deliveries.length,
-        successful,
-        failed
-      });
-      if (failed > 0) {
-        throw new Error(`Batch partially failed: ${failed}/${deliveries.length} jobs failed`);
-      }
-    } catch (error) {
-      this.emit("batchExecutionError", {
-        batchId: batch.id,
-        endpointId: batch.endpointId,
-        error: error instanceof Error ? error.message : "Unknown error"
-      });
-      throw error;
-    }
-  }
-  /**
-   * 개별 작업 실행 (실제로는 WebhookDispatcher 사용)
-   */
-  async executeJob(job) {
-    const delivery = {
-      id: `delivery_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-      endpointId: job.endpoint.id,
-      eventId: job.event.id,
-      url: job.endpoint.url,
-      httpMethod: "POST",
-      headers: { "Content-Type": "application/json" },
-      payload: JSON.stringify(job.event),
-      attempts: [],
-      status: "pending",
-      createdAt: /* @__PURE__ */ new Date()
-    };
-    const success = Math.random() > 0.1;
-    delivery.attempts.push({
-      attemptNumber: 1,
-      timestamp: /* @__PURE__ */ new Date(),
-      httpStatus: success ? 200 : 500,
-      responseBody: success ? "OK" : "Internal Server Error",
-      error: success ? void 0 : "Server error",
-      latencyMs: Math.floor(Math.random() * 1e3) + 100
-    });
-    delivery.status = success ? "success" : "failed";
-    delivery.completedAt = /* @__PURE__ */ new Date();
-    return delivery;
-  }
-  /**
-   * 실패한 작업들을 다시 큐에 추가
-   */
-  requeueFailedJobs(jobs) {
-    for (const job of jobs) {
-      job.attempts++;
-      if (job.attempts < job.maxAttempts) {
-        const baseDelay = 1e3;
-        const backoffMultiplier = 2;
-        const delay = baseDelay * Math.pow(backoffMultiplier, job.attempts - 1);
-        job.nextRetryAt = new Date(Date.now() + delay);
-        job.scheduledAt = job.nextRetryAt;
-        setTimeout(() => {
-          this.addJob(job).catch((error) => {
-            this.emit("requeueError", { jobId: job.id, error: error instanceof Error ? error.message : "Unknown error" });
-          });
-        }, delay);
-      } else {
-        this.emit("jobExhausted", { jobId: job.id, endpointId: job.endpoint.id, attempts: job.attempts });
-      }
-    }
-  }
-  /**
-   * 배치 처리기 정지
-   */
-  async shutdown() {
-    if (this.batchProcessor) {
-      clearInterval(this.batchProcessor);
-      this.batchProcessor = null;
-    }
-    const maxWaitTime = 3e4;
-    const startTime = Date.now();
-    while (this.activeBatches.size > 0 && Date.now() - startTime < maxWaitTime) {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    this.emit("shutdown", {
-      pendingJobs: this.getBatchStats().pendingJobsCount,
-      activeBatches: this.activeBatches.size
-    });
-  }
-};
-
-// src/dispatcher/queue.manager.ts
-var import_events2 = require("events");
-var fs = __toESM(require("fs/promises"), 1);
-var path = __toESM(require("path"), 1);
-var QueueManager = class extends import_events2.EventEmitter {
-  config;
-  queues = /* @__PURE__ */ new Map();
-  // priority level -> jobs
-  highPriorityQueue = [];
-  mediumPriorityQueue = [];
-  lowPriorityQueue = [];
-  delayedJobs = /* @__PURE__ */ new Map();
-  totalJobs = 0;
-  defaultConfig = {
-    maxQueueSize: 1e4,
-    persistToDisk: false,
-    compressionEnabled: false,
-    ttlMs: 24 * 60 * 60 * 1e3
-    // 24시간
-  };
-  constructor(config = {}) {
-    super();
-    this.config = { ...this.defaultConfig, ...config };
-    this.queues.set("high", this.highPriorityQueue);
-    this.queues.set("medium", this.mediumPriorityQueue);
-    this.queues.set("low", this.lowPriorityQueue);
-    if (this.config.persistToDisk && this.config.diskPath) {
-      this.loadFromDisk().catch((error) => {
-        this.emit("diskLoadError", error);
-      });
-    }
-    this.startTTLCleanup();
-  }
-  /**
-   * 작업을 큐에 추가
-   */
-  async enqueue(job) {
-    if (this.totalJobs >= this.config.maxQueueSize) {
-      this.emit("queueFull", { totalJobs: this.totalJobs, maxSize: this.config.maxQueueSize });
-      return false;
-    }
-    if (job.scheduledAt > /* @__PURE__ */ new Date()) {
-      await this.scheduleDelayedJob(job);
-      return true;
-    }
-    const queueName = this.getQueueName(job.priority);
-    const queue = this.queues.get(queueName);
-    if (!queue) {
-      throw new Error(`Invalid queue name: ${queueName}`);
-    }
-    queue.push(job);
-    this.totalJobs++;
-    this.emit("jobEnqueued", {
-      jobId: job.id,
-      priority: job.priority,
-      queueName,
-      totalJobs: this.totalJobs
-    });
-    if (this.config.persistToDisk) {
-      await this.saveToDisk().catch((error) => {
-        this.emit("diskSaveError", error);
-      });
-    }
-    return true;
-  }
-  /**
-   * 우선순위에 따라 작업 추출
-   */
-  async dequeue() {
-    for (const [queueName, queue] of this.queues.entries()) {
-      if (queue.length > 0) {
-        const job = queue.shift();
-        this.totalJobs--;
-        this.emit("jobDequeued", {
-          jobId: job.id,
-          queueName,
-          totalJobs: this.totalJobs
-        });
-        if (this.config.persistToDisk) {
-          await this.saveToDisk().catch((error) => {
-            this.emit("diskSaveError", error);
-          });
-        }
-        return job;
-      }
-    }
-    return null;
-  }
-  /**
-   * 특정 우선순위 큐에서 작업 추출
-   */
-  async dequeueFromPriority(priority) {
-    const queueName = this.getQueueName(priority);
-    const queue = this.queues.get(queueName);
-    if (!queue || queue.length === 0) {
-      return null;
-    }
-    const job = queue.shift();
-    this.totalJobs--;
-    this.emit("jobDequeued", {
-      jobId: job.id,
-      queueName,
-      totalJobs: this.totalJobs
-    });
-    return job;
-  }
-  /**
-   * 작업 상태 확인
-   */
-  peek() {
-    for (const queue of this.queues.values()) {
-      if (queue.length > 0) {
-        return queue[0];
-      }
-    }
-    return null;
-  }
-  /**
-   * 특정 작업 제거
-   */
-  async removeJob(jobId) {
-    for (const [queueName, queue] of this.queues.entries()) {
-      const index = queue.findIndex((job) => job.id === jobId);
-      if (index !== -1) {
-        queue.splice(index, 1);
-        this.totalJobs--;
-        this.emit("jobRemoved", {
-          jobId,
-          queueName,
-          totalJobs: this.totalJobs
-        });
-        if (this.config.persistToDisk) {
-          await this.saveToDisk().catch((error) => {
-            this.emit("diskSaveError", error);
-          });
-        }
-        return true;
-      }
-    }
-    const delayedTimeout = this.delayedJobs.get(jobId);
-    if (delayedTimeout) {
-      clearTimeout(delayedTimeout);
-      this.delayedJobs.delete(jobId);
-      this.emit("delayedJobCanceled", { jobId });
-      return true;
-    }
-    return false;
-  }
-  /**
-   * 큐 통계 조회
-   */
-  getStats() {
-    return {
-      totalJobs: this.totalJobs,
-      highPriorityJobs: this.highPriorityQueue.length,
-      mediumPriorityJobs: this.mediumPriorityQueue.length,
-      lowPriorityJobs: this.lowPriorityQueue.length,
-      delayedJobs: this.delayedJobs.size,
-      queueUtilization: this.totalJobs / this.config.maxQueueSize * 100
-    };
-  }
-  /**
-   * 큐 비우기
-   */
-  async clear() {
-    for (const queue of this.queues.values()) {
-      queue.length = 0;
-    }
-    for (const timeout of this.delayedJobs.values()) {
-      clearTimeout(timeout);
-    }
-    this.delayedJobs.clear();
-    this.totalJobs = 0;
-    this.emit("queueCleared");
-    if (this.config.persistToDisk) {
-      await this.saveToDisk().catch((error) => {
-        this.emit("diskSaveError", error);
-      });
-    }
-  }
-  /**
-   * 만료된 작업 정리
-   */
-  async cleanupExpiredJobs() {
-    const now = /* @__PURE__ */ new Date();
-    let removedCount = 0;
-    for (const [queueName, queue] of this.queues.entries()) {
-      const initialLength = queue.length;
-      for (let i = queue.length - 1; i >= 0; i--) {
-        const job = queue[i];
-        const age = now.getTime() - job.createdAt.getTime();
-        if (age > this.config.ttlMs) {
-          queue.splice(i, 1);
-          this.totalJobs--;
-          removedCount++;
-          this.emit("jobExpired", {
-            jobId: job.id,
-            queueName,
-            age
-          });
-        }
-      }
-    }
-    if (removedCount > 0) {
-      this.emit("expiredJobsCleanup", { removedCount, totalJobs: this.totalJobs });
-      if (this.config.persistToDisk) {
-        await this.saveToDisk().catch((error) => {
-          this.emit("diskSaveError", error);
-        });
-      }
-    }
-    return removedCount;
-  }
-  /**
-   * 우선순위 숫자를 큐 이름으로 변환
-   */
-  getQueueName(priority) {
-    if (priority >= 8) return "high";
-    if (priority >= 5) return "medium";
-    return "low";
-  }
-  /**
-   * 지연된 작업 스케줄링
-   */
-  async scheduleDelayedJob(job) {
-    const delay = job.scheduledAt.getTime() - Date.now();
-    const timeout = setTimeout(async () => {
-      this.delayedJobs.delete(job.id);
-      const success = await this.enqueue({
-        ...job,
-        scheduledAt: /* @__PURE__ */ new Date()
-        // 즉시 처리 가능하도록 변경
-      });
-      if (success) {
-        this.emit("delayedJobActivated", { jobId: job.id });
-      }
-    }, delay);
-    this.delayedJobs.set(job.id, timeout);
-    this.emit("jobScheduled", {
-      jobId: job.id,
-      scheduledAt: job.scheduledAt,
-      delay
-    });
-  }
-  /**
-   * TTL 정리 작업 시작
-   */
-  startTTLCleanup() {
-    setInterval(async () => {
-      try {
-        await this.cleanupExpiredJobs();
-      } catch (error) {
-        this.emit("cleanupError", error);
-      }
-    }, 5 * 60 * 1e3);
-  }
-  /**
-   * 디스크에 큐 상태 저장
-   */
-  async saveToDisk() {
-    if (!this.config.diskPath) return;
-    try {
-      const data = {
-        queues: {
-          high: this.highPriorityQueue,
-          medium: this.mediumPriorityQueue,
-          low: this.lowPriorityQueue
-        },
-        totalJobs: this.totalJobs,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      const json = JSON.stringify(data, null, 2);
-      const filePath = path.join(this.config.diskPath, "webhook-queue.json");
-      await fs.mkdir(path.dirname(filePath), { recursive: true });
-      await fs.writeFile(filePath, json, "utf8");
-      this.emit("diskSaved", { filePath, totalJobs: this.totalJobs });
-    } catch (error) {
-      this.emit("diskSaveError", error);
-      throw error;
-    }
-  }
-  /**
-   * 디스크에서 큐 상태 로드
-   */
-  async loadFromDisk() {
-    if (!this.config.diskPath) return;
-    try {
-      const filePath = path.join(this.config.diskPath, "webhook-queue.json");
-      const json = await fs.readFile(filePath, "utf8");
-      const data = JSON.parse(json);
-      this.highPriorityQueue.length = 0;
-      this.mediumPriorityQueue.length = 0;
-      this.lowPriorityQueue.length = 0;
-      this.highPriorityQueue.push(...data.queues.high || []);
-      this.mediumPriorityQueue.push(...data.queues.medium || []);
-      this.lowPriorityQueue.push(...data.queues.low || []);
-      this.totalJobs = data.totalJobs || 0;
-      this.emit("diskLoaded", {
-        filePath,
-        totalJobs: this.totalJobs,
-        timestamp: data.timestamp
-      });
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        this.emit("diskLoadError", error);
-      }
-    }
-  }
-  /**
-   * 큐 관리자 종료
-   */
-  async shutdown() {
-    for (const timeout of this.delayedJobs.values()) {
-      clearTimeout(timeout);
-    }
-    this.delayedJobs.clear();
-    if (this.config.persistToDisk) {
-      await this.saveToDisk().catch((error) => {
-        this.emit("diskSaveError", error);
-      });
-    }
-    this.emit("shutdown", { totalJobs: this.totalJobs });
-  }
-};
-
-// src/dispatcher/load-balancer.ts
-var import_events3 = require("events");
-var LoadBalancer = class extends import_events3.EventEmitter {
-  config;
-  endpointHealth = /* @__PURE__ */ new Map();
-  circuitBreakers = /* @__PURE__ */ new Map();
-  connectionCounts = /* @__PURE__ */ new Map();
-  roundRobinIndex = 0;
-  healthCheckInterval = null;
-  defaultConfig = {
-    strategy: "round-robin",
-    healthCheckInterval: 3e4,
-    // 30초
-    healthCheckTimeoutMs: 5e3,
-    weights: {}
-  };
-  constructor(config = {}) {
-    super();
-    this.config = { ...this.defaultConfig, ...config };
-    this.startHealthChecks();
-  }
-  /**
-   * 엔드포인트 등록
-   */
-  async registerEndpoint(endpoint) {
-    const health = {
-      endpointId: endpoint.id,
-      isHealthy: true,
-      consecutiveFailures: 0,
-      lastHealthCheckAt: /* @__PURE__ */ new Date(),
-      averageResponseTime: 0,
-      activeConnections: 0
-    };
-    this.endpointHealth.set(endpoint.id, health);
-    this.connectionCounts.set(endpoint.id, 0);
-    await this.checkEndpointHealth(endpoint);
-    this.emit("endpointRegistered", { endpointId: endpoint.id, isHealthy: health.isHealthy });
-  }
-  /**
-   * 엔드포인트 등록 해제
-   */
-  async unregisterEndpoint(endpointId) {
-    this.endpointHealth.delete(endpointId);
-    this.circuitBreakers.delete(endpointId);
-    this.connectionCounts.delete(endpointId);
-    this.emit("endpointUnregistered", { endpointId });
-  }
-  /**
-   * 로드 밸런싱을 통한 엔드포인트 선택
-   */
-  async selectEndpoint(endpoints) {
-    const healthyEndpoints = endpoints.filter((endpoint) => {
-      const health = this.endpointHealth.get(endpoint.id);
-      const circuitBreaker = this.circuitBreakers.get(endpoint.id);
-      return health?.isHealthy && endpoint.status === "active" && circuitBreaker?.state !== "open";
-    });
-    if (healthyEndpoints.length === 0) {
-      const halfOpenEndpoint = this.tryHalfOpenEndpoint(endpoints);
-      if (halfOpenEndpoint) {
-        return halfOpenEndpoint;
-      }
-      this.emit("noHealthyEndpoints", { totalEndpoints: endpoints.length });
-      return null;
-    }
-    let selectedEndpoint;
-    switch (this.config.strategy) {
-      case "round-robin":
-        selectedEndpoint = this.selectRoundRobin(healthyEndpoints);
-        break;
-      case "least-connections":
-        selectedEndpoint = this.selectLeastConnections(healthyEndpoints);
-        break;
-      case "weighted":
-        selectedEndpoint = this.selectWeighted(healthyEndpoints);
-        break;
-      case "random":
-        selectedEndpoint = this.selectRandom(healthyEndpoints);
-        break;
-      default:
-        selectedEndpoint = healthyEndpoints[0];
-    }
-    this.incrementConnections(selectedEndpoint.id);
-    this.emit("endpointSelected", {
-      endpointId: selectedEndpoint.id,
-      strategy: this.config.strategy,
-      availableEndpoints: healthyEndpoints.length
-    });
-    return selectedEndpoint;
-  }
-  /**
-   * 요청 완료 시 호출 (연결 수 감소 및 통계 업데이트)
-   */
-  async onRequestComplete(endpointId, success, responseTime) {
-    this.decrementConnections(endpointId);
-    const health = this.endpointHealth.get(endpointId);
-    if (health) {
-      if (health.averageResponseTime === 0) {
-        health.averageResponseTime = responseTime;
-      } else {
-        health.averageResponseTime = health.averageResponseTime * 0.8 + responseTime * 0.2;
-      }
-      if (success) {
-        health.consecutiveFailures = 0;
-        health.isHealthy = true;
-        const circuitBreaker = this.circuitBreakers.get(endpointId);
-        if (circuitBreaker) {
-          if (circuitBreaker.state === "half-open") {
-            circuitBreaker.state = "closed";
-            circuitBreaker.failureCount = 0;
-            this.emit("circuitBreakerClosed", { endpointId });
-          }
-        }
-      } else {
-        health.consecutiveFailures++;
-        if (health.consecutiveFailures >= 3) {
-          health.isHealthy = false;
-          this.emit("endpointUnhealthy", { endpointId, consecutiveFailures: health.consecutiveFailures });
-        }
-        this.updateCircuitBreaker(endpointId, false);
-      }
-    }
-    this.emit("requestCompleted", {
-      endpointId,
-      success,
-      responseTime,
-      averageResponseTime: health?.averageResponseTime
-    });
-  }
-  /**
-   * 엔드포인트 건강 상태 조회
-   */
-  getEndpointHealth(endpointId) {
-    return this.endpointHealth.get(endpointId) || null;
-  }
-  /**
-   * 모든 엔드포인트 건강 상태 조회
-   */
-  getAllEndpointHealth() {
-    return Array.from(this.endpointHealth.values());
-  }
-  /**
-   * 로드 밸런서 통계 조회
-   */
-  getStats() {
-    const healths = Array.from(this.endpointHealth.values());
-    const totalConnections = Array.from(this.connectionCounts.values()).reduce((sum, count) => sum + count, 0);
-    const circuitBreakersOpen = Array.from(this.circuitBreakers.values()).filter((cb) => cb.state === "open").length;
-    const avgResponseTime = healths.length > 0 ? healths.reduce((sum, h) => sum + h.averageResponseTime, 0) / healths.length : 0;
-    return {
-      totalEndpoints: healths.length,
-      healthyEndpoints: healths.filter((h) => h.isHealthy).length,
-      activeConnections: totalConnections,
-      circuitBreakersOpen,
-      averageResponseTime: avgResponseTime
-    };
-  }
-  /**
-   * Round Robin 전략
-   */
-  selectRoundRobin(endpoints) {
-    const endpoint = endpoints[this.roundRobinIndex % endpoints.length];
-    this.roundRobinIndex = (this.roundRobinIndex + 1) % endpoints.length;
-    return endpoint;
-  }
-  /**
-   * Least Connections 전략
-   */
-  selectLeastConnections(endpoints) {
-    return endpoints.reduce((least, current) => {
-      const leastConnections = this.connectionCounts.get(least.id) || 0;
-      const currentConnections = this.connectionCounts.get(current.id) || 0;
-      return currentConnections < leastConnections ? current : least;
-    });
-  }
-  /**
-   * Weighted 전략
-   */
-  selectWeighted(endpoints) {
-    const weights = this.config.weights || {};
-    const totalWeight = endpoints.reduce((sum, endpoint) => {
-      return sum + (weights[endpoint.id] || 1);
-    }, 0);
-    let random = Math.random() * totalWeight;
-    for (const endpoint of endpoints) {
-      const weight = weights[endpoint.id] || 1;
-      random -= weight;
-      if (random <= 0) {
-        return endpoint;
-      }
-    }
-    return endpoints[0];
-  }
-  /**
-   * Random 전략
-   */
-  selectRandom(endpoints) {
-    const randomIndex = Math.floor(Math.random() * endpoints.length);
-    return endpoints[randomIndex];
-  }
-  /**
-   * Half-open Circuit Breaker 엔드포인트 시도
-   */
-  tryHalfOpenEndpoint(endpoints) {
-    const now = /* @__PURE__ */ new Date();
-    for (const endpoint of endpoints) {
-      const circuitBreaker = this.circuitBreakers.get(endpoint.id);
-      if (circuitBreaker?.state === "open" && circuitBreaker.nextRetryTime && now >= circuitBreaker.nextRetryTime) {
-        circuitBreaker.state = "half-open";
-        this.emit("circuitBreakerHalfOpen", { endpointId: endpoint.id });
-        return endpoint;
-      }
-    }
-    return null;
-  }
-  /**
-   * Circuit Breaker 상태 업데이트
-   */
-  updateCircuitBreaker(endpointId, success) {
-    let circuitBreaker = this.circuitBreakers.get(endpointId);
-    if (!circuitBreaker) {
-      circuitBreaker = {
-        endpointId,
-        state: "closed",
-        failureCount: 0
-      };
-      this.circuitBreakers.set(endpointId, circuitBreaker);
-    }
-    if (!success) {
-      circuitBreaker.failureCount++;
-      circuitBreaker.lastFailureTime = /* @__PURE__ */ new Date();
-      if (circuitBreaker.failureCount >= 5 && circuitBreaker.state === "closed") {
-        circuitBreaker.state = "open";
-        circuitBreaker.nextRetryTime = new Date(Date.now() + 6e4);
-        this.emit("circuitBreakerOpened", {
-          endpointId,
-          failureCount: circuitBreaker.failureCount,
-          nextRetryTime: circuitBreaker.nextRetryTime
-        });
-      }
-    }
-  }
-  /**
-   * 연결 수 증가
-   */
-  incrementConnections(endpointId) {
-    const currentCount = this.connectionCounts.get(endpointId) || 0;
-    this.connectionCounts.set(endpointId, currentCount + 1);
-    const health = this.endpointHealth.get(endpointId);
-    if (health) {
-      health.activeConnections = currentCount + 1;
-    }
-  }
-  /**
-   * 연결 수 감소
-   */
-  decrementConnections(endpointId) {
-    const currentCount = this.connectionCounts.get(endpointId) || 0;
-    const newCount = Math.max(0, currentCount - 1);
-    this.connectionCounts.set(endpointId, newCount);
-    const health = this.endpointHealth.get(endpointId);
-    if (health) {
-      health.activeConnections = newCount;
-    }
-  }
-  /**
-   * 엔드포인트 건강 상태 확인
-   */
-  async checkEndpointHealth(endpoint) {
-    const startTime = Date.now();
-    try {
-      const response = await fetch(endpoint.url, {
-        method: "HEAD",
-        signal: AbortSignal.timeout(this.config.healthCheckTimeoutMs)
-      });
-      const responseTime = Date.now() - startTime;
-      const success = response.ok;
-      await this.onRequestComplete(endpoint.id, success, responseTime);
-      this.emit("healthCheckCompleted", {
-        endpointId: endpoint.id,
-        success,
-        responseTime,
-        httpStatus: response.status
-      });
-    } catch (error) {
-      const responseTime = Date.now() - startTime;
-      await this.onRequestComplete(endpoint.id, false, responseTime);
-      this.emit("healthCheckFailed", {
-        endpointId: endpoint.id,
-        error: error instanceof Error ? error.message : "Unknown error",
-        responseTime
-      });
-    }
-  }
-  /**
-   * 건강 상태 확인 시작
-   */
-  startHealthChecks() {
-    this.healthCheckInterval = setInterval(async () => {
-      const endpoints = Array.from(this.endpointHealth.keys());
-      for (const endpointId of endpoints) {
-        const health = this.endpointHealth.get(endpointId);
-        if (health) {
-          const mockEndpoint = {
-            id: endpointId,
-            url: `https://webhook.example.com/${endpointId}`,
-            active: true,
-            events: [],
-            createdAt: /* @__PURE__ */ new Date(),
-            updatedAt: /* @__PURE__ */ new Date(),
-            status: "active"
-          };
-          await this.checkEndpointHealth(mockEndpoint);
-        }
-      }
-    }, this.config.healthCheckInterval);
-  }
-  /**
-   * 로드 밸런서 종료
-   */
-  async shutdown() {
-    if (this.healthCheckInterval) {
-      clearInterval(this.healthCheckInterval);
-      this.healthCheckInterval = null;
-    }
-    this.emit("shutdown", {
-      totalEndpoints: this.endpointHealth.size,
-      activeConnections: Array.from(this.connectionCounts.values()).reduce((sum, count) => sum + count, 0)
-    });
-  }
-};
-
-// src/registry/endpoint.manager.ts
-var import_events4 = require("events");
-var fs2 = __toESM(require("fs/promises"), 1);
-var path2 = __toESM(require("path"), 1);
-var EndpointManager = class extends import_events4.EventEmitter {
-  config;
-  endpoints = /* @__PURE__ */ new Map();
-  indexByUrl = /* @__PURE__ */ new Map();
-  // url -> id
-  indexByEvent = /* @__PURE__ */ new Map();
-  // event -> endpoint ids
-  indexByStatus = /* @__PURE__ */ new Map();
-  // status -> endpoint ids
-  defaultConfig = {
-    type: "memory",
-    retentionDays: 90,
-    enableEncryption: false
-  };
-  constructor(config = {}) {
-    super();
-    this.config = { ...this.defaultConfig, ...config };
-    this.initializeIndexes();
-    if (this.config.type === "file" && this.config.filePath) {
-      this.loadFromFile().catch((error) => {
-        this.emit("loadError", error);
-      });
-    }
-  }
-  /**
-   * 엔드포인트 추가
-   */
-  async addEndpoint(endpoint) {
-    if (this.indexByUrl.has(endpoint.url)) {
-      const existingId = this.indexByUrl.get(endpoint.url);
-      if (existingId !== endpoint.id) {
-        throw new Error(`Endpoint with URL ${endpoint.url} already exists with different ID`);
-      }
-    }
-    const existingEndpoint = this.endpoints.get(endpoint.id);
-    if (existingEndpoint) {
-      this.removeFromIndexes(existingEndpoint);
-    }
-    this.endpoints.set(endpoint.id, endpoint);
-    this.addToIndexes(endpoint);
-    if (this.config.type === "file") {
-      await this.saveToFile();
-    }
-    this.emit("endpointAdded", { endpointId: endpoint.id, url: endpoint.url });
-  }
-  /**
-   * 엔드포인트 업데이트
-   */
-  async updateEndpoint(endpointId, updates) {
-    const existingEndpoint = this.endpoints.get(endpointId);
-    if (!existingEndpoint) {
-      throw new Error(`Endpoint ${endpointId} not found`);
-    }
-    if (updates.url && updates.url !== existingEndpoint.url) {
-      if (this.indexByUrl.has(updates.url)) {
-        const existingId = this.indexByUrl.get(updates.url);
-        if (existingId !== endpointId) {
-          throw new Error(`Endpoint with URL ${updates.url} already exists`);
-        }
-      }
-    }
-    this.removeFromIndexes(existingEndpoint);
-    const updatedEndpoint = {
-      ...existingEndpoint,
-      ...updates,
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    this.endpoints.set(endpointId, updatedEndpoint);
-    this.addToIndexes(updatedEndpoint);
-    if (this.config.type === "file") {
-      await this.saveToFile();
-    }
-    this.emit("endpointUpdated", {
-      endpointId,
-      changes: Object.keys(updates),
-      oldUrl: existingEndpoint.url,
-      newUrl: updatedEndpoint.url
-    });
-    return updatedEndpoint;
-  }
-  /**
-   * 엔드포인트 제거
-   */
-  async removeEndpoint(endpointId) {
-    const endpoint = this.endpoints.get(endpointId);
-    if (!endpoint) {
-      return false;
-    }
-    this.removeFromIndexes(endpoint);
-    this.endpoints.delete(endpointId);
-    if (this.config.type === "file") {
-      await this.saveToFile();
-    }
-    this.emit("endpointRemoved", { endpointId, url: endpoint.url });
-    return true;
-  }
-  /**
-   * 엔드포인트 조회
-   */
-  async getEndpoint(endpointId) {
-    return this.endpoints.get(endpointId) || null;
-  }
-  /**
-   * URL로 엔드포인트 조회
-   */
-  async getEndpointByUrl(url) {
-    const endpointId = this.indexByUrl.get(url);
-    return endpointId ? this.endpoints.get(endpointId) || null : null;
-  }
-  /**
-   * 필터 조건에 맞는 엔드포인트 검색
-   */
-  async searchEndpoints(filter = {}, pagination = { page: 1, limit: 100 }) {
-    let candidateIds = null;
-    if (filter.status) {
-      const statusIds = this.indexByStatus.get(filter.status);
-      candidateIds = statusIds ? new Set(statusIds) : /* @__PURE__ */ new Set();
-    }
-    if (filter.events && filter.events.length > 0) {
-      const eventIds = /* @__PURE__ */ new Set();
-      for (const eventType of filter.events) {
-        const ids = this.indexByEvent.get(eventType);
-        if (ids) {
-          ids.forEach((id) => eventIds.add(id));
-        }
-      }
-      if (candidateIds) {
-        candidateIds = new Set(Array.from(candidateIds).filter((id) => eventIds.has(id)));
-      } else {
-        candidateIds = eventIds;
-      }
-    }
-    if (!candidateIds) {
-      candidateIds = new Set(this.endpoints.keys());
-    }
-    const filteredEndpoints = Array.from(candidateIds).map((id) => this.endpoints.get(id)).filter((endpoint) => this.matchesFilter(endpoint, filter));
-    if (pagination.sortBy) {
-      filteredEndpoints.sort((a, b) => {
-        const aValue = this.getFieldValue(a, pagination.sortBy);
-        const bValue = this.getFieldValue(b, pagination.sortBy);
-        let comparison = 0;
-        if (aValue < bValue) comparison = -1;
-        else if (aValue > bValue) comparison = 1;
-        return pagination.sortOrder === "desc" ? -comparison : comparison;
-      });
-    }
-    const totalCount = filteredEndpoints.length;
-    const totalPages = Math.ceil(totalCount / pagination.limit);
-    const startIndex = (pagination.page - 1) * pagination.limit;
-    const endIndex = startIndex + pagination.limit;
-    const items = filteredEndpoints.slice(startIndex, endIndex);
-    return {
-      items,
-      totalCount,
-      page: pagination.page,
-      totalPages,
-      hasNext: pagination.page < totalPages,
-      hasPrevious: pagination.page > 1
-    };
-  }
-  /**
-   * 특정 이벤트 타입을 구독하는 활성 엔드포인트 조회
-   */
-  async getActiveEndpointsForEvent(eventType) {
-    const endpointIds = this.indexByEvent.get(eventType);
-    if (!endpointIds) {
-      return [];
-    }
-    return Array.from(endpointIds).map((id) => this.endpoints.get(id)).filter((endpoint) => endpoint.status === "active");
-  }
-  /**
-   * 엔드포인트 통계 조회
-   */
-  getStats() {
-    const total = this.endpoints.size;
-    const active = this.indexByStatus.get("active")?.size || 0;
-    const inactive = this.indexByStatus.get("inactive")?.size || 0;
-    const error = this.indexByStatus.get("error")?.size || 0;
-    const suspended = this.indexByStatus.get("suspended")?.size || 0;
-    const eventSubscriptions = {};
-    for (const [eventType, endpointIds] of this.indexByEvent.entries()) {
-      eventSubscriptions[eventType] = endpointIds.size;
-    }
-    return {
-      totalEndpoints: total,
-      activeEndpoints: active,
-      inactiveEndpoints: inactive,
-      errorEndpoints: error,
-      suspendedEndpoints: suspended,
-      eventSubscriptions
-    };
-  }
-  /**
-   * 만료된 엔드포인트 정리
-   */
-  async cleanupExpiredEndpoints() {
-    if (!this.config.retentionDays) {
-      return 0;
-    }
-    const cutoffDate = /* @__PURE__ */ new Date();
-    cutoffDate.setDate(cutoffDate.getDate() - this.config.retentionDays);
-    const expiredEndpoints = Array.from(this.endpoints.values()).filter((endpoint) => {
-      return endpoint.status === "inactive" && (!endpoint.lastTriggeredAt || endpoint.lastTriggeredAt < cutoffDate);
-    });
-    for (const endpoint of expiredEndpoints) {
-      await this.removeEndpoint(endpoint.id);
-    }
-    if (expiredEndpoints.length > 0) {
-      this.emit("expiredEndpointsCleanup", {
-        removedCount: expiredEndpoints.length,
-        cutoffDate
-      });
-    }
-    return expiredEndpoints.length;
-  }
-  /**
-   * 인덱스 초기화
-   */
-  initializeIndexes() {
-    const eventTypes = Object.values(WebhookEventType);
-    for (const eventType of eventTypes) {
-      this.indexByEvent.set(eventType, /* @__PURE__ */ new Set());
-    }
-    const statuses = ["active", "inactive", "error", "suspended"];
-    for (const status of statuses) {
-      this.indexByStatus.set(status, /* @__PURE__ */ new Set());
-    }
-  }
-  /**
-   * 인덱스에 엔드포인트 추가
-   */
-  addToIndexes(endpoint) {
-    this.indexByUrl.set(endpoint.url, endpoint.id);
-    const statusSet = this.indexByStatus.get(endpoint.status);
-    if (statusSet) {
-      statusSet.add(endpoint.id);
-    }
-    for (const eventType of endpoint.events) {
-      const eventSet = this.indexByEvent.get(eventType);
-      if (eventSet) {
-        eventSet.add(endpoint.id);
-      }
-    }
-  }
-  /**
-   * 인덱스에서 엔드포인트 제거
-   */
-  removeFromIndexes(endpoint) {
-    this.indexByUrl.delete(endpoint.url);
-    const statusSet = this.indexByStatus.get(endpoint.status);
-    if (statusSet) {
-      statusSet.delete(endpoint.id);
-    }
-    for (const eventType of endpoint.events) {
-      const eventSet = this.indexByEvent.get(eventType);
-      if (eventSet) {
-        eventSet.delete(endpoint.id);
-      }
-    }
-  }
-  /**
-   * 필터 조건 매칭 확인
-   */
-  matchesFilter(endpoint, filter) {
-    if (filter.providerId && filter.providerId.length > 0) {
-      const hasMatchingProvider = filter.providerId.some(
-        (providerId) => endpoint.filters?.providerId?.includes(providerId)
-      );
-      if (!hasMatchingProvider) return false;
-    }
-    if (filter.channelId && filter.channelId.length > 0) {
-      const hasMatchingChannel = filter.channelId.some(
-        (channelId) => endpoint.filters?.channelId?.includes(channelId)
-      );
-      if (!hasMatchingChannel) return false;
-    }
-    if (filter.createdAfter && endpoint.createdAt < filter.createdAfter) {
-      return false;
-    }
-    if (filter.createdBefore && endpoint.createdAt > filter.createdBefore) {
-      return false;
-    }
-    if (filter.lastTriggeredAfter && (!endpoint.lastTriggeredAt || endpoint.lastTriggeredAt < filter.lastTriggeredAfter)) {
-      return false;
-    }
-    if (filter.lastTriggeredBefore && (!endpoint.lastTriggeredAt || endpoint.lastTriggeredAt > filter.lastTriggeredBefore)) {
-      return false;
-    }
-    return true;
-  }
-  /**
-   * 객체 필드 값 가져오기 (정렬용)
-   */
-  getFieldValue(obj, fieldPath) {
-    return fieldPath.split(".").reduce((value, key) => value?.[key], obj);
-  }
-  /**
-   * 파일에서 데이터 로드
-   */
-  async loadFromFile() {
-    if (!this.config.filePath) return;
-    try {
-      const data = await fs2.readFile(this.config.filePath, "utf8");
-      const parsed = JSON.parse(data);
-      for (const endpointData of parsed.endpoints || []) {
-        const endpoint = {
-          ...endpointData,
-          createdAt: new Date(endpointData.createdAt),
-          updatedAt: new Date(endpointData.updatedAt),
-          lastTriggeredAt: endpointData.lastTriggeredAt ? new Date(endpointData.lastTriggeredAt) : void 0
-        };
-        this.endpoints.set(endpoint.id, endpoint);
-        this.addToIndexes(endpoint);
-      }
-      this.emit("dataLoaded", {
-        filePath: this.config.filePath,
-        endpointCount: this.endpoints.size
-      });
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        this.emit("loadError", error);
-      }
-    }
-  }
-  /**
-   * 파일에 데이터 저장
-   */
-  async saveToFile() {
-    if (!this.config.filePath) return;
-    try {
-      const data = {
-        endpoints: Array.from(this.endpoints.values()),
-        savedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      const json = JSON.stringify(data, null, 2);
-      await fs2.mkdir(path2.dirname(this.config.filePath), { recursive: true });
-      await fs2.writeFile(this.config.filePath, json, "utf8");
-      this.emit("dataSaved", {
-        filePath: this.config.filePath,
-        endpointCount: this.endpoints.size
-      });
-    } catch (error) {
-      this.emit("saveError", error);
-      throw error;
-    }
-  }
-  /**
-   * 엔드포인트 관리자 종료
-   */
-  async shutdown() {
-    if (this.config.type === "file") {
-      await this.saveToFile().catch((error) => {
-        this.emit("saveError", error);
-      });
-    }
-    this.emit("shutdown", { endpointCount: this.endpoints.size });
-  }
-};
-
-// src/registry/delivery.store.ts
-var import_events5 = require("events");
-var fs3 = __toESM(require("fs/promises"), 1);
-var path3 = __toESM(require("path"), 1);
-var DeliveryStore = class extends import_events5.EventEmitter {
-  config;
-  deliveries = /* @__PURE__ */ new Map();
-  indexByEndpoint = /* @__PURE__ */ new Map();
-  // endpointId -> delivery ids
-  indexByStatus = /* @__PURE__ */ new Map();
-  // status -> delivery ids
-  indexByDate = /* @__PURE__ */ new Map();
-  // YYYY-MM-DD -> delivery ids
-  cleanupInterval = null;
-  defaultConfig = {
-    type: "memory",
-    retentionDays: 30,
-    enableCompression: false,
-    maxMemoryUsage: 100 * 1024 * 1024
-    // 100MB
-  };
-  constructor(config = {}) {
-    super();
-    this.config = { ...this.defaultConfig, ...config };
-    this.initializeIndexes();
-    this.startCleanupTask();
-    if (this.config.type === "file" && this.config.filePath) {
-      this.loadFromFile().catch((error) => {
-        this.emit("loadError", error);
-      });
-    }
-  }
-  /**
-   * 전달 기록 저장
-   */
-  async saveDelivery(delivery) {
-    const existingDelivery = this.deliveries.get(delivery.id);
-    if (existingDelivery) {
-      this.removeFromIndexes(existingDelivery);
-    }
-    if (this.config.type === "memory" && this.config.maxMemoryUsage) {
-      await this.checkMemoryUsage();
-    }
-    this.deliveries.set(delivery.id, delivery);
-    this.addToIndexes(delivery);
-    if (this.config.type === "file") {
-      await this.appendToFile(delivery);
-    }
-    this.emit("deliverySaved", {
-      deliveryId: delivery.id,
-      endpointId: delivery.endpointId,
-      status: delivery.status
-    });
-  }
-  /**
-   * 전달 기록 조회
-   */
-  async getDelivery(deliveryId) {
-    return this.deliveries.get(deliveryId) || null;
-  }
-  /**
-   * 필터 조건에 맞는 전달 기록 검색
-   */
-  async searchDeliveries(filter = {}, pagination = { page: 1, limit: 100 }) {
-    let candidateIds = null;
-    if (filter.endpointId) {
-      const endpointIds = this.indexByEndpoint.get(filter.endpointId);
-      candidateIds = endpointIds ? new Set(endpointIds) : /* @__PURE__ */ new Set();
-    }
-    if (filter.status) {
-      const statusIds = this.indexByStatus.get(filter.status);
-      if (candidateIds) {
-        candidateIds = new Set(Array.from(candidateIds).filter((id) => statusIds?.has(id)));
-      } else {
-        candidateIds = statusIds ? new Set(statusIds) : /* @__PURE__ */ new Set();
-      }
-    }
-    if (filter.createdAfter || filter.createdBefore) {
-      const dateIds = this.getDeliveryIdsByDateRange(filter.createdAfter, filter.createdBefore);
-      if (candidateIds) {
-        candidateIds = new Set(Array.from(candidateIds).filter((id) => dateIds.has(id)));
-      } else {
-        candidateIds = dateIds;
-      }
-    }
-    if (!candidateIds) {
-      candidateIds = new Set(this.deliveries.keys());
-    }
-    const filteredDeliveries = Array.from(candidateIds).map((id) => this.deliveries.get(id)).filter((delivery) => this.matchesFilter(delivery, filter));
-    filteredDeliveries.sort((a, b) => {
-      if (pagination.sortBy === "createdAt" || !pagination.sortBy) {
-        const comparison2 = b.createdAt.getTime() - a.createdAt.getTime();
-        return pagination.sortOrder === "asc" ? -comparison2 : comparison2;
-      }
-      const aValue = this.getFieldValue(a, pagination.sortBy);
-      const bValue = this.getFieldValue(b, pagination.sortBy);
-      let comparison = 0;
-      if (aValue < bValue) comparison = -1;
-      else if (aValue > bValue) comparison = 1;
-      return pagination.sortOrder === "desc" ? -comparison : comparison;
-    });
-    const totalCount = filteredDeliveries.length;
-    const totalPages = Math.ceil(totalCount / pagination.limit);
-    const startIndex = (pagination.page - 1) * pagination.limit;
-    const endIndex = startIndex + pagination.limit;
-    const items = filteredDeliveries.slice(startIndex, endIndex);
-    return {
-      items,
-      totalCount,
-      page: pagination.page,
-      totalPages,
-      hasNext: pagination.page < totalPages,
-      hasPrevious: pagination.page > 1
-    };
-  }
-  /**
-   * 엔드포인트별 전달 기록 조회
-   */
-  async getDeliveriesByEndpoint(endpointId, limit = 100) {
-    const deliveryIds = this.indexByEndpoint.get(endpointId);
-    if (!deliveryIds) {
-      return [];
-    }
-    return Array.from(deliveryIds).map((id) => this.deliveries.get(id)).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime()).slice(0, limit);
-  }
-  /**
-   * 실패한 전달 기록 조회
-   */
-  async getFailedDeliveries(endpointId, limit = 100) {
-    const filter = {
-      status: "failed",
-      endpointId
-    };
-    const result = await this.searchDeliveries(filter, { page: 1, limit });
-    return result.items;
-  }
-  /**
-   * 전달 통계 조회
-   */
-  async getDeliveryStats(endpointId, timeRange) {
-    const filter = {
-      endpointId,
-      createdAfter: timeRange?.start,
-      createdBefore: timeRange?.end
-    };
-    const result = await this.searchDeliveries(filter, { page: 1, limit: 1e4 });
-    const deliveries = result.items;
-    const successful = deliveries.filter((d) => d.status === "success");
-    const failed = deliveries.filter((d) => d.status === "failed");
-    const pending = deliveries.filter((d) => d.status === "pending");
-    const exhausted = deliveries.filter((d) => d.status === "exhausted");
-    const completedDeliveries = deliveries.filter((d) => d.completedAt);
-    const totalLatency = completedDeliveries.reduce((sum, delivery) => {
-      const lastAttempt = delivery.attempts[delivery.attempts.length - 1];
-      return sum + (lastAttempt?.latencyMs || 0);
-    }, 0);
-    const averageLatency = completedDeliveries.length > 0 ? totalLatency / completedDeliveries.length : 0;
-    const errorBreakdown = {};
-    for (const delivery of [...failed, ...exhausted]) {
-      const lastAttempt = delivery.attempts[delivery.attempts.length - 1];
-      if (lastAttempt?.error) {
-        errorBreakdown[lastAttempt.error] = (errorBreakdown[lastAttempt.error] || 0) + 1;
-      } else if (lastAttempt?.httpStatus) {
-        const errorKey = `HTTP ${lastAttempt.httpStatus}`;
-        errorBreakdown[errorKey] = (errorBreakdown[errorKey] || 0) + 1;
-      }
-    }
-    return {
-      totalDeliveries: deliveries.length,
-      successfulDeliveries: successful.length,
-      failedDeliveries: failed.length,
-      pendingDeliveries: pending.length,
-      exhaustedDeliveries: exhausted.length,
-      averageLatency,
-      successRate: deliveries.length > 0 ? successful.length / deliveries.length * 100 : 0,
-      errorBreakdown
-    };
-  }
-  /**
-   * 오래된 전달 기록 정리
-   */
-  async cleanupOldDeliveries() {
-    if (!this.config.retentionDays) {
-      return 0;
-    }
-    const cutoffDate = /* @__PURE__ */ new Date();
-    cutoffDate.setDate(cutoffDate.getDate() - this.config.retentionDays);
-    const oldDeliveries = Array.from(this.deliveries.values()).filter(
-      (delivery) => delivery.createdAt < cutoffDate
-    );
-    for (const delivery of oldDeliveries) {
-      this.removeFromIndexes(delivery);
-      this.deliveries.delete(delivery.id);
-    }
-    if (oldDeliveries.length > 0) {
-      this.emit("oldDeliveriesCleanup", {
-        removedCount: oldDeliveries.length,
-        cutoffDate
-      });
-      if (this.config.type === "file") {
-        await this.saveToFile();
-      }
-    }
-    return oldDeliveries.length;
-  }
-  /**
-   * 저장소 통계 조회
-   */
-  getStorageStats() {
-    const memoryUsage = this.estimateMemoryUsage();
-    return {
-      totalDeliveries: this.deliveries.size,
-      memoryUsage,
-      indexSizes: {
-        byEndpoint: this.indexByEndpoint.size,
-        byStatus: this.indexByStatus.size,
-        byDate: this.indexByDate.size
-      }
-    };
-  }
-  /**
-   * 인덱스 초기화
-   */
-  initializeIndexes() {
-    const statuses = ["pending", "success", "failed", "exhausted"];
-    for (const status of statuses) {
-      this.indexByStatus.set(status, /* @__PURE__ */ new Set());
-    }
-  }
-  /**
-   * 인덱스에 전달 기록 추가
-   */
-  addToIndexes(delivery) {
-    if (!this.indexByEndpoint.has(delivery.endpointId)) {
-      this.indexByEndpoint.set(delivery.endpointId, /* @__PURE__ */ new Set());
-    }
-    this.indexByEndpoint.get(delivery.endpointId).add(delivery.id);
-    const statusSet = this.indexByStatus.get(delivery.status);
-    if (statusSet) {
-      statusSet.add(delivery.id);
-    }
-    const dateKey = delivery.createdAt.toISOString().split("T")[0];
-    if (!this.indexByDate.has(dateKey)) {
-      this.indexByDate.set(dateKey, /* @__PURE__ */ new Set());
-    }
-    this.indexByDate.get(dateKey).add(delivery.id);
-  }
-  /**
-   * 인덱스에서 전달 기록 제거
-   */
-  removeFromIndexes(delivery) {
-    const endpointSet = this.indexByEndpoint.get(delivery.endpointId);
-    if (endpointSet) {
-      endpointSet.delete(delivery.id);
-      if (endpointSet.size === 0) {
-        this.indexByEndpoint.delete(delivery.endpointId);
-      }
-    }
-    const statusSet = this.indexByStatus.get(delivery.status);
-    if (statusSet) {
-      statusSet.delete(delivery.id);
-    }
-    const dateKey = delivery.createdAt.toISOString().split("T")[0];
-    const dateSet = this.indexByDate.get(dateKey);
-    if (dateSet) {
-      dateSet.delete(delivery.id);
-      if (dateSet.size === 0) {
-        this.indexByDate.delete(dateKey);
-      }
-    }
-  }
-  /**
-   * 날짜 범위로 전달 기록 ID 조회
-   */
-  getDeliveryIdsByDateRange(startDate, endDate) {
-    const ids = /* @__PURE__ */ new Set();
-    for (const [dateKey, deliveryIds] of this.indexByDate.entries()) {
-      const date = new Date(dateKey);
-      if (startDate && date < startDate) continue;
-      if (endDate && date > endDate) continue;
-      deliveryIds.forEach((id) => ids.add(id));
-    }
-    return ids;
-  }
-  /**
-   * 필터 조건 매칭 확인
-   */
-  matchesFilter(delivery, filter) {
-    if (filter.eventId && delivery.eventId !== filter.eventId) {
-      return false;
-    }
-    if (filter.httpStatusCode && filter.httpStatusCode.length > 0) {
-      const lastAttempt = delivery.attempts[delivery.attempts.length - 1];
-      if (!lastAttempt?.httpStatus || !filter.httpStatusCode.includes(lastAttempt.httpStatus)) {
-        return false;
-      }
-    }
-    if (filter.hasError !== void 0) {
-      const hasError = delivery.attempts.some((attempt) => attempt.error);
-      if (filter.hasError !== hasError) {
-        return false;
-      }
-    }
-    if (filter.completedAfter && (!delivery.completedAt || delivery.completedAt < filter.completedAfter)) {
-      return false;
-    }
-    if (filter.completedBefore && (!delivery.completedAt || delivery.completedAt > filter.completedBefore)) {
-      return false;
-    }
-    return true;
-  }
-  /**
-   * 객체 필드 값 가져오기
-   */
-  getFieldValue(obj, fieldPath) {
-    return fieldPath.split(".").reduce((value, key) => value?.[key], obj);
-  }
-  /**
-   * 메모리 사용량 추정
-   */
-  estimateMemoryUsage() {
-    let totalSize = 0;
-    for (const delivery of this.deliveries.values()) {
-      totalSize += JSON.stringify(delivery).length * 2;
-    }
-    return totalSize;
-  }
-  /**
-   * 메모리 사용량 확인 및 정리
-   */
-  async checkMemoryUsage() {
-    if (!this.config.maxMemoryUsage) return;
-    const currentUsage = this.estimateMemoryUsage();
-    if (currentUsage > this.config.maxMemoryUsage) {
-      const deliveries = Array.from(this.deliveries.values()).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
-      let removedCount = 0;
-      const targetUsage = this.config.maxMemoryUsage * 0.8;
-      for (const delivery of deliveries) {
-        if (this.estimateMemoryUsage() <= targetUsage) break;
-        this.removeFromIndexes(delivery);
-        this.deliveries.delete(delivery.id);
-        removedCount++;
-      }
-      if (removedCount > 0) {
-        this.emit("memoryCleanup", {
-          removedCount,
-          previousUsage: currentUsage,
-          currentUsage: this.estimateMemoryUsage()
-        });
-      }
-    }
-  }
-  /**
-   * 정리 작업 시작
-   */
-  startCleanupTask() {
-    this.cleanupInterval = setInterval(async () => {
-      try {
-        await this.cleanupOldDeliveries();
-        await this.checkMemoryUsage();
-      } catch (error) {
-        this.emit("cleanupError", error);
-      }
-    }, 60 * 60 * 1e3);
-  }
-  /**
-   * 파일에 전달 기록 추가
-   */
-  async appendToFile(delivery) {
-    if (!this.config.filePath) return;
-    try {
-      const line = JSON.stringify(delivery) + "\n";
-      await fs3.appendFile(this.config.filePath, line, "utf8");
-    } catch (error) {
-      this.emit("appendError", error);
-    }
-  }
-  /**
-   * 파일에서 데이터 로드
-   */
-  async loadFromFile() {
-    if (!this.config.filePath) return;
-    try {
-      const data = await fs3.readFile(this.config.filePath, "utf8");
-      const lines = data.trim().split("\n").filter((line) => line.trim());
-      for (const line of lines) {
-        try {
-          const deliveryData = JSON.parse(line);
-          const delivery = {
-            ...deliveryData,
-            createdAt: new Date(deliveryData.createdAt),
-            completedAt: deliveryData.completedAt ? new Date(deliveryData.completedAt) : void 0,
-            nextRetryAt: deliveryData.nextRetryAt ? new Date(deliveryData.nextRetryAt) : void 0,
-            attempts: deliveryData.attempts.map((attempt) => ({
-              ...attempt,
-              timestamp: new Date(attempt.timestamp)
-            }))
-          };
-          this.deliveries.set(delivery.id, delivery);
-          this.addToIndexes(delivery);
-        } catch (parseError) {
-          this.emit("parseError", { line, error: parseError });
-        }
-      }
-      this.emit("dataLoaded", {
-        filePath: this.config.filePath,
-        deliveryCount: this.deliveries.size
-      });
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        this.emit("loadError", error);
-      }
-    }
-  }
-  /**
-   * 파일에 데이터 저장
-   */
-  async saveToFile() {
-    if (!this.config.filePath) return;
-    try {
-      const lines = Array.from(this.deliveries.values()).map((delivery) => JSON.stringify(delivery)).join("\n");
-      await fs3.mkdir(path3.dirname(this.config.filePath), { recursive: true });
-      await fs3.writeFile(this.config.filePath, lines + "\n", "utf8");
-      this.emit("dataSaved", {
-        filePath: this.config.filePath,
-        deliveryCount: this.deliveries.size
-      });
-    } catch (error) {
-      this.emit("saveError", error);
-      throw error;
-    }
-  }
-  /**
-   * 전달 저장소 종료
-   */
-  async shutdown() {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-    if (this.config.type === "file") {
-      await this.saveToFile().catch((error) => {
-        this.emit("saveError", error);
-      });
-    }
-    this.emit("shutdown", { deliveryCount: this.deliveries.size });
-  }
-};
-
-// src/registry/event.store.ts
-var import_events6 = require("events");
-var fs4 = __toESM(require("fs/promises"), 1);
-var path4 = __toESM(require("path"), 1);
-var EventStore = class extends import_events6.EventEmitter {
-  config;
-  events = /* @__PURE__ */ new Map();
-  indexByType = /* @__PURE__ */ new Map();
-  indexByDate = /* @__PURE__ */ new Map();
-  // YYYY-MM-DD -> event ids
-  indexByProvider = /* @__PURE__ */ new Map();
-  indexByChannel = /* @__PURE__ */ new Map();
-  cleanupInterval = null;
-  defaultConfig = {
-    type: "memory",
-    retentionDays: 7,
-    enableCompression: false,
-    maxMemoryUsage: 50 * 1024 * 1024
-    // 50MB
-  };
-  constructor(config = {}) {
-    super();
-    this.config = { ...this.defaultConfig, ...config };
-    this.initializeIndexes();
-    this.startCleanupTask();
-    if (this.config.type === "file" && this.config.filePath) {
-      this.loadFromFile().catch((error) => {
-        this.emit("loadError", error);
-      });
-    }
-  }
-  /**
-   * 이벤트 저장
-   */
-  async saveEvent(event) {
-    if (this.events.has(event.id)) {
-      this.emit("duplicateEvent", { eventId: event.id });
-      return;
-    }
-    if (this.config.type === "memory" && this.config.maxMemoryUsage) {
-      await this.checkMemoryUsage();
-    }
-    this.events.set(event.id, event);
-    this.addToIndexes(event);
-    if (this.config.type === "file") {
-      await this.appendToFile(event);
-    }
-    this.emit("eventSaved", {
-      eventId: event.id,
-      type: event.type,
-      providerId: event.metadata.providerId
-    });
-  }
-  /**
-   * 이벤트 조회
-   */
-  async getEvent(eventId) {
-    return this.events.get(eventId) || null;
-  }
-  /**
-   * 필터 조건에 맞는 이벤트 검색
-   */
-  async searchEvents(filter = {}, pagination = { page: 1, limit: 100 }) {
-    let candidateIds = null;
-    if (filter.type && filter.type.length > 0) {
-      const typeIds = /* @__PURE__ */ new Set();
-      for (const eventType of filter.type) {
-        const ids = this.indexByType.get(eventType);
-        if (ids) {
-          ids.forEach((id) => typeIds.add(id));
-        }
-      }
-      candidateIds = typeIds;
-    }
-    if (filter.providerId && filter.providerId.length > 0) {
-      const providerIds = /* @__PURE__ */ new Set();
-      for (const providerId of filter.providerId) {
-        const ids = this.indexByProvider.get(providerId);
-        if (ids) {
-          ids.forEach((id) => providerIds.add(id));
-        }
-      }
-      if (candidateIds) {
-        candidateIds = new Set(Array.from(candidateIds).filter((id) => providerIds.has(id)));
-      } else {
-        candidateIds = providerIds;
-      }
-    }
-    if (filter.channelId && filter.channelId.length > 0) {
-      const channelIds = /* @__PURE__ */ new Set();
-      for (const channelId of filter.channelId) {
-        const ids = this.indexByChannel.get(channelId);
-        if (ids) {
-          ids.forEach((id) => channelIds.add(id));
-        }
-      }
-      if (candidateIds) {
-        candidateIds = new Set(Array.from(candidateIds).filter((id) => channelIds.has(id)));
-      } else {
-        candidateIds = channelIds;
-      }
-    }
-    if (filter.createdAfter || filter.createdBefore) {
-      const dateIds = this.getEventIdsByDateRange(filter.createdAfter, filter.createdBefore);
-      if (candidateIds) {
-        candidateIds = new Set(Array.from(candidateIds).filter((id) => dateIds.has(id)));
-      } else {
-        candidateIds = dateIds;
-      }
-    }
-    if (!candidateIds) {
-      candidateIds = new Set(this.events.keys());
-    }
-    const filteredEvents = Array.from(candidateIds).map((id) => this.events.get(id)).filter((event) => this.matchesFilter(event, filter));
-    filteredEvents.sort((a, b) => {
-      if (pagination.sortBy === "timestamp" || !pagination.sortBy) {
-        const comparison2 = b.timestamp.getTime() - a.timestamp.getTime();
-        return pagination.sortOrder === "asc" ? -comparison2 : comparison2;
-      }
-      const aValue = this.getFieldValue(a, pagination.sortBy);
-      const bValue = this.getFieldValue(b, pagination.sortBy);
-      let comparison = 0;
-      if (aValue < bValue) comparison = -1;
-      else if (aValue > bValue) comparison = 1;
-      return pagination.sortOrder === "desc" ? -comparison : comparison;
-    });
-    const totalCount = filteredEvents.length;
-    const totalPages = Math.ceil(totalCount / pagination.limit);
-    const startIndex = (pagination.page - 1) * pagination.limit;
-    const endIndex = startIndex + pagination.limit;
-    const items = filteredEvents.slice(startIndex, endIndex);
-    return {
-      items,
-      totalCount,
-      page: pagination.page,
-      totalPages,
-      hasNext: pagination.page < totalPages,
-      hasPrevious: pagination.page > 1
-    };
-  }
-  /**
-   * 이벤트 타입별 조회
-   */
-  async getEventsByType(eventType, limit = 100) {
-    const eventIds = this.indexByType.get(eventType);
-    if (!eventIds) {
-      return [];
-    }
-    return Array.from(eventIds).map((id) => this.events.get(id)).sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime()).slice(0, limit);
-  }
-  /**
-   * 이벤트 통계 조회
-   */
-  async getEventStats(timeRange) {
-    const filter = {
-      createdAfter: timeRange?.start,
-      createdBefore: timeRange?.end
-    };
-    const result = await this.searchEvents(filter, { page: 1, limit: 1e4 });
-    const events = result.items;
-    const eventsByType = {};
-    for (const eventType of Object.values(WebhookEventType)) {
-      eventsByType[eventType] = 0;
-    }
-    const eventsByProvider = {};
-    const eventsByChannel = {};
-    const eventsPerHour = {};
-    for (const event of events) {
-      eventsByType[event.type]++;
-      if (event.metadata.providerId) {
-        eventsByProvider[event.metadata.providerId] = (eventsByProvider[event.metadata.providerId] || 0) + 1;
-      }
-      if (event.metadata.channelId) {
-        eventsByChannel[event.metadata.channelId] = (eventsByChannel[event.metadata.channelId] || 0) + 1;
-      }
-      const hourKey = event.timestamp.toISOString().substring(0, 13);
-      eventsPerHour[hourKey] = (eventsPerHour[hourKey] || 0) + 1;
-    }
-    return {
-      totalEvents: events.length,
-      eventsByType,
-      eventsByProvider,
-      eventsByChannel,
-      eventsPerHour
-    };
-  }
-  /**
-   * 오래된 이벤트 정리
-   */
-  async cleanupOldEvents() {
-    if (!this.config.retentionDays) {
-      return 0;
-    }
-    const cutoffDate = /* @__PURE__ */ new Date();
-    cutoffDate.setDate(cutoffDate.getDate() - this.config.retentionDays);
-    const oldEvents = Array.from(this.events.values()).filter(
-      (event) => event.timestamp < cutoffDate
-    );
-    for (const event of oldEvents) {
-      this.removeFromIndexes(event);
-      this.events.delete(event.id);
-    }
-    if (oldEvents.length > 0) {
-      this.emit("oldEventsCleanup", {
-        removedCount: oldEvents.length,
-        cutoffDate
-      });
-      if (this.config.type === "file") {
-        await this.saveToFile();
-      }
-    }
-    return oldEvents.length;
-  }
-  /**
-   * 중복 이벤트 정리
-   */
-  async cleanupDuplicateEvents() {
-    const eventsByContent = /* @__PURE__ */ new Map();
-    for (const event of this.events.values()) {
-      const contentKey = this.generateContentKey(event);
-      if (!eventsByContent.has(contentKey)) {
-        eventsByContent.set(contentKey, []);
-      }
-      eventsByContent.get(contentKey).push(event);
-    }
-    let removedCount = 0;
-    for (const [contentKey, duplicateEvents] of eventsByContent.entries()) {
-      if (duplicateEvents.length > 1) {
-        duplicateEvents.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
-        for (let i = 1; i < duplicateEvents.length; i++) {
-          const eventToRemove = duplicateEvents[i];
-          this.removeFromIndexes(eventToRemove);
-          this.events.delete(eventToRemove.id);
-          removedCount++;
-        }
-      }
-    }
-    if (removedCount > 0) {
-      this.emit("duplicateEventsCleanup", { removedCount });
-      if (this.config.type === "file") {
-        await this.saveToFile();
-      }
-    }
-    return removedCount;
-  }
-  /**
-   * 저장소 통계 조회
-   */
-  getStorageStats() {
-    const memoryUsage = this.estimateMemoryUsage();
-    return {
-      totalEvents: this.events.size,
-      memoryUsage,
-      indexSizes: {
-        byType: this.indexByType.size,
-        byDate: this.indexByDate.size,
-        byProvider: this.indexByProvider.size,
-        byChannel: this.indexByChannel.size
-      }
-    };
-  }
-  /**
-   * 인덱스 초기화
-   */
-  initializeIndexes() {
-    const eventTypes = Object.values(WebhookEventType);
-    for (const eventType of eventTypes) {
-      this.indexByType.set(eventType, /* @__PURE__ */ new Set());
-    }
-  }
-  /**
-   * 인덱스에 이벤트 추가
-   */
-  addToIndexes(event) {
-    const typeSet = this.indexByType.get(event.type);
-    if (typeSet) {
-      typeSet.add(event.id);
-    }
-    const dateKey = event.timestamp.toISOString().split("T")[0];
-    if (!this.indexByDate.has(dateKey)) {
-      this.indexByDate.set(dateKey, /* @__PURE__ */ new Set());
-    }
-    this.indexByDate.get(dateKey).add(event.id);
-    if (event.metadata.providerId) {
-      if (!this.indexByProvider.has(event.metadata.providerId)) {
-        this.indexByProvider.set(event.metadata.providerId, /* @__PURE__ */ new Set());
-      }
-      this.indexByProvider.get(event.metadata.providerId).add(event.id);
-    }
-    if (event.metadata.channelId) {
-      if (!this.indexByChannel.has(event.metadata.channelId)) {
-        this.indexByChannel.set(event.metadata.channelId, /* @__PURE__ */ new Set());
-      }
-      this.indexByChannel.get(event.metadata.channelId).add(event.id);
-    }
-  }
-  /**
-   * 인덱스에서 이벤트 제거
-   */
-  removeFromIndexes(event) {
-    const typeSet = this.indexByType.get(event.type);
-    if (typeSet) {
-      typeSet.delete(event.id);
-    }
-    const dateKey = event.timestamp.toISOString().split("T")[0];
-    const dateSet = this.indexByDate.get(dateKey);
-    if (dateSet) {
-      dateSet.delete(event.id);
-      if (dateSet.size === 0) {
-        this.indexByDate.delete(dateKey);
-      }
-    }
-    if (event.metadata.providerId) {
-      const providerSet = this.indexByProvider.get(event.metadata.providerId);
-      if (providerSet) {
-        providerSet.delete(event.id);
-        if (providerSet.size === 0) {
-          this.indexByProvider.delete(event.metadata.providerId);
-        }
-      }
-    }
-    if (event.metadata.channelId) {
-      const channelSet = this.indexByChannel.get(event.metadata.channelId);
-      if (channelSet) {
-        channelSet.delete(event.id);
-        if (channelSet.size === 0) {
-          this.indexByChannel.delete(event.metadata.channelId);
-        }
-      }
-    }
-  }
-  /**
-   * 날짜 범위로 이벤트 ID 조회
-   */
-  getEventIdsByDateRange(startDate, endDate) {
-    const ids = /* @__PURE__ */ new Set();
-    for (const [dateKey, eventIds] of this.indexByDate.entries()) {
-      const date = new Date(dateKey);
-      if (startDate && date < startDate) continue;
-      if (endDate && date > endDate) continue;
-      eventIds.forEach((id) => ids.add(id));
-    }
-    return ids;
-  }
-  /**
-   * 필터 조건 매칭 확인
-   */
-  matchesFilter(event, filter) {
-    if (filter.templateId && filter.templateId.length > 0) {
-      if (!event.metadata.templateId || !filter.templateId.includes(event.metadata.templateId)) {
-        return false;
-      }
-    }
-    if (filter.messageId && filter.messageId.length > 0) {
-      if (!event.metadata.messageId || !filter.messageId.includes(event.metadata.messageId)) {
-        return false;
-      }
-    }
-    if (filter.userId && filter.userId.length > 0) {
-      if (!event.metadata.userId || !filter.userId.includes(event.metadata.userId)) {
-        return false;
-      }
-    }
-    if (filter.organizationId && filter.organizationId.length > 0) {
-      if (!event.metadata.organizationId || !filter.organizationId.includes(event.metadata.organizationId)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * 객체 필드 값 가져오기
-   */
-  getFieldValue(obj, fieldPath) {
-    return fieldPath.split(".").reduce((value, key) => value?.[key], obj);
-  }
-  /**
-   * 메모리 사용량 추정
-   */
-  estimateMemoryUsage() {
-    let totalSize = 0;
-    for (const event of this.events.values()) {
-      totalSize += JSON.stringify(event).length * 2;
-    }
-    return totalSize;
-  }
-  /**
-   * 메모리 사용량 확인 및 정리
-   */
-  async checkMemoryUsage() {
-    if (!this.config.maxMemoryUsage) return;
-    const currentUsage = this.estimateMemoryUsage();
-    if (currentUsage > this.config.maxMemoryUsage) {
-      const events = Array.from(this.events.values()).sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-      let removedCount = 0;
-      const targetUsage = this.config.maxMemoryUsage * 0.8;
-      for (const event of events) {
-        if (this.estimateMemoryUsage() <= targetUsage) break;
-        this.removeFromIndexes(event);
-        this.events.delete(event.id);
-        removedCount++;
-      }
-      if (removedCount > 0) {
-        this.emit("memoryCleanup", {
-          removedCount,
-          previousUsage: currentUsage,
-          currentUsage: this.estimateMemoryUsage()
-        });
-      }
-    }
-  }
-  /**
-   * 이벤트 내용 키 생성 (중복 검사용)
-   */
-  generateContentKey(event) {
-    return `${event.type}_${event.metadata.messageId || ""}_${event.metadata.templateId || ""}_${JSON.stringify(event.data)}`;
-  }
-  /**
-   * 정리 작업 시작
-   */
-  startCleanupTask() {
-    this.cleanupInterval = setInterval(async () => {
-      try {
-        await this.cleanupOldEvents();
-        await this.cleanupDuplicateEvents();
-      } catch (error) {
-        this.emit("cleanupError", error);
-      }
-    }, 60 * 60 * 1e3);
-  }
-  /**
-   * 파일에 이벤트 추가
-   */
-  async appendToFile(event) {
-    if (!this.config.filePath) return;
-    try {
-      const line = JSON.stringify(event) + "\n";
-      await fs4.appendFile(this.config.filePath, line, "utf8");
-    } catch (error) {
-      this.emit("appendError", error);
-    }
-  }
-  /**
-   * 파일에서 데이터 로드
-   */
-  async loadFromFile() {
-    if (!this.config.filePath) return;
-    try {
-      const data = await fs4.readFile(this.config.filePath, "utf8");
-      const lines = data.trim().split("\n").filter((line) => line.trim());
-      for (const line of lines) {
-        try {
-          const eventData = JSON.parse(line);
-          const event = {
-            ...eventData,
-            timestamp: new Date(eventData.timestamp)
-          };
-          this.events.set(event.id, event);
-          this.addToIndexes(event);
-        } catch (parseError) {
-          this.emit("parseError", { line, error: parseError });
-        }
-      }
-      this.emit("dataLoaded", {
-        filePath: this.config.filePath,
-        eventCount: this.events.size
-      });
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        this.emit("loadError", error);
-      }
-    }
-  }
-  /**
-   * 파일에 데이터 저장
-   */
-  async saveToFile() {
-    if (!this.config.filePath) return;
-    try {
-      const lines = Array.from(this.events.values()).map((event) => JSON.stringify(event)).join("\n");
-      await fs4.mkdir(path4.dirname(this.config.filePath), { recursive: true });
-      await fs4.writeFile(this.config.filePath, lines + "\n", "utf8");
-      this.emit("dataSaved", {
-        filePath: this.config.filePath,
-        eventCount: this.events.size
-      });
-    } catch (error) {
-      this.emit("saveError", error);
-      throw error;
-    }
-  }
-  /**
-   * 이벤트 저장소 종료
-   */
-  async shutdown() {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-    if (this.config.type === "file") {
-      await this.saveToFile().catch((error) => {
-        this.emit("saveError", error);
-      });
-    }
-    this.emit("shutdown", { eventCount: this.events.size });
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BatchDispatcher,
-  DeliveryStore,
-  EndpointManager,
-  EventStore,
-  LoadBalancer,
-  QueueManager,
-  RetryManager,
-  SecurityManager,
-  WebhookDispatcher,
-  WebhookEventType,
-  WebhookRegistry,
-  WebhookService
-});
-//# sourceMappingURL=index.cjs.map