@cybermp/rpc-core 0.1.0-rc.1 → 0.1.0-rc.2

package/dist/definitions/index.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+const utils_index = require('../shared/rpc-core.Dn7eTH9H.cjs');
+const rpcPacket = require('../shared/rpc-core.T_c3MAf6.cjs');
+
+class RpcContext {
+  data;
+  meta;
+  packet;
+  constructor({ data, meta, packet }) {
+    this.data = data;
+    this.meta = meta;
+    this.packet = packet;
+  }
+}
+
+exports.MpEnv = utils_index.MpEnv;
+exports.CommonRpcErrorCode = rpcPacket.CommonRpcErrorCode;
+exports.RpcApplyType = rpcPacket.RpcApplyType;
+exports.RpcEnv = rpcPacket.RpcEnv;
+exports.RpcError = rpcPacket.RpcError;
+exports.RpcPacket = rpcPacket.RpcPacket;
+exports.RpcPacketType = rpcPacket.RpcPacketType;
+exports.getRpcError = rpcPacket.getRpcError;
+exports.RpcContext = RpcContext;

package/dist/definitions/index.d.cts

@@ -0,0 +1,97 @@
+import { M as MpEnv } from '../shared/rpc-core.tDMABvlQ.cjs';
+
+type RpcEnvOptions = {
+    source?: MpEnv;
+    target: MpEnv;
+};
+declare class RpcEnv {
+    source: MpEnv;
+    target: MpEnv;
+    constructor(opts: RpcEnvOptions);
+}
+
+declare const enum CommonRpcErrorCode {
+    UNKNOWN = "UNKNOWN",
+    UNAUTHORIZED = "UNAUTHORIZED",
+    FORBIDDEN = "FORBIDDEN",
+    NOT_FOUND = "NOT_FOUND",
+    METHOD_NOT_FOUND = "METHOD_NOT_FOUND",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    TIMEOUT = "TIMEOUT",
+    INVALID_DATA = "INVALID_DATA",
+    TOO_MANY_PENDING_REQUESTS = "TOO_MANY_PENDING_REQUESTS"
+}
+interface RpcErrorOptions {
+    message?: string;
+    code?: string;
+    data?: any;
+    method?: string;
+}
+declare class RpcError<D = any> extends Error {
+    code: string;
+    data?: D;
+    method?: string;
+    constructor(options?: RpcErrorOptions);
+    static unknown(options?: RpcErrorOptions): RpcError<any>;
+    static tooManyPendingRequests(options?: RpcErrorOptions): RpcError<any>;
+    static unauthorized(options?: RpcErrorOptions): RpcError<any>;
+    static forbidden(options?: RpcErrorOptions): RpcError<any>;
+    static notFound(options?: RpcErrorOptions): RpcError<any>;
+    static methodNotFound(options?: RpcErrorOptions): RpcError<any>;
+    static internalError(options?: RpcErrorOptions): RpcError<any>;
+    static timeout(options?: RpcErrorOptions): RpcError<any>;
+    static invalidData(options?: RpcErrorOptions): RpcError<any>;
+}
+declare const getRpcError: (err: any, method?: string) => RpcError<any>;
+
+declare enum RpcPacketType {
+    CALL = "call",
+    TRIGGER = "trigger",
+    RESPONSE = "response"
+}
+type RpcPacketOptions<D = any, M extends Record<string, any> = Record<string, any>> = {
+    id?: string | null;
+    type: RpcPacketType;
+    method: string;
+    data?: D;
+    meta?: M;
+    error?: RpcError;
+};
+declare class RpcPacket<D = any, M extends Record<string, any> = Record<string, any>> {
+    readonly id?: string | null;
+    type: RpcPacketType;
+    method: string;
+    data: D;
+    meta: M;
+    error?: RpcError;
+    env: RpcEnv;
+    constructor({ id, type, data, method, error, meta, }: RpcPacketOptions<D, M>, env: RpcEnvOptions);
+}
+
+interface RpcSerializer {
+    serialize<O = any>(obj: O): any;
+    deserialize<R = any>(obj: any): R;
+}
+
+declare enum RpcApplyType {
+    ON = "on",
+    REGISTER = "register"
+}
+
+type RpcContextConstructor<D = any, M extends Record<string, any> = Record<string, any>> = {
+    data: D;
+    meta: M;
+    packet: RpcPacket<D, M>;
+};
+declare abstract class RpcContext<D = any, M extends Record<string, any> = Record<string, any>> {
+    data: D;
+    meta: M;
+    packet: RpcPacket<D, M>;
+    constructor({ data, meta, packet }: RpcContextConstructor<D, M>);
+}
+
+type RpcNext = () => Promise<any>;
+type RpcHandler<C extends RpcContext = RpcContext> = (ctx: C, next: RpcNext) => any;
+
+export { CommonRpcErrorCode, MpEnv, RpcApplyType, RpcContext, RpcEnv, RpcError, RpcPacket, RpcPacketType, getRpcError };
+export type { RpcContextConstructor, RpcEnvOptions, RpcErrorOptions, RpcHandler, RpcNext, RpcPacketOptions, RpcSerializer };

