@parsrun/service 0.1.0

package/dist/rpc/index.js

@@ -0,0 +1,1175 @@
+// src/rpc/client.ts
+import { generateId } 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/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;
+  };
+}
+
+// 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?.();
+  }
+};
+function createRpcClient(options) {
+  return new RpcClient(options);
+}
+
+// src/rpc/server.ts
+import { createLogger } from "@parsrun/core";
+
+// src/define.ts
+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/rpc/server.ts
+var RpcServer = class {
+  definition;
+  handlers;
+  logger;
+  defaultTimeout;
+  middleware;
+  constructor(options) {
+    this.definition = options.definition;
+    this.handlers = options.handlers;
+    this.logger = options.logger ?? createLogger({ 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/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"
+};
+
+// 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;
+  }
+}
+export {
+  BulkheadRejectedError,
+  CircuitOpenError,
+  EmbeddedRegistry,
+  EmbeddedTransport,
+  HttpTransport,
+  MethodNotFoundError,
+  RpcClient,
+  RpcError,
+  RpcServer,
+  SerializationError,
+  ServiceNotFoundError,
+  TimeoutError,
+  TransportError,
+  VersionMismatchError,
+  createEmbeddedTransport,
+  createHttpHandler,
+  createHttpTransport,
+  createRpcClient,
+  createRpcServer,
+  getEmbeddedRegistry,
+  loggingMiddleware,
+  tenantMiddleware,
+  toRpcError,
+  validationMiddleware
+};
+//# sourceMappingURL=index.js.map