@parsrun/service 0.1.0

package/dist/client.js

@@ -0,0 +1,1474 @@
+// 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
+    }
+  };
+}
+
+// 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 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;
+  };
+}
+
+// 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);
+      }
+    }
+  };
+}
+
+// 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?.();
+  }
+};
+
+// 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() {
+  }
+};
+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"
+};
+
+// 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}`;
+}
+
+// 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 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;
+}
+
+// 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 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/exporters.ts
+import { createLogger as createLogger3 } from "@parsrun/core";
+
+// src/tracing/tracer.ts
+var globalTracer = null;
+function getGlobalTracer() {
+  return globalTracer;
+}
+
+// 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);
+}
+export {
+  ServiceRegistry,
+  createServiceRegistry,
+  useService,
+  useTypedService
+};
+//# sourceMappingURL=client.js.map