package/dist/definitions/index.d.mts

@@ -0,0 +1,97 @@
+import { M as MpEnv } from '../shared/rpc-core.tDMABvlQ.mjs';
+
+type RpcEnvOptions = {
+    source?: MpEnv;
+    target: MpEnv;
+};
+declare class RpcEnv {
+    source: MpEnv;
+    target: MpEnv;
+    constructor(opts: RpcEnvOptions);
+}
+
+declare const enum CommonRpcErrorCode {
+    UNKNOWN = "UNKNOWN",
+    UNAUTHORIZED = "UNAUTHORIZED",
+    FORBIDDEN = "FORBIDDEN",
+    NOT_FOUND = "NOT_FOUND",
+    METHOD_NOT_FOUND = "METHOD_NOT_FOUND",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    TIMEOUT = "TIMEOUT",
+    INVALID_DATA = "INVALID_DATA",
+    TOO_MANY_PENDING_REQUESTS = "TOO_MANY_PENDING_REQUESTS"
+}
+interface RpcErrorOptions {
+    message?: string;
+    code?: string;
+    data?: any;
+    method?: string;
+}
+declare class RpcError<D = any> extends Error {
+    code: string;
+    data?: D;
+    method?: string;
+    constructor(options?: RpcErrorOptions);
+    static unknown(options?: RpcErrorOptions): RpcError<any>;
+    static tooManyPendingRequests(options?: RpcErrorOptions): RpcError<any>;
+    static unauthorized(options?: RpcErrorOptions): RpcError<any>;
+    static forbidden(options?: RpcErrorOptions): RpcError<any>;
+    static notFound(options?: RpcErrorOptions): RpcError<any>;
+    static methodNotFound(options?: RpcErrorOptions): RpcError<any>;
+    static internalError(options?: RpcErrorOptions): RpcError<any>;
+    static timeout(options?: RpcErrorOptions): RpcError<any>;
+    static invalidData(options?: RpcErrorOptions): RpcError<any>;
+}
+declare const getRpcError: (err: any, method?: string) => RpcError<any>;
+
+declare enum RpcPacketType {
+    CALL = "call",
+    TRIGGER = "trigger",
+    RESPONSE = "response"
+}
+type RpcPacketOptions<D = any, M extends Record<string, any> = Record<string, any>> = {
+    id?: string | null;
+    type: RpcPacketType;
+    method: string;
+    data?: D;
+    meta?: M;
+    error?: RpcError;
+};
+declare class RpcPacket<D = any, M extends Record<string, any> = Record<string, any>> {
+    readonly id?: string | null;
+    type: RpcPacketType;
+    method: string;
+    data: D;
+    meta: M;
+    error?: RpcError;
+    env: RpcEnv;
+    constructor({ id, type, data, method, error, meta, }: RpcPacketOptions<D, M>, env: RpcEnvOptions);
+}
+
+interface RpcSerializer {
+    serialize<O = any>(obj: O): any;
+    deserialize<R = any>(obj: any): R;
+}
+
+declare enum RpcApplyType {
+    ON = "on",
+    REGISTER = "register"
+}
+
+type RpcContextConstructor<D = any, M extends Record<string, any> = Record<string, any>> = {
+    data: D;
+    meta: M;
+    packet: RpcPacket<D, M>;
+};
+declare abstract class RpcContext<D = any, M extends Record<string, any> = Record<string, any>> {
+    data: D;
+    meta: M;
+    packet: RpcPacket<D, M>;
+    constructor({ data, meta, packet }: RpcContextConstructor<D, M>);
+}
+
+type RpcNext = () => Promise<any>;
+type RpcHandler<C extends RpcContext = RpcContext> = (ctx: C, next: RpcNext) => any;
+
+export { CommonRpcErrorCode, MpEnv, RpcApplyType, RpcContext, RpcEnv, RpcError, RpcPacket, RpcPacketType, getRpcError };
+export type { RpcContextConstructor, RpcEnvOptions, RpcErrorOptions, RpcHandler, RpcNext, RpcPacketOptions, RpcSerializer };

