@parsrun/service 0.1.0

package/dist/index.js

@@ -0,0 +1,3589 @@
+// src/define.ts
+function defineService(definition) {
+  validateServiceDefinition(definition);
+  return Object.freeze({
+    ...definition,
+    queries: definition.queries ? Object.freeze({ ...definition.queries }) : void 0,
+    mutations: definition.mutations ? Object.freeze({ ...definition.mutations }) : void 0,
+    events: definition.events ? Object.freeze({
+      emits: definition.events.emits ? Object.freeze({ ...definition.events.emits }) : void 0,
+      handles: definition.events.handles ? Object.freeze([...definition.events.handles]) : void 0
+    }) : void 0
+  });
+}
+function validateServiceDefinition(definition) {
+  if (!definition.name) {
+    throw new Error("Service name is required");
+  }
+  if (!definition.version) {
+    throw new Error("Service version is required");
+  }
+  const versionRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?$/;
+  if (!versionRegex.test(definition.version)) {
+    throw new Error(`Invalid version format: ${definition.version}. Expected semver (e.g., 1.0.0)`);
+  }
+  const nameRegex = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+  if (definition.queries) {
+    for (const name of Object.keys(definition.queries)) {
+      if (!nameRegex.test(name)) {
+        throw new Error(
+          `Invalid query name: ${name}. Must start with letter and contain only alphanumeric and underscore`
+        );
+      }
+    }
+  }
+  if (definition.mutations) {
+    for (const name of Object.keys(definition.mutations)) {
+      if (!nameRegex.test(name)) {
+        throw new Error(
+          `Invalid mutation name: ${name}. Must start with letter and contain only alphanumeric and underscore`
+        );
+      }
+    }
+  }
+  const eventNameRegex = /^[a-zA-Z][a-zA-Z0-9_.]*$/;
+  if (definition.events?.emits) {
+    for (const name of Object.keys(definition.events.emits)) {
+      if (!eventNameRegex.test(name)) {
+        throw new Error(
+          `Invalid event name: ${name}. Must start with letter and contain only alphanumeric, underscore, and dot`
+        );
+      }
+    }
+  }
+  if (definition.events?.handles) {
+    for (const name of definition.events.handles) {
+      if (!eventNameRegex.test(name)) {
+        throw new Error(
+          `Invalid handled event name: ${name}. Must start with letter and contain only alphanumeric, underscore, and dot`
+        );
+      }
+    }
+  }
+}
+function getServiceMethods(definition) {
+  return {
+    queries: definition.queries ? Object.keys(definition.queries) : [],
+    mutations: definition.mutations ? Object.keys(definition.mutations) : []
+  };
+}
+function getServiceEvents(definition) {
+  return {
+    emits: definition.events?.emits ? Object.keys(definition.events.emits) : [],
+    handles: definition.events?.handles ?? []
+  };
+}
+function satisfiesVersion(version, requirement) {
+  const versionParts = version.split(".").map((p) => parseInt(p, 10));
+  const requirementParts = requirement.split(".");
+  for (let i = 0; i < requirementParts.length; i++) {
+    const req = requirementParts[i];
+    if (req === "x" || req === "*") {
+      continue;
+    }
+    const reqNum = parseInt(req ?? "0", 10);
+    const verNum = versionParts[i] ?? 0;
+    if (verNum !== reqNum) {
+      return false;
+    }
+  }
+  return true;
+}
+function isMethodDeprecated(definition, methodName, type) {
+  const methods = type === "query" ? definition.queries : definition.mutations;
+  const method = methods?.[methodName];
+  if (!method?.deprecated) {
+    return { deprecated: false };
+  }
+  const result = {
+    deprecated: true,
+    since: method.deprecated
+  };
+  if (method.replacement) {
+    result.replacement = method.replacement;
+  }
+  return result;
+}
+function getMethodTimeout(definition, methodName, type, defaultTimeout) {
+  const methods = type === "query" ? definition.queries : definition.mutations;
+  const method = methods?.[methodName];
+  return method?.timeout ?? defaultTimeout;
+}
+
+// src/client.ts
+import { generateId as generateId3 } from "@parsrun/core";
+
+// src/config.ts
+var DEFAULT_EVENT_CONFIG = {
+  format: "cloudevents",
+  internalCompact: true
+};
+var DEFAULT_SERIALIZATION_CONFIG = {
+  format: "json"
+};
+var DEFAULT_TRACING_CONFIG = {
+  enabled: true,
+  sampler: { ratio: 0.1 },
+  exporter: "console",
+  endpoint: "",
+  serviceName: "pars-service"
+};
+var DEFAULT_VERSIONING_CONFIG = {
+  strategy: "header",
+  defaultVersion: "1.x"
+};
+var DEFAULT_RESILIENCE_CONFIG = {
+  circuitBreaker: {
+    enabled: true,
+    failureThreshold: 5,
+    resetTimeout: 3e4,
+    successThreshold: 2
+  },
+  bulkhead: {
+    maxConcurrent: 100,
+    maxQueue: 50
+  },
+  timeout: 5e3,
+  retry: {
+    attempts: 3,
+    backoff: "exponential",
+    initialDelay: 100,
+    maxDelay: 1e4
+  }
+};
+var DEFAULT_DEAD_LETTER_CONFIG = {
+  enabled: true,
+  retention: "30d",
+  onFail: "alert",
+  alertThreshold: 10
+};
+var DEFAULT_SERVICE_CONFIG = {
+  events: DEFAULT_EVENT_CONFIG,
+  serialization: DEFAULT_SERIALIZATION_CONFIG,
+  tracing: DEFAULT_TRACING_CONFIG,
+  versioning: DEFAULT_VERSIONING_CONFIG,
+  resilience: DEFAULT_RESILIENCE_CONFIG,
+  deadLetter: DEFAULT_DEAD_LETTER_CONFIG
+};
+function mergeConfig(userConfig) {
+  if (!userConfig) {
+    return { ...DEFAULT_SERVICE_CONFIG };
+  }
+  return {
+    events: {
+      ...DEFAULT_EVENT_CONFIG,
+      ...userConfig.events
+    },
+    serialization: {
+      ...DEFAULT_SERIALIZATION_CONFIG,
+      ...userConfig.serialization
+    },
+    tracing: {
+      ...DEFAULT_TRACING_CONFIG,
+      ...userConfig.tracing
+    },
+    versioning: {
+      ...DEFAULT_VERSIONING_CONFIG,
+      ...userConfig.versioning
+    },
+    resilience: {
+      ...DEFAULT_RESILIENCE_CONFIG,
+      ...userConfig.resilience,
+      circuitBreaker: {
+        ...DEFAULT_RESILIENCE_CONFIG.circuitBreaker,
+        ...userConfig.resilience?.circuitBreaker
+      },
+      bulkhead: {
+        ...DEFAULT_RESILIENCE_CONFIG.bulkhead,
+        ...userConfig.resilience?.bulkhead
+      },
+      retry: {
+        ...DEFAULT_RESILIENCE_CONFIG.retry,
+        ...userConfig.resilience?.retry
+      }
+    },
+    deadLetter: {
+      ...DEFAULT_DEAD_LETTER_CONFIG,
+      ...userConfig.deadLetter
+    }
+  };
+}
+function createDevConfig(overrides) {
+  return mergeConfig({
+    tracing: {
+      enabled: true,
+      sampler: "always",
+      exporter: "console"
+    },
+    resilience: {
+      circuitBreaker: { enabled: false },
+      timeout: 3e4
+    },
+    ...overrides
+  });
+}
+function createProdConfig(overrides) {
+  return mergeConfig({
+    tracing: {
+      enabled: true,
+      sampler: { ratio: 0.1 },
+      exporter: "otlp"
+    },
+    resilience: {
+      circuitBreaker: { enabled: true },
+      timeout: 5e3
+    },
+    ...overrides
+  });
+}
+function validateConfig(config) {
+  const errors = [];
+  if (config.tracing?.sampler && typeof config.tracing.sampler === "object") {
+    const ratio = config.tracing.sampler.ratio;
+    if (ratio < 0 || ratio > 1) {
+      errors.push("tracing.sampler.ratio must be between 0 and 1");
+    }
+  }
+  if (config.resilience?.timeout !== void 0 && config.resilience.timeout < 0) {
+    errors.push("resilience.timeout must be non-negative");
+  }
+  if (config.resilience?.circuitBreaker?.failureThreshold !== void 0) {
+    if (config.resilience.circuitBreaker.failureThreshold < 1) {
+      errors.push("resilience.circuitBreaker.failureThreshold must be at least 1");
+    }
+  }
+  if (config.resilience?.bulkhead?.maxConcurrent !== void 0) {
+    if (config.resilience.bulkhead.maxConcurrent < 1) {
+      errors.push("resilience.bulkhead.maxConcurrent must be at least 1");
+    }
+  }
+  if (config.resilience?.retry?.attempts !== void 0) {
+    if (config.resilience.retry.attempts < 0) {
+      errors.push("resilience.retry.attempts must be non-negative");
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// src/rpc/client.ts
+import { generateId } from "@parsrun/core";
+
+// src/rpc/errors.ts
+import { ParsError } from "@parsrun/core";
+var RpcError = class extends ParsError {
+  retryable;
+  retryAfter;
+  constructor(message, code, statusCode = 500, options) {
+    super(message, code, statusCode, options?.details);
+    this.name = "RpcError";
+    this.retryable = options?.retryable ?? false;
+    if (options?.retryAfter !== void 0) {
+      this.retryAfter = options.retryAfter;
+    }
+  }
+};
+var ServiceNotFoundError = class extends RpcError {
+  constructor(serviceName) {
+    super(`Service not found: ${serviceName}`, "SERVICE_NOT_FOUND", 404, {
+      retryable: false,
+      details: { service: serviceName }
+    });
+    this.name = "ServiceNotFoundError";
+  }
+};
+var MethodNotFoundError = class extends RpcError {
+  constructor(serviceName, methodName) {
+    super(
+      `Method not found: ${serviceName}.${methodName}`,
+      "METHOD_NOT_FOUND",
+      404,
+      {
+        retryable: false,
+        details: { service: serviceName, method: methodName }
+      }
+    );
+    this.name = "MethodNotFoundError";
+  }
+};
+var VersionMismatchError = class extends RpcError {
+  constructor(serviceName, requested, available) {
+    super(
+      `Version mismatch for ${serviceName}: requested ${requested}, available ${available}`,
+      "VERSION_MISMATCH",
+      400,
+      {
+        retryable: false,
+        details: { service: serviceName, requested, available }
+      }
+    );
+    this.name = "VersionMismatchError";
+  }
+};
+var TimeoutError = class extends RpcError {
+  constructor(serviceName, methodName, timeoutMs) {
+    super(
+      `Request to ${serviceName}.${methodName} timed out after ${timeoutMs}ms`,
+      "TIMEOUT",
+      504,
+      {
+        retryable: true,
+        details: { service: serviceName, method: methodName, timeout: timeoutMs }
+      }
+    );
+    this.name = "TimeoutError";
+  }
+};
+var CircuitOpenError = class extends RpcError {
+  constructor(serviceName, resetAfterMs) {
+    super(
+      `Circuit breaker open for ${serviceName}`,
+      "CIRCUIT_OPEN",
+      503,
+      {
+        retryable: true,
+        retryAfter: Math.ceil(resetAfterMs / 1e3),
+        details: { service: serviceName, resetAfterMs }
+      }
+    );
+    this.name = "CircuitOpenError";
+  }
+};
+var BulkheadRejectedError = class extends RpcError {
+  constructor(serviceName) {
+    super(
+      `Request rejected by bulkhead for ${serviceName}: too many concurrent requests`,
+      "BULKHEAD_REJECTED",
+      503,
+      {
+        retryable: true,
+        retryAfter: 1,
+        details: { service: serviceName }
+      }
+    );
+    this.name = "BulkheadRejectedError";
+  }
+};
+var TransportError = class extends RpcError {
+  constructor(message, cause) {
+    const options = {
+      retryable: true
+    };
+    if (cause) {
+      options.details = { cause: cause.message };
+    }
+    super(message, "TRANSPORT_ERROR", 502, options);
+    this.name = "TransportError";
+  }
+};
+var SerializationError = class extends RpcError {
+  constructor(message, cause) {
+    const options = {
+      retryable: false
+    };
+    if (cause) {
+      options.details = { cause: cause.message };
+    }
+    super(message, "SERIALIZATION_ERROR", 400, options);
+    this.name = "SerializationError";
+  }
+};
+function toRpcError(error) {
+  if (error instanceof RpcError) {
+    return error;
+  }
+  if (error instanceof Error) {
+    return new RpcError(error.message, "INTERNAL_ERROR", 500, {
+      retryable: false,
+      details: { originalError: error.name }
+    });
+  }
+  return new RpcError(String(error), "UNKNOWN_ERROR", 500, {
+    retryable: false
+  });
+}
+
+// src/resilience/circuit-breaker.ts
+var CircuitBreaker = class {
+  _state = "closed";
+  failures = 0;
+  successes = 0;
+  lastFailureTime = 0;
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * Get current state
+   */
+  get state() {
+    if (this._state === "open") {
+      const timeSinceFailure = Date.now() - this.lastFailureTime;
+      if (timeSinceFailure >= this.options.resetTimeout) {
+        this.transitionTo("half-open");
+      }
+    }
+    return this._state;
+  }
+  /**
+   * Execute a function with circuit breaker protection
+   */
+  async execute(fn) {
+    const currentState = this.state;
+    if (currentState === "open") {
+      const resetAfter = this.options.resetTimeout - (Date.now() - this.lastFailureTime);
+      throw new CircuitOpenError("service", Math.max(0, resetAfter));
+    }
+    try {
+      const result = await fn();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure();
+      throw error;
+    }
+  }
+  /**
+   * Record a successful call
+   */
+  onSuccess() {
+    if (this._state === "half-open") {
+      this.successes++;
+      if (this.successes >= this.options.successThreshold) {
+        this.transitionTo("closed");
+      }
+    } else if (this._state === "closed") {
+      this.failures = 0;
+    }
+  }
+  /**
+   * Record a failed call
+   */
+  onFailure() {
+    this.lastFailureTime = Date.now();
+    if (this._state === "half-open") {
+      this.transitionTo("open");
+    } else if (this._state === "closed") {
+      this.failures++;
+      if (this.failures >= this.options.failureThreshold) {
+        this.transitionTo("open");
+      }
+    }
+  }
+  /**
+   * Transition to a new state
+   */
+  transitionTo(newState) {
+    const oldState = this._state;
+    this._state = newState;
+    if (newState === "closed") {
+      this.failures = 0;
+      this.successes = 0;
+    } else if (newState === "half-open") {
+      this.successes = 0;
+    }
+    this.options.onStateChange?.(oldState, newState);
+  }
+  /**
+   * Manually reset the circuit breaker
+   */
+  reset() {
+    this.transitionTo("closed");
+  }
+  /**
+   * Get circuit breaker statistics
+   */
+  getStats() {
+    return {
+      state: this.state,
+      failures: this.failures,
+      successes: this.successes,
+      lastFailureTime: this.lastFailureTime
+    };
+  }
+};
+
+// src/resilience/bulkhead.ts
+var Bulkhead = class {
+  _concurrent = 0;
+  queue = [];
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * Get current concurrent count
+   */
+  get concurrent() {
+    return this._concurrent;
+  }
+  /**
+   * Get current queue size
+   */
+  get queued() {
+    return this.queue.length;
+  }
+  /**
+   * Check if bulkhead is full
+   */
+  get isFull() {
+    return this._concurrent >= this.options.maxConcurrent && this.queue.length >= this.options.maxQueue;
+  }
+  /**
+   * Execute a function with bulkhead protection
+   */
+  async execute(fn) {
+    if (this._concurrent < this.options.maxConcurrent) {
+      return this.doExecute(fn);
+    }
+    if (this.queue.length < this.options.maxQueue) {
+      return this.enqueue(fn);
+    }
+    this.options.onRejected?.();
+    throw new BulkheadRejectedError("service");
+  }
+  /**
+   * Execute immediately
+   */
+  async doExecute(fn) {
+    this._concurrent++;
+    try {
+      return await fn();
+    } finally {
+      this._concurrent--;
+      this.processQueue();
+    }
+  }
+  /**
+   * Add to queue
+   */
+  enqueue(fn) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({
+        fn,
+        resolve,
+        reject
+      });
+    });
+  }
+  /**
+   * Process queued requests
+   */
+  processQueue() {
+    if (this.queue.length === 0) return;
+    if (this._concurrent >= this.options.maxConcurrent) return;
+    const queued = this.queue.shift();
+    if (!queued) return;
+    this.doExecute(queued.fn).then(queued.resolve).catch(queued.reject);
+  }
+  /**
+   * Get bulkhead statistics
+   */
+  getStats() {
+    return {
+      concurrent: this._concurrent,
+      queued: this.queue.length,
+      maxConcurrent: this.options.maxConcurrent,
+      maxQueue: this.options.maxQueue
+    };
+  }
+  /**
+   * Clear the queue (reject all pending)
+   */
+  clearQueue() {
+    const error = new BulkheadRejectedError("service");
+    while (this.queue.length > 0) {
+      const queued = this.queue.shift();
+      queued?.reject(error);
+    }
+  }
+};
+
+// src/resilience/retry.ts
+var defaultShouldRetry = (error) => {
+  if (error && typeof error === "object" && "retryable" in error) {
+    return error.retryable;
+  }
+  return false;
+};
+function calculateDelay(attempt, options) {
+  let delay;
+  if (options.backoff === "exponential") {
+    delay = options.initialDelay * Math.pow(2, attempt);
+  } else {
+    delay = options.initialDelay * (attempt + 1);
+  }
+  delay = Math.min(delay, options.maxDelay);
+  if (options.jitter && options.jitter > 0) {
+    const jitterRange = delay * options.jitter;
+    delay = delay - jitterRange / 2 + Math.random() * jitterRange;
+  }
+  return Math.round(delay);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function withRetry(fn, options) {
+  const shouldRetry = options.shouldRetry ?? defaultShouldRetry;
+  return async () => {
+    let lastError;
+    for (let attempt = 0; attempt <= options.attempts; attempt++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error;
+        if (attempt >= options.attempts || !shouldRetry(error, attempt)) {
+          throw error;
+        }
+        const delay = calculateDelay(attempt, options);
+        options.onRetry?.(error, attempt + 1, delay);
+        await sleep(delay);
+      }
+    }
+    throw lastError;
+  };
+}
+async function executeWithRetry(fn, options) {
+  return withRetry(fn, options)();
+}
+function createRetryWrapper(defaultOptions) {
+  const defaults = {
+    attempts: defaultOptions.attempts ?? 3,
+    backoff: defaultOptions.backoff ?? "exponential",
+    initialDelay: defaultOptions.initialDelay ?? 100,
+    maxDelay: defaultOptions.maxDelay ?? 1e4,
+    jitter: defaultOptions.jitter ?? 0.1
+  };
+  if (defaultOptions.shouldRetry) {
+    defaults.shouldRetry = defaultOptions.shouldRetry;
+  }
+  if (defaultOptions.onRetry) {
+    defaults.onRetry = defaultOptions.onRetry;
+  }
+  return async (fn, options) => {
+    return executeWithRetry(fn, { ...defaults, ...options });
+  };
+}
+
+// src/resilience/timeout.ts
+var TimeoutExceededError = class extends Error {
+  timeout;
+  constructor(timeout) {
+    super(`Operation timed out after ${timeout}ms`);
+    this.name = "TimeoutExceededError";
+    this.timeout = timeout;
+  }
+};
+function withTimeout(fn, timeoutMs, onTimeout) {
+  return async () => {
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        if (onTimeout) {
+          try {
+            onTimeout();
+          } catch (error) {
+            reject(error);
+            return;
+          }
+        }
+        reject(new TimeoutExceededError(timeoutMs));
+      }, timeoutMs);
+    });
+    try {
+      return await Promise.race([fn(), timeoutPromise]);
+    } finally {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+      }
+    }
+  };
+}
+async function executeWithTimeout(fn, timeoutMs, onTimeout) {
+  return withTimeout(fn, timeoutMs, onTimeout)();
+}
+function createTimeoutWrapper(defaultTimeoutMs) {
+  return async (fn, timeoutMs) => {
+    return executeWithTimeout(fn, timeoutMs ?? defaultTimeoutMs);
+  };
+}
+async function raceWithTimeout(promises, timeoutMs) {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new TimeoutExceededError(timeoutMs));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([...promises, timeoutPromise]);
+  } finally {
+    if (timeoutId !== void 0) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+async function executeWithDeadline(fn, deadline) {
+  const now = Date.now();
+  const deadlineMs = deadline.getTime();
+  const timeoutMs = Math.max(0, deadlineMs - now);
+  if (timeoutMs === 0) {
+    throw new TimeoutExceededError(0);
+  }
+  return executeWithTimeout(fn, timeoutMs);
+}
+
+// src/rpc/client.ts
+var RpcClient = class {
+  service;
+  transport;
+  config;
+  defaultMetadata;
+  circuitBreaker;
+  bulkhead;
+  constructor(options) {
+    this.service = options.service;
+    this.transport = options.transport;
+    this.config = mergeConfig(options.config);
+    this.defaultMetadata = options.defaultMetadata ?? {};
+    const cbConfig = this.config.resilience?.circuitBreaker;
+    if (cbConfig && cbConfig.enabled && cbConfig.failureThreshold !== void 0 && cbConfig.resetTimeout !== void 0 && cbConfig.successThreshold !== void 0) {
+      this.circuitBreaker = new CircuitBreaker({
+        failureThreshold: cbConfig.failureThreshold,
+        resetTimeout: cbConfig.resetTimeout,
+        successThreshold: cbConfig.successThreshold
+      });
+    } else {
+      this.circuitBreaker = null;
+    }
+    const bhConfig = this.config.resilience?.bulkhead;
+    if (bhConfig && bhConfig.maxConcurrent !== void 0 && bhConfig.maxQueue !== void 0) {
+      this.bulkhead = new Bulkhead({
+        maxConcurrent: bhConfig.maxConcurrent,
+        maxQueue: bhConfig.maxQueue
+      });
+    } else {
+      this.bulkhead = null;
+    }
+  }
+  /**
+   * Execute a query
+   */
+  async query(method, input, options) {
+    return this.call("query", method, input, options);
+  }
+  /**
+   * Execute a mutation
+   */
+  async mutate(method, input, options) {
+    return this.call("mutation", method, input, options);
+  }
+  /**
+   * Internal call implementation
+   */
+  async call(type, method, input, options) {
+    const request = {
+      id: generateId(),
+      service: this.service,
+      method,
+      type,
+      input,
+      metadata: {
+        ...this.defaultMetadata,
+        ...options?.metadata
+      }
+    };
+    const version = options?.version ?? this.config.versioning.defaultVersion;
+    if (version) {
+      request.version = version;
+    }
+    if (options?.traceContext) {
+      request.traceContext = options.traceContext;
+    }
+    const timeout = options?.timeout ?? this.config.resilience.timeout ?? 3e4;
+    const retryConfig = options?.retry ?? this.config.resilience.retry;
+    let execute = async () => {
+      const response = await this.transport.call(request);
+      if (!response.success) {
+        const error = toRpcError(
+          new Error(response.error?.message ?? "Unknown error")
+        );
+        throw error;
+      }
+      return response.output;
+    };
+    execute = withTimeout(execute, timeout, () => {
+      throw new TimeoutError(this.service, method, timeout);
+    });
+    const attempts = retryConfig?.attempts ?? 0;
+    if (attempts > 0) {
+      execute = withRetry(execute, {
+        attempts,
+        backoff: retryConfig?.backoff ?? "exponential",
+        initialDelay: retryConfig?.initialDelay ?? 100,
+        maxDelay: retryConfig?.maxDelay ?? 5e3,
+        shouldRetry: (error) => {
+          if (error instanceof Error && "retryable" in error) {
+            return error.retryable;
+          }
+          return false;
+        }
+      });
+    }
+    if (this.circuitBreaker) {
+      const cb = this.circuitBreaker;
+      const originalExecute = execute;
+      execute = async () => {
+        return cb.execute(originalExecute);
+      };
+    }
+    if (this.bulkhead) {
+      const bh = this.bulkhead;
+      const originalExecute = execute;
+      execute = async () => {
+        return bh.execute(originalExecute);
+      };
+    }
+    return execute();
+  }
+  /**
+   * Get circuit breaker state
+   */
+  getCircuitState() {
+    return this.circuitBreaker?.state ?? null;
+  }
+  /**
+   * Get bulkhead stats
+   */
+  getBulkheadStats() {
+    if (!this.bulkhead) return null;
+    return {
+      concurrent: this.bulkhead.concurrent,
+      queued: this.bulkhead.queued
+    };
+  }
+  /**
+   * Close the client and release resources
+   */
+  async close() {
+    await this.transport.close?.();
+  }
+};
+function createRpcClient(options) {
+  return new RpcClient(options);
+}
+
+// src/rpc/transports/embedded.ts
+var EmbeddedTransport = class {
+  name = "embedded";
+  server;
+  constructor(server) {
+    this.server = server;
+  }
+  async call(request) {
+    return this.server.handle(request);
+  }
+  async close() {
+  }
+};
+function createEmbeddedTransport(server) {
+  return new EmbeddedTransport(server);
+}
+var EmbeddedRegistry = class _EmbeddedRegistry {
+  static instance = null;
+  servers = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  static getInstance() {
+    if (!_EmbeddedRegistry.instance) {
+      _EmbeddedRegistry.instance = new _EmbeddedRegistry();
+    }
+    return _EmbeddedRegistry.instance;
+  }
+  /**
+   * Register a service
+   */
+  register(name, server) {
+    if (this.servers.has(name)) {
+      throw new Error(`Service already registered: ${name}`);
+    }
+    this.servers.set(name, server);
+  }
+  /**
+   * Unregister a service
+   */
+  unregister(name) {
+    return this.servers.delete(name);
+  }
+  /**
+   * Get a service by name
+   */
+  get(name) {
+    return this.servers.get(name);
+  }
+  /**
+   * Check if a service is registered
+   */
+  has(name) {
+    return this.servers.has(name);
+  }
+  /**
+   * Get all registered service names
+   */
+  getServiceNames() {
+    return Array.from(this.servers.keys());
+  }
+  /**
+   * Create a transport for a registered service
+   */
+  createTransport(name) {
+    const server = this.servers.get(name);
+    if (!server) {
+      throw new Error(`Service not found: ${name}`);
+    }
+    return new EmbeddedTransport(server);
+  }
+  /**
+   * Clear all registered services
+   */
+  clear() {
+    this.servers.clear();
+  }
+  /**
+   * Reset the singleton instance (for testing)
+   */
+  static reset() {
+    _EmbeddedRegistry.instance = null;
+  }
+};
+function getEmbeddedRegistry() {
+  return EmbeddedRegistry.getInstance();
+}
+
+// src/serialization/index.ts
+var jsonSerializer = {
+  encode(data) {
+    return JSON.stringify(data);
+  },
+  decode(raw) {
+    if (raw instanceof ArrayBuffer) {
+      const decoder = new TextDecoder();
+      return JSON.parse(decoder.decode(raw));
+    }
+    return JSON.parse(raw);
+  },
+  contentType: "application/json"
+};
+function msgpackEncode(value) {
+  const parts = [];
+  function encode(val) {
+    if (val === null || val === void 0) {
+      parts.push(new Uint8Array([192]));
+      return;
+    }
+    if (typeof val === "boolean") {
+      parts.push(new Uint8Array([val ? 195 : 194]));
+      return;
+    }
+    if (typeof val === "number") {
+      if (Number.isInteger(val)) {
+        if (val >= 0 && val <= 127) {
+          parts.push(new Uint8Array([val]));
+        } else if (val < 0 && val >= -32) {
+          parts.push(new Uint8Array([val & 255]));
+        } else if (val >= 0 && val <= 255) {
+          parts.push(new Uint8Array([204, val]));
+        } else if (val >= 0 && val <= 65535) {
+          parts.push(new Uint8Array([205, val >> 8 & 255, val & 255]));
+        } else if (val >= 0 && val <= 4294967295) {
+          parts.push(
+            new Uint8Array([
+              206,
+              val >> 24 & 255,
+              val >> 16 & 255,
+              val >> 8 & 255,
+              val & 255
+            ])
+          );
+        } else if (val >= -128 && val <= 127) {
+          parts.push(new Uint8Array([208, val & 255]));
+        } else if (val >= -32768 && val <= 32767) {
+          parts.push(new Uint8Array([209, val >> 8 & 255, val & 255]));
+        } else if (val >= -2147483648 && val <= 2147483647) {
+          parts.push(
+            new Uint8Array([
+              210,
+              val >> 24 & 255,
+              val >> 16 & 255,
+              val >> 8 & 255,
+              val & 255
+            ])
+          );
+        } else {
+          const buffer = new ArrayBuffer(9);
+          const view = new DataView(buffer);
+          view.setUint8(0, 203);
+          view.setFloat64(1, val, false);
+          parts.push(new Uint8Array(buffer));
+        }
+      } else {
+        const buffer = new ArrayBuffer(9);
+        const view = new DataView(buffer);
+        view.setUint8(0, 203);
+        view.setFloat64(1, val, false);
+        parts.push(new Uint8Array(buffer));
+      }
+      return;
+    }
+    if (typeof val === "string") {
+      const encoded = new TextEncoder().encode(val);
+      const len = encoded.length;
+      if (len <= 31) {
+        parts.push(new Uint8Array([160 | len]));
+      } else if (len <= 255) {
+        parts.push(new Uint8Array([217, len]));
+      } else if (len <= 65535) {
+        parts.push(new Uint8Array([218, len >> 8 & 255, len & 255]));
+      } else {
+        parts.push(
+          new Uint8Array([
+            219,
+            len >> 24 & 255,
+            len >> 16 & 255,
+            len >> 8 & 255,
+            len & 255
+          ])
+        );
+      }
+      parts.push(encoded);
+      return;
+    }
+    if (Array.isArray(val)) {
+      const len = val.length;
+      if (len <= 15) {
+        parts.push(new Uint8Array([144 | len]));
+      } else if (len <= 65535) {
+        parts.push(new Uint8Array([220, len >> 8 & 255, len & 255]));
+      } else {
+        parts.push(
+          new Uint8Array([
+            221,
+            len >> 24 & 255,
+            len >> 16 & 255,
+            len >> 8 & 255,
+            len & 255
+          ])
+        );
+      }
+      for (const item of val) {
+        encode(item);
+      }
+      return;
+    }
+    if (typeof val === "object") {
+      const keys = Object.keys(val);
+      const len = keys.length;
+      if (len <= 15) {
+        parts.push(new Uint8Array([128 | len]));
+      } else if (len <= 65535) {
+        parts.push(new Uint8Array([222, len >> 8 & 255, len & 255]));
+      } else {
+        parts.push(
+          new Uint8Array([
+            223,
+            len >> 24 & 255,
+            len >> 16 & 255,
+            len >> 8 & 255,
+            len & 255
+          ])
+        );
+      }
+      for (const key of keys) {
+        encode(key);
+        encode(val[key]);
+      }
+      return;
+    }
+    parts.push(new Uint8Array([192]));
+  }
+  encode(value);
+  const totalLength = parts.reduce((sum, p) => sum + p.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const part of parts) {
+    result.set(part, offset);
+    offset += part.length;
+  }
+  return result;
+}
+function msgpackDecode(buffer) {
+  let offset = 0;
+  function decode() {
+    if (offset >= buffer.length) {
+      throw new Error("Unexpected end of buffer");
+    }
+    const byte = buffer[offset++];
+    if (byte <= 127) {
+      return byte;
+    }
+    if (byte >= 224) {
+      return byte - 256;
+    }
+    if (byte >= 128 && byte <= 143) {
+      const len = byte - 128;
+      const result = {};
+      for (let i = 0; i < len; i++) {
+        const key = decode();
+        result[key] = decode();
+      }
+      return result;
+    }
+    if (byte >= 144 && byte <= 159) {
+      const len = byte - 144;
+      const result = [];
+      for (let i = 0; i < len; i++) {
+        result.push(decode());
+      }
+      return result;
+    }
+    if (byte >= 160 && byte <= 191) {
+      const len = byte - 160;
+      const str = new TextDecoder().decode(buffer.subarray(offset, offset + len));
+      offset += len;
+      return str;
+    }
+    switch (byte) {
+      case 192:
+        return null;
+      case 194:
+        return false;
+      case 195:
+        return true;
+      case 204:
+        return buffer[offset++];
+      case 205:
+        return buffer[offset++] << 8 | buffer[offset++];
+      case 206:
+        return (buffer[offset++] << 24 >>> 0) + (buffer[offset++] << 16) + (buffer[offset++] << 8) + buffer[offset++];
+      case 208: {
+        const val = buffer[offset++];
+        return val > 127 ? val - 256 : val;
+      }
+      case 209: {
+        const val = buffer[offset++] << 8 | buffer[offset++];
+        return val > 32767 ? val - 65536 : val;
+      }
+      case 210: {
+        const val = buffer[offset++] << 24 | buffer[offset++] << 16 | buffer[offset++] << 8 | buffer[offset++];
+        return val;
+      }
+      case 203: {
+        const view = new DataView(buffer.buffer, buffer.byteOffset + offset, 8);
+        offset += 8;
+        return view.getFloat64(0, false);
+      }
+      case 217: {
+        const len = buffer[offset++];
+        const str = new TextDecoder().decode(buffer.subarray(offset, offset + len));
+        offset += len;
+        return str;
+      }
+      case 218: {
+        const len = buffer[offset++] << 8 | buffer[offset++];
+        const str = new TextDecoder().decode(buffer.subarray(offset, offset + len));
+        offset += len;
+        return str;
+      }
+      case 219: {
+        const len = buffer[offset++] << 24 | buffer[offset++] << 16 | buffer[offset++] << 8 | buffer[offset++];
+        const str = new TextDecoder().decode(buffer.subarray(offset, offset + len));
+        offset += len;
+        return str;
+      }
+      case 220: {
+        const len = buffer[offset++] << 8 | buffer[offset++];
+        const result = [];
+        for (let i = 0; i < len; i++) {
+          result.push(decode());
+        }
+        return result;
+      }
+      case 221: {
+        const len = buffer[offset++] << 24 | buffer[offset++] << 16 | buffer[offset++] << 8 | buffer[offset++];
+        const result = [];
+        for (let i = 0; i < len; i++) {
+          result.push(decode());
+        }
+        return result;
+      }
+      case 222: {
+        const len = buffer[offset++] << 8 | buffer[offset++];
+        const result = {};
+        for (let i = 0; i < len; i++) {
+          const key = decode();
+          result[key] = decode();
+        }
+        return result;
+      }
+      case 223: {
+        const len = buffer[offset++] << 24 | buffer[offset++] << 16 | buffer[offset++] << 8 | buffer[offset++];
+        const result = {};
+        for (let i = 0; i < len; i++) {
+          const key = decode();
+          result[key] = decode();
+        }
+        return result;
+      }
+      default:
+        throw new Error(`Unknown MessagePack type: 0x${byte.toString(16)}`);
+    }
+  }
+  return decode();
+}
+var msgpackSerializer = {
+  encode(data) {
+    const encoded = msgpackEncode(data);
+    const buffer = new ArrayBuffer(encoded.byteLength);
+    new Uint8Array(buffer).set(encoded);
+    return buffer;
+  },
+  decode(raw) {
+    if (typeof raw === "string") {
+      const binary = atob(raw);
+      const bytes = new Uint8Array(binary.length);
+      for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+      }
+      return msgpackDecode(bytes);
+    }
+    return msgpackDecode(new Uint8Array(raw));
+  },
+  contentType: "application/msgpack"
+};
+function getSerializer(format) {
+  switch (format) {
+    case "json":
+      return jsonSerializer;
+    case "msgpack":
+      return msgpackSerializer;
+    default:
+      return jsonSerializer;
+  }
+}
+function createSerializer(options) {
+  return options;
+}
+
+// src/rpc/transports/http.ts
+var HttpTransport = class {
+  name = "http";
+  baseUrl;
+  serializer;
+  headers;
+  fetchFn;
+  timeout;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.serializer = options.serializer ?? jsonSerializer;
+    this.headers = options.headers ?? {};
+    this.fetchFn = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.timeout = options.timeout ?? 3e4;
+  }
+  async call(request) {
+    const url = `${this.baseUrl}/rpc`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      let body;
+      try {
+        body = this.serializer.encode(request);
+      } catch (error) {
+        throw new SerializationError(
+          "Failed to serialize request",
+          error instanceof Error ? error : void 0
+        );
+      }
+      const response = await this.fetchFn(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": this.serializer.contentType,
+          Accept: this.serializer.contentType,
+          "X-Request-ID": request.id,
+          "X-Service": request.service,
+          "X-Method": request.method,
+          "X-Method-Type": request.type,
+          ...request.version ? { "X-Service-Version": request.version } : {},
+          ...request.traceContext ? {
+            traceparent: formatTraceparent(request.traceContext),
+            ...request.traceContext.traceState ? { tracestate: request.traceContext.traceState } : {}
+          } : {},
+          ...this.headers
+        },
+        body: body instanceof ArrayBuffer ? body : body,
+        signal: controller.signal
+      });
+      let responseData;
+      try {
+        const contentType = response.headers.get("Content-Type") ?? "";
+        if (contentType.includes("msgpack")) {
+          const buffer = await response.arrayBuffer();
+          responseData = this.serializer.decode(buffer);
+        } else {
+          const text = await response.text();
+          responseData = this.serializer.decode(text);
+        }
+      } catch (error) {
+        throw new SerializationError(
+          "Failed to deserialize response",
+          error instanceof Error ? error : void 0
+        );
+      }
+      return responseData;
+    } catch (error) {
+      if (error instanceof SerializationError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new TransportError(`Request timeout after ${this.timeout}ms`);
+        }
+        throw new TransportError(`HTTP request failed: ${error.message}`, error);
+      }
+      throw new TransportError("Unknown transport error");
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async close() {
+  }
+};
+function createHttpTransport(options) {
+  return new HttpTransport(options);
+}
+function formatTraceparent(ctx) {
+  const flags = ctx.traceFlags.toString(16).padStart(2, "0");
+  return `00-${ctx.traceId}-${ctx.spanId}-${flags}`;
+}
+function parseTraceparent(header) {
+  const parts = header.split("-");
+  if (parts.length !== 4) {
+    return null;
+  }
+  const [version, traceId, spanId, flags] = parts;
+  if (version !== "00" || !traceId || !spanId || !flags) {
+    return null;
+  }
+  if (traceId.length !== 32 || spanId.length !== 16 || flags.length !== 2) {
+    return null;
+  }
+  return {
+    traceId,
+    spanId,
+    traceFlags: parseInt(flags, 16)
+  };
+}
+function createHttpHandler(server) {
+  return async (request) => {
+    try {
+      const contentType = request.headers.get("Content-Type") ?? "application/json";
+      let body;
+      if (contentType.includes("msgpack")) {
+        const buffer = await request.arrayBuffer();
+        body = JSON.parse(new TextDecoder().decode(buffer));
+      } else {
+        body = await request.json();
+      }
+      const rpcRequest = body;
+      const traceparent = request.headers.get("traceparent");
+      if (traceparent) {
+        const traceContext = parseTraceparent(traceparent);
+        if (traceContext) {
+          const tracestate = request.headers.get("tracestate");
+          if (tracestate) {
+            traceContext.traceState = tracestate;
+          }
+          rpcRequest.traceContext = traceContext;
+        }
+      }
+      const response = await server.handle(rpcRequest);
+      return new Response(JSON.stringify(response), {
+        status: response.success ? 200 : getHttpStatus(response.error?.code),
+        headers: {
+          "Content-Type": "application/json",
+          "X-Request-ID": rpcRequest.id
+        }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return new Response(
+        JSON.stringify({
+          success: false,
+          error: {
+            code: "INTERNAL_ERROR",
+            message
+          }
+        }),
+        {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+  };
+}
+function getHttpStatus(code) {
+  switch (code) {
+    case "METHOD_NOT_FOUND":
+    case "SERVICE_NOT_FOUND":
+      return 404;
+    case "VERSION_MISMATCH":
+    case "VALIDATION_ERROR":
+    case "SERIALIZATION_ERROR":
+      return 400;
+    case "UNAUTHORIZED":
+      return 401;
+    case "FORBIDDEN":
+      return 403;
+    case "TIMEOUT":
+      return 504;
+    case "CIRCUIT_OPEN":
+    case "BULKHEAD_REJECTED":
+      return 503;
+    default:
+      return 500;
+  }
+}
+
+// src/events/transports/memory.ts
+import { createLogger as createLogger2 } from "@parsrun/core";
+
+// src/events/handler.ts
+import { createLogger } from "@parsrun/core";
+
+// src/events/format.ts
+import { generateId as generateId2 } from "@parsrun/core";
+function createEvent(options) {
+  const event = {
+    specversion: "1.0",
+    type: options.type,
+    source: options.source,
+    id: options.id ?? generateId2(),
+    time: (/* @__PURE__ */ new Date()).toISOString(),
+    datacontenttype: "application/json",
+    data: options.data
+  };
+  if (options.subject) event.subject = options.subject;
+  if (options.tenantId) event.parstenantid = options.tenantId;
+  if (options.requestId) event.parsrequestid = options.requestId;
+  if (options.traceContext) event.parstracecontext = formatTraceContext(options.traceContext);
+  if (options.delivery) event.parsdelivery = options.delivery;
+  return event;
+}
+function toCloudEvent(event) {
+  return { ...event };
+}
+function toCompactEvent(event) {
+  const compact = {
+    e: event.type,
+    s: event.source,
+    i: event.id,
+    t: new Date(event.time).getTime(),
+    d: event.data
+  };
+  if (event.parstracecontext) compact.ctx = event.parstracecontext;
+  if (event.parstenantid) compact.tid = event.parstenantid;
+  return compact;
+}
+function fromCompactEvent(compact, source) {
+  const event = {
+    specversion: "1.0",
+    type: compact.e,
+    source: source ?? compact.s,
+    id: compact.i,
+    time: new Date(compact.t).toISOString(),
+    datacontenttype: "application/json",
+    data: compact.d
+  };
+  if (compact.ctx) event.parstracecontext = compact.ctx;
+  if (compact.tid) event.parstenantid = compact.tid;
+  return event;
+}
+function formatEventType(source, type) {
+  return `com.pars.${source}.${type}`;
+}
+function parseEventType(fullType) {
+  const prefix = "com.pars.";
+  if (!fullType.startsWith(prefix)) {
+    const parts = fullType.split(".");
+    if (parts.length >= 2) {
+      const [source, ...rest] = parts;
+      return { source, type: rest.join(".") };
+    }
+    return null;
+  }
+  const withoutPrefix = fullType.slice(prefix.length);
+  const dotIndex = withoutPrefix.indexOf(".");
+  if (dotIndex === -1) {
+    return null;
+  }
+  return {
+    source: withoutPrefix.slice(0, dotIndex),
+    type: withoutPrefix.slice(dotIndex + 1)
+  };
+}
+function matchEventType(type, pattern) {
+  if (pattern === "*" || pattern === "**") {
+    return true;
+  }
+  const typeParts = type.split(".");
+  const patternParts = pattern.split(".");
+  let ti = 0;
+  let pi = 0;
+  while (ti < typeParts.length && pi < patternParts.length) {
+    const pp = patternParts[pi];
+    if (pp === "**") {
+      if (pi === patternParts.length - 1) {
+        return true;
+      }
+      for (let i = ti; i <= typeParts.length; i++) {
+        const remaining = typeParts.slice(i).join(".");
+        const remainingPattern = patternParts.slice(pi + 1).join(".");
+        if (matchEventType(remaining, remainingPattern)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    if (pp === "*") {
+      ti++;
+      pi++;
+      continue;
+    }
+    if (pp !== typeParts[ti]) {
+      return false;
+    }
+    ti++;
+    pi++;
+  }
+  return ti === typeParts.length && pi === patternParts.length;
+}
+function formatTraceContext(ctx) {
+  const flags = ctx.traceFlags.toString(16).padStart(2, "0");
+  return `00-${ctx.traceId}-${ctx.spanId}-${flags}`;
+}
+function validateEvent(event) {
+  if (!event || typeof event !== "object") {
+    return false;
+  }
+  const e = event;
+  if (e["specversion"] !== "1.0") return false;
+  if (typeof e["type"] !== "string" || e["type"].length === 0) return false;
+  if (typeof e["source"] !== "string" || e["source"].length === 0) return false;
+  if (typeof e["id"] !== "string" || e["id"].length === 0) return false;
+  if (typeof e["time"] !== "string") return false;
+  return true;
+}
+function validateCompactEvent(event) {
+  if (!event || typeof event !== "object") {
+    return false;
+  }
+  const e = event;
+  if (typeof e["e"] !== "string" || e["e"].length === 0) return false;
+  if (typeof e["s"] !== "string" || e["s"].length === 0) return false;
+  if (typeof e["i"] !== "string" || e["i"].length === 0) return false;
+  if (typeof e["t"] !== "number") return false;
+  return true;
+}
+
+// src/events/handler.ts
+var EventHandlerRegistry = class {
+  handlers = /* @__PURE__ */ new Map();
+  logger;
+  deadLetterQueue;
+  defaultOptions;
+  constructor(options = {}) {
+    this.logger = options.logger ?? createLogger({ name: "event-handler" });
+    if (options.deadLetterQueue) {
+      this.deadLetterQueue = options.deadLetterQueue;
+    }
+    const defaultOpts = {
+      retries: options.defaultOptions?.retries ?? 3,
+      backoff: options.defaultOptions?.backoff ?? "exponential",
+      maxDelay: options.defaultOptions?.maxDelay ?? 3e4,
+      onExhausted: options.defaultOptions?.onExhausted ?? "log"
+    };
+    if (options.defaultOptions?.deadLetter) {
+      defaultOpts.deadLetter = options.defaultOptions.deadLetter;
+    }
+    this.defaultOptions = defaultOpts;
+  }
+  /**
+   * Register an event handler
+   */
+  register(pattern, handler, options) {
+    const registration = {
+      pattern,
+      handler,
+      options: {
+        ...this.defaultOptions,
+        ...options
+      }
+    };
+    const handlers = this.handlers.get(pattern) ?? [];
+    handlers.push(registration);
+    this.handlers.set(pattern, handlers);
+    this.logger.debug(`Handler registered for pattern: ${pattern}`);
+    return () => {
+      const currentHandlers = this.handlers.get(pattern);
+      if (currentHandlers) {
+        const index = currentHandlers.indexOf(registration);
+        if (index !== -1) {
+          currentHandlers.splice(index, 1);
+          if (currentHandlers.length === 0) {
+            this.handlers.delete(pattern);
+          }
+          this.logger.debug(`Handler unregistered for pattern: ${pattern}`);
+        }
+      }
+    };
+  }
+  /**
+   * Handle an event
+   */
+  async handle(event) {
+    const matchingHandlers = this.getMatchingHandlers(event.type);
+    if (matchingHandlers.length === 0) {
+      this.logger.debug(`No handlers for event type: ${event.type}`, {
+        eventId: event.id
+      });
+      return;
+    }
+    this.logger.debug(`Handling event: ${event.type}`, {
+      eventId: event.id,
+      handlerCount: matchingHandlers.length
+    });
+    const results = await Promise.allSettled(
+      matchingHandlers.map((reg) => this.executeHandler(event, reg))
+    );
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      if (result?.status === "rejected") {
+        this.logger.error(
+          `Handler failed for ${event.type}`,
+          result.reason,
+          { eventId: event.id, pattern: matchingHandlers[i]?.pattern }
+        );
+      }
+    }
+  }
+  /**
+   * Execute a single handler with retry logic
+   */
+  async executeHandler(event, registration) {
+    const { handler, options } = registration;
+    const maxAttempts = options.retries + 1;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const context = {
+          logger: this.logger.child({
+            eventId: event.id,
+            pattern: registration.pattern,
+            attempt
+          }),
+          attempt,
+          maxAttempts,
+          isRetry: attempt > 1
+        };
+        if (event.parstracecontext) {
+          const traceCtx = parseTraceContext(event.parstracecontext);
+          if (traceCtx) {
+            context.traceContext = traceCtx;
+          }
+        }
+        await handler(event, context);
+        return;
+      } catch (error) {
+        lastError = error;
+        if (attempt < maxAttempts) {
+          const delay = this.calculateBackoff(attempt, options);
+          this.logger.warn(
+            `Handler failed, retrying in ${delay}ms`,
+            { eventId: event.id, attempt, maxAttempts }
+          );
+          await sleep2(delay);
+        }
+      }
+    }
+    await this.handleExhausted(event, registration, lastError);
+  }
+  /**
+   * Calculate backoff delay
+   */
+  calculateBackoff(attempt, options) {
+    const baseDelay = 100;
+    if (options.backoff === "exponential") {
+      return Math.min(baseDelay * Math.pow(2, attempt - 1), options.maxDelay);
+    }
+    return Math.min(baseDelay * attempt, options.maxDelay);
+  }
+  /**
+   * Handle exhausted retries
+   */
+  async handleExhausted(event, registration, error) {
+    const { options } = registration;
+    if (options.deadLetter && this.deadLetterQueue) {
+      await this.deadLetterQueue.add({
+        event,
+        error: error.message,
+        pattern: registration.pattern,
+        attempts: options.retries + 1
+      });
+    }
+    switch (options.onExhausted) {
+      case "alert":
+        this.logger.error(
+          `[ALERT] Event handler exhausted all retries`,
+          error,
+          {
+            eventId: event.id,
+            eventType: event.type,
+            pattern: registration.pattern
+          }
+        );
+        break;
+      case "discard":
+        this.logger.debug(`Event discarded after exhausted retries`, {
+          eventId: event.id
+        });
+        break;
+      case "log":
+      default:
+        this.logger.warn(`Event handler exhausted all retries`, {
+          eventId: event.id,
+          error: error.message
+        });
+    }
+  }
+  /**
+   * Get handlers matching an event type
+   */
+  getMatchingHandlers(eventType) {
+    const matching = [];
+    for (const [pattern, handlers] of this.handlers) {
+      if (matchEventType(eventType, pattern)) {
+        matching.push(...handlers);
+      }
+    }
+    return matching;
+  }
+  /**
+   * Get all registered patterns
+   */
+  getPatterns() {
+    return Array.from(this.handlers.keys());
+  }
+  /**
+   * Check if a pattern has handlers
+   */
+  hasHandlers(pattern) {
+    return this.handlers.has(pattern);
+  }
+  /**
+   * Clear all handlers
+   */
+  clear() {
+    this.handlers.clear();
+  }
+};
+function createEventHandlerRegistry(options) {
+  return new EventHandlerRegistry(options);
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseTraceContext(traceparent) {
+  const parts = traceparent.split("-");
+  if (parts.length !== 4) return void 0;
+  const [, traceId, spanId, flags] = parts;
+  if (!traceId || !spanId || !flags) return void 0;
+  return {
+    traceId,
+    spanId,
+    traceFlags: parseInt(flags, 16)
+  };
+}
+
+// src/events/transports/memory.ts
+var MemoryEventTransport = class {
+  name = "memory";
+  registry;
+  logger;
+  sync;
+  pendingEvents = [];
+  processing = false;
+  constructor(options = {}) {
+    this.logger = options.logger ?? createLogger2({ name: "memory-transport" });
+    this.sync = options.sync ?? false;
+    const registryOptions = {
+      logger: this.logger
+    };
+    if (options.defaultHandlerOptions) {
+      registryOptions.defaultOptions = options.defaultHandlerOptions;
+    }
+    this.registry = new EventHandlerRegistry(registryOptions);
+  }
+  /**
+   * Emit an event
+   */
+  async emit(event) {
+    this.logger.debug(`Event emitted: ${event.type}`, {
+      eventId: event.id,
+      tenantId: event.parstenantid
+    });
+    if (this.sync) {
+      await this.registry.handle(event);
+    } else {
+      this.pendingEvents.push(event);
+      this.processQueue();
+    }
+  }
+  /**
+   * Subscribe to events
+   */
+  subscribe(eventType, handler, options) {
+    return this.registry.register(eventType, handler, options);
+  }
+  /**
+   * Process pending events asynchronously
+   */
+  async processQueue() {
+    if (this.processing) return;
+    this.processing = true;
+    try {
+      while (this.pendingEvents.length > 0) {
+        const event = this.pendingEvents.shift();
+        if (event) {
+          await this.registry.handle(event);
+        }
+      }
+    } finally {
+      this.processing = false;
+    }
+  }
+  /**
+   * Wait for all pending events to be processed
+   */
+  async flush() {
+    while (this.pendingEvents.length > 0 || this.processing) {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+  }
+  /**
+   * Get pending event count
+   */
+  get pendingCount() {
+    return this.pendingEvents.length;
+  }
+  /**
+   * Get registered patterns
+   */
+  getPatterns() {
+    return this.registry.getPatterns();
+  }
+  /**
+   * Clear all subscriptions
+   */
+  clear() {
+    this.registry.clear();
+    this.pendingEvents.length = 0;
+  }
+  /**
+   * Close the transport
+   */
+  async close() {
+    await this.flush();
+    this.clear();
+  }
+};
+function createMemoryEventTransport(options) {
+  return new MemoryEventTransport(options);
+}
+var GlobalEventBus = class _GlobalEventBus {
+  static instance = null;
+  transports = /* @__PURE__ */ new Map();
+  logger;
+  constructor() {
+    this.logger = createLogger2({ name: "global-event-bus" });
+  }
+  static getInstance() {
+    if (!_GlobalEventBus.instance) {
+      _GlobalEventBus.instance = new _GlobalEventBus();
+    }
+    return _GlobalEventBus.instance;
+  }
+  /**
+   * Register a service's event transport
+   */
+  register(serviceName, transport) {
+    if (this.transports.has(serviceName)) {
+      throw new Error(`Service already registered: ${serviceName}`);
+    }
+    this.transports.set(serviceName, transport);
+    this.logger.debug(`Service registered: ${serviceName}`);
+  }
+  /**
+   * Unregister a service
+   */
+  unregister(serviceName) {
+    const deleted = this.transports.delete(serviceName);
+    if (deleted) {
+      this.logger.debug(`Service unregistered: ${serviceName}`);
+    }
+    return deleted;
+  }
+  /**
+   * Broadcast an event to all services (except source)
+   */
+  async broadcast(event, excludeSource) {
+    const promises = [];
+    for (const [name, transport] of this.transports) {
+      if (name !== excludeSource) {
+        promises.push(transport.emit(event));
+      }
+    }
+    await Promise.allSettled(promises);
+  }
+  /**
+   * Send an event to a specific service
+   */
+  async send(serviceName, event) {
+    const transport = this.transports.get(serviceName);
+    if (!transport) {
+      this.logger.warn(`Target service not found: ${serviceName}`, {
+        eventId: event.id
+      });
+      return;
+    }
+    await transport.emit(event);
+  }
+  /**
+   * Get all registered service names
+   */
+  getServices() {
+    return Array.from(this.transports.keys());
+  }
+  /**
+   * Clear all registrations
+   */
+  clear() {
+    this.transports.clear();
+  }
+  /**
+   * Reset singleton (for testing)
+   */
+  static reset() {
+    _GlobalEventBus.instance = null;
+  }
+};
+function getGlobalEventBus() {
+  return GlobalEventBus.getInstance();
+}
+
+// src/tracing/tracer.ts
+import { createLogger as createLogger4 } from "@parsrun/core";
+
+// src/tracing/context.ts
+function generateTraceId() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function generateSpanId() {
+  const bytes = new Uint8Array(8);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function createTraceContext(options) {
+  const ctx = {
+    traceId: options?.traceId ?? generateTraceId(),
+    spanId: options?.spanId ?? generateSpanId(),
+    traceFlags: options?.traceFlags ?? 1
+    // Default: sampled
+  };
+  if (options?.traceState) {
+    ctx.traceState = options.traceState;
+  }
+  return ctx;
+}
+function createChildContext(parent) {
+  const ctx = {
+    traceId: parent.traceId,
+    spanId: generateSpanId(),
+    traceFlags: parent.traceFlags
+  };
+  if (parent.traceState) {
+    ctx.traceState = parent.traceState;
+  }
+  return ctx;
+}
+function formatTraceparent2(ctx) {
+  const version = "00";
+  const flags = ctx.traceFlags.toString(16).padStart(2, "0");
+  return `${version}-${ctx.traceId}-${ctx.spanId}-${flags}`;
+}
+function parseTraceparent2(header) {
+  const parts = header.trim().split("-");
+  if (parts.length !== 4) {
+    return null;
+  }
+  const [version, traceId, spanId, flags] = parts;
+  if (version !== "00") {
+    return null;
+  }
+  if (!traceId || traceId.length !== 32 || !/^[0-9a-f]+$/i.test(traceId)) {
+    return null;
+  }
+  if (!spanId || spanId.length !== 16 || !/^[0-9a-f]+$/i.test(spanId)) {
+    return null;
+  }
+  if (!flags || flags.length !== 2 || !/^[0-9a-f]+$/i.test(flags)) {
+    return null;
+  }
+  return {
+    traceId: traceId.toLowerCase(),
+    spanId: spanId.toLowerCase(),
+    traceFlags: parseInt(flags, 16)
+  };
+}
+function formatTracestate(state) {
+  return Object.entries(state).map(([key, value]) => `${key}=${value}`).join(",");
+}
+function parseTracestate(header) {
+  const state = {};
+  for (const pair of header.split(",")) {
+    const [key, value] = pair.trim().split("=");
+    if (key && value) {
+      state[key] = value;
+    }
+  }
+  return state;
+}
+var TraceContextManager = class {
+  stack = [];
+  /**
+   * Get current trace context
+   */
+  current() {
+    return this.stack[this.stack.length - 1];
+  }
+  /**
+   * Run a function with a trace context
+   */
+  async run(ctx, fn) {
+    this.stack.push(ctx);
+    try {
+      return await fn();
+    } finally {
+      this.stack.pop();
+    }
+  }
+  /**
+   * Run a function with a new child context
+   */
+  async runChild(fn) {
+    const parent = this.current();
+    const child = parent ? createChildContext(parent) : createTraceContext();
+    return this.run(child, fn);
+  }
+  /**
+   * Create context from incoming request headers
+   */
+  fromHeaders(headers) {
+    const traceparent = headers instanceof Headers ? headers.get("traceparent") : headers["traceparent"];
+    if (!traceparent) {
+      return void 0;
+    }
+    const ctx = parseTraceparent2(traceparent);
+    if (!ctx) {
+      return void 0;
+    }
+    const tracestate = headers instanceof Headers ? headers.get("tracestate") : headers["tracestate"];
+    if (tracestate) {
+      ctx.traceState = tracestate;
+    }
+    return ctx;
+  }
+  /**
+   * Add trace context to outgoing request headers
+   */
+  toHeaders(ctx) {
+    const headers = {
+      traceparent: formatTraceparent2(ctx)
+    };
+    if (ctx.traceState) {
+      headers["tracestate"] = ctx.traceState;
+    }
+    return headers;
+  }
+  /**
+   * Check if current context is sampled
+   */
+  isSampled() {
+    const ctx = this.current();
+    return ctx ? (ctx.traceFlags & 1) === 1 : false;
+  }
+  /**
+   * Clear all contexts (for testing)
+   */
+  clear() {
+    this.stack.length = 0;
+  }
+};
+function shouldSample(sampler, traceId) {
+  if (sampler === "always") {
+    return true;
+  }
+  if (sampler === "never") {
+    return false;
+  }
+  if (traceId) {
+    const hash = parseInt(traceId.slice(-8), 16);
+    const threshold = Math.floor(sampler.ratio * 4294967295);
+    return hash < threshold;
+  }
+  return Math.random() < sampler.ratio;
+}
+
+// src/tracing/spans.ts
+function createSpan(options) {
+  let traceContext;
+  if (options.parent) {
+    traceContext = {
+      traceId: options.parent.traceId,
+      spanId: generateSpanId(),
+      traceFlags: options.parent.traceFlags
+    };
+    if (options.parent.traceState) {
+      traceContext.traceState = options.parent.traceState;
+    }
+  } else {
+    traceContext = createTraceContext();
+  }
+  const span = {
+    name: options.name,
+    kind: options.kind ?? "internal",
+    traceContext,
+    startTime: options.startTime ?? Date.now(),
+    status: "unset",
+    attributes: options.attributes ?? {},
+    events: []
+  };
+  if (options.parent?.spanId) {
+    span.parentSpanId = options.parent.spanId;
+  }
+  return span;
+}
+var SpanManager = class {
+  spans = /* @__PURE__ */ new Map();
+  /**
+   * Start a new span
+   */
+  startSpan(options) {
+    const span = createSpan(options);
+    this.spans.set(span.traceContext.spanId, span);
+    return span;
+  }
+  /**
+   * End a span
+   */
+  endSpan(span, status) {
+    span.endTime = Date.now();
+    if (status) {
+      span.status = status;
+    } else if (span.status === "unset") {
+      span.status = "ok";
+    }
+    return span;
+  }
+  /**
+   * Set span attribute
+   */
+  setAttribute(span, key, value) {
+    span.attributes[key] = value;
+  }
+  /**
+   * Set multiple span attributes
+   */
+  setAttributes(span, attributes) {
+    Object.assign(span.attributes, attributes);
+  }
+  /**
+   * Add span event
+   */
+  addEvent(span, name, attributes) {
+    const event = {
+      name,
+      time: Date.now()
+    };
+    if (attributes) {
+      event.attributes = attributes;
+    }
+    span.events.push(event);
+  }
+  /**
+   * Set span status
+   */
+  setStatus(span, status) {
+    span.status = status;
+  }
+  /**
+   * Record exception on span
+   */
+  recordException(span, error) {
+    span.status = "error";
+    this.addEvent(span, "exception", {
+      "exception.type": error.name,
+      "exception.message": error.message,
+      "exception.stacktrace": error.stack ?? ""
+    });
+  }
+  /**
+   * Get span by ID
+   */
+  getSpan(spanId) {
+    return this.spans.get(spanId);
+  }
+  /**
+   * Get all completed spans and clear
+   */
+  flush() {
+    const completed = Array.from(this.spans.values()).filter((s) => s.endTime);
+    for (const span of completed) {
+      this.spans.delete(span.traceContext.spanId);
+    }
+    return completed;
+  }
+  /**
+   * Clear all spans
+   */
+  clear() {
+    this.spans.clear();
+  }
+};
+function getSpanDuration(span) {
+  if (!span.endTime) return void 0;
+  return span.endTime - span.startTime;
+}
+function isSpanCompleted(span) {
+  return span.endTime !== void 0;
+}
+function spanToLogObject(span) {
+  return {
+    traceId: span.traceContext.traceId,
+    spanId: span.traceContext.spanId,
+    parentSpanId: span.parentSpanId,
+    name: span.name,
+    kind: span.kind,
+    status: span.status,
+    startTime: new Date(span.startTime).toISOString(),
+    endTime: span.endTime ? new Date(span.endTime).toISOString() : void 0,
+    durationMs: getSpanDuration(span),
+    attributes: span.attributes,
+    events: span.events.map((e) => ({
+      name: e.name,
+      time: new Date(e.time).toISOString(),
+      attributes: e.attributes
+    }))
+  };
+}
+var SpanAttributes = {
+  // HTTP
+  HTTP_METHOD: "http.method",
+  HTTP_URL: "http.url",
+  HTTP_STATUS_CODE: "http.status_code",
+  HTTP_REQUEST_CONTENT_LENGTH: "http.request_content_length",
+  HTTP_RESPONSE_CONTENT_LENGTH: "http.response_content_length",
+  // RPC
+  RPC_SYSTEM: "rpc.system",
+  RPC_SERVICE: "rpc.service",
+  RPC_METHOD: "rpc.method",
+  // Database
+  DB_SYSTEM: "db.system",
+  DB_NAME: "db.name",
+  DB_OPERATION: "db.operation",
+  DB_STATEMENT: "db.statement",
+  // Messaging
+  MESSAGING_SYSTEM: "messaging.system",
+  MESSAGING_DESTINATION: "messaging.destination",
+  MESSAGING_MESSAGE_ID: "messaging.message_id",
+  // Service
+  SERVICE_NAME: "service.name",
+  SERVICE_VERSION: "service.version",
+  // Error
+  EXCEPTION_TYPE: "exception.type",
+  EXCEPTION_MESSAGE: "exception.message",
+  EXCEPTION_STACKTRACE: "exception.stacktrace",
+  // Custom Pars attributes
+  PARS_TENANT_ID: "pars.tenant_id",
+  PARS_USER_ID: "pars.user_id",
+  PARS_REQUEST_ID: "pars.request_id"
+};
+
+// src/tracing/exporters.ts
+import { createLogger as createLogger3 } from "@parsrun/core";
+var ConsoleExporter = class {
+  name = "console";
+  logger;
+  pretty;
+  includeAttributes;
+  includeEvents;
+  constructor(options = {}) {
+    this.logger = options.logger ?? createLogger3({ name: "trace-exporter" });
+    this.pretty = options.pretty ?? true;
+    this.includeAttributes = options.includeAttributes ?? true;
+    this.includeEvents = options.includeEvents ?? true;
+  }
+  async export(spans) {
+    for (const span of spans) {
+      const duration = getSpanDuration(span);
+      const status = span.status === "error" ? "ERROR" : span.status === "ok" ? "OK" : "UNSET";
+      if (this.pretty) {
+        const indent = span.parentSpanId ? "  \u2514\u2500" : "\u2500\u2500";
+        const statusIcon = span.status === "error" ? "\u2717" : span.status === "ok" ? "\u2713" : "\u25CB";
+        const durationStr = duration !== void 0 ? `${duration}ms` : "?ms";
+        console.log(
+          `${indent} ${statusIcon} [${span.kind}] ${span.name} (${durationStr}) trace=${span.traceContext.traceId.slice(0, 8)}`
+        );
+        if (this.includeAttributes && Object.keys(span.attributes).length > 0) {
+          console.log(`     attributes:`, span.attributes);
+        }
+        if (this.includeEvents && span.events.length > 0) {
+          for (const event of span.events) {
+            console.log(`     event: ${event.name}`, event.attributes ?? "");
+          }
+        }
+      } else {
+        const logObj = spanToLogObject(span);
+        this.logger.info(`Span: ${span.name}`, {
+          ...logObj,
+          status,
+          durationMs: duration
+        });
+      }
+    }
+  }
+  async shutdown() {
+  }
+};
+function createConsoleExporter(options) {
+  return new ConsoleExporter(options);
+}
+var OtlpExporter = class {
+  name = "otlp";
+  endpoint;
+  serviceName;
+  serviceVersion;
+  headers;
+  timeout;
+  batchSize;
+  flushInterval;
+  logger;
+  buffer = [];
+  flushTimer = null;
+  constructor(options) {
+    this.endpoint = options.endpoint.replace(/\/$/, "");
+    this.serviceName = options.serviceName;
+    this.serviceVersion = options.serviceVersion ?? "1.0.0";
+    this.headers = options.headers ?? {};
+    this.timeout = options.timeout ?? 1e4;
+    this.batchSize = options.batchSize ?? 100;
+    this.flushInterval = options.flushInterval ?? 5e3;
+    this.logger = options.logger ?? createLogger3({ name: "otlp-exporter" });
+    this.flushTimer = setInterval(() => this.flush(), this.flushInterval);
+  }
+  async export(spans) {
+    this.buffer.push(...spans);
+    if (this.buffer.length >= this.batchSize) {
+      await this.flush();
+    }
+  }
+  async flush() {
+    if (this.buffer.length === 0) return;
+    const spansToExport = this.buffer.splice(0, this.batchSize);
+    try {
+      const payload = this.buildOtlpPayload(spansToExport);
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      try {
+        const response = await fetch(`${this.endpoint}/v1/traces`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...this.headers
+          },
+          body: JSON.stringify(payload),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          throw new Error(`OTLP export failed: ${response.status} ${response.statusText}`);
+        }
+        this.logger.debug(`Exported ${spansToExport.length} spans to OTLP`);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (error) {
+      this.logger.error(`Failed to export spans to OTLP`, error);
+      this.buffer.unshift(...spansToExport);
+    }
+  }
+  buildOtlpPayload(spans) {
+    return {
+      resourceSpans: [
+        {
+          resource: {
+            attributes: [
+              { key: "service.name", value: { stringValue: this.serviceName } },
+              { key: "service.version", value: { stringValue: this.serviceVersion } }
+            ]
+          },
+          scopeSpans: [
+            {
+              scope: {
+                name: "@parsrun/service",
+                version: "0.1.0"
+              },
+              spans: spans.map((span) => this.convertSpan(span))
+            }
+          ]
+        }
+      ]
+    };
+  }
+  convertSpan(span) {
+    const otlpSpan = {
+      traceId: span.traceContext.traceId,
+      spanId: span.traceContext.spanId,
+      name: span.name,
+      kind: this.convertSpanKind(span.kind),
+      startTimeUnixNano: String(span.startTime * 1e6),
+      attributes: Object.entries(span.attributes).map(([key, value]) => ({
+        key,
+        value: this.convertAttributeValue(value)
+      })),
+      events: span.events.map((event) => ({
+        name: event.name,
+        timeUnixNano: String(event.time * 1e6),
+        attributes: event.attributes ? Object.entries(event.attributes).map(([key, value]) => ({
+          key,
+          value: this.convertAttributeValue(value)
+        })) : []
+      })),
+      status: {
+        code: span.status === "error" ? 2 : span.status === "ok" ? 1 : 0
+      }
+    };
+    if (span.parentSpanId) {
+      otlpSpan.parentSpanId = span.parentSpanId;
+    }
+    if (span.endTime) {
+      otlpSpan.endTimeUnixNano = String(span.endTime * 1e6);
+    }
+    return otlpSpan;
+  }
+  convertSpanKind(kind) {
+    switch (kind) {
+      case "internal":
+        return 1;
+      case "server":
+        return 2;
+      case "client":
+        return 3;
+      case "producer":
+        return 4;
+      case "consumer":
+        return 5;
+      default:
+        return 0;
+    }
+  }
+  convertAttributeValue(value) {
+    if (typeof value === "string") {
+      return { stringValue: value };
+    }
+    if (typeof value === "number") {
+      if (Number.isInteger(value)) {
+        return { intValue: String(value) };
+      }
+      return { doubleValue: value };
+    }
+    if (typeof value === "boolean") {
+      return { boolValue: value };
+    }
+    if (Array.isArray(value)) {
+      return {
+        arrayValue: {
+          values: value.map((v) => this.convertAttributeValue(v))
+        }
+      };
+    }
+    return { stringValue: String(value) };
+  }
+  async shutdown() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+  }
+};
+function createOtlpExporter(options) {
+  return new OtlpExporter(options);
+}
+
+// src/tracing/tracer.ts
+var Tracer = class {
+  serviceName;
+  serviceVersion;
+  sampler;
+  exporter;
+  logger;
+  contextManager;
+  spanManager;
+  enabled;
+  flushTimer = null;
+  constructor(options) {
+    this.serviceName = options.serviceName;
+    this.serviceVersion = options.serviceVersion ?? "1.0.0";
+    this.enabled = options.config?.enabled ?? true;
+    this.sampler = options.config?.sampler ?? { ratio: 0.1 };
+    this.exporter = options.exporter ?? new ConsoleExporter();
+    this.logger = options.logger ?? createLogger4({ name: `tracer:${options.serviceName}` });
+    this.contextManager = new TraceContextManager();
+    this.spanManager = new SpanManager();
+    if (this.enabled) {
+      this.flushTimer = setInterval(() => this.flush(), 5e3);
+    }
+  }
+  /**
+   * Start a new span
+   */
+  startSpan(name, options) {
+    if (!this.enabled) return null;
+    const parent = options?.parent ?? this.contextManager.current();
+    if (!parent && !shouldSample(this.sampler)) {
+      return null;
+    }
+    const spanOptions = {
+      name,
+      kind: options?.kind ?? "internal",
+      attributes: {
+        [SpanAttributes.SERVICE_NAME]: this.serviceName,
+        [SpanAttributes.SERVICE_VERSION]: this.serviceVersion,
+        ...options?.attributes
+      }
+    };
+    if (parent) {
+      spanOptions.parent = parent;
+    }
+    const span = this.spanManager.startSpan(spanOptions);
+    return span;
+  }
+  /**
+   * End a span
+   */
+  endSpan(span, error) {
+    if (!span) return;
+    if (error) {
+      this.spanManager.recordException(span, error);
+    }
+    this.spanManager.endSpan(span, error ? "error" : "ok");
+  }
+  /**
+   * Run a function with automatic span creation
+   */
+  async trace(name, fn, options) {
+    const span = this.startSpan(name, options);
+    if (!span) {
+      return fn(null);
+    }
+    try {
+      const result = await this.contextManager.run(span.traceContext, () => fn(span));
+      this.endSpan(span);
+      return result;
+    } catch (error) {
+      this.endSpan(span, error);
+      throw error;
+    }
+  }
+  /**
+   * Add attribute to current span
+   */
+  setAttribute(key, value) {
+    const ctx = this.contextManager.current();
+    if (!ctx) return;
+    const span = this.spanManager.getSpan(ctx.spanId);
+    if (span) {
+      this.spanManager.setAttribute(span, key, value);
+    }
+  }
+  /**
+   * Add event to current span
+   */
+  addEvent(name, attributes) {
+    const ctx = this.contextManager.current();
+    if (!ctx) return;
+    const span = this.spanManager.getSpan(ctx.spanId);
+    if (span) {
+      this.spanManager.addEvent(span, name, attributes);
+    }
+  }
+  /**
+   * Get current trace context
+   */
+  currentContext() {
+    return this.contextManager.current();
+  }
+  /**
+   * Get context manager for advanced use
+   */
+  getContextManager() {
+    return this.contextManager;
+  }
+  /**
+   * Extract trace context from incoming request
+   */
+  extract(headers) {
+    return this.contextManager.fromHeaders(headers);
+  }
+  /**
+   * Inject trace context into outgoing request headers
+   */
+  inject(ctx) {
+    const context = ctx ?? this.contextManager.current();
+    if (!context) return {};
+    return this.contextManager.toHeaders(context);
+  }
+  /**
+   * Flush completed spans to exporter
+   */
+  async flush() {
+    const spans = this.spanManager.flush();
+    if (spans.length > 0) {
+      try {
+        await this.exporter.export(spans);
+      } catch (error) {
+        this.logger.error("Failed to export spans", error);
+      }
+    }
+  }
+  /**
+   * Shutdown tracer
+   */
+  async shutdown() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+    await this.exporter.shutdown();
+    this.spanManager.clear();
+    this.contextManager.clear();
+  }
+};
+function createTracer(options) {
+  return new Tracer(options);
+}
+var globalTracer = null;
+function getGlobalTracer() {
+  return globalTracer;
+}
+function setGlobalTracer(tracer) {
+  globalTracer = tracer;
+}
+function resetGlobalTracer() {
+  globalTracer = null;
+}
+function createTracingMiddleware(tracer) {
+  return async (request, next) => {
+    const parentCtx = tracer.extract(request.headers);
+    const url = new URL(request.url);
+    const spanOpts = {
+      kind: "server",
+      attributes: {
+        [SpanAttributes.HTTP_METHOD]: request.method,
+        [SpanAttributes.HTTP_URL]: request.url
+      }
+    };
+    if (parentCtx) {
+      spanOpts.parent = parentCtx;
+    }
+    const span = tracer.startSpan(`${request.method} ${url.pathname}`, spanOpts);
+    if (!span) {
+      return next();
+    }
+    try {
+      const response = await tracer.getContextManager().run(span.traceContext, next);
+      tracer.endSpan(span);
+      span.attributes[SpanAttributes.HTTP_STATUS_CODE] = response.status;
+      return response;
+    } catch (error) {
+      tracer.endSpan(span, error);
+      throw error;
+    }
+  };
+}
+function createRpcTracing(tracer) {
+  return {
+    /**
+     * Trace an outgoing RPC call
+     */
+    async traceCall(service, method, fn) {
+      return tracer.trace(
+        `rpc.${service}.${method}`,
+        fn,
+        {
+          kind: "client",
+          attributes: {
+            [SpanAttributes.RPC_SYSTEM]: "pars",
+            [SpanAttributes.RPC_SERVICE]: service,
+            [SpanAttributes.RPC_METHOD]: method
+          }
+        }
+      );
+    },
+    /**
+     * Trace an incoming RPC request
+     */
+    async traceHandler(service, method, fn, parentCtx) {
+      const handlerOpts = {
+        kind: "server",
+        attributes: {
+          [SpanAttributes.RPC_SYSTEM]: "pars",
+          [SpanAttributes.RPC_SERVICE]: service,
+          [SpanAttributes.RPC_METHOD]: method
+        }
+      };
+      if (parentCtx) {
+        handlerOpts.parent = parentCtx;
+      }
+      const span = tracer.startSpan(`rpc.${service}.${method}`, handlerOpts);
+      if (!span) {
+        return fn();
+      }
+      try {
+        const result = await tracer.getContextManager().run(span.traceContext, fn);
+        tracer.endSpan(span);
+        return result;
+      } catch (error) {
+        tracer.endSpan(span, error);
+        throw error;
+      }
+    }
+  };
+}
+
+// src/client.ts
+var ServiceClientImpl = class {
+  name;
+  rpcClient;
+  eventTransport;
+  config;
+  tracer;
+  constructor(definition, rpcTransport, eventTransport, config, _logger) {
+    this.name = definition.name;
+    this.config = mergeConfig(config);
+    this.tracer = getGlobalTracer();
+    this.rpcClient = new RpcClient({
+      service: definition.name,
+      transport: rpcTransport,
+      config: this.config
+    });
+    this.eventTransport = eventTransport;
+  }
+  /**
+   * Execute a query
+   */
+  async query(method, input) {
+    const methodName = String(method);
+    const traceContext = this.tracer?.currentContext();
+    if (this.tracer && traceContext) {
+      return this.tracer.trace(
+        `rpc.${this.name}.${methodName}`,
+        async () => {
+          return this.rpcClient.query(methodName, input, {
+            traceContext
+          });
+        },
+        { kind: "client" }
+      );
+    }
+    return this.rpcClient.query(methodName, input);
+  }
+  /**
+   * Execute a mutation
+   */
+  async mutate(method, input) {
+    const methodName = String(method);
+    const traceContext = this.tracer?.currentContext();
+    if (this.tracer && traceContext) {
+      return this.tracer.trace(
+        `rpc.${this.name}.${methodName}`,
+        async () => {
+          return this.rpcClient.mutate(methodName, input, {
+            traceContext
+          });
+        },
+        { kind: "client" }
+      );
+    }
+    return this.rpcClient.mutate(methodName, input);
+  }
+  /**
+   * Emit an event
+   */
+  async emit(eventType, data) {
+    const type = String(eventType);
+    const traceContext = this.tracer?.currentContext();
+    const event = {
+      specversion: "1.0",
+      type,
+      source: this.name,
+      id: generateId3(),
+      time: (/* @__PURE__ */ new Date()).toISOString(),
+      data
+    };
+    if (traceContext) {
+      event.parstracecontext = `00-${traceContext.traceId}-${traceContext.spanId}-01`;
+    }
+    await this.eventTransport.emit(event);
+  }
+  /**
+   * Subscribe to events
+   */
+  on(eventType, handler, options) {
+    return this.eventTransport.subscribe(eventType, handler, options);
+  }
+  /**
+   * Get circuit breaker state
+   */
+  getCircuitState() {
+    return this.rpcClient.getCircuitState();
+  }
+  /**
+   * Close the client
+   */
+  async close() {
+    await this.rpcClient.close();
+    await this.eventTransport.close?.();
+  }
+};
+function useService(serviceName, options = {}) {
+  const mode = options.mode ?? "embedded";
+  const config = options.config ?? {};
+  let rpcTransport;
+  let eventTransport;
+  switch (mode) {
+    case "embedded": {
+      const registry = getEmbeddedRegistry();
+      if (!registry.has(serviceName)) {
+        throw new Error(
+          `Service not found in embedded registry: ${serviceName}. Make sure the service is registered before using it.`
+        );
+      }
+      rpcTransport = registry.createTransport(serviceName);
+      const eventBus = getGlobalEventBus();
+      const services = eventBus.getServices();
+      if (services.includes(serviceName)) {
+        eventTransport = createMemoryEventTransport();
+      } else {
+        eventTransport = createMemoryEventTransport();
+      }
+      break;
+    }
+    case "http": {
+      if (!options.baseUrl) {
+        throw new Error("baseUrl is required for HTTP mode");
+      }
+      rpcTransport = createHttpTransport({
+        baseUrl: options.baseUrl
+      });
+      eventTransport = createMemoryEventTransport();
+      break;
+    }
+    case "binding": {
+      if (!options.binding) {
+        throw new Error("binding is required for binding mode");
+      }
+      rpcTransport = createBindingTransport(serviceName, options.binding);
+      eventTransport = createMemoryEventTransport();
+      break;
+    }
+    default:
+      throw new Error(`Unknown service client mode: ${mode}`);
+  }
+  if (options.rpcTransport) {
+    rpcTransport = options.rpcTransport;
+  }
+  if (options.eventTransport) {
+    eventTransport = options.eventTransport;
+  }
+  const definition = {
+    name: serviceName,
+    version: "1.x"
+  };
+  return new ServiceClientImpl(
+    definition,
+    rpcTransport,
+    eventTransport,
+    config
+  );
+}
+function useTypedService(definition, options = {}) {
+  return useService(definition.name, options);
+}
+function createBindingTransport(_serviceName, binding) {
+  return {
+    name: "binding",
+    async call(request) {
+      const response = await binding.fetch("http://internal/rpc", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Request-ID": request.id,
+          "X-Service": request.service,
+          "X-Method": request.method
+        },
+        body: JSON.stringify(request)
+      });
+      return response.json();
+    },
+    async close() {
+    }
+  };
+}
+var ServiceRegistry = class {
+  clients = /* @__PURE__ */ new Map();
+  config;
+  constructor(config) {
+    this.config = config ?? {};
+  }
+  /**
+   * Get or create a service client
+   */
+  get(serviceName, options) {
+    let client = this.clients.get(serviceName);
+    if (!client) {
+      client = useService(serviceName, {
+        ...options,
+        config: { ...this.config, ...options?.config }
+      });
+      this.clients.set(serviceName, client);
+    }
+    return client;
+  }
+  /**
+   * Close all clients
+   */
+  async closeAll() {
+    const closePromises = Array.from(this.clients.values()).map((client) => {
+      if ("close" in client && typeof client.close === "function") {
+        return client.close();
+      }
+      return Promise.resolve();
+    });
+    await Promise.all(closePromises);
+    this.clients.clear();
+  }
+};
+function createServiceRegistry(config) {
+  return new ServiceRegistry(config);
+}
+
+// src/rpc/server.ts
+import { createLogger as createLogger5 } from "@parsrun/core";
+var RpcServer = class {
+  definition;
+  handlers;
+  logger;
+  defaultTimeout;
+  middleware;
+  constructor(options) {
+    this.definition = options.definition;
+    this.handlers = options.handlers;
+    this.logger = options.logger ?? createLogger5({ name: `rpc:${options.definition.name}` });
+    this.defaultTimeout = options.defaultTimeout ?? 3e4;
+    this.middleware = options.middleware ?? [];
+  }
+  /**
+   * Handle an RPC request
+   */
+  async handle(request) {
+    const startTime = Date.now();
+    const context = {
+      requestId: request.id,
+      service: request.service,
+      method: request.method,
+      type: request.type,
+      metadata: request.metadata ?? {},
+      logger: this.logger.child({ requestId: request.id, method: request.method })
+    };
+    if (request.traceContext) {
+      context.traceContext = request.traceContext;
+    }
+    try {
+      if (request.version && !satisfiesVersion(this.definition.version, request.version)) {
+        throw new VersionMismatchError(
+          this.definition.name,
+          request.version,
+          this.definition.version
+        );
+      }
+      const handler = this.getHandler(request.method, request.type);
+      if (!handler) {
+        throw new MethodNotFoundError(this.definition.name, request.method);
+      }
+      const deprecation = isMethodDeprecated(this.definition, request.method, request.type);
+      if (deprecation.deprecated) {
+        context.logger.warn(`Method ${request.method} is deprecated`, {
+          since: deprecation.since,
+          replacement: deprecation.replacement
+        });
+      }
+      const chain = this.buildMiddlewareChain(request, context, handler);
+      const timeout = getMethodTimeout(
+        this.definition,
+        request.method,
+        request.type,
+        this.defaultTimeout
+      );
+      const output = await Promise.race([
+        chain(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Handler timeout")), timeout)
+        )
+      ]);
+      const duration = Date.now() - startTime;
+      context.logger.info(`${request.type} ${request.method} completed`, { durationMs: duration });
+      const successResponse = {
+        id: request.id,
+        success: true,
+        version: this.definition.version,
+        output
+      };
+      if (request.traceContext) {
+        successResponse.traceContext = request.traceContext;
+      }
+      return successResponse;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const rpcError = toRpcError(error);
+      context.logger.error(`${request.type} ${request.method} failed`, error, {
+        durationMs: duration,
+        errorCode: rpcError.code
+      });
+      const errorData = {
+        code: rpcError.code,
+        message: rpcError.message,
+        retryable: rpcError.retryable
+      };
+      if (rpcError.details) {
+        errorData.details = rpcError.details;
+      }
+      if (rpcError.retryAfter !== void 0) {
+        errorData.retryAfter = rpcError.retryAfter;
+      }
+      const errorResponse = {
+        id: request.id,
+        success: false,
+        version: this.definition.version,
+        error: errorData
+      };
+      if (request.traceContext) {
+        errorResponse.traceContext = request.traceContext;
+      }
+      return errorResponse;
+    }
+  }
+  /**
+   * Get handler for a method
+   */
+  getHandler(method, type) {
+    const handlers = type === "query" ? this.handlers.queries : this.handlers.mutations;
+    return handlers?.[method];
+  }
+  /**
+   * Build middleware chain
+   */
+  buildMiddlewareChain(request, context, handler) {
+    let index = -1;
+    const dispatch = async (i) => {
+      if (i <= index) {
+        throw new Error("next() called multiple times");
+      }
+      index = i;
+      if (i < this.middleware.length) {
+        const mw = this.middleware[i];
+        return mw(request, context, () => dispatch(i + 1));
+      }
+      return handler(request.input, context);
+    };
+    return () => dispatch(0);
+  }
+  /**
+   * Get service definition
+   */
+  getDefinition() {
+    return this.definition;
+  }
+  /**
+   * Get registered methods
+   */
+  getMethods() {
+    return {
+      queries: Object.keys(this.handlers.queries ?? {}),
+      mutations: Object.keys(this.handlers.mutations ?? {})
+    };
+  }
+};
+function createRpcServer(options) {
+  return new RpcServer(options);
+}
+function loggingMiddleware() {
+  return async (request, context, next) => {
+    context.logger.debug(`Handling ${request.type} ${request.method}`, {
+      inputKeys: Object.keys(request.input)
+    });
+    const result = await next();
+    context.logger.debug(`Completed ${request.type} ${request.method}`);
+    return result;
+  };
+}
+function validationMiddleware(validators) {
+  return async (request, _context, next) => {
+    const validator = validators[request.method];
+    if (validator) {
+      request.input = validator(request.input);
+    }
+    return next();
+  };
+}
+function tenantMiddleware() {
+  return async (_request, context, next) => {
+    const tenantId = context.metadata["tenantId"];
+    if (tenantId) {
+      context.logger = context.logger.child({ tenantId });
+    }
+    return next();
+  };
+}
+
+// src/events/emitter.ts
+import { createLogger as createLogger6 } from "@parsrun/core";
+var EventEmitter = class {
+  service;
+  definition;
+  transport;
+  logger;
+  defaultTenantId;
+  validateEvents;
+  constructor(options) {
+    this.service = options.service;
+    if (options.definition) {
+      this.definition = options.definition;
+    }
+    this.transport = options.transport;
+    this.logger = options.logger ?? createLogger6({ name: `events:${options.service}` });
+    if (options.defaultTenantId) {
+      this.defaultTenantId = options.defaultTenantId;
+    }
+    this.validateEvents = options.validateEvents ?? true;
+  }
+  /**
+   * Emit an event
+   */
+  async emit(type, data, options) {
+    if (this.validateEvents && this.definition?.events?.emits) {
+      const emits = this.definition.events.emits;
+      if (!(type in emits)) {
+        this.logger.warn(`Event type not declared in service definition: ${type}`);
+      }
+    }
+    let delivery;
+    if (this.definition?.events?.emits?.[type]) {
+      delivery = this.definition.events.emits[type].delivery;
+    }
+    const eventOptions = {
+      type,
+      source: this.service,
+      data
+    };
+    if (options?.eventId) eventOptions.id = options.eventId;
+    if (options?.subject) eventOptions.subject = options.subject;
+    const tenantId = options?.tenantId ?? this.defaultTenantId;
+    if (tenantId) eventOptions.tenantId = tenantId;
+    if (options?.requestId) eventOptions.requestId = options.requestId;
+    if (options?.traceContext) eventOptions.traceContext = options.traceContext;
+    const eventDelivery = options?.delivery ?? delivery;
+    if (eventDelivery) eventOptions.delivery = eventDelivery;
+    const event = createEvent(eventOptions);
+    try {
+      await this.transport.emit(event);
+      this.logger.debug(`Event emitted: ${type}`, {
+        eventId: event.id,
+        tenantId: event.parstenantid
+      });
+      return event.id;
+    } catch (error) {
+      this.logger.error(`Failed to emit event: ${type}`, error, {
+        eventId: event.id
+      });
+      throw error;
+    }
+  }
+  /**
+   * Emit multiple events
+   */
+  async emitBatch(events) {
+    const results = [];
+    for (const { type, data, options } of events) {
+      const eventId = await this.emit(type, data, options);
+      results.push(eventId);
+    }
+    return results;
+  }
+  /**
+   * Create a scoped emitter with preset options
+   */
+  scoped(options) {
+    return new ScopedEmitter(this, options);
+  }
+  /**
+   * Get service name
+   */
+  get serviceName() {
+    return this.service;
+  }
+};
+var ScopedEmitter = class {
+  emitter;
+  defaultOptions;
+  constructor(emitter, defaultOptions) {
+    this.emitter = emitter;
+    this.defaultOptions = defaultOptions;
+  }
+  async emit(type, data, options) {
+    return this.emitter.emit(type, data, {
+      ...this.defaultOptions,
+      ...options
+    });
+  }
+};
+function createEventEmitter(options) {
+  return new EventEmitter(options);
+}
+function createTypedEmitter(definition, options) {
+  const emitter = new EventEmitter({
+    ...options,
+    service: definition.name,
+    definition
+  });
+  return emitter;
+}
+
+// src/events/dead-letter.ts
+import { createLogger as createLogger7, generateId as generateId4 } from "@parsrun/core";
+var DeadLetterQueue = class {
+  entries = /* @__PURE__ */ new Map();
+  resolvedOptions;
+  logger;
+  cleanupTimer = null;
+  constructor(options = {}) {
+    this.resolvedOptions = {
+      maxSize: options.maxSize ?? 1e3,
+      retentionMs: options.retentionMs ?? 30 * 24 * 60 * 60 * 1e3,
+      // 30 days
+      alertThreshold: options.alertThreshold ?? 10
+    };
+    if (options.onAdd) this.resolvedOptions.onAdd = options.onAdd;
+    if (options.onThreshold) this.resolvedOptions.onThreshold = options.onThreshold;
+    if (options.logger) this.resolvedOptions.logger = options.logger;
+    this.logger = options.logger ?? createLogger7({ name: "dlq" });
+    this.cleanupTimer = setInterval(() => this.cleanup(), 60 * 60 * 1e3);
+  }
+  /**
+   * Add an entry to the DLQ
+   */
+  async add(options) {
+    const entry = {
+      id: generateId4(),
+      event: options.event,
+      error: options.error,
+      pattern: options.pattern,
+      attempts: options.attempts,
+      addedAt: /* @__PURE__ */ new Date()
+    };
+    if (options.metadata) {
+      entry.metadata = options.metadata;
+    }
+    if (this.entries.size >= this.resolvedOptions.maxSize) {
+      const oldest = this.getOldest();
+      if (oldest) {
+        this.entries.delete(oldest.id);
+        this.logger.debug(`DLQ: Removed oldest entry to make room`, {
+          removedId: oldest.id
+        });
+      }
+    }
+    this.entries.set(entry.id, entry);
+    this.logger.warn(`DLQ: Entry added`, {
+      id: entry.id,
+      eventId: entry.event.id,
+      eventType: entry.event.type,
+      error: entry.error
+    });
+    this.resolvedOptions.onAdd?.(entry);
+    if (this.entries.size >= this.resolvedOptions.alertThreshold) {
+      this.resolvedOptions.onThreshold?.(this.entries.size);
+    }
+    return entry.id;
+  }
+  /**
+   * Get an entry by ID
+   */
+  get(id) {
+    return this.entries.get(id);
+  }
+  /**
+   * Get all entries
+   */
+  getAll() {
+    return Array.from(this.entries.values());
+  }
+  /**
+   * Get entries by event type
+   */
+  getByEventType(eventType) {
+    return Array.from(this.entries.values()).filter(
+      (e) => e.event.type === eventType
+    );
+  }
+  /**
+   * Get entries by pattern
+   */
+  getByPattern(pattern) {
+    return Array.from(this.entries.values()).filter(
+      (e) => e.pattern === pattern
+    );
+  }
+  /**
+   * Remove an entry
+   */
+  remove(id) {
+    const deleted = this.entries.delete(id);
+    if (deleted) {
+      this.logger.debug(`DLQ: Entry removed`, { id });
+    }
+    return deleted;
+  }
+  /**
+   * Retry an entry (remove from DLQ and return event)
+   */
+  retry(id) {
+    const entry = this.entries.get(id);
+    if (!entry) return void 0;
+    this.entries.delete(id);
+    this.logger.info(`DLQ: Entry removed for retry`, {
+      id,
+      eventId: entry.event.id
+    });
+    return entry.event;
+  }
+  /**
+   * Get count
+   */
+  get size() {
+    return this.entries.size;
+  }
+  /**
+   * Clear all entries
+   */
+  clear() {
+    this.entries.clear();
+    this.logger.info(`DLQ: Cleared all entries`);
+  }
+  /**
+   * Cleanup expired entries
+   */
+  cleanup() {
+    const now = Date.now();
+    let removed = 0;
+    for (const [id, entry] of this.entries) {
+      const age = now - entry.addedAt.getTime();
+      if (age > this.resolvedOptions.retentionMs) {
+        this.entries.delete(id);
+        removed++;
+      }
+    }
+    if (removed > 0) {
+      this.logger.debug(`DLQ: Cleaned up ${removed} expired entries`);
+    }
+  }
+  /**
+   * Get oldest entry
+   */
+  getOldest() {
+    let oldest;
+    for (const entry of this.entries.values()) {
+      if (!oldest || entry.addedAt < oldest.addedAt) {
+        oldest = entry;
+      }
+    }
+    return oldest;
+  }
+  /**
+   * Stop cleanup timer
+   */
+  close() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+  /**
+   * Export entries for persistence
+   */
+  export() {
+    return Array.from(this.entries.values()).map((e) => ({
+      ...e,
+      addedAt: e.addedAt
+    }));
+  }
+  /**
+   * Import entries from persistence
+   */
+  import(entries) {
+    for (const entry of entries) {
+      this.entries.set(entry.id, {
+        ...entry,
+        addedAt: new Date(entry.addedAt)
+      });
+    }
+    this.logger.info(`DLQ: Imported ${entries.length} entries`);
+  }
+};
+function createDeadLetterQueue(options) {
+  return new DeadLetterQueue(options);
+}
+export {
+  Bulkhead,
+  BulkheadRejectedError,
+  CircuitBreaker,
+  CircuitOpenError,
+  ConsoleExporter,
+  DEFAULT_DEAD_LETTER_CONFIG,
+  DEFAULT_EVENT_CONFIG,
+  DEFAULT_RESILIENCE_CONFIG,
+  DEFAULT_SERIALIZATION_CONFIG,
+  DEFAULT_SERVICE_CONFIG,
+  DEFAULT_TRACING_CONFIG,
+  DEFAULT_VERSIONING_CONFIG,
+  DeadLetterQueue,
+  EmbeddedRegistry,
+  EmbeddedTransport,
+  EventEmitter,
+  EventHandlerRegistry,
+  GlobalEventBus,
+  HttpTransport,
+  MemoryEventTransport,
+  MethodNotFoundError,
+  OtlpExporter,
+  RpcClient,
+  RpcError,
+  RpcServer,
+  ScopedEmitter,
+  SerializationError,
+  ServiceNotFoundError,
+  ServiceRegistry,
+  SpanAttributes,
+  SpanManager,
+  TimeoutError,
+  TimeoutExceededError,
+  TraceContextManager,
+  Tracer,
+  TransportError,
+  VersionMismatchError,
+  createChildContext,
+  createConsoleExporter,
+  createDeadLetterQueue,
+  createDevConfig,
+  createEmbeddedTransport,
+  createEvent,
+  createEventEmitter,
+  createEventHandlerRegistry,
+  createHttpHandler,
+  createHttpTransport,
+  createMemoryEventTransport,
+  createOtlpExporter,
+  createProdConfig,
+  createRetryWrapper,
+  createRpcClient,
+  createRpcServer,
+  createRpcTracing,
+  createSerializer,
+  createServiceRegistry,
+  createSpan,
+  createTimeoutWrapper,
+  createTraceContext,
+  createTracer,
+  createTracingMiddleware,
+  createTypedEmitter,
+  defineService,
+  executeWithDeadline,
+  executeWithRetry,
+  executeWithTimeout,
+  formatEventType,
+  formatTraceparent2 as formatTraceparent,
+  formatTracestate,
+  fromCompactEvent,
+  generateSpanId,
+  generateTraceId,
+  getEmbeddedRegistry,
+  getGlobalEventBus,
+  getGlobalTracer,
+  getMethodTimeout,
+  getSerializer,
+  getServiceEvents,
+  getServiceMethods,
+  getSpanDuration,
+  isMethodDeprecated,
+  isSpanCompleted,
+  jsonSerializer,
+  loggingMiddleware,
+  matchEventType,
+  mergeConfig,
+  msgpackSerializer,
+  parseEventType,
+  parseTraceparent,
+  parseTracestate,
+  raceWithTimeout,
+  resetGlobalTracer,
+  satisfiesVersion,
+  setGlobalTracer,
+  shouldSample,
+  spanToLogObject,
+  tenantMiddleware,
+  toCloudEvent,
+  toCompactEvent,
+  toRpcError,
+  useService,
+  useTypedService,
+  validateCompactEvent,
+  validateConfig,
+  validateEvent,
+  validationMiddleware,
+  withRetry,
+  withTimeout
+};
+//# sourceMappingURL=index.js.map