Configuration information for a connection.

Handle a connection to another vat. Returns when the connection is closed.

A reference to a capability, which may be live either in the current vat or elsewhere. Holding a client affords making method calls on a capability or modifying the local vat's reference count to it.

Queue a call on a client.

A null client. This is the only client value that can be represented statically. Throws exceptions in response to all method calls.

Create a new client based on a promise. The fulfiller can be used to supply the final client.

Types which may be converted to and from Clients. Typically these will be simple type wrappers for capabilities.

A Pipeline is a reference to a value within a message that has not yet arrived.

walkPipleinePtr follows a pointer starting from the object referred to by the Pipeline. The Pipeline must refer to a struct, and the pointer is referred to by its index into the struct's pointer section.

Convert a Pipeline into a Client, which can be used to send messages to the referant of the Pipeline, using promise pipelining.

Wait for the pipeline's target to resolve, and return the corresponding pointer.

Spawn a local server with its lifetime bound to the supervisor, and return a client for it. When the client is garbage collected, the server will be stopped (if it is still running).

Attempt to unwrap a client, to get at an underlying value from the server. Returns Nothing on failure.

This shells out to the underlying server's implementation of unwrap. It will fail with Nothing if any of these are true:

• The client is a promise.
• The client points to an object in a remote vat.
• The underlying Server's unwrap method returns Nothing for type a.

Wait for the client to be fully resolved, and then return a client pointing directly to the destination.

If the argument is null, a local client, or a (permanent) remote client, this returns the argument immediately. If the argument is a promise client, then this waits for the promise to resolve and returns the result of the resolution. If the promise resolves to *another* promise, then this waits for that promise to also resolve.

If the promise is rejected, then this throws the corresponding exception.

Errors which can be thrown by the rpc system.