package/dist/definitions/index.d.ts

@@ -0,0 +1,97 @@
+import { M as MpEnv } from '../shared/rpc-core.tDMABvlQ.js';
+
+type RpcEnvOptions = {
+    source?: MpEnv;
+    target: MpEnv;
+};
+declare class RpcEnv {
+    source: MpEnv;
+    target: MpEnv;
+    constructor(opts: RpcEnvOptions);
+}
+
+declare const enum CommonRpcErrorCode {
+    UNKNOWN = "UNKNOWN",
+    UNAUTHORIZED = "UNAUTHORIZED",
+    FORBIDDEN = "FORBIDDEN",
+    NOT_FOUND = "NOT_FOUND",
+    METHOD_NOT_FOUND = "METHOD_NOT_FOUND",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    TIMEOUT = "TIMEOUT",
+    INVALID_DATA = "INVALID_DATA",
+    TOO_MANY_PENDING_REQUESTS = "TOO_MANY_PENDING_REQUESTS"
+}
+interface RpcErrorOptions {
+    message?: string;
+    code?: string;
+    data?: any;
+    method?: string;
+}
+declare class RpcError<D = any> extends Error {
+    code: string;
+    data?: D;
+    method?: string;
+    constructor(options?: RpcErrorOptions);
+    static unknown(options?: RpcErrorOptions): RpcError<any>;
+    static tooManyPendingRequests(options?: RpcErrorOptions): RpcError<any>;
+    static unauthorized(options?: RpcErrorOptions): RpcError<any>;
+    static forbidden(options?: RpcErrorOptions): RpcError<any>;
+    static notFound(options?: RpcErrorOptions): RpcError<any>;
+    static methodNotFound(options?: RpcErrorOptions): RpcError<any>;
+    static internalError(options?: RpcErrorOptions): RpcError<any>;
+    static timeout(options?: RpcErrorOptions): RpcError<any>;
+    static invalidData(options?: RpcErrorOptions): RpcError<any>;
+}
+declare const getRpcError: (err: any, method?: string) => RpcError<any>;
+
+declare enum RpcPacketType {
+    CALL = "call",
+    TRIGGER = "trigger",
+    RESPONSE = "response"
+}
+type RpcPacketOptions<D = any, M extends Record<string, any> = Record<string, any>> = {
+    id?: string | null;
+    type: RpcPacketType;
+    method: string;
+    data?: D;
+    meta?: M;
+    error?: RpcError;
+};
+declare class RpcPacket<D = any, M extends Record<string, any> = Record<string, any>> {
+    readonly id?: string | null;
+    type: RpcPacketType;
+    method: string;
+    data: D;
+    meta: M;
+    error?: RpcError;
+    env: RpcEnv;
+    constructor({ id, type, data, method, error, meta, }: RpcPacketOptions<D, M>, env: RpcEnvOptions);
+}
+
+interface RpcSerializer {
+    serialize<O = any>(obj: O): any;
+    deserialize<R = any>(obj: any): R;
+}
+
+declare enum RpcApplyType {
+    ON = "on",
+    REGISTER = "register"
+}
+
+type RpcContextConstructor<D = any, M extends Record<string, any> = Record<string, any>> = {
+    data: D;
+    meta: M;
+    packet: RpcPacket<D, M>;
+};
+declare abstract class RpcContext<D = any, M extends Record<string, any> = Record<string, any>> {
+    data: D;
+    meta: M;
+    packet: RpcPacket<D, M>;
+    constructor({ data, meta, packet }: RpcContextConstructor<D, M>);
+}
+
+type RpcNext = () => Promise<any>;
+type RpcHandler<C extends RpcContext = RpcContext> = (ctx: C, next: RpcNext) => any;
+
+export { CommonRpcErrorCode, MpEnv, RpcApplyType, RpcContext, RpcEnv, RpcError, RpcPacket, RpcPacketType, getRpcError };
+export type { RpcContextConstructor, RpcEnvOptions, RpcErrorOptions, RpcHandler, RpcNext, RpcPacketOptions, RpcSerializer };

