{
  "version": 3,
  "sources": ["../../../src/errors.ts", "../../../src/rpc.ts", "../../../src/service.ts", "../../../src/testing.ts", "../../../src/trace.ts"],
  "sourcesContent": ["//\n// Copyright 2021 DXOS.org\n//\n\nimport { StackTrace } from '@dxos/debug';\nimport { decodeError } from '@dxos/protocols';\nimport { type Error as ErrorResponse } from '@dxos/protocols/proto/dxos/error';\n\nexport const decodeRpcError = (err: ErrorResponse, rpcMethod: string): Error =>\n  decodeError(err, {\n    appendStack: `\\n    at RPC ${rpcMethod} \\n` + new StackTrace().getStack(1),\n  });\n", "//\n// Copyright 2021 DXOS.org\n//\n\nimport { Trigger, asyncTimeout, synchronized } from '@dxos/async';\nimport { type Any, type ProtoCodec, type RequestOptions, Stream } from '@dxos/codec-protobuf';\nimport { type Context, ContextRpcCodec } from '@dxos/context';\nimport { StackTrace } from '@dxos/debug';\nimport { invariant } from '@dxos/invariant';\nimport { log } from '@dxos/log';\nimport { RpcClosedError, RpcNotOpenError, encodeError } from '@dxos/protocols';\nimport { schema } from '@dxos/protocols/proto';\nimport { type Request, type Response, type RpcMessage } from '@dxos/protocols/proto/dxos/rpc';\nimport { exponentialBackoffInterval } from '@dxos/util';\n\nimport { decodeRpcError } from './errors';\n\nconst DEFAULT_TIMEOUT = 30_000;\nconst BYE_SEND_TIMEOUT = 2_000;\n\nconst DEBUG_CALLS = true;\n\ntype MaybePromise<T> = Promise<T> | T;\n\nexport interface RpcPeerOptions {\n  port: RpcPort;\n\n  /**\n   * Time to wait for a response to an RPC call.\n   */\n  timeout?: number;\n\n  callHandler: (method: string, request: Any, options?: RequestOptions) => MaybePromise<Any>;\n  streamHandler?: (method: string, request: Any, options?: RequestOptions) => Stream<Any>;\n\n  /**\n   * Do not require or send handshake messages.\n   */\n  noHandshake?: boolean;\n\n  /**\n   * What options get passed to the `callHandler` and `streamHandler`.\n   */\n  handlerRpcOptions?: RequestOptions;\n}\n\n/**\n * Interface for a transport-agnostic port to send/receive binary messages.\n */\nexport interface RpcPort {\n  send: (msg: Uint8Array, timeout?: number) => MaybePromise<void>;\n  subscribe: (cb: (msg: Uint8Array) => void) => (() => void) | void;\n}\n\nconst CLOSE_TIMEOUT = 3_000;\n\nexport type CloseOptions = {\n  /**\n   * Time to wait for the other side to confirm close.\n   */\n  timeout?: number;\n};\n\nclass PendingRpcRequest {\n  constructor(\n    public readonly resolve: (response: Response) => void,\n    public readonly reject: (error?: Error) => void,\n    public readonly stream: boolean,\n  ) {}\n}\n\n// NOTE: Lazy so that code that doesn't use indexing doesn't need to load the codec (breaks in workerd).\nlet RpcMessageCodec!: ProtoCodec<RpcMessage>;\nconst getRpcMessageCodec = () => (RpcMessageCodec ??= schema.getCodecForType('dxos.rpc.RpcMessage'));\n\nenum RpcState {\n  INITIAL = 'INITIAL',\n\n  OPENING = 'OPENING',\n\n  OPENED = 'OPENED',\n\n  /**\n   * Bye message sent, waiting for the other side to close.\n   * Not possible to send requests.\n   * All pending requests will be rejected.\n   */\n  CLOSING = 'CLOSING',\n\n  /**\n   * Connection fully closed.\n   * The underlying transport can be disposed.\n   */\n  CLOSED = 'CLOSED',\n}\n\n/**\n * A remote procedure call peer.\n *\n * Provides a away to make RPC calls and get a response back as a promise.\n * Does not handle encoding/decoding and only works with byte buffers.\n * For type safe approach see `createRpcClient` and `createRpcServer`.\n *\n * Must be connected with another instance on the other side via `send`/`receive` methods.\n * Both sides must be opened before making any RPC calls.\n *\n * Errors inside the handler get serialized and sent to the other side.\n *\n * Inspired by JSON-RPC 2.0 https://www.jsonrpc.org/specification.\n */\nexport class RpcPeer {\n  private readonly _params: RpcPeerOptions;\n\n  private readonly _outgoingRequests = new Map<number, PendingRpcRequest>();\n  private readonly _localStreams = new Map<number, Stream<any>>();\n  private readonly _remoteOpenTrigger = new Trigger();\n\n  /**\n   * Triggered when the peer starts closing.\n   */\n  private readonly _closingTrigger = new Trigger();\n\n  /**\n   * Triggered when peer receives a bye message.\n   */\n  private readonly _byeTrigger = new Trigger();\n\n  private _nextId = 0;\n  private _state: RpcState = RpcState.INITIAL;\n  private _unsubscribeFromPort: (() => void) | undefined = undefined;\n  private _clearOpenInterval: (() => void) | undefined = undefined;\n\n  constructor(params: RpcPeerOptions) {\n    this._params = {\n      timeout: undefined,\n      streamHandler: undefined,\n      noHandshake: false,\n      ...params,\n    };\n  }\n\n  /**\n   * Open the peer. Required before making any calls.\n   *\n   * Will block before the other peer calls `open`.\n   */\n  @synchronized\n  async open(): Promise<void> {\n    if (this._state !== RpcState.INITIAL) {\n      return;\n    }\n\n    this._unsubscribeFromPort = this._params.port.subscribe(async (msg) => {\n      try {\n        await this._receive(msg);\n      } catch (err: any) {\n        log.catch(err);\n      }\n    }) as any;\n\n    this._state = RpcState.OPENING;\n\n    if (this._params.noHandshake) {\n      this._state = RpcState.OPENED;\n      this._remoteOpenTrigger.wake();\n      return;\n    }\n\n    log('sending open message', { state: this._state });\n    await this._sendMessage({ open: true });\n\n    if (this._state !== RpcState.OPENING) {\n      return;\n    }\n\n    // Retry sending.\n    this._clearOpenInterval = exponentialBackoffInterval(() => {\n      void this._sendMessage({ open: true }).catch((err) => log.warn(err));\n    }, 50);\n\n    await Promise.race([this._remoteOpenTrigger.wait(), this._closingTrigger.wait()]);\n\n    this._clearOpenInterval?.();\n\n    if ((this._state as RpcState) !== RpcState.OPENED) {\n      // Closed while opening.\n      return; // TODO(dmaretskyi): Throw error?\n    }\n\n    // TODO(burdon): This seems error prone.\n    // Send an \"open\" message in case the other peer has missed our first \"open\" message and is still waiting.\n    log('resending open message', { state: this._state });\n    await this._sendMessage({ openAck: true });\n  }\n\n  /**\n   * Close the peer.\n   * Stop taking or making requests.\n   * Will wait for confirmation from the other side.\n   * Any responses for RPC calls made before close will be delivered.\n   */\n  async close({ timeout = CLOSE_TIMEOUT }: CloseOptions = {}): Promise<void> {\n    if (this._state === RpcState.CLOSED) {\n      return;\n    }\n\n    this._abortRequests();\n\n    if (this._state === RpcState.OPENED && !this._params.noHandshake) {\n      try {\n        this._state = RpcState.CLOSING;\n        await this._sendMessage({ bye: {} }, BYE_SEND_TIMEOUT);\n      } catch (err: any) {\n        log('error closing peer, sending bye', { err });\n      }\n      try {\n        log('closing waiting on bye');\n        await this._byeTrigger.wait({ timeout });\n      } catch (err: any) {\n        log('error closing peer', { err });\n        return;\n      }\n    }\n\n    this._disposeAndClose();\n  }\n\n  /**\n   * Dispose the connection without waiting for the other side.\n   */\n  async abort(): Promise<void> {\n    if (this._state === RpcState.CLOSED) {\n      return;\n    }\n\n    this._abortRequests();\n    this._disposeAndClose();\n  }\n\n  private _abortRequests(): void {\n    // Abort open\n    this._clearOpenInterval?.();\n    this._closingTrigger.wake();\n\n    // Abort pending requests\n    for (const req of this._outgoingRequests.values()) {\n      req.reject(new RpcClosedError());\n    }\n    this._outgoingRequests.clear();\n  }\n\n  private _disposeAndClose(): void {\n    this._unsubscribeFromPort?.();\n    this._unsubscribeFromPort = undefined;\n    this._clearOpenInterval?.();\n    this._state = RpcState.CLOSED;\n  }\n\n  /**\n   * Handle incoming message. Should be called as the result of other peer's `send` callback.\n   */\n  private async _receive(msg: Uint8Array): Promise<void> {\n    const decoded = getRpcMessageCodec().decode(msg, { preserveAny: true });\n    DEBUG_CALLS && log.trace('received message', { type: Object.keys(decoded)[0] });\n\n    if (decoded.request) {\n      if (this._state !== RpcState.OPENED && this._state !== RpcState.OPENING) {\n        log('received request while closed');\n        await this._sendMessage({\n          response: {\n            id: decoded.request.id,\n            error: encodeError(new RpcClosedError()),\n          },\n        });\n        return;\n      }\n\n      const req = decoded.request;\n      if (req.stream) {\n        log('stream request', { method: req.method });\n        this._callStreamHandler(req, (response) => {\n          log.trace('sending stream response', {\n            method: req.method,\n            response: response.payload?.type_url,\n            error: response.error,\n            close: response.close,\n          });\n\n          void this._sendMessage({ response }).catch((err) => {\n            log.warn('failed during close', err);\n          });\n        });\n      } else {\n        DEBUG_CALLS && log.trace('requesting...', { method: req.method });\n        const response = await this._callHandler(req);\n        DEBUG_CALLS &&\n          log.trace('sending response', {\n            method: req.method,\n            response: response.payload?.type_url,\n            error: response.error,\n          });\n        await this._sendMessage({ response });\n      }\n    } else if (decoded.response) {\n      if (this._state !== RpcState.OPENED) {\n        log('received response while closed');\n        return; // Ignore when not open.\n      }\n\n      const responseId = decoded.response.id;\n      invariant(typeof responseId === 'number');\n      if (!this._outgoingRequests.has(responseId)) {\n        log.trace('received response with invalid id', { responseId });\n        return; // Ignore requests with incorrect id.\n      }\n\n      const item = this._outgoingRequests.get(responseId)!;\n      // Delete the request record if no more responses are expected.\n      if (!item.stream) {\n        this._outgoingRequests.delete(responseId);\n      }\n\n      DEBUG_CALLS && log.trace('response', { type_url: decoded.response.payload?.type_url });\n      item.resolve(decoded.response);\n    } else if (decoded.open) {\n      log('received open message', { state: this._state });\n      if (this._params.noHandshake) {\n        return;\n      }\n\n      await this._sendMessage({ openAck: true });\n    } else if (decoded.openAck) {\n      log('received openAck message', { state: this._state });\n      if (this._params.noHandshake) {\n        return;\n      }\n\n      this._state = RpcState.OPENED;\n      this._remoteOpenTrigger.wake();\n    } else if (decoded.streamClose) {\n      if (this._state !== RpcState.OPENED) {\n        log('received stream close while closed');\n        return; // Ignore when not open.\n      }\n\n      log('received stream close', { id: decoded.streamClose.id });\n      invariant(typeof decoded.streamClose.id === 'number');\n      const stream = this._localStreams.get(decoded.streamClose.id);\n      if (!stream) {\n        log('no local stream', { id: decoded.streamClose.id });\n        return; // Ignore requests with incorrect id.\n      }\n\n      this._localStreams.delete(decoded.streamClose.id);\n      await stream.close();\n    } else if (decoded.bye) {\n      this._byeTrigger.wake();\n      // If we haven't already started closing, close now.\n      if (this._state !== RpcState.CLOSING && this._state !== RpcState.CLOSED) {\n        log('replying to bye');\n        this._state = RpcState.CLOSING;\n        await this._sendMessage({ bye: {} });\n\n        this._abortRequests();\n        this._disposeAndClose();\n      }\n    } else {\n      log.error('received malformed message', { msg });\n      throw new Error('Malformed message.');\n    }\n  }\n\n  /**\n   * Make RPC call. Will trigger a handler on the other side.\n   * Peer should be open before making this call.\n   */\n  async call(method: string, request: Any, options?: RequestOptions): Promise<Any> {\n    DEBUG_CALLS && log.trace('calling...', { method });\n    throwIfNotOpen(this._state);\n\n    let response: Response;\n    try {\n      // Set-up response listener.\n      const id = this._nextId++;\n      const responseReceived = new Promise<Response>((resolve, reject) => {\n        this._outgoingRequests.set(id, new PendingRpcRequest(resolve, reject, false));\n      });\n\n      let traceContext;\n      try {\n        traceContext = options?.ctx ? ContextRpcCodec.encode(options.ctx) : undefined;\n      } catch (err) {\n        log.warn('failed to encode trace context', { err });\n      }\n\n      // Send request call.\n      const sending = this._sendMessage({\n        request: {\n          id,\n          method,\n          payload: request,\n          stream: false,\n          ...(traceContext ? { traceContext } : {}),\n        },\n      });\n\n      // Wait until send completes or throws an error (or response throws a timeout), the resume waiting.\n      const timeout = options?.timeout ?? this._params.timeout;\n      const waiting =\n        timeout === 0 ? responseReceived : asyncTimeout<any>(responseReceived, timeout ?? DEFAULT_TIMEOUT);\n\n      await Promise.race([sending, waiting]);\n      response = await waiting;\n      invariant(response.id === id);\n    } catch (err) {\n      if (err instanceof RpcClosedError) {\n        // Rethrow the error here to have the correct stack-trace.\n        const error = new RpcClosedError();\n        error.stack += `\\n\\n info: RPC client was closed at:\\n${err.stack?.split('\\n').slice(1).join('\\n')}`;\n        throw error;\n      }\n\n      throw err;\n    }\n\n    if (response.payload) {\n      return response.payload;\n    } else if (response.error) {\n      throw decodeRpcError(response.error, method);\n    } else {\n      throw new Error('Malformed response.');\n    }\n  }\n\n  /**\n   * Make RPC call with a streaming response.\n   * Will trigger a handler on the other side.\n   * Peer should be open before making this call.\n   */\n  callStream(method: string, request: Any, options?: RequestOptions): Stream<Any> {\n    throwIfNotOpen(this._state);\n    const id = this._nextId++;\n\n    return new Stream(({ ready, next, close }) => {\n      const onResponse = (response: Response) => {\n        if (response.streamReady) {\n          ready();\n        } else if (response.close) {\n          close();\n        } else if (response.error) {\n          // TODO(dmaretskyi): Stack trace might be lost because the stream producer function is called asynchronously.\n          close(decodeRpcError(response.error, method));\n        } else if (response.payload) {\n          next(response.payload);\n        } else {\n          throw new Error('Malformed response.');\n        }\n      };\n\n      const stack = new StackTrace();\n      const closeStream = (err?: Error) => {\n        if (!err) {\n          close();\n        } else {\n          err.stack += `\\n\\nError happened in the stream at:\\n${stack.getStack()}`;\n          close(err);\n        }\n      };\n\n      this._outgoingRequests.set(id, new PendingRpcRequest(onResponse, closeStream, true));\n\n      let traceContext;\n      try {\n        traceContext = options?.ctx ? ContextRpcCodec.encode(options.ctx) : undefined;\n      } catch (err) {\n        log.warn('failed to encode trace context', { err });\n      }\n\n      try {\n        this._sendMessage({\n          request: {\n            id,\n            method,\n            payload: request,\n            stream: true,\n            ...(traceContext ? { traceContext } : {}),\n          },\n        }).catch((err) => {\n          this._outgoingRequests.delete(id);\n          close(err);\n        });\n      } catch (err) {\n        this._outgoingRequests.delete(id);\n        throw err;\n      }\n\n      return () => {\n        this._sendMessage({\n          streamClose: { id },\n        }).catch((err) => {\n          log.catch(err);\n        });\n        this._outgoingRequests.delete(id);\n      };\n    });\n  }\n\n  private async _sendMessage(message: RpcMessage, timeout?: number): Promise<void> {\n    DEBUG_CALLS && log.trace('sending message', { type: Object.keys(message)[0] });\n    await this._params.port.send(getRpcMessageCodec().encode(message, { preserveAny: true }), timeout);\n  }\n\n  private _getHandlerRpcOptions(req: Request): RequestOptions | undefined {\n    let traceCtx: Context | undefined;\n    if (req.traceContext) {\n      try {\n        traceCtx = ContextRpcCodec.decode(req.traceContext);\n      } catch (err) {\n        log.warn('failed to decode trace context', { traceContext: req.traceContext, err });\n      }\n    }\n    if (!traceCtx && !this._params.handlerRpcOptions) {\n      return undefined;\n    }\n    return { ...this._params.handlerRpcOptions, ...(traceCtx ? { ctx: traceCtx } : {}) };\n  }\n\n  private async _callHandler(req: Request): Promise<Response> {\n    try {\n      invariant(typeof req.id === 'number');\n      invariant(req.payload);\n      invariant(req.method);\n\n      const response = await this._params.callHandler(req.method, req.payload, this._getHandlerRpcOptions(req));\n      return {\n        id: req.id,\n        payload: response,\n      };\n    } catch (err) {\n      return {\n        id: req.id,\n        error: encodeError(err),\n      };\n    }\n  }\n\n  private _callStreamHandler(req: Request, callback: (response: Response) => void): void {\n    try {\n      invariant(this._params.streamHandler, 'Requests with streaming responses are not supported.');\n      invariant(typeof req.id === 'number');\n      invariant(req.payload);\n      invariant(req.method);\n\n      const responseStream = this._params.streamHandler(req.method, req.payload, this._getHandlerRpcOptions(req));\n      responseStream.onReady(() => {\n        callback({\n          id: req.id,\n          streamReady: true,\n        });\n      });\n\n      responseStream.subscribe(\n        (msg) => {\n          callback({\n            id: req.id,\n            payload: msg,\n          });\n        },\n        (error) => {\n          if (error) {\n            callback({\n              id: req.id,\n              error: encodeError(error),\n            });\n          } else {\n            callback({\n              id: req.id,\n              close: true,\n            });\n          }\n        },\n      );\n\n      this._localStreams.set(req.id, responseStream);\n    } catch (err: any) {\n      callback({\n        id: req.id,\n        error: encodeError(err),\n      });\n    }\n  }\n}\n\nconst throwIfNotOpen = (state: RpcState) => {\n  switch (state) {\n    case RpcState.OPENED: {\n      return;\n    }\n    case RpcState.INITIAL: {\n      throw new RpcNotOpenError();\n    }\n    case RpcState.CLOSED: {\n      throw new RpcClosedError();\n    }\n  }\n};\n", "//\n// Copyright 2021 DXOS.org\n//\n\nimport {\n  type EncodingOptions,\n  type ServiceDescriptor,\n  type ServiceHandler,\n  type ServiceProvider,\n} from '@dxos/codec-protobuf';\nimport { invariant } from '@dxos/invariant';\n\nimport { RpcPeer, type RpcPeerOptions } from './rpc';\n\n/**\n * Map of service definitions.\n */\n// TODO(burdon): Rename ServiceMap.\nexport type ServiceBundle<Services> = { [Key in keyof Services]: ServiceDescriptor<Services[Key]> };\n\nexport type ServiceHandlers<Services> = { [ServiceName in keyof Services]: ServiceProvider<Services[ServiceName]> };\n\nexport type ServiceTypesOf<Bundle extends ServiceBundle<any>> =\n  Bundle extends ServiceBundle<infer Services> ? Services : never;\n\n/**\n * Groups multiple services together to be served by a single RPC peer.\n */\nexport const createServiceBundle = <Service>(services: ServiceBundle<Service>): ServiceBundle<Service> => services;\n\n/**\n * Type-safe RPC peer.\n */\nexport class ProtoRpcPeer<Service> {\n  constructor(\n    public readonly rpc: Service,\n    private readonly _peer: RpcPeer,\n  ) {}\n\n  async open(): Promise<void> {\n    await this._peer.open();\n  }\n\n  async close(): Promise<void> {\n    await this._peer.close();\n  }\n\n  async abort(): Promise<void> {\n    await this._peer.abort();\n  }\n}\n\nexport interface ProtoRpcPeerOptions<Client, Server> extends Omit<RpcPeerOptions, 'callHandler' | 'streamHandler'> {\n  /**\n   * Services that are expected to be implemented by the counter-space.\n   */\n  // TODO(burdon): Rename proxy.\n  requested?: ServiceBundle<Client>;\n\n  /**\n   * Services exposed to the counter-space.\n   */\n  // TODO(burdon): Rename service.\n  exposed?: ServiceBundle<Server>;\n\n  /**\n   * Handlers for the exposed services\n   */\n  handlers?: ServiceHandlers<Server>;\n\n  /**\n   * Encoding options passed to the underlying proto codec.\n   */\n  encodingOptions?: EncodingOptions;\n}\n\n/**\n * Create type-safe RPC peer from a service bundle.\n * Can both handle and issue requests.\n */\n// TODO(burdon): Currently assumes that the proto service name is unique.\n//  Support multiple instances services definitions (e.g., halo/space invitations).\nexport const createProtoRpcPeer = <Client = {}, Server = {}>({\n  requested,\n  exposed,\n  handlers,\n  encodingOptions,\n  ...rest\n}: ProtoRpcPeerOptions<Client, Server>): ProtoRpcPeer<Client> => {\n  // Create map of RPCs.\n  const exposedRpcs: Record<string, ServiceHandler<any>> = {};\n  if (exposed) {\n    invariant(handlers);\n    for (const serviceName of Object.keys(exposed) as (keyof Server)[]) {\n      // Get full service name with the package name without '.' at the beginning.\n      const serviceFqn = exposed[serviceName].serviceProto.fullName.slice(1);\n      const serviceProvider = handlers[serviceName];\n      exposedRpcs[serviceFqn] = exposed[serviceName].createServer(serviceProvider, encodingOptions);\n    }\n  }\n\n  // Create peer.\n  const peer = new RpcPeer({\n    ...rest,\n\n    callHandler: (method, request, options) => {\n      const [serviceName, methodName] = parseMethodName(method);\n      if (!exposedRpcs[serviceName]) {\n        throw new Error(`Service not supported: ${serviceName}`);\n      }\n\n      return exposedRpcs[serviceName].call(methodName, request, options);\n    },\n\n    streamHandler: (method, request, options) => {\n      const [serviceName, methodName] = parseMethodName(method);\n      if (!exposedRpcs[serviceName]) {\n        throw new Error(`Service not supported: ${serviceName}`);\n      }\n\n      return exposedRpcs[serviceName].callStream(methodName, request, options);\n    },\n  });\n\n  const requestedRpcs: Client = {} as Client;\n  if (requested) {\n    for (const serviceName of Object.keys(requested) as (keyof Client)[]) {\n      // Get full service name with the package name without '.' at the beginning.\n      const serviceFqn = requested[serviceName].serviceProto.fullName.slice(1);\n\n      requestedRpcs[serviceName] = requested[serviceName].createClient(\n        {\n          call: (method, req, options) => peer.call(`${serviceFqn}.${method}`, req, options),\n          callStream: (method, req, options) => peer.callStream(`${serviceFqn}.${method}`, req, options),\n        },\n        encodingOptions,\n      );\n    }\n  }\n\n  return new ProtoRpcPeer(requestedRpcs, peer);\n};\n\nexport const parseMethodName = (method: string): [serviceName: string, methodName: string] => {\n  const separator = method.lastIndexOf('.');\n  const serviceName = method.slice(0, separator);\n  const methodName = method.slice(separator + 1);\n  if (serviceName.length === 0 || methodName.length === 0) {\n    throw new Error(`Invalid method: ${method}`);\n  }\n\n  return [serviceName, methodName];\n};\n\n//\n// TODO(burdon): Remove deprecated (only bot factory).\n//\n\n/**\n * Create a type-safe RPC client.\n * @deprecated Use createProtoRpcPeer instead.\n */\nexport const createRpcClient = <S>(\n  serviceDef: ServiceDescriptor<S>,\n  options: Omit<RpcPeerOptions, 'callHandler'>,\n): ProtoRpcPeer<S> => {\n  const peer = new RpcPeer({\n    ...options,\n    callHandler: () => {\n      throw new Error('Requests to client are not supported.');\n    },\n  });\n\n  const client = serviceDef.createClient({\n    call: peer.call.bind(peer),\n    callStream: peer.callStream.bind(peer),\n  });\n\n  return new ProtoRpcPeer(client, peer);\n};\n\n/**\n * @deprecated\n */\nexport interface RpcServerOptions<S> extends Omit<RpcPeerOptions, 'callHandler'> {\n  service: ServiceDescriptor<S>;\n  handlers: S;\n}\n\n/**\n * Create a type-safe RPC server.\n * @deprecated Use createProtoRpcPeer instead.\n */\nexport const createRpcServer = <S>({ service, handlers, ...rest }: RpcServerOptions<S>): RpcPeer => {\n  const server = service.createServer(handlers);\n  return new RpcPeer({\n    ...rest,\n    callHandler: server.call.bind(server),\n    streamHandler: server.callStream.bind(server),\n  });\n};\n\n/**\n * Create type-safe RPC client from a service bundle.\n * @deprecated Use createProtoRpcPeer instead.\n */\nexport const createBundledRpcClient = <S>(\n  descriptors: ServiceBundle<S>,\n  options: Omit<RpcPeerOptions, 'callHandler' | 'streamHandler'>,\n): ProtoRpcPeer<S> => {\n  return createProtoRpcPeer({\n    requested: descriptors,\n    ...options,\n  });\n};\n\n/**\n * @deprecated\n */\nexport interface RpcBundledServerOptions<S> extends Omit<RpcPeerOptions, 'callHandler'> {\n  services: ServiceBundle<S>;\n  handlers: S;\n}\n\n/**\n * Create type-safe RPC server from a service bundle.\n * @deprecated Use createProtoRpcPeer instead.\n */\n// TODO(burdon): Support late-binding via providers.\nexport const createBundledRpcServer = <S>({ services, handlers, ...rest }: RpcBundledServerOptions<S>): RpcPeer => {\n  const rpc: Record<string, ServiceHandler<any>> = {};\n  for (const serviceName of Object.keys(services) as (keyof S)[]) {\n    // Get full service name with the package name without '.' at the beginning.\n    const serviceFqn = services[serviceName].serviceProto.fullName.slice(1);\n    rpc[serviceFqn] = services[serviceName].createServer(handlers[serviceName] as any);\n  }\n\n  return new RpcPeer({\n    ...rest,\n\n    callHandler: (method, request) => {\n      const [serviceName, methodName] = parseMethodName(method);\n      if (!rpc[serviceName]) {\n        throw new Error(`Service not supported: ${serviceName}`);\n      }\n\n      return rpc[serviceName].call(methodName, request);\n    },\n\n    streamHandler: (method, request) => {\n      const [serviceName, methodName] = parseMethodName(method);\n      if (!rpc[serviceName]) {\n        throw new Error(`Service not supported: ${serviceName}`);\n      }\n\n      return rpc[serviceName].callStream(methodName, request);\n    },\n  });\n};\n", "//\n// Copyright 2021 DXOS.org\n//\n\nimport { isNode } from '@dxos/util';\n\nimport { type RpcPort } from './rpc';\n\nexport type CreateLinkedPortsOptions = {\n  delay?: number;\n};\n\n/**\n * Create bi-directionally linked ports.\n */\nexport const createLinkedPorts = ({ delay }: CreateLinkedPortsOptions = {}): [RpcPort, RpcPort] => {\n  let port1Received: RpcPort['send'] | undefined;\n  let port2Received: RpcPort['send'] | undefined;\n\n  const send = (handler: RpcPort['send'] | undefined, msg: Uint8Array) => {\n    if (delay) {\n      setTimeout(() => handler?.(msg), delay);\n    } else {\n      void handler?.(msg);\n    }\n  };\n\n  const port1: RpcPort = {\n    send: (msg) => send(port2Received, msg),\n    subscribe: (cb) => {\n      port1Received = cb;\n    },\n  };\n\n  const port2: RpcPort = {\n    send: (msg) => send(port1Received, msg),\n    subscribe: (cb) => {\n      port2Received = cb;\n    },\n  };\n\n  return [port1, port2];\n};\n\nexport const encodeMessage = (msg: string): Uint8Array => (isNode() ? Buffer.from(msg) : new TextEncoder().encode(msg));\n", "//\n// Copyright 2021 DXOS.org\n//\n\nimport { Event } from '@dxos/async';\nimport { MessageTrace } from '@dxos/protocols/proto/dxos/rpc';\n\nimport { type RpcPort } from './rpc';\n\nexport class PortTracer {\n  readonly message = new Event<MessageTrace>();\n\n  private readonly _port: RpcPort;\n\n  constructor(private readonly _wrappedPort: RpcPort) {\n    this._port = {\n      send: (msg: Uint8Array) => {\n        this.message.emit({\n          direction: MessageTrace.Direction.OUTGOING,\n          data: msg,\n        });\n\n        return this._wrappedPort.send(msg);\n      },\n      subscribe: (cb: (msg: Uint8Array) => void) => {\n        return this._wrappedPort.subscribe((msg) => {\n          this.message.emit({\n            direction: MessageTrace.Direction.INCOMING,\n            data: msg,\n          });\n          cb(msg);\n        });\n      },\n    };\n  }\n\n  public get port() {\n    return this._port;\n  }\n}\n"],
  "mappings": "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",
  "names": ["StackTrace", "decodeError", "decodeRpcError", "err", "rpcMethod", "appendStack", "getStack", "Stream", "ContextRpcCodec", "StackTrace", "invariant", "log", "RpcClosedError", "schema", "exponentialBackoffInterval", "decodeRpcError", "BYE_SEND_TIMEOUT", "DEBUG_CALLS", "CLOSE_TIMEOUT", "PendingRpcRequest", "resolve", "reject", "stream", "RpcState", "_params", "_outgoingRequests", "_localStreams", "Map", "_remoteOpenTrigger", "_nextId", "_state", "_unsubscribeFromPort", "_clearOpenInterval", "undefined", "timeout", "streamHandler", "noHandshake", "err", "catch", "log", "state", "_sendMessage", "open", "_closingTrigger", "wait", "openAck", "bye", "BYE_SEND_TIMEOUT", "_disposeAndClose", "_abortRequests", "reject", "RpcClosedError", "decoded", "getRpcMessageCodec", "preserveAny", "DEBUG_CALLS", "Object", "keys", "request", "response", "error", "encodeError", "req", "stream", "method", "_callStreamHandler", "close", "warn", "trace", "invariant", "responseId", "payload", "item", "streamClose", "id", "_byeTrigger", "wake", "msg", "Error", "throwIfNotOpen", "responseReceived", "set", "PendingRpcRequest", "traceContext", "waiting", "Promise", "race", "sending", "stack", "decodeRpcError", "Stream", "onResponse", "streamReady", "ready", "closeStream", "message", "send", "encode", "_getHandlerRpcOptions", "traceCtx", "callHandler", "responseStream", "callback", "invariant", "__dxlog_file", "_peer", "open", "close", "abort", "exposedRpcs", "invariant", "handlers", "serviceFqn", "exposed", "serviceName", "serviceProto", "createServer", "serviceProvider", "callHandler", "method", "methodName", "request", "options", "streamHandler", "requested", "call", "req", "callStream", "encodingOptions", "parseMethodName", "slice", "separator", "length", "Error", "peer", "ProtoRpcPeer", "RpcPeer", "server", "descriptors", "keys", "services", "isNode", "createLinkedPorts", "delay", "port1Received", "port2Received", "send", "handler", "msg", "setTimeout", "port1", "subscribe", "cb", "port2", "encodeMessage", "Buffer", "from", "TextEncoder", "encode", "Event", "MessageTrace", "PortTracer", "message", "_port", "_wrappedPort", "send", "msg", "emit", "direction", "Direction", "OUTGOING", "data", "subscribe", "cb", "INCOMING", "port"]
}