class WireServer

Set the active state of the limbo. Will trigger the `WatchActive` event

if there was a change, meaning that any listening components will receive

a notification. This includes the caller of `SetActive`.

When a limbo is inactive, there will not be any processes waiting on it,

meaning that any waiting processes will be freed upon deactivating the

limbo.

Get whether the limbo is currently active. An active limbo could be empty

(not have any processes waiting on an exception). When a limbo is inactive,

there will not be any processes waiting on it.

Watch for changes determining whether the limbo is currently active,

using a Hanging Get pattern.

List processes that are waiting on exceptions.

Returns information on all the processes currently waiting on an exception.

The information provided will not contain any handle, so that it can be

transported over Overnet (see https://fxbug.dev/42182115).

The implementation should ensure that at any time there are no more than

MAX_EXCEPTIONS exceptions held in the limbo, so that no pagination is needed.

Returns ZX_ERR_UNAVAILABLE if limbo is not active.

Watch for processes that are waiting on exceptions, using a Hanging Get

Pattern.

Returns information on all the processes currently waiting on an exception.

The information provided is intended to correctly identify an exception

and determine whether the caller wants to actually handle it.

To retrieve an exception, use the `GetException` call.

Returns ZX_ERR_UNAVAILABLE if limbo is not active.

Returns ZX_ERR_CANCELED if there was an outstanding call and the limbo

becomes inactive.

NOTE: The `process` and `thread` handle will only have the ZX_RIGHT_READ

right, so no modification will be able to be done on them.

Removes the process from limbo and retrieves the exception handle and

associated metadata from an exception.

Use `ListProcessesWaitingOnException` to choose a `process_koid` from the

list of available exceptions.

Returns ZX_ERR_NOT_FOUND if the process is not waiting on an exception.

Returns ZX_ERR_UNAVAILABLE if limbo is not active.

Removes the process from limbo, releasing the exception. This will make

it "bubble up" beyond the scope of of this limbo, making it

unretrievable in the future from here.

Adds filters to the limbo. Filters determine what processes the limbo

will store when receiving an exception. Repeated filters will be

ignored. Filters work by "filtering out" processes. It means that if a

filter matches, that process won't get included.

Filters work by substring matching. This means that a process name has

to have the filter as a substring in order to match it. Example:

Filter = "dev".

Process = "process" won't match.

Process = "devcoordinator" will match.

Adding filters is transactional: either all of them go in, or none at

all. The maximum amount of filters is determined by

`MAX_FILTERS_PER_CALL`. If the maximum is exceeded, ZX_ERR_NO_RESOURCES

is returned.

Changing filters have no effect on processes that are currently waiting

on an exception, but rather which future processes that will remain in

the limbo.

Returns ZX_ERR_UNAVAILABLE if limbo is not active.

Removes filters to the limbo. Any filters that are not currently present

on the limbo will be ignored.

Returns ZX_ERR_UNAVAILABLE if limbo is not active.

Returns filters that are currently active within the limbo. If the limbo

is inactive, it will return an empty vector.

|bind_handler| returns a handler that binds incoming connections to this

server implementation.

The returned handler borrows the server instance.

The server must outlive the provided |dispatcher|. Only after

the dispatcher is shutdown will it be safe to destroy the servers.

The server should not be moved.