package/dist/index.cjs

@@ -0,0 +1,390 @@
+'use strict';
+
+const utils_index = require('./shared/rpc-core.Dn7eTH9H.cjs');
+const rpcPacket = require('./shared/rpc-core.T_c3MAf6.cjs');
+
+class RpcInterceptorManager {
+  handlers = [];
+  use(handler) {
+    this.handlers.push(handler);
+    return this.handlers.length - 1;
+  }
+  eject(id) {
+    if (this.handlers[id]) {
+      this.handlers[id] = null;
+    }
+  }
+  getHandlers() {
+    return this.handlers.filter((h) => h !== null);
+  }
+}
+
+class RpcOptions {
+  throwUnknownMethods = true;
+  maxPending = 1e3;
+  pendingTimeout = 1e4;
+  prefix = "";
+  serializer;
+}
+
+const anyAbortSignal = (iterable) => {
+  const controller = new AbortController();
+  function abort() {
+    controller.abort(this.reason);
+    clean();
+  }
+  function clean() {
+    for (const signal of iterable) {
+      signal.removeEventListener("abort", abort);
+    }
+  }
+  for (const signal of iterable) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      break;
+    } else {
+      signal.addEventListener("abort", abort);
+    }
+  }
+  return controller.signal;
+};
+const timeoutAbortSignal = (ms) => {
+  const controller = new AbortController();
+  setTimeout(() => {
+    controller.abort("TimeoutError");
+  }, ms);
+  return controller.signal;
+};
+
+class RpcPendingStore {
+  constructor(options) {
+    this.options = options;
+  }
+  pendingRequests = /* @__PURE__ */ new Map();
+  processPending({ resolve, reject, packet }) {
+    if (!packet) {
+      return;
+    }
+    if (packet.error) {
+      reject(packet.error);
+    } else {
+      resolve(packet.data);
+    }
+  }
+  addPending({
+    packet,
+    reject,
+    resolve,
+    // TODO: sync abort signals both ways, so if request was aborted from client, it execution would also abort in registry
+    signal: externalSignal,
+    timeout
+  }) {
+    const { id, method } = packet;
+    if (!id) {
+      return;
+    }
+    const timeoutValue = timeout || this.options.pendingTimeout;
+    const combinedSignal = anyAbortSignal([
+      ...externalSignal ? [externalSignal] : [],
+      ...timeoutValue ? [timeoutAbortSignal(timeoutValue)] : []
+    ]);
+    const onAbort = () => {
+      this.pendingRequests.delete(id);
+      const isTimeout = combinedSignal.reason?.name === "TimeoutError" || combinedSignal.reason === "TimeoutError";
+      const error = isTimeout ? rpcPacket.RpcError.timeout({
+        message: `RPC call ${method}:${id} timed out after ${timeoutValue}ms`,
+        method,
+        data: combinedSignal.reason
+      }) : new rpcPacket.RpcError({
+        method,
+        data: combinedSignal.reason,
+        message: combinedSignal.reason
+      });
+      this.processPending({
+        reject,
+        resolve,
+        packet: new rpcPacket.RpcPacket(
+          { id, method, error, type: rpcPacket.RpcPacketType.RESPONSE },
+          { target: utils_index.CURRENT_ENVIRONMENT }
+        )
+      });
+    };
+    if (combinedSignal.aborted) {
+      onAbort();
+      return;
+    }
+    if (this.options.maxPending && this.pendingRequests.size >= this.options.maxPending) {
+      const error = rpcPacket.RpcError.tooManyPendingRequests();
+      this.processPending({
+        reject,
+        resolve,
+        packet: new rpcPacket.RpcPacket(
+          { id, method, error, type: rpcPacket.RpcPacketType.RESPONSE },
+          { target: utils_index.CURRENT_ENVIRONMENT }
+        )
+      });
+      return;
+    }
+    combinedSignal.addEventListener("abort", onAbort, { once: true });
+    this.pendingRequests.set(id, async (packet2) => {
+      combinedSignal.removeEventListener("abort", onAbort);
+      this.pendingRequests.delete(id);
+      this.processPending({ reject, resolve, packet: packet2 });
+    });
+  }
+  resolvePending(packet) {
+    if (!packet.id || packet.type !== rpcPacket.RpcPacketType.RESPONSE) {
+      return;
+    }
+    const handler = this.pendingRequests.get(packet.id);
+    if (!handler) {
+      return;
+    }
+    handler(packet);
+  }
+}
+
+class RpcRegistry {
+  constructor(options) {
+    this.options = options;
+  }
+  globalMiddlewares = [];
+  callHandlers = /* @__PURE__ */ new Map();
+  triggerHandlers = /* @__PURE__ */ new Map();
+  use(...middlewares) {
+    this.globalMiddlewares.push(...middlewares);
+  }
+  isApplied(method, type) {
+    if (type === rpcPacket.RpcApplyType.ON) {
+      return this.triggerHandlers.has(method);
+    } else if (type === rpcPacket.RpcApplyType.REGISTER) {
+      return this.callHandlers.has(method);
+    }
+  }
+  register(method, ...stack) {
+    this.callHandlers.set(method, stack);
+  }
+  unregister(method) {
+    this.callHandlers.delete(method);
+  }
+  on(eventName, ...stack) {
+    if (!this.triggerHandlers.has(eventName)) {
+      this.triggerHandlers.set(eventName, []);
+    }
+    this.triggerHandlers.get(eventName).push(stack);
+  }
+  off(eventName, handler) {
+    const containers = this.triggerHandlers.get(eventName);
+    if (!containers) {
+      return;
+    }
+    const index = containers.findIndex(
+      (c) => c[c.length - 1] === handler
+    );
+    if (index !== -1) {
+      containers.splice(index, 1);
+    }
+    if (containers.length === 0) {
+      this.triggerHandlers.delete(eventName);
+    }
+  }
+  offAll(eventName) {
+    this.triggerHandlers.delete(eventName);
+  }
+  async execute(ctx) {
+    const { type, method } = ctx.packet;
+    if (type === rpcPacket.RpcPacketType.CALL) {
+      const stack = this.callHandlers.get(method);
+      if (!stack) {
+        if (this.options.throwUnknownMethods) {
+          throw rpcPacket.RpcError.methodNotFound({ method });
+        }
+        return;
+      }
+      return this.runStack(ctx, stack);
+    }
+    if (type === rpcPacket.RpcPacketType.TRIGGER) {
+      const listenerStacks = this.triggerHandlers.get(method);
+      if (!listenerStacks) {
+        return;
+      }
+      for (const stack of listenerStacks) {
+        this.runStack(ctx, stack).catch((err) => {
+          console.error("RPC UNHANDLDED REJECTION", err);
+        });
+      }
+    }
+  }
+  async runStack(ctx, handlers) {
+    const fullStack = [...this.globalMiddlewares, ...handlers];
+    let index = 0;
+    const next = async () => {
+      if (index >= fullStack.length) {
+        return;
+      }
+      const current = fullStack[index++];
+      try {
+        return await current?.(ctx, next);
+      } catch (err) {
+        throw rpcPacket.getRpcError(err, ctx.packet.method);
+      }
+    };
+    return next();
+  }
+}
+
+class RpcBase {
+  options;
+  registry;
+  pendingStore;
+  interceptors = {
+    request: new RpcInterceptorManager(),
+    response: new RpcInterceptorManager()
+  };
+  constructor(options = {}) {
+    this.options = Object.assign(new RpcOptions(), options);
+    this.registry = new RpcRegistry(this.options);
+    this.pendingStore = new RpcPendingStore(this.options);
+  }
+  async call(packet, options, remoteInfo) {
+    const interceptedPacket = await this.runRequestInterceptors(packet);
+    return this.internalCall(interceptedPacket, options, remoteInfo);
+  }
+  async trigger(packet, remoteInfo) {
+    const interceptedPacket = await this.runRequestInterceptors(packet);
+    this.internalTrigger(interceptedPacket, remoteInfo);
+  }
+  init() {
+    this.databus.listen(
+      (packet, remoteInfo) => this.handleIncoming(packet, remoteInfo)
+    );
+  }
+  async runRequestInterceptors(request) {
+    let req = { ...request };
+    for (const handler of this.interceptors.request.getHandlers()) {
+      req = await handler(req);
+    }
+    return req;
+  }
+  async runResponseInterceptors(response) {
+    let res = { ...response };
+    if (res.error) {
+      let error = res.error;
+      for (const handler of this.interceptors.response.getHandlers()) {
+        if (handler.onRejected) {
+          error = await handler.onRejected(error);
+        }
+      }
+      res.error = error;
+      return res;
+    }
+    for (const handler of this.interceptors.response.getHandlers()) {
+      if (handler.onFulfilled) {
+        res = await handler.onFulfilled(res);
+      }
+    }
+    return res;
+  }
+  async handleIncoming(packet, remoteInfo) {
+    if (packet.env.target !== utils_index.CURRENT_ENVIRONMENT) {
+      return this.forward(packet, remoteInfo);
+    }
+    if (packet.type === rpcPacket.RpcPacketType.RESPONSE) {
+      this.pendingStore.resolvePending(
+        await this.runResponseInterceptors(packet)
+      );
+      return;
+    }
+    const ctx = this.createContext(packet, remoteInfo);
+    try {
+      const result = await this.registry.execute(ctx);
+      if (packet.type === rpcPacket.RpcPacketType.CALL && packet.id) {
+        this.sendResponse(packet, result, remoteInfo);
+      }
+    } catch (err) {
+      if (packet.type === rpcPacket.RpcPacketType.CALL && packet.id) {
+        this.sendResponse(packet, null, remoteInfo, err);
+      }
+    }
+  }
+  sendResponse(original, data, remoteInfo, error) {
+    const response = new rpcPacket.RpcPacket(
+      {
+        id: original.id,
+        method: original.method,
+        type: rpcPacket.RpcPacketType.RESPONSE,
+        data,
+        error: error ? rpcPacket.getRpcError(error, original.method) : void 0
+      },
+      { target: original.env.source }
+    );
+    this.databus.send(response, remoteInfo);
+  }
+  parseCallArgs(args) {
+    const [first, second, third] = args;
+    const isConfig = (obj) => {
+      return obj && typeof obj === "object" && ("timeout" in obj || "signal" in obj || "data" in obj || "meta" in obj);
+    };
+    if (args.length === 1 && isConfig(first)) {
+      return {
+        data: first.data,
+        meta: first.meta,
+        options: first
+      };
+    }
+    return {
+      data: first,
+      meta: second,
+      options: third
+    };
+  }
+  on(eventName, ...stack) {
+    this.registry.on(eventName, ...stack);
+  }
+  register(method, ...stack) {
+    this.registry.register(method, ...stack);
+  }
+  unregister(method) {
+    this.registry.unregister(method);
+  }
+  isApplied(method, type) {
+    return this.registry.isApplied(method, type);
+  }
+  off(eventName, handler) {
+    this.registry.off(eventName, handler);
+  }
+  offAll(eventName) {
+    this.registry.offAll(eventName);
+  }
+  use(...middlewares) {
+    this.registry.use(...middlewares);
+  }
+}
+
+class RpcDatabus {
+  constructor(options) {
+    this.options = options;
+  }
+  get RPC_INVOKE_EVENT() {
+    return `${this.options.prefix}__rpc:invoke`;
+  }
+  get RPC_RESPONSE_EVENT() {
+    return `${this.options.prefix}__rpc:response`;
+  }
+  serialize(obj) {
+    return this.options.serializer?.serialize(obj) ?? obj;
+  }
+  deserialize(obj) {
+    return this.options.serializer?.deserialize(obj) ?? obj;
+  }
+  onPacketReceived;
+  listen(cb) {
+    this.onPacketReceived = cb;
+  }
+}
+
+exports.RpcBase = RpcBase;
+exports.RpcDatabus = RpcDatabus;
+exports.RpcOptions = RpcOptions;
+exports.RpcPendingStore = RpcPendingStore;
+exports.RpcRegistry = RpcRegistry;