@stryke/capnp 0.4.5 → 0.6.0

package/dist/rpc.js

@@ -1,4543 +1,12 @@
 import {
-  AnyStruct,
-  CompositeList,
-  Data,
-  ErrorAnswer,
-  ErrorClient,
-  FixedAnswer,
-  INVARIANT_UNREACHABLE_CODE,
-  List,
-  ListElementSize,
-  MAX_DEPTH,
+  Conn,
+  Deferred,
+  DeferredTransport
+} from "./chunk-I2TLOFS6.js";
+import {
   Message,
-  NOT_IMPLEMENTED,
-  ObjectSize,
-  Pointer,
-  PointerType,
-  RPC_BAD_TARGET,
-  RPC_CALL_QUEUE_FULL,
-  RPC_ERROR,
-  RPC_FINISH_UNKNOWN_ANSWER,
-  RPC_FULFILL_ALREADY_CALLED,
-  RPC_IMPORT_CLOSED,
-  RPC_METHOD_ERROR,
-  RPC_NO_MAIN_INTERFACE,
-  RPC_NULL_CLIENT,
-  RPC_QUESTION_ID_REUSED,
-  RPC_QUEUE_CALL_CANCEL,
-  RPC_RETURN_FOR_UNKNOWN_QUESTION,
-  RPC_UNKNOWN_ANSWER_ID,
-  RPC_UNKNOWN_CAP_DESCRIPTOR,
-  RPC_UNKNOWN_EXPORT_ID,
-  RPC_ZERO_REF,
-  Struct,
-  Text,
-  __name,
-  adopt,
-  copyFrom,
-  disown,
-  format,
-  getAs,
-  getBit,
-  getBitMask,
-  getContent,
-  getInterfaceClientOrNull,
-  getList,
-  getPointer,
-  getStruct,
-  getTargetPointerType,
-  getText,
-  getUint16,
-  getUint32,
-  getUint64,
-  getUint8,
-  getUint8Mask,
-  initList,
-  initStruct,
-  initStructAt,
-  isNull,
-  setBit,
-  setText,
-  setUint16,
-  setUint32,
-  setUint64,
-  setUint8,
-  testWhich
-} from "./chunk-U3UL3P5H.js";
-
-// ../../node_modules/.pnpm/capnp-es@0.0.11_patch_hash=53996ae63a1465953815fff49405f2224c85d26eeeff469d2b1f87e1c2af451d_typescript@5.8.3/node_modules/capnp-es/dist/shared/capnp-es.UAt3nLGq.mjs
-var Interface = class extends Pointer {
-  static {
-    __name(this, "Interface");
-  }
-  static _capnp = {
-    displayName: "Interface"
-  };
-  static getCapID = getCapID;
-  static getAsInterface = getAsInterface;
-  static isInterface = isInterface;
-  static getClient = getClient;
-  constructor(segment, byteOffset, depthLimit = MAX_DEPTH) {
-    super(segment, byteOffset, depthLimit);
-  }
-  static fromPointer(p) {
-    return getAsInterface(p);
-  }
-  getCapId() {
-    return getCapID(this);
-  }
-  getClient() {
-    return getClient(this);
-  }
-  [Symbol.for("nodejs.util.inspect.custom")]() {
-    return format(
-      "Interface_%d@%a,%d,limit:%x",
-      this.segment.id,
-      this.byteOffset,
-      this.getCapId(),
-      this._capnp.depthLimit
-    );
-  }
-};
-function getAsInterface(p) {
-  if (getTargetPointerType(p) === PointerType.OTHER) {
-    return new Interface(p.segment, p.byteOffset, p._capnp.depthLimit);
-  }
-  return null;
-}
-__name(getAsInterface, "getAsInterface");
-function isInterface(p) {
-  return getTargetPointerType(p) === PointerType.OTHER;
-}
-__name(isInterface, "isInterface");
-function getCapID(i) {
-  if (i.segment.getUint32(i.byteOffset) !== PointerType.OTHER) {
-    return -1;
-  }
-  return i.segment.getUint32(i.byteOffset + 4);
-}
-__name(getCapID, "getCapID");
-function getClient(i) {
-  const capID = getCapID(i);
-  const { capTable } = i.segment.message._capnp;
-  if (!capTable) {
-    return null;
-  }
-  return capTable[capID];
-}
-__name(getClient, "getClient");
-function isDataCall(call) {
-  return !!call.params;
-}
-__name(isDataCall, "isDataCall");
-function copyCall(call) {
-  if (isDataCall(call)) {
-    return call;
-  }
-  return {
-    method: call.method,
-    params: placeParams(call, void 0)
-  };
-}
-__name(copyCall, "copyCall");
-function placeParams(call, contentPtr) {
-  if (isDataCall(call)) {
-    return call.params;
-  }
-  let p;
-  if (contentPtr) {
-    p = new call.method.ParamsClass(
-      contentPtr.segment,
-      contentPtr.byteOffset,
-      contentPtr._capnp.depthLimit
-    );
-  } else {
-    const msg = new Message();
-    p = new call.method.ParamsClass(msg.getSegment(0), 0);
-  }
-  initStruct(call.method.ParamsClass._capnp.size, p);
-  if (call.paramsFunc) {
-    call.paramsFunc(p);
-  }
-  return p;
-}
-__name(placeParams, "placeParams");
-function pointerToStruct(p) {
-  if (getTargetPointerType(p) === PointerType.STRUCT) {
-    return new Struct(
-      p.segment,
-      p.byteOffset,
-      p._capnp.depthLimit,
-      p._capnp.compositeIndex
-    );
-  }
-  return null;
-}
-__name(pointerToStruct, "pointerToStruct");
-function transformPtr(p, transform) {
-  if (transform.length === 0) {
-    return p;
-  }
-  let s = pointerToStruct(p);
-  if (!s) {
-    return p;
-  }
-  for (const op of transform) {
-    s = getPointer(op.field, s);
-  }
-  return s;
-}
-__name(transformPtr, "transformPtr");
-var Deferred = class _Deferred {
-  static {
-    __name(this, "Deferred");
-  }
-  static fromPromise(p) {
-    const d = new _Deferred();
-    p.then(d.resolve, d.reject);
-    return d;
-  }
-  promise;
-  reject;
-  resolve;
-  constructor() {
-    this.promise = new Promise((a, b) => {
-      this.resolve = a;
-      this.reject = b;
-    });
-  }
-};
-var ImmediateAnswer = class extends FixedAnswer {
-  static {
-    __name(this, "ImmediateAnswer");
-  }
-  constructor(s) {
-    super();
-    this.s = s;
-  }
-  structSync() {
-    return this.s;
-  }
-  findClient(transform) {
-    const p = transformPtr(this.s, transform);
-    return getInterfaceClientOrNull(p);
-  }
-  pipelineCall(transform, call) {
-    return this.findClient(transform).call(call);
-  }
-  pipelineClose(transform) {
-    this.findClient(transform).close();
-  }
-};
-var Queue = class {
-  static {
-    __name(this, "Queue");
-  }
-  // creates a new queue that starts with n elements.
-  // The interface's length must not change over the course of
-  // the queue's usage.
-  constructor(q, n) {
-    this.q = q;
-    this.n = n;
-    this.cap = q.len();
-  }
-  start = 0;
-  cap;
-  // len returns the length of the queue. This is different from the underlying
-  // interface's length, which is the queue's capacity.
-  len() {
-    return this.n;
-  }
-  // push reserves space for an element on the queue, returning its index.
-  // if the queue is full, push returns -1.
-  push() {
-    if (this.n >= this.cap) {
-      return -1;
-    }
-    const i = (this.start + this.n) % this.cap;
-    this.n++;
-    return i;
-  }
-  // front returns the index of the front of the queue, or -1 if the queue is empty.
-  front() {
-    if (this.n === 0) {
-      return -1;
-    }
-    return this.start;
-  }
-  // pop pops an element from the queue, returning whether it succeeded.
-  pop() {
-    if (this.n === 0) {
-      return false;
-    }
-    this.q.clear(this.start);
-    this.start = (this.start + 1) % this.cap;
-    this.n--;
-    return true;
-  }
-};
-var EmbargoClient = class {
-  static {
-    __name(this, "EmbargoClient");
-  }
-  _client;
-  q;
-  calls;
-  constructor(client, queue) {
-    this._client = client;
-    this.calls = queue.copy();
-    this.q = new Queue(this.calls, this.calls.len());
-    this.flushQueue();
-  }
-  flushQueue() {
-    let c = null;
-    {
-      const i = this.q.front();
-      if (i !== -1) {
-        c = this.calls.data[i];
-      }
-    }
-    while (c && c.call) {
-      const ans = this._client.call(c.call);
-      void (async (f, ans2) => {
-        try {
-          f.fulfill(await ans2.struct());
-        } catch (error_) {
-          f.reject(error_);
-        }
-      })(c.f, ans);
-      this.q.pop();
-      {
-        const i = this.q.front();
-        c = i === -1 ? null : this.calls.data[i];
-      }
-    }
-  }
-  // client returns the underlying client if the embargo has
-  // been lifted and null otherwise
-  client() {
-    return this.isPassthrough() ? this._client : null;
-  }
-  isPassthrough() {
-    return this.q.len() === 0;
-  }
-  // call either queues a call to the underlying client or starts a
-  // call if the embargo has been lifted
-  call(call) {
-    if (this.isPassthrough()) {
-      return this._client.call(call);
-    }
-    return this.push(call);
-  }
-  push(_call) {
-    const f = new Fulfiller();
-    const call = copyCall(_call);
-    const i = this.q.push();
-    if (i === -1) {
-      return new ErrorAnswer(new Error(RPC_CALL_QUEUE_FULL));
-    }
-    this.calls.data[i] = {
-      call,
-      f
-    };
-    return f;
-  }
-  close() {
-    while (this.q.len() > 0) {
-      const first = this.calls.data[this.q.front()];
-      if (!first) {
-        throw new Error(INVARIANT_UNREACHABLE_CODE);
-      }
-      first.f.reject(new Error(RPC_QUEUE_CALL_CANCEL));
-      this.q.pop();
-    }
-    this._client.close();
-  }
-};
-var Ecalls = class _Ecalls {
-  static {
-    __name(this, "Ecalls");
-  }
-  data;
-  constructor(data) {
-    this.data = data;
-  }
-  static copyOf(data) {
-    return new _Ecalls([...data]);
-  }
-  len() {
-    return this.data.length;
-  }
-  clear(i) {
-    this.data[i] = null;
-  }
-  copy() {
-    return _Ecalls.copyOf(this.data);
-  }
-};
-var callQueueSize = 64;
-var Fulfiller = class _Fulfiller {
-  static {
-    __name(this, "Fulfiller");
-  }
-  resolved = false;
-  answer;
-  queue = [];
-  queueCap = callQueueSize;
-  deferred = new Deferred();
-  fulfill(s) {
-    this.answer = new ImmediateAnswer(s);
-    const queues = this.emptyQueue(s);
-    const msgcap = s.segment.message._capnp;
-    if (!msgcap.capTable) {
-      msgcap.capTable = [];
-    }
-    const ctab = msgcap.capTable;
-    for (const _capIdx of Object.keys(queues)) {
-      const capIdx = +_capIdx;
-      const q = queues[capIdx];
-      const client = ctab[capIdx];
-      if (!client) {
-        throw new Error(INVARIANT_UNREACHABLE_CODE);
-      }
-      ctab[capIdx] = new EmbargoClient(client, q);
-    }
-    this.deferred.resolve(s);
-  }
-  reject(err) {
-    this.deferred.reject(err);
-  }
-  peek() {
-    return this.answer;
-  }
-  async struct() {
-    return await this.deferred.promise;
-  }
-  // pipelineCall calls pipelineCall on the fulfilled answer or
-  // queues the call if f has not been fulfilled
-  pipelineCall(transform, call) {
-    {
-      const a = this.peek();
-      if (a) {
-        return a.pipelineCall(transform, call);
-      }
-    }
-    if (this.queue.length === this.queueCap) {
-      return new ErrorAnswer(new Error(RPC_CALL_QUEUE_FULL));
-    }
-    const cc = copyCall(call);
-    const g = new _Fulfiller();
-    this.queue.push({
-      call: cc,
-      f: g,
-      transform
-    });
-    return g;
-  }
-  // pipelineClose waits until f is resolved and then calls
-  // pipelineClose on the fulfilled answer
-  // FIXME: should this be async?
-  pipelineClose(transform) {
-    const onFinally = /* @__PURE__ */ __name(() => {
-      if (this.answer) {
-        this.answer.pipelineClose(transform);
-      }
-    }, "onFinally");
-    this.deferred.promise.then(onFinally, onFinally);
-  }
-  // emptyQueue splits the queue by which capability it targets and
-  // drops any invalid calls.  Once this function returns, f.queue will
-  // be nil.
-  emptyQueue(s) {
-    const qs = {};
-    for (let i = 0; i < this.queue.length; i++) {
-      const pc = this.queue[i];
-      let c;
-      try {
-        c = transformPtr(s, pc.transform);
-      } catch (error_) {
-        pc.f.reject(error_);
-        continue;
-      }
-      const iface = Interface.fromPointer(c);
-      if (!iface) {
-        pc.f.reject(new Error(RPC_NULL_CLIENT));
-        continue;
-      }
-      const cn = iface.getCapId();
-      if (!qs[cn]) {
-        qs[cn] = new Ecalls([]);
-      }
-      qs[cn].data.push(pc);
-    }
-    this.queue = [];
-    return qs;
-  }
-};
-var PipelineClient = class {
-  static {
-    __name(this, "PipelineClient");
-  }
-  constructor(pipeline) {
-    this.pipeline = pipeline;
-  }
-  transform() {
-    return this.pipeline.transform();
-  }
-  call(call) {
-    return this.pipeline.answer.pipelineCall(this.transform(), call);
-  }
-  close() {
-    this.pipeline.answer.pipelineClose(this.transform());
-  }
-};
-var Pipeline = class _Pipeline {
-  static {
-    __name(this, "Pipeline");
-  }
-  // Returns a new Pipeline based on an answer
-  constructor(ResultsClass, answer, op, parent) {
-    this.ResultsClass = ResultsClass;
-    this.answer = answer;
-    this.parent = parent;
-    this.op = op || { field: 0 };
-  }
-  op;
-  pipelineClient;
-  // transform returns the operations needed to transform the root answer
-  // into the value p represents.
-  transform() {
-    const xform = [];
-    for (let q = this; q.parent; q = q.parent) {
-      xform.unshift(q.op);
-    }
-    return xform;
-  }
-  // Struct waits until the answer is resolved and returns the struct
-  // this pipeline represents.
-  async struct() {
-    const s = await this.answer.struct();
-    const t = transformPtr(s, this.transform());
-    if (!t) {
-      if (this.op.defaultValue) {
-        copyFrom(this.op.defaultValue, t);
-      } else {
-        initStruct(this.ResultsClass._capnp.size, t);
-      }
-    }
-    return getAs(this.ResultsClass, t);
-  }
-  // client returns the client version of this pipeline
-  client() {
-    if (!this.pipelineClient) {
-      this.pipelineClient = new PipelineClient(this);
-    }
-    return this.pipelineClient;
-  }
-  // getPipeline returns a derived pipeline which yields the pointer field given
-  getPipeline(ResultsClass, off, defaultValue) {
-    return new _Pipeline(
-      ResultsClass,
-      this.answer,
-      { field: off, defaultValue },
-      this
-    );
-  }
-};
-var MethodError = class extends Error {
-  static {
-    __name(this, "MethodError");
-  }
-  constructor(method, message) {
-    super(
-      format(
-        RPC_METHOD_ERROR,
-        method.interfaceName,
-        method.methodName,
-        message
-      )
-    );
-    this.method = method;
-  }
-};
-var Registry = class {
-  static {
-    __name(this, "Registry");
-  }
-  static interfaces = /* @__PURE__ */ new Map();
-  static register(id, def) {
-    this.interfaces.set(id, def);
-  }
-  static lookup(id) {
-    return this.interfaces.get(id);
-  }
-};
-
-// ../../node_modules/.pnpm/capnp-es@0.0.11_patch_hash=53996ae63a1465953815fff49405f2224c85d26eeeff469d2b1f87e1c2af451d_typescript@5.8.3/node_modules/capnp-es/dist/capnp/rpc.mjs
-var _capnpFileId = BigInt("0xb312981b2552a250");
-var Message_Which = {
-  /**
-  * The sender previously received this message from the peer but didn't understand it or doesn't
-  * yet implement the functionality that was requested.  So, the sender is echoing the message
-  * back.  In some cases, the receiver may be able to recover from this by pretending the sender
-  * had taken some appropriate "null" action.
-  *
-  * For example, say `resolve` is received by a level 0 implementation (because a previous call
-  * or return happened to contain a promise).  The level 0 implementation will echo it back as
-  * `unimplemented`.  The original sender can then simply release the cap to which the promise
-  * had resolved, thus avoiding a leak.
-  *
-  * For any message type that introduces a question, if the message comes back unimplemented,
-  * the original sender may simply treat it as if the question failed with an exception.
-  *
-  * In cases where there is no sensible way to react to an `unimplemented` message (without
-  * resource leaks or other serious problems), the connection may need to be aborted.  This is
-  * a gray area; different implementations may take different approaches.
-  *
-  */
-  UNIMPLEMENTED: 0,
-  /**
-  * Sent when a connection is being aborted due to an unrecoverable error.  This could be e.g.
-  * because the sender received an invalid or nonsensical message or because the sender had an
-  * internal error.  The sender will shut down the outgoing half of the connection after `abort`
-  * and will completely close the connection shortly thereafter (it's up to the sender how much
-  * of a time buffer they want to offer for the client to receive the `abort` before the
-  * connection is reset).
-  *
-  */
-  ABORT: 1,
-  /**
-  * Request the peer's bootstrap interface.
-  *
-  */
-  BOOTSTRAP: 8,
-  /**
-  * Begin a method call.
-  *
-  */
-  CALL: 2,
-  /**
-  * Complete a method call.
-  *
-  */
-  RETURN: 3,
-  /**
-  * Release a returned answer / cancel a call.
-  *
-  */
-  FINISH: 4,
-  /**
-  * Resolve a previously-sent promise.
-  *
-  */
-  RESOLVE: 5,
-  /**
-  * Release a capability so that the remote object can be deallocated.
-  *
-  */
-  RELEASE: 6,
-  /**
-  * Lift an embargo used to enforce E-order over promise resolution.
-  *
-  */
-  DISEMBARGO: 13,
-  /**
-  * Obsolete request to save a capability, resulting in a SturdyRef. This has been replaced
-  * by the `Persistent` interface defined in `persistent.capnp`. This operation was never
-  * implemented.
-  *
-  */
-  OBSOLETE_SAVE: 7,
-  /**
-  * Obsolete way to delete a SturdyRef. This operation was never implemented.
-  *
-  */
-  OBSOLETE_DELETE: 9,
-  /**
-  * Provide a capability to a third party.
-  *
-  */
-  PROVIDE: 10,
-  /**
-  * Accept a capability provided by a third party.
-  *
-  */
-  ACCEPT: 11,
-  /**
-  * Directly connect to the common root of two or more proxied caps.
-  *
-  */
-  JOIN: 12
-};
-var Message2 = class _Message extends Struct {
-  static {
-    __name(this, "Message");
-  }
-  static UNIMPLEMENTED = Message_Which.UNIMPLEMENTED;
-  static ABORT = Message_Which.ABORT;
-  static BOOTSTRAP = Message_Which.BOOTSTRAP;
-  static CALL = Message_Which.CALL;
-  static RETURN = Message_Which.RETURN;
-  static FINISH = Message_Which.FINISH;
-  static RESOLVE = Message_Which.RESOLVE;
-  static RELEASE = Message_Which.RELEASE;
-  static DISEMBARGO = Message_Which.DISEMBARGO;
-  static OBSOLETE_SAVE = Message_Which.OBSOLETE_SAVE;
-  static OBSOLETE_DELETE = Message_Which.OBSOLETE_DELETE;
-  static PROVIDE = Message_Which.PROVIDE;
-  static ACCEPT = Message_Which.ACCEPT;
-  static JOIN = Message_Which.JOIN;
-  static _capnp = {
-    displayName: "Message",
-    id: "91b79f1f808db032",
-    size: new ObjectSize(8, 1)
-  };
-  _adoptUnimplemented(value) {
-    setUint16(0, 0, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownUnimplemented() {
-    return disown(this.unimplemented);
-  }
-  /**
-  * The sender previously received this message from the peer but didn't understand it or doesn't
-  * yet implement the functionality that was requested.  So, the sender is echoing the message
-  * back.  In some cases, the receiver may be able to recover from this by pretending the sender
-  * had taken some appropriate "null" action.
-  *
-  * For example, say `resolve` is received by a level 0 implementation (because a previous call
-  * or return happened to contain a promise).  The level 0 implementation will echo it back as
-  * `unimplemented`.  The original sender can then simply release the cap to which the promise
-  * had resolved, thus avoiding a leak.
-  *
-  * For any message type that introduces a question, if the message comes back unimplemented,
-  * the original sender may simply treat it as if the question failed with an exception.
-  *
-  * In cases where there is no sensible way to react to an `unimplemented` message (without
-  * resource leaks or other serious problems), the connection may need to be aborted.  This is
-  * a gray area; different implementations may take different approaches.
-  *
-  */
-  get unimplemented() {
-    testWhich("unimplemented", getUint16(0, this), 0, this);
-    return getStruct(0, _Message, this);
-  }
-  _hasUnimplemented() {
-    return !isNull(getPointer(0, this));
-  }
-  _initUnimplemented() {
-    setUint16(0, 0, this);
-    return initStructAt(0, _Message, this);
-  }
-  get _isUnimplemented() {
-    return getUint16(0, this) === 0;
-  }
-  set unimplemented(value) {
-    setUint16(0, 0, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptAbort(value) {
-    setUint16(0, 1, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownAbort() {
-    return disown(this.abort);
-  }
-  /**
-  * Sent when a connection is being aborted due to an unrecoverable error.  This could be e.g.
-  * because the sender received an invalid or nonsensical message or because the sender had an
-  * internal error.  The sender will shut down the outgoing half of the connection after `abort`
-  * and will completely close the connection shortly thereafter (it's up to the sender how much
-  * of a time buffer they want to offer for the client to receive the `abort` before the
-  * connection is reset).
-  *
-  */
-  get abort() {
-    testWhich("abort", getUint16(0, this), 1, this);
-    return getStruct(0, Exception, this);
-  }
-  _hasAbort() {
-    return !isNull(getPointer(0, this));
-  }
-  _initAbort() {
-    setUint16(0, 1, this);
-    return initStructAt(0, Exception, this);
-  }
-  get _isAbort() {
-    return getUint16(0, this) === 1;
-  }
-  set abort(value) {
-    setUint16(0, 1, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptBootstrap(value) {
-    setUint16(0, 8, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownBootstrap() {
-    return disown(this.bootstrap);
-  }
-  /**
-  * Request the peer's bootstrap interface.
-  *
-  */
-  get bootstrap() {
-    testWhich("bootstrap", getUint16(0, this), 8, this);
-    return getStruct(0, Bootstrap, this);
-  }
-  _hasBootstrap() {
-    return !isNull(getPointer(0, this));
-  }
-  _initBootstrap() {
-    setUint16(0, 8, this);
-    return initStructAt(0, Bootstrap, this);
-  }
-  get _isBootstrap() {
-    return getUint16(0, this) === 8;
-  }
-  set bootstrap(value) {
-    setUint16(0, 8, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptCall(value) {
-    setUint16(0, 2, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownCall() {
-    return disown(this.call);
-  }
-  /**
-  * Begin a method call.
-  *
-  */
-  get call() {
-    testWhich("call", getUint16(0, this), 2, this);
-    return getStruct(0, Call, this);
-  }
-  _hasCall() {
-    return !isNull(getPointer(0, this));
-  }
-  _initCall() {
-    setUint16(0, 2, this);
-    return initStructAt(0, Call, this);
-  }
-  get _isCall() {
-    return getUint16(0, this) === 2;
-  }
-  set call(value) {
-    setUint16(0, 2, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptReturn(value) {
-    setUint16(0, 3, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownReturn() {
-    return disown(this.return);
-  }
-  /**
-  * Complete a method call.
-  *
-  */
-  get return() {
-    testWhich("return", getUint16(0, this), 3, this);
-    return getStruct(0, Return, this);
-  }
-  _hasReturn() {
-    return !isNull(getPointer(0, this));
-  }
-  _initReturn() {
-    setUint16(0, 3, this);
-    return initStructAt(0, Return, this);
-  }
-  get _isReturn() {
-    return getUint16(0, this) === 3;
-  }
-  set return(value) {
-    setUint16(0, 3, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptFinish(value) {
-    setUint16(0, 4, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownFinish() {
-    return disown(this.finish);
-  }
-  /**
-  * Release a returned answer / cancel a call.
-  *
-  */
-  get finish() {
-    testWhich("finish", getUint16(0, this), 4, this);
-    return getStruct(0, Finish, this);
-  }
-  _hasFinish() {
-    return !isNull(getPointer(0, this));
-  }
-  _initFinish() {
-    setUint16(0, 4, this);
-    return initStructAt(0, Finish, this);
-  }
-  get _isFinish() {
-    return getUint16(0, this) === 4;
-  }
-  set finish(value) {
-    setUint16(0, 4, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptResolve(value) {
-    setUint16(0, 5, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownResolve() {
-    return disown(this.resolve);
-  }
-  /**
-  * Resolve a previously-sent promise.
-  *
-  */
-  get resolve() {
-    testWhich("resolve", getUint16(0, this), 5, this);
-    return getStruct(0, Resolve, this);
-  }
-  _hasResolve() {
-    return !isNull(getPointer(0, this));
-  }
-  _initResolve() {
-    setUint16(0, 5, this);
-    return initStructAt(0, Resolve, this);
-  }
-  get _isResolve() {
-    return getUint16(0, this) === 5;
-  }
-  set resolve(value) {
-    setUint16(0, 5, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptRelease(value) {
-    setUint16(0, 6, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownRelease() {
-    return disown(this.release);
-  }
-  /**
-  * Release a capability so that the remote object can be deallocated.
-  *
-  */
-  get release() {
-    testWhich("release", getUint16(0, this), 6, this);
-    return getStruct(0, Release, this);
-  }
-  _hasRelease() {
-    return !isNull(getPointer(0, this));
-  }
-  _initRelease() {
-    setUint16(0, 6, this);
-    return initStructAt(0, Release, this);
-  }
-  get _isRelease() {
-    return getUint16(0, this) === 6;
-  }
-  set release(value) {
-    setUint16(0, 6, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptDisembargo(value) {
-    setUint16(0, 13, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownDisembargo() {
-    return disown(this.disembargo);
-  }
-  /**
-  * Lift an embargo used to enforce E-order over promise resolution.
-  *
-  */
-  get disembargo() {
-    testWhich("disembargo", getUint16(0, this), 13, this);
-    return getStruct(0, Disembargo, this);
-  }
-  _hasDisembargo() {
-    return !isNull(getPointer(0, this));
-  }
-  _initDisembargo() {
-    setUint16(0, 13, this);
-    return initStructAt(0, Disembargo, this);
-  }
-  get _isDisembargo() {
-    return getUint16(0, this) === 13;
-  }
-  set disembargo(value) {
-    setUint16(0, 13, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptObsoleteSave(value) {
-    setUint16(0, 7, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownObsoleteSave() {
-    return disown(this.obsoleteSave);
-  }
-  /**
-  * Obsolete request to save a capability, resulting in a SturdyRef. This has been replaced
-  * by the `Persistent` interface defined in `persistent.capnp`. This operation was never
-  * implemented.
-  *
-  */
-  get obsoleteSave() {
-    testWhich("obsoleteSave", getUint16(0, this), 7, this);
-    return getPointer(0, this);
-  }
-  _hasObsoleteSave() {
-    return !isNull(getPointer(0, this));
-  }
-  get _isObsoleteSave() {
-    return getUint16(0, this) === 7;
-  }
-  set obsoleteSave(value) {
-    setUint16(0, 7, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptObsoleteDelete(value) {
-    setUint16(0, 9, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownObsoleteDelete() {
-    return disown(this.obsoleteDelete);
-  }
-  /**
-  * Obsolete way to delete a SturdyRef. This operation was never implemented.
-  *
-  */
-  get obsoleteDelete() {
-    testWhich("obsoleteDelete", getUint16(0, this), 9, this);
-    return getPointer(0, this);
-  }
-  _hasObsoleteDelete() {
-    return !isNull(getPointer(0, this));
-  }
-  get _isObsoleteDelete() {
-    return getUint16(0, this) === 9;
-  }
-  set obsoleteDelete(value) {
-    setUint16(0, 9, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptProvide(value) {
-    setUint16(0, 10, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownProvide() {
-    return disown(this.provide);
-  }
-  /**
-  * Provide a capability to a third party.
-  *
-  */
-  get provide() {
-    testWhich("provide", getUint16(0, this), 10, this);
-    return getStruct(0, Provide, this);
-  }
-  _hasProvide() {
-    return !isNull(getPointer(0, this));
-  }
-  _initProvide() {
-    setUint16(0, 10, this);
-    return initStructAt(0, Provide, this);
-  }
-  get _isProvide() {
-    return getUint16(0, this) === 10;
-  }
-  set provide(value) {
-    setUint16(0, 10, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptAccept(value) {
-    setUint16(0, 11, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownAccept() {
-    return disown(this.accept);
-  }
-  /**
-  * Accept a capability provided by a third party.
-  *
-  */
-  get accept() {
-    testWhich("accept", getUint16(0, this), 11, this);
-    return getStruct(0, Accept, this);
-  }
-  _hasAccept() {
-    return !isNull(getPointer(0, this));
-  }
-  _initAccept() {
-    setUint16(0, 11, this);
-    return initStructAt(0, Accept, this);
-  }
-  get _isAccept() {
-    return getUint16(0, this) === 11;
-  }
-  set accept(value) {
-    setUint16(0, 11, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptJoin(value) {
-    setUint16(0, 12, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownJoin() {
-    return disown(this.join);
-  }
-  /**
-  * Directly connect to the common root of two or more proxied caps.
-  *
-  */
-  get join() {
-    testWhich("join", getUint16(0, this), 12, this);
-    return getStruct(0, Join, this);
-  }
-  _hasJoin() {
-    return !isNull(getPointer(0, this));
-  }
-  _initJoin() {
-    setUint16(0, 12, this);
-    return initStructAt(0, Join, this);
-  }
-  get _isJoin() {
-    return getUint16(0, this) === 12;
-  }
-  set join(value) {
-    setUint16(0, 12, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  toString() {
-    return "Message_" + super.toString();
-  }
-  which() {
-    return getUint16(0, this);
-  }
-};
-var Bootstrap = class extends Struct {
-  static {
-    __name(this, "Bootstrap");
-  }
-  static _capnp = {
-    displayName: "Bootstrap",
-    id: "e94ccf8031176ec4",
-    size: new ObjectSize(8, 1)
-  };
-  /**
-  * A new question ID identifying this request, which will eventually receive a Return message
-  * containing the restored capability.
-  *
-  */
-  get questionId() {
-    return getUint32(0, this);
-  }
-  set questionId(value) {
-    setUint32(0, value, this);
-  }
-  _adoptDeprecatedObjectId(value) {
-    adopt(value, getPointer(0, this));
-  }
-  _disownDeprecatedObjectId() {
-    return disown(this.deprecatedObjectId);
-  }
-  /**
-  * ** DEPRECATED **
-  *
-  * A Vat may export multiple bootstrap interfaces. In this case, `deprecatedObjectId` specifies
-  * which one to return. If this pointer is null, then the default bootstrap interface is returned.
-  *
-  * As of version 0.5, use of this field is deprecated. If a service wants to export multiple
-  * bootstrap interfaces, it should instead define a single bootstrap interface that has methods
-  * that return each of the other interfaces.
-  *
-  * **History**
-  *
-  * In the first version of Cap'n Proto RPC (0.4.x) the `Bootstrap` message was called `Restore`.
-  * At the time, it was thought that this would eventually serve as the way to restore SturdyRefs
-  * (level 2). Meanwhile, an application could offer its "main" interface on a well-known
-  * (non-secret) SturdyRef.
-  *
-  * Since level 2 RPC was not implemented at the time, the `Restore` message was in practice only
-  * used to obtain the main interface. Since most applications had only one main interface that
-  * they wanted to restore, they tended to designate this with a null `objectId`.
-  *
-  * Unfortunately, the earliest version of the EZ RPC interfaces set a precedent of exporting
-  * multiple main interfaces by allowing them to be exported under string names. In this case,
-  * `objectId` was a Text value specifying the name.
-  *
-  * All of this proved problematic for several reasons:
-  *
-  * - The arrangement assumed that a client wishing to restore a SturdyRef would know exactly what
-  *   machine to connect to and would be able to immediately restore a SturdyRef on connection.
-  *   However, in practice, the ability to restore SturdyRefs is itself a capability that may
-  *   require going through an authentication process to obtain. Thus, it makes more sense to
-  *   define a "restorer service" as a full Cap'n Proto interface. If this restorer interface is
-  *   offered as the vat's bootstrap interface, then this is equivalent to the old arrangement.
-  *
-  * - Overloading "Restore" for the purpose of obtaining well-known capabilities encouraged the
-  *   practice of exporting singleton services with string names. If singleton services are desired,
-  *   it is better to have one main interface that has methods that can be used to obtain each
-  *   service, in order to get all the usual benefits of schemas and type checking.
-  *
-  * - Overloading "Restore" also had a security problem: Often, "main" or "well-known"
-  *   capabilities exported by a vat are in fact not public: they are intended to be accessed only
-  *   by clients who are capable of forming a connection to the vat. This can lead to trouble if
-  *   the client itself has other clients and wishes to forward some `Restore` requests from those
-  *   external clients -- it has to be very careful not to allow through `Restore` requests
-  *   addressing the default capability.
-  *
-  *   For example, consider the case of a sandboxed Sandstorm application and its supervisor. The
-  *   application exports a default capability to its supervisor that provides access to
-  *   functionality that only the supervisor is supposed to access. Meanwhile, though, applications
-  *   may publish other capabilities that may be persistent, in which case the application needs
-  *   to field `Restore` requests that could come from anywhere. These requests of course have to
-  *   pass through the supervisor, as all communications with the outside world must. But, the
-  *   supervisor has to be careful not to honor an external request addressing the application's
-  *   default capability, since this capability is privileged. Unfortunately, the default
-  *   capability cannot be given an unguessable name, because then the supervisor itself would not
-  *   be able to address it!
-  *
-  * As of Cap'n Proto 0.5, `Restore` has been renamed to `Bootstrap` and is no longer planned for
-  * use in restoring SturdyRefs.
-  *
-  * Note that 0.4 also defined a message type called `Delete` that, like `Restore`, addressed a
-  * SturdyRef, but indicated that the client would not restore the ref again in the future. This
-  * operation was never implemented, so it was removed entirely. If a "delete" operation is desired,
-  * it should exist as a method on the same interface that handles restoring SturdyRefs. However,
-  * the utility of such an operation is questionable. You wouldn't be able to rely on it for
-  * garbage collection since a client could always disappear permanently without remembering to
-  * delete all its SturdyRefs, thus leaving them dangling forever. Therefore, it is advisable to
-  * design systems such that SturdyRefs never represent "owned" pointers.
-  *
-  * For example, say a SturdyRef points to an image file hosted on some server. That image file
-  * should also live inside a collection (a gallery, perhaps) hosted on the same server, owned by
-  * a user who can delete the image at any time. If the user deletes the image, the SturdyRef
-  * stops working. On the other hand, if the SturdyRef is discarded, this has no effect on the
-  * existence of the image in its collection.
-  *
-  */
-  get deprecatedObjectId() {
-    return getPointer(0, this);
-  }
-  _hasDeprecatedObjectId() {
-    return !isNull(getPointer(0, this));
-  }
-  set deprecatedObjectId(value) {
-    copyFrom(value, getPointer(0, this));
-  }
-  toString() {
-    return "Bootstrap_" + super.toString();
-  }
-};
-var Call_SendResultsTo_Which = {
-  /**
-  * Send the return message back to the caller (the usual).
-  *
-  */
-  CALLER: 0,
-  /**
-  * **(level 1)**
-  *
-  * Don't actually return the results to the sender.  Instead, hold on to them and await
-  * instructions from the sender regarding what to do with them.  In particular, the sender
-  * may subsequently send a `Return` for some other call (which the receiver had previously made
-  * to the sender) with `takeFromOtherQuestion` set.  The results from this call are then used
-  * as the results of the other call.
-  *
-  * When `yourself` is used, the receiver must still send a `Return` for the call, but sets the
-  * field `resultsSentElsewhere` in that `Return` rather than including the results.
-  *
-  * This feature can be used to implement tail calls in which a call from Vat A to Vat B ends up
-  * returning the result of a call from Vat B back to Vat A.
-  *
-  * In particular, the most common use case for this feature is when Vat A makes a call to a
-  * promise in Vat B, and then that promise ends up resolving to a capability back in Vat A.
-  * Vat B must forward all the queued calls on that promise back to Vat A, but can set `yourself`
-  * in the calls so that the results need not pass back through Vat B.
-  *
-  * For example:
-  * - Alice, in Vat A, calls foo() on Bob in Vat B.
-  * - Alice makes a pipelined call bar() on the promise returned by foo().
-  * - Later on, Bob resolves the promise from foo() to point at Carol, who lives in Vat A (next
-  *   to Alice).
-  * - Vat B dutifully forwards the bar() call to Carol.  Let us call this forwarded call bar'().
-  *   Notice that bar() and bar'() are travelling in opposite directions on the same network
-  *   link.
-  * - The `Call` for bar'() has `sendResultsTo` set to `yourself`.
-  * - Vat B sends a `Return` for bar() with `takeFromOtherQuestion` set in place of the results,
-  *   with the value set to the question ID of bar'().  Vat B does not wait for bar'() to return,
-  *   as doing so would introduce unnecessary round trip latency.
-  * - Vat A receives bar'() and delivers it to Carol.
-  * - When bar'() returns, Vat A sends a `Return` for bar'() to Vat B, with `resultsSentElsewhere`
-  *   set in place of results.
-  * - Vat A sends a `Finish` for the bar() call to Vat B.
-  * - Vat B receives the `Finish` for bar() and sends a `Finish` for bar'().
-  *
-  */
-  YOURSELF: 1,
-  /**
-  * **(level 3)**
-  *
-  * The call's result should be returned to a different vat.  The receiver (the callee) expects
-  * to receive an `Accept` message from the indicated vat, and should return the call's result
-  * to it, rather than to the sender of the `Call`.
-  *
-  * This operates much like `yourself`, above, except that Carol is in a separate Vat C.  `Call`
-  * messages are sent from Vat A -> Vat B and Vat B -> Vat C.  A `Return` message is sent from
-  * Vat B -> Vat A that contains `acceptFromThirdParty` in place of results.  When Vat A sends
-  * an `Accept` to Vat C, it receives back a `Return` containing the call's actual result.  Vat C
-  * also sends a `Return` to Vat B with `resultsSentElsewhere`.
-  *
-  */
-  THIRD_PARTY: 2
-};
-var Call_SendResultsTo = class extends Struct {
-  static {
-    __name(this, "Call_SendResultsTo");
-  }
-  static CALLER = Call_SendResultsTo_Which.CALLER;
-  static YOURSELF = Call_SendResultsTo_Which.YOURSELF;
-  static THIRD_PARTY = Call_SendResultsTo_Which.THIRD_PARTY;
-  static _capnp = {
-    displayName: "sendResultsTo",
-    id: "dae8b0f61aab5f99",
-    size: new ObjectSize(24, 3)
-  };
-  get _isCaller() {
-    return getUint16(6, this) === 0;
-  }
-  set caller(_) {
-    setUint16(6, 0, this);
-  }
-  get _isYourself() {
-    return getUint16(6, this) === 1;
-  }
-  set yourself(_) {
-    setUint16(6, 1, this);
-  }
-  _adoptThirdParty(value) {
-    setUint16(6, 2, this);
-    adopt(value, getPointer(2, this));
-  }
-  _disownThirdParty() {
-    return disown(this.thirdParty);
-  }
-  /**
-  * **(level 3)**
-  *
-  * The call's result should be returned to a different vat.  The receiver (the callee) expects
-  * to receive an `Accept` message from the indicated vat, and should return the call's result
-  * to it, rather than to the sender of the `Call`.
-  *
-  * This operates much like `yourself`, above, except that Carol is in a separate Vat C.  `Call`
-  * messages are sent from Vat A -> Vat B and Vat B -> Vat C.  A `Return` message is sent from
-  * Vat B -> Vat A that contains `acceptFromThirdParty` in place of results.  When Vat A sends
-  * an `Accept` to Vat C, it receives back a `Return` containing the call's actual result.  Vat C
-  * also sends a `Return` to Vat B with `resultsSentElsewhere`.
-  *
-  */
-  get thirdParty() {
-    testWhich("thirdParty", getUint16(6, this), 2, this);
-    return getPointer(2, this);
-  }
-  _hasThirdParty() {
-    return !isNull(getPointer(2, this));
-  }
-  get _isThirdParty() {
-    return getUint16(6, this) === 2;
-  }
-  set thirdParty(value) {
-    setUint16(6, 2, this);
-    copyFrom(value, getPointer(2, this));
-  }
-  toString() {
-    return "Call_SendResultsTo_" + super.toString();
-  }
-  which() {
-    return getUint16(6, this);
-  }
-};
-var Call = class _Call extends Struct {
-  static {
-    __name(this, "Call");
-  }
-  static _capnp = {
-    displayName: "Call",
-    id: "836a53ce789d4cd4",
-    size: new ObjectSize(24, 3),
-    defaultAllowThirdPartyTailCall: getBitMask(false, 0),
-    defaultNoPromisePipelining: getBitMask(false, 1),
-    defaultOnlyPromisePipeline: getBitMask(false, 2)
-  };
-  /**
-  * A number, chosen by the caller, that identifies this call in future messages.  This number
-  * must be different from all other calls originating from the same end of the connection (but
-  * may overlap with question IDs originating from the opposite end).  A fine strategy is to use
-  * sequential question IDs, but the recipient should not assume this.
-  *
-  * A question ID can be reused once both:
-  * - A matching Return has been received from the callee.
-  * - A matching Finish has been sent from the caller.
-  *
-  */
-  get questionId() {
-    return getUint32(0, this);
-  }
-  set questionId(value) {
-    setUint32(0, value, this);
-  }
-  _adoptTarget(value) {
-    adopt(value, getPointer(0, this));
-  }
-  _disownTarget() {
-    return disown(this.target);
-  }
-  /**
-  * The object that should receive this call.
-  *
-  */
-  get target() {
-    return getStruct(0, MessageTarget, this);
-  }
-  _hasTarget() {
-    return !isNull(getPointer(0, this));
-  }
-  _initTarget() {
-    return initStructAt(0, MessageTarget, this);
-  }
-  set target(value) {
-    copyFrom(value, getPointer(0, this));
-  }
-  /**
-  * The type ID of the interface being called.  Each capability may implement multiple interfaces.
-  *
-  */
-  get interfaceId() {
-    return getUint64(8, this);
-  }
-  set interfaceId(value) {
-    setUint64(8, value, this);
-  }
-  /**
-  * The ordinal number of the method to call within the requested interface.
-  *
-  */
-  get methodId() {
-    return getUint16(4, this);
-  }
-  set methodId(value) {
-    setUint16(4, value, this);
-  }
-  /**
-  * Indicates whether or not the receiver is allowed to send a `Return` containing
-  * `acceptFromThirdParty`.  Level 3 implementations should set this true.  Otherwise, the callee
-  * will have to proxy the return in the case of a tail call to a third-party vat.
-  *
-  */
-  get allowThirdPartyTailCall() {
-    return getBit(128, this, _Call._capnp.defaultAllowThirdPartyTailCall);
-  }
-  set allowThirdPartyTailCall(value) {
-    setBit(128, value, this, _Call._capnp.defaultAllowThirdPartyTailCall);
-  }
-  /**
-  * If true, the sender promises that it won't make any promise-pipelined calls on the results of
-  * this call. If it breaks this promise, the receiver may throw an arbitrary error from such
-  * calls.
-  *
-  * The receiver may use this as an optimization, by skipping the bookkeeping needed for pipelining
-  * when no pipelined calls are expected. The sender typically sets this to false when the method's
-  * schema does not specify any return capabilities.
-  *
-  */
-  get noPromisePipelining() {
-    return getBit(129, this, _Call._capnp.defaultNoPromisePipelining);
-  }
-  set noPromisePipelining(value) {
-    setBit(129, value, this, _Call._capnp.defaultNoPromisePipelining);
-  }
-  /**
-  * If true, the sender only plans to use this call to make pipelined calls. The receiver need not
-  * send a `Return` message (but is still allowed to do so).
-  *
-  * Since the sender does not know whether a `Return` will be sent, it must release all state
-  * related to the call when it sends `Finish`. However, in the case that the callee does not
-  * recognize this hint and chooses to send a `Return`, then technically the caller is not allowed
-  * to reuse the question ID until it receives said `Return`. This creates a conundrum: How does
-  * the caller decide when it's OK to reuse the ID? To sidestep the problem, the C++ implementation
-  * uses high-numbered IDs (with the high-order bit set) for such calls, and cycles through the
-  * IDs in order. If all 2^31 IDs in this space are used without ever seeing a `Return`, then the
-  * implementation assumes that the other end is in fact honoring the hint, and the ID counter is
-  * allowed to loop around. If a `Return` is ever seen when `onlyPromisePipeline` was set, then
-  * the implementation stops using this hint.
-  *
-  */
-  get onlyPromisePipeline() {
-    return getBit(130, this, _Call._capnp.defaultOnlyPromisePipeline);
-  }
-  set onlyPromisePipeline(value) {
-    setBit(130, value, this, _Call._capnp.defaultOnlyPromisePipeline);
-  }
-  _adoptParams(value) {
-    adopt(value, getPointer(1, this));
-  }
-  _disownParams() {
-    return disown(this.params);
-  }
-  /**
-  * The call parameters.  `params.content` is a struct whose fields correspond to the parameters of
-  * the method.
-  *
-  */
-  get params() {
-    return getStruct(1, Payload, this);
-  }
-  _hasParams() {
-    return !isNull(getPointer(1, this));
-  }
-  _initParams() {
-    return initStructAt(1, Payload, this);
-  }
-  set params(value) {
-    copyFrom(value, getPointer(1, this));
-  }
-  /**
-  * Where should the return message be sent?
-  *
-  */
-  get sendResultsTo() {
-    return getAs(Call_SendResultsTo, this);
-  }
-  _initSendResultsTo() {
-    return getAs(Call_SendResultsTo, this);
-  }
-  toString() {
-    return "Call_" + super.toString();
-  }
-};
-var Return_Which = {
-  /**
-  * Equal to the QuestionId of the corresponding `Call` message.
-  *
-  */
-  RESULTS: 0,
-  /**
-  * If true, all capabilities that were in the params should be considered released.  The sender
-  * must not send separate `Release` messages for them.  Level 0 implementations in particular
-  * should always set this true.  This defaults true because if level 0 implementations forget to
-  * set it they'll never notice (just silently leak caps), but if level >=1 implementations forget
-  * to set it to false they'll quickly get errors.
-  *
-  * The receiver should act as if the sender had sent a release message with count=1 for each
-  * CapDescriptor in the original Call message.
-  *
-  */
-  EXCEPTION: 1,
-  /**
-  * The result.
-  *
-  * For regular method calls, `results.content` points to the result struct.
-  *
-  * For a `Return` in response to an `Accept` or `Bootstrap`, `results` contains a single
-  * capability (rather than a struct), and `results.content` is just a capability pointer with
-  * index 0.  A `Finish` is still required in this case.
-  *
-  */
-  CANCELED: 2,
-  /**
-  * Indicates that the call failed and explains why.
-  *
-  */
-  RESULTS_SENT_ELSEWHERE: 3,
-  /**
-  * Indicates that the call was canceled due to the caller sending a Finish message
-  * before the call had completed.
-  *
-  */
-  TAKE_FROM_OTHER_QUESTION: 4,
-  /**
-  * This is set when returning from a `Call` that had `sendResultsTo` set to something other
-  * than `caller`.
-  *
-  * It doesn't matter too much when this is sent, as the receiver doesn't need to do anything
-  * with it, but the C++ implementation appears to wait for the call to finish before sending
-  * this.
-  *
-  */
-  ACCEPT_FROM_THIRD_PARTY: 5
-};
-var Return = class _Return extends Struct {
-  static {
-    __name(this, "Return");
-  }
-  static RESULTS = Return_Which.RESULTS;
-  static EXCEPTION = Return_Which.EXCEPTION;
-  static CANCELED = Return_Which.CANCELED;
-  static RESULTS_SENT_ELSEWHERE = Return_Which.RESULTS_SENT_ELSEWHERE;
-  static TAKE_FROM_OTHER_QUESTION = Return_Which.TAKE_FROM_OTHER_QUESTION;
-  static ACCEPT_FROM_THIRD_PARTY = Return_Which.ACCEPT_FROM_THIRD_PARTY;
-  static _capnp = {
-    displayName: "Return",
-    id: "9e19b28d3db3573a",
-    size: new ObjectSize(16, 1),
-    defaultReleaseParamCaps: getBitMask(true, 0),
-    defaultNoFinishNeeded: getBitMask(false, 1)
-  };
-  /**
-  * Equal to the QuestionId of the corresponding `Call` message.
-  *
-  */
-  get answerId() {
-    return getUint32(0, this);
-  }
-  set answerId(value) {
-    setUint32(0, value, this);
-  }
-  /**
-  * If true, all capabilities that were in the params should be considered released.  The sender
-  * must not send separate `Release` messages for them.  Level 0 implementations in particular
-  * should always set this true.  This defaults true because if level 0 implementations forget to
-  * set it they'll never notice (just silently leak caps), but if level >=1 implementations forget
-  * to set it to false they'll quickly get errors.
-  *
-  * The receiver should act as if the sender had sent a release message with count=1 for each
-  * CapDescriptor in the original Call message.
-  *
-  */
-  get releaseParamCaps() {
-    return getBit(32, this, _Return._capnp.defaultReleaseParamCaps);
-  }
-  set releaseParamCaps(value) {
-    setBit(32, value, this, _Return._capnp.defaultReleaseParamCaps);
-  }
-  /**
-  * If true, the sender does not need the receiver to send a `Finish` message; its answer table
-  * entry has already been cleaned up. This implies that the results do not contain any
-  * capabilities, since the `Finish` message would normally release those capabilities from
-  * promise pipelining responsibility. The caller may still send a `Finish` message if it wants,
-  * which will be silently ignored by the callee.
-  *
-  */
-  get noFinishNeeded() {
-    return getBit(33, this, _Return._capnp.defaultNoFinishNeeded);
-  }
-  set noFinishNeeded(value) {
-    setBit(33, value, this, _Return._capnp.defaultNoFinishNeeded);
-  }
-  _adoptResults(value) {
-    setUint16(6, 0, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownResults() {
-    return disown(this.results);
-  }
-  /**
-  * The result.
-  *
-  * For regular method calls, `results.content` points to the result struct.
-  *
-  * For a `Return` in response to an `Accept` or `Bootstrap`, `results` contains a single
-  * capability (rather than a struct), and `results.content` is just a capability pointer with
-  * index 0.  A `Finish` is still required in this case.
-  *
-  */
-  get results() {
-    testWhich("results", getUint16(6, this), 0, this);
-    return getStruct(0, Payload, this);
-  }
-  _hasResults() {
-    return !isNull(getPointer(0, this));
-  }
-  _initResults() {
-    setUint16(6, 0, this);
-    return initStructAt(0, Payload, this);
-  }
-  get _isResults() {
-    return getUint16(6, this) === 0;
-  }
-  set results(value) {
-    setUint16(6, 0, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptException(value) {
-    setUint16(6, 1, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownException() {
-    return disown(this.exception);
-  }
-  /**
-  * Indicates that the call failed and explains why.
-  *
-  */
-  get exception() {
-    testWhich("exception", getUint16(6, this), 1, this);
-    return getStruct(0, Exception, this);
-  }
-  _hasException() {
-    return !isNull(getPointer(0, this));
-  }
-  _initException() {
-    setUint16(6, 1, this);
-    return initStructAt(0, Exception, this);
-  }
-  get _isException() {
-    return getUint16(6, this) === 1;
-  }
-  set exception(value) {
-    setUint16(6, 1, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  get _isCanceled() {
-    return getUint16(6, this) === 2;
-  }
-  set canceled(_) {
-    setUint16(6, 2, this);
-  }
-  get _isResultsSentElsewhere() {
-    return getUint16(6, this) === 3;
-  }
-  set resultsSentElsewhere(_) {
-    setUint16(6, 3, this);
-  }
-  /**
-  * The sender has also sent (before this message) a `Call` with the given question ID and with
-  * `sendResultsTo.yourself` set, and the results of that other call should be used as the
-  * results here.  `takeFromOtherQuestion` can only used once per question.
-  *
-  */
-  get takeFromOtherQuestion() {
-    testWhich("takeFromOtherQuestion", getUint16(6, this), 4, this);
-    return getUint32(8, this);
-  }
-  get _isTakeFromOtherQuestion() {
-    return getUint16(6, this) === 4;
-  }
-  set takeFromOtherQuestion(value) {
-    setUint16(6, 4, this);
-    setUint32(8, value, this);
-  }
-  _adoptAcceptFromThirdParty(value) {
-    setUint16(6, 5, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownAcceptFromThirdParty() {
-    return disown(this.acceptFromThirdParty);
-  }
-  /**
-  * **(level 3)**
-  *
-  * The caller should contact a third-party vat to pick up the results.  An `Accept` message
-  * sent to the vat will return the result.  This pairs with `Call.sendResultsTo.thirdParty`.
-  * It should only be used if the corresponding `Call` had `allowThirdPartyTailCall` set.
-  *
-  */
-  get acceptFromThirdParty() {
-    testWhich("acceptFromThirdParty", getUint16(6, this), 5, this);
-    return getPointer(0, this);
-  }
-  _hasAcceptFromThirdParty() {
-    return !isNull(getPointer(0, this));
-  }
-  get _isAcceptFromThirdParty() {
-    return getUint16(6, this) === 5;
-  }
-  set acceptFromThirdParty(value) {
-    setUint16(6, 5, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  toString() {
-    return "Return_" + super.toString();
-  }
-  which() {
-    return getUint16(6, this);
-  }
-};
-var Finish = class _Finish extends Struct {
-  static {
-    __name(this, "Finish");
-  }
-  static _capnp = {
-    displayName: "Finish",
-    id: "d37d2eb2c2f80e63",
-    size: new ObjectSize(8, 0),
-    defaultReleaseResultCaps: getBitMask(true, 0),
-    defaultRequireEarlyCancellationWorkaround: getBitMask(true, 1)
-  };
-  /**
-  * ID of the call whose result is to be released.
-  *
-  */
-  get questionId() {
-    return getUint32(0, this);
-  }
-  set questionId(value) {
-    setUint32(0, value, this);
-  }
-  /**
-  * If true, all capabilities that were in the results should be considered released.  The sender
-  * must not send separate `Release` messages for them.  Level 0 implementations in particular
-  * should always set this true.  This defaults true because if level 0 implementations forget to
-  * set it they'll never notice (just silently leak caps), but if level >=1 implementations forget
-  * set it false they'll quickly get errors.
-  *
-  */
-  get releaseResultCaps() {
-    return getBit(32, this, _Finish._capnp.defaultReleaseResultCaps);
-  }
-  set releaseResultCaps(value) {
-    setBit(32, value, this, _Finish._capnp.defaultReleaseResultCaps);
-  }
-  /**
-  * If true, if the RPC system receives this Finish message before the original call has even been
-  * delivered, it should defer cancellation util after delivery. In particular, this gives the
-  * destination object a chance to opt out of cancellation, e.g. as controlled by the
-  * `allowCancellation` annotation defined in `c++.capnp`.
-  *
-  * This is a work-around. Versions 1.0 and up of Cap'n Proto always set this to false. However,
-  * older versions of Cap'n Proto unintentionally exhibited this errant behavior by default, and
-  * as a result programs built with older versions could be inadvertently relying on their peers
-  * to implement the behavior. The purpose of this flag is to let newer versions know when the
-  * peer is an older version, so that it can attempt to work around the issue.
-  *
-  * See also comments in handleFinish() in rpc.c++ for more details.
-  *
-  */
-  get requireEarlyCancellationWorkaround() {
-    return getBit(33, this, _Finish._capnp.defaultRequireEarlyCancellationWorkaround);
-  }
-  set requireEarlyCancellationWorkaround(value) {
-    setBit(33, value, this, _Finish._capnp.defaultRequireEarlyCancellationWorkaround);
-  }
-  toString() {
-    return "Finish_" + super.toString();
-  }
-};
-var Resolve_Which = {
-  /**
-  * The ID of the promise to be resolved.
-  *
-  * Unlike all other instances of `ExportId` sent from the exporter, the `Resolve` message does
-  * _not_ increase the reference count of `promiseId`.  In fact, it is expected that the receiver
-  * will release the export soon after receiving `Resolve`, and the sender will not send this
-  * `ExportId` again until it has been released and recycled.
-  *
-  * When an export ID sent over the wire (e.g. in a `CapDescriptor`) is indicated to be a promise,
-  * this indicates that the sender will follow up at some point with a `Resolve` message.  If the
-  * same `promiseId` is sent again before `Resolve`, still only one `Resolve` is sent.  If the
-  * same ID is sent again later _after_ a `Resolve`, it can only be because the export's
-  * reference count hit zero in the meantime and the ID was re-assigned to a new export, therefore
-  * this later promise does _not_ correspond to the earlier `Resolve`.
-  *
-  * If a promise ID's reference count reaches zero before a `Resolve` is sent, the `Resolve`
-  * message may or may not still be sent (the `Resolve` may have already been in-flight when
-  * `Release` was sent, but if the `Release` is received before `Resolve` then there is no longer
-  * any reason to send a `Resolve`).  Thus a `Resolve` may be received for a promise of which
-  * the receiver has no knowledge, because it already released it earlier.  In this case, the
-  * receiver should simply release the capability to which the promise resolved.
-  *
-  */
-  CAP: 0,
-  /**
-  * The object to which the promise resolved.
-  *
-  * The sender promises that from this point forth, until `promiseId` is released, it shall
-  * simply forward all messages to the capability designated by `cap`.  This is true even if
-  * `cap` itself happens to designate another promise, and that other promise later resolves --
-  * messages sent to `promiseId` shall still go to that other promise, not to its resolution.
-  * This is important in the case that the receiver of the `Resolve` ends up sending a
-  * `Disembargo` message towards `promiseId` in order to control message ordering -- that
-  * `Disembargo` really needs to reflect back to exactly the object designated by `cap` even
-  * if that object is itself a promise.
-  *
-  */
-  EXCEPTION: 1
-};
-var Resolve = class extends Struct {
-  static {
-    __name(this, "Resolve");
-  }
-  static CAP = Resolve_Which.CAP;
-  static EXCEPTION = Resolve_Which.EXCEPTION;
-  static _capnp = {
-    displayName: "Resolve",
-    id: "bbc29655fa89086e",
-    size: new ObjectSize(8, 1)
-  };
-  /**
-  * The ID of the promise to be resolved.
-  *
-  * Unlike all other instances of `ExportId` sent from the exporter, the `Resolve` message does
-  * _not_ increase the reference count of `promiseId`.  In fact, it is expected that the receiver
-  * will release the export soon after receiving `Resolve`, and the sender will not send this
-  * `ExportId` again until it has been released and recycled.
-  *
-  * When an export ID sent over the wire (e.g. in a `CapDescriptor`) is indicated to be a promise,
-  * this indicates that the sender will follow up at some point with a `Resolve` message.  If the
-  * same `promiseId` is sent again before `Resolve`, still only one `Resolve` is sent.  If the
-  * same ID is sent again later _after_ a `Resolve`, it can only be because the export's
-  * reference count hit zero in the meantime and the ID was re-assigned to a new export, therefore
-  * this later promise does _not_ correspond to the earlier `Resolve`.
-  *
-  * If a promise ID's reference count reaches zero before a `Resolve` is sent, the `Resolve`
-  * message may or may not still be sent (the `Resolve` may have already been in-flight when
-  * `Release` was sent, but if the `Release` is received before `Resolve` then there is no longer
-  * any reason to send a `Resolve`).  Thus a `Resolve` may be received for a promise of which
-  * the receiver has no knowledge, because it already released it earlier.  In this case, the
-  * receiver should simply release the capability to which the promise resolved.
-  *
-  */
-  get promiseId() {
-    return getUint32(0, this);
-  }
-  set promiseId(value) {
-    setUint32(0, value, this);
-  }
-  _adoptCap(value) {
-    setUint16(4, 0, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownCap() {
-    return disown(this.cap);
-  }
-  /**
-  * The object to which the promise resolved.
-  *
-  * The sender promises that from this point forth, until `promiseId` is released, it shall
-  * simply forward all messages to the capability designated by `cap`.  This is true even if
-  * `cap` itself happens to designate another promise, and that other promise later resolves --
-  * messages sent to `promiseId` shall still go to that other promise, not to its resolution.
-  * This is important in the case that the receiver of the `Resolve` ends up sending a
-  * `Disembargo` message towards `promiseId` in order to control message ordering -- that
-  * `Disembargo` really needs to reflect back to exactly the object designated by `cap` even
-  * if that object is itself a promise.
-  *
-  */
-  get cap() {
-    testWhich("cap", getUint16(4, this), 0, this);
-    return getStruct(0, CapDescriptor, this);
-  }
-  _hasCap() {
-    return !isNull(getPointer(0, this));
-  }
-  _initCap() {
-    setUint16(4, 0, this);
-    return initStructAt(0, CapDescriptor, this);
-  }
-  get _isCap() {
-    return getUint16(4, this) === 0;
-  }
-  set cap(value) {
-    setUint16(4, 0, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptException(value) {
-    setUint16(4, 1, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownException() {
-    return disown(this.exception);
-  }
-  /**
-  * Indicates that the promise was broken.
-  *
-  */
-  get exception() {
-    testWhich("exception", getUint16(4, this), 1, this);
-    return getStruct(0, Exception, this);
-  }
-  _hasException() {
-    return !isNull(getPointer(0, this));
-  }
-  _initException() {
-    setUint16(4, 1, this);
-    return initStructAt(0, Exception, this);
-  }
-  get _isException() {
-    return getUint16(4, this) === 1;
-  }
-  set exception(value) {
-    setUint16(4, 1, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  toString() {
-    return "Resolve_" + super.toString();
-  }
-  which() {
-    return getUint16(4, this);
-  }
-};
-var Release = class extends Struct {
-  static {
-    __name(this, "Release");
-  }
-  static _capnp = {
-    displayName: "Release",
-    id: "ad1a6c0d7dd07497",
-    size: new ObjectSize(8, 0)
-  };
-  /**
-  * What to release.
-  *
-  */
-  get id() {
-    return getUint32(0, this);
-  }
-  set id(value) {
-    setUint32(0, value, this);
-  }
-  /**
-  * The amount by which to decrement the reference count.  The export is only actually released
-  * when the reference count reaches zero.
-  *
-  */
-  get referenceCount() {
-    return getUint32(4, this);
-  }
-  set referenceCount(value) {
-    setUint32(4, value, this);
-  }
-  toString() {
-    return "Release_" + super.toString();
-  }
-};
-var Disembargo_Context_Which = {
-  /**
-  * The sender is requesting a disembargo on a promise that is known to resolve back to a
-  * capability hosted by the sender.  As soon as the receiver has echoed back all pipelined calls
-  * on this promise, it will deliver the Disembargo back to the sender with `receiverLoopback`
-  * set to the same value as `senderLoopback`.  This value is chosen by the sender, and since
-  * it is also consumed be the sender, the sender can use whatever strategy it wants to make sure
-  * the value is unambiguous.
-  *
-  * The receiver must verify that the target capability actually resolves back to the sender's
-  * vat.  Otherwise, the sender has committed a protocol error and should be disconnected.
-  *
-  */
-  SENDER_LOOPBACK: 0,
-  /**
-  * The receiver previously sent a `senderLoopback` Disembargo towards a promise resolving to
-  * this capability, and that Disembargo is now being echoed back.
-  *
-  */
-  RECEIVER_LOOPBACK: 1,
-  /**
-  * **(level 3)**
-  *
-  * The sender is requesting a disembargo on a promise that is known to resolve to a third-party
-  * capability that the sender is currently in the process of accepting (using `Accept`).
-  * The receiver of this `Disembargo` has an outstanding `Provide` on said capability.  The
-  * receiver should now send a `Disembargo` with `provide` set to the question ID of that
-  * `Provide` message.
-  *
-  * See `Accept.embargo` for an example.
-  *
-  */
-  ACCEPT: 2,
-  /**
-  * **(level 3)**
-  *
-  * The sender is requesting a disembargo on a capability currently being provided to a third
-  * party.  The question ID identifies the `Provide` message previously sent by the sender to
-  * this capability.  On receipt, the receiver (the capability host) shall release the embargo
-  * on the `Accept` message that it has received from the third party.  See `Accept.embargo` for
-  * an example.
-  *
-  */
-  PROVIDE: 3
-};
-var Disembargo_Context = class extends Struct {
-  static {
-    __name(this, "Disembargo_Context");
-  }
-  static SENDER_LOOPBACK = Disembargo_Context_Which.SENDER_LOOPBACK;
-  static RECEIVER_LOOPBACK = Disembargo_Context_Which.RECEIVER_LOOPBACK;
-  static ACCEPT = Disembargo_Context_Which.ACCEPT;
-  static PROVIDE = Disembargo_Context_Which.PROVIDE;
-  static _capnp = {
-    displayName: "context",
-    id: "d562b4df655bdd4d",
-    size: new ObjectSize(8, 1)
-  };
-  /**
-  * The sender is requesting a disembargo on a promise that is known to resolve back to a
-  * capability hosted by the sender.  As soon as the receiver has echoed back all pipelined calls
-  * on this promise, it will deliver the Disembargo back to the sender with `receiverLoopback`
-  * set to the same value as `senderLoopback`.  This value is chosen by the sender, and since
-  * it is also consumed be the sender, the sender can use whatever strategy it wants to make sure
-  * the value is unambiguous.
-  *
-  * The receiver must verify that the target capability actually resolves back to the sender's
-  * vat.  Otherwise, the sender has committed a protocol error and should be disconnected.
-  *
-  */
-  get senderLoopback() {
-    testWhich("senderLoopback", getUint16(4, this), 0, this);
-    return getUint32(0, this);
-  }
-  get _isSenderLoopback() {
-    return getUint16(4, this) === 0;
-  }
-  set senderLoopback(value) {
-    setUint16(4, 0, this);
-    setUint32(0, value, this);
-  }
-  /**
-  * The receiver previously sent a `senderLoopback` Disembargo towards a promise resolving to
-  * this capability, and that Disembargo is now being echoed back.
-  *
-  */
-  get receiverLoopback() {
-    testWhich("receiverLoopback", getUint16(4, this), 1, this);
-    return getUint32(0, this);
-  }
-  get _isReceiverLoopback() {
-    return getUint16(4, this) === 1;
-  }
-  set receiverLoopback(value) {
-    setUint16(4, 1, this);
-    setUint32(0, value, this);
-  }
-  get _isAccept() {
-    return getUint16(4, this) === 2;
-  }
-  set accept(_) {
-    setUint16(4, 2, this);
-  }
-  /**
-  * **(level 3)**
-  *
-  * The sender is requesting a disembargo on a capability currently being provided to a third
-  * party.  The question ID identifies the `Provide` message previously sent by the sender to
-  * this capability.  On receipt, the receiver (the capability host) shall release the embargo
-  * on the `Accept` message that it has received from the third party.  See `Accept.embargo` for
-  * an example.
-  *
-  */
-  get provide() {
-    testWhich("provide", getUint16(4, this), 3, this);
-    return getUint32(0, this);
-  }
-  get _isProvide() {
-    return getUint16(4, this) === 3;
-  }
-  set provide(value) {
-    setUint16(4, 3, this);
-    setUint32(0, value, this);
-  }
-  toString() {
-    return "Disembargo_Context_" + super.toString();
-  }
-  which() {
-    return getUint16(4, this);
-  }
-};
-var Disembargo = class extends Struct {
-  static {
-    __name(this, "Disembargo");
-  }
-  static _capnp = {
-    displayName: "Disembargo",
-    id: "f964368b0fbd3711",
-    size: new ObjectSize(8, 1)
-  };
-  _adoptTarget(value) {
-    adopt(value, getPointer(0, this));
-  }
-  _disownTarget() {
-    return disown(this.target);
-  }
-  /**
-  * What is to be disembargoed.
-  *
-  */
-  get target() {
-    return getStruct(0, MessageTarget, this);
-  }
-  _hasTarget() {
-    return !isNull(getPointer(0, this));
-  }
-  _initTarget() {
-    return initStructAt(0, MessageTarget, this);
-  }
-  set target(value) {
-    copyFrom(value, getPointer(0, this));
-  }
-  get context() {
-    return getAs(Disembargo_Context, this);
-  }
-  _initContext() {
-    return getAs(Disembargo_Context, this);
-  }
-  toString() {
-    return "Disembargo_" + super.toString();
-  }
-};
-var Provide = class extends Struct {
-  static {
-    __name(this, "Provide");
-  }
-  static _capnp = {
-    displayName: "Provide",
-    id: "9c6a046bfbc1ac5a",
-    size: new ObjectSize(8, 2)
-  };
-  /**
-  * Question ID to be held open until the recipient has received the capability.  A result will be
-  * returned once the third party has successfully received the capability.  The sender must at some
-  * point send a `Finish` message as with any other call, and that message can be used to cancel the
-  * whole operation.
-  *
-  */
-  get questionId() {
-    return getUint32(0, this);
-  }
-  set questionId(value) {
-    setUint32(0, value, this);
-  }
-  _adoptTarget(value) {
-    adopt(value, getPointer(0, this));
-  }
-  _disownTarget() {
-    return disown(this.target);
-  }
-  /**
-  * What is to be provided to the third party.
-  *
-  */
-  get target() {
-    return getStruct(0, MessageTarget, this);
-  }
-  _hasTarget() {
-    return !isNull(getPointer(0, this));
-  }
-  _initTarget() {
-    return initStructAt(0, MessageTarget, this);
-  }
-  set target(value) {
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptRecipient(value) {
-    adopt(value, getPointer(1, this));
-  }
-  _disownRecipient() {
-    return disown(this.recipient);
-  }
-  /**
-  * Identity of the third party that is expected to pick up the capability.
-  *
-  */
-  get recipient() {
-    return getPointer(1, this);
-  }
-  _hasRecipient() {
-    return !isNull(getPointer(1, this));
-  }
-  set recipient(value) {
-    copyFrom(value, getPointer(1, this));
-  }
-  toString() {
-    return "Provide_" + super.toString();
-  }
-};
-var Accept = class extends Struct {
-  static {
-    __name(this, "Accept");
-  }
-  static _capnp = {
-    displayName: "Accept",
-    id: "d4c9b56290554016",
-    size: new ObjectSize(8, 1)
-  };
-  /**
-  * A new question ID identifying this accept message, which will eventually receive a Return
-  * message containing the provided capability (or the call result in the case of a redirected
-  * return).
-  *
-  */
-  get questionId() {
-    return getUint32(0, this);
-  }
-  set questionId(value) {
-    setUint32(0, value, this);
-  }
-  _adoptProvision(value) {
-    adopt(value, getPointer(0, this));
-  }
-  _disownProvision() {
-    return disown(this.provision);
-  }
-  /**
-  * Identifies the provided object to be picked up.
-  *
-  */
-  get provision() {
-    return getPointer(0, this);
-  }
-  _hasProvision() {
-    return !isNull(getPointer(0, this));
-  }
-  set provision(value) {
-    copyFrom(value, getPointer(0, this));
-  }
-  /**
-  * If true, this accept shall be temporarily embargoed.  The resulting `Return` will not be sent,
-  * and any pipelined calls will not be delivered, until the embargo is released.  The receiver
-  * (the capability host) will expect the provider (the vat that sent the `Provide` message) to
-  * eventually send a `Disembargo` message with the field `context.provide` set to the question ID
-  * of the original `Provide` message.  At that point, the embargo is released and the queued
-  * messages are delivered.
-  *
-  * For example:
-  * - Alice, in Vat A, holds a promise P, which currently points toward Vat B.
-  * - Alice calls foo() on P.  The `Call` message is sent to Vat B.
-  * - The promise P in Vat B ends up resolving to Carol, in Vat C.
-  * - Vat B sends a `Provide` message to Vat C, identifying Vat A as the recipient.
-  * - Vat B sends a `Resolve` message to Vat A, indicating that the promise has resolved to a
-  *   `ThirdPartyCapId` identifying Carol in Vat C.
-  * - Vat A sends an `Accept` message to Vat C to pick up the capability.  Since Vat A knows that
-  *   it has an outstanding call to the promise, it sets `embargo` to `true` in the `Accept`
-  *   message.
-  * - Vat A sends a `Disembargo` message to Vat B on promise P, with `context.accept` set.
-  * - Alice makes a call bar() to promise P, which is now pointing towards Vat C.  Alice doesn't
-  *   know anything about the mechanics of promise resolution happening under the hood, but she
-  *   expects that bar() will be delivered after foo() because that is the order in which she
-  *   initiated the calls.
-  * - Vat A sends the bar() call to Vat C, as a pipelined call on the result of the `Accept` (which
-  *   hasn't returned yet, due to the embargo).  Since calls to the newly-accepted capability
-  *   are embargoed, Vat C does not deliver the call yet.
-  * - At some point, Vat B forwards the foo() call from the beginning of this example on to Vat C.
-  * - Vat B forwards the `Disembargo` from Vat A on to vat C.  It sets `context.provide` to the
-  *   question ID of the `Provide` message it had sent previously.
-  * - Vat C receives foo() before `Disembargo`, thus allowing it to correctly deliver foo()
-  *   before delivering bar().
-  * - Vat C receives `Disembargo` from Vat B.  It can now send a `Return` for the `Accept` from
-  *   Vat A, as well as deliver bar().
-  *
-  */
-  get embargo() {
-    return getBit(32, this);
-  }
-  set embargo(value) {
-    setBit(32, value, this);
-  }
-  toString() {
-    return "Accept_" + super.toString();
-  }
-};
-var Join = class extends Struct {
-  static {
-    __name(this, "Join");
-  }
-  static _capnp = {
-    displayName: "Join",
-    id: "fbe1980490e001af",
-    size: new ObjectSize(8, 2)
-  };
-  /**
-  * Question ID used to respond to this Join.  (Note that this ID only identifies one part of the
-  * request for one hop; each part has a different ID and relayed copies of the request have
-  * (probably) different IDs still.)
-  *
-  * The receiver will reply with a `Return` whose `results` is a JoinResult.  This `JoinResult`
-  * is relayed from the joined object's host, possibly with transformation applied as needed
-  * by the network.
-  *
-  * Like any return, the result must be released using a `Finish`.  However, this release
-  * should not occur until the joiner has either successfully connected to the joined object.
-  * Vats relaying a `Join` message similarly must not release the result they receive until the
-  * return they relayed back towards the joiner has itself been released.  This allows the
-  * joined object's host to detect when the Join operation is canceled before completing -- if
-  * it receives a `Finish` for one of the join results before the joiner successfully
-  * connects.  It can then free any resources it had allocated as part of the join.
-  *
-  */
-  get questionId() {
-    return getUint32(0, this);
-  }
-  set questionId(value) {
-    setUint32(0, value, this);
-  }
-  _adoptTarget(value) {
-    adopt(value, getPointer(0, this));
-  }
-  _disownTarget() {
-    return disown(this.target);
-  }
-  /**
-  * The capability to join.
-  *
-  */
-  get target() {
-    return getStruct(0, MessageTarget, this);
-  }
-  _hasTarget() {
-    return !isNull(getPointer(0, this));
-  }
-  _initTarget() {
-    return initStructAt(0, MessageTarget, this);
-  }
-  set target(value) {
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptKeyPart(value) {
-    adopt(value, getPointer(1, this));
-  }
-  _disownKeyPart() {
-    return disown(this.keyPart);
-  }
-  /**
-  * A part of the join key.  These combine to form the complete join key, which is used to establish
-  * a direct connection.
-  *
-  */
-  get keyPart() {
-    return getPointer(1, this);
-  }
-  _hasKeyPart() {
-    return !isNull(getPointer(1, this));
-  }
-  set keyPart(value) {
-    copyFrom(value, getPointer(1, this));
-  }
-  toString() {
-    return "Join_" + super.toString();
-  }
-};
-var MessageTarget_Which = {
-  /**
-  * This message is to a capability or promise previously imported by the caller (exported by
-  * the receiver).
-  *
-  */
-  IMPORTED_CAP: 0,
-  /**
-  * This message is to a capability that is expected to be returned by another call that has not
-  * yet been completed.
-  *
-  * At level 0, this is supported only for addressing the result of a previous `Bootstrap`, so
-  * that initial startup doesn't require a round trip.
-  *
-  */
-  PROMISED_ANSWER: 1
-};
-var MessageTarget = class extends Struct {
-  static {
-    __name(this, "MessageTarget");
-  }
-  static IMPORTED_CAP = MessageTarget_Which.IMPORTED_CAP;
-  static PROMISED_ANSWER = MessageTarget_Which.PROMISED_ANSWER;
-  static _capnp = {
-    displayName: "MessageTarget",
-    id: "95bc14545813fbc1",
-    size: new ObjectSize(8, 1)
-  };
-  /**
-  * This message is to a capability or promise previously imported by the caller (exported by
-  * the receiver).
-  *
-  */
-  get importedCap() {
-    testWhich("importedCap", getUint16(4, this), 0, this);
-    return getUint32(0, this);
-  }
-  get _isImportedCap() {
-    return getUint16(4, this) === 0;
-  }
-  set importedCap(value) {
-    setUint16(4, 0, this);
-    setUint32(0, value, this);
-  }
-  _adoptPromisedAnswer(value) {
-    setUint16(4, 1, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownPromisedAnswer() {
-    return disown(this.promisedAnswer);
-  }
-  /**
-  * This message is to a capability that is expected to be returned by another call that has not
-  * yet been completed.
-  *
-  * At level 0, this is supported only for addressing the result of a previous `Bootstrap`, so
-  * that initial startup doesn't require a round trip.
-  *
-  */
-  get promisedAnswer() {
-    testWhich("promisedAnswer", getUint16(4, this), 1, this);
-    return getStruct(0, PromisedAnswer, this);
-  }
-  _hasPromisedAnswer() {
-    return !isNull(getPointer(0, this));
-  }
-  _initPromisedAnswer() {
-    setUint16(4, 1, this);
-    return initStructAt(0, PromisedAnswer, this);
-  }
-  get _isPromisedAnswer() {
-    return getUint16(4, this) === 1;
-  }
-  set promisedAnswer(value) {
-    setUint16(4, 1, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  toString() {
-    return "MessageTarget_" + super.toString();
-  }
-  which() {
-    return getUint16(4, this);
-  }
-};
-var Payload = class _Payload extends Struct {
-  static {
-    __name(this, "Payload");
-  }
-  static _capnp = {
-    displayName: "Payload",
-    id: "9a0e61223d96743b",
-    size: new ObjectSize(0, 2)
-  };
-  static _CapTable;
-  _adoptContent(value) {
-    adopt(value, getPointer(0, this));
-  }
-  _disownContent() {
-    return disown(this.content);
-  }
-  /**
-  * Some Cap'n Proto data structure.  Capability pointers embedded in this structure index into
-  * `capTable`.
-  *
-  */
-  get content() {
-    return getPointer(0, this);
-  }
-  _hasContent() {
-    return !isNull(getPointer(0, this));
-  }
-  set content(value) {
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptCapTable(value) {
-    adopt(value, getPointer(1, this));
-  }
-  _disownCapTable() {
-    return disown(this.capTable);
-  }
-  /**
-  * Descriptors corresponding to the cap pointers in `content`.
-  *
-  */
-  get capTable() {
-    return getList(1, _Payload._CapTable, this);
-  }
-  _hasCapTable() {
-    return !isNull(getPointer(1, this));
-  }
-  _initCapTable(length) {
-    return initList(1, _Payload._CapTable, length, this);
-  }
-  set capTable(value) {
-    copyFrom(value, getPointer(1, this));
-  }
-  toString() {
-    return "Payload_" + super.toString();
-  }
-};
-var CapDescriptor_Which = {
-  /**
-  * There is no capability here.  This `CapDescriptor` should not appear in the payload content.
-  * A `none` CapDescriptor can be generated when an application inserts a capability into a
-  * message and then later changes its mind and removes it -- rewriting all of the other
-  * capability pointers may be hard, so instead a tombstone is left, similar to the way a removed
-  * struct or list instance is zeroed out of the message but the space is not reclaimed.
-  * Hopefully this is unusual.
-  *
-  */
-  NONE: 0,
-  /**
-  * The ID of a capability in the sender's export table (receiver's import table).  It may be a
-  * newly allocated table entry, or an existing entry (increments the reference count).
-  *
-  */
-  SENDER_HOSTED: 1,
-  /**
-  * A promise that the sender will resolve later.  The sender will send exactly one Resolve
-  * message at a future point in time to replace this promise.  Note that even if the same
-  * `senderPromise` is received multiple times, only one `Resolve` is sent to cover all of
-  * them.  If `senderPromise` is released before the `Resolve` is sent, the sender (of this
-  * `CapDescriptor`) may choose not to send the `Resolve` at all.
-  *
-  */
-  SENDER_PROMISE: 2,
-  /**
-  * A capability (or promise) previously exported by the receiver (imported by the sender).
-  *
-  */
-  RECEIVER_HOSTED: 3,
-  /**
-  * A capability expected to be returned in the results of a currently-outstanding call posed
-  * by the sender.
-  *
-  */
-  RECEIVER_ANSWER: 4,
-  /**
-  * **(level 3)**
-  *
-  * A capability that lives in neither the sender's nor the receiver's vat.  The sender needs
-  * to form a direct connection to a third party to pick up the capability.
-  *
-  * Level 1 and 2 implementations that receive a `thirdPartyHosted` may simply send calls to its
-  * `vine` instead.
-  *
-  */
-  THIRD_PARTY_HOSTED: 5
-};
-var CapDescriptor = class _CapDescriptor extends Struct {
-  static {
-    __name(this, "CapDescriptor");
-  }
-  static NONE = CapDescriptor_Which.NONE;
-  static SENDER_HOSTED = CapDescriptor_Which.SENDER_HOSTED;
-  static SENDER_PROMISE = CapDescriptor_Which.SENDER_PROMISE;
-  static RECEIVER_HOSTED = CapDescriptor_Which.RECEIVER_HOSTED;
-  static RECEIVER_ANSWER = CapDescriptor_Which.RECEIVER_ANSWER;
-  static THIRD_PARTY_HOSTED = CapDescriptor_Which.THIRD_PARTY_HOSTED;
-  static _capnp = {
-    displayName: "CapDescriptor",
-    id: "8523ddc40b86b8b0",
-    size: new ObjectSize(8, 1),
-    defaultAttachedFd: getUint8Mask(255)
-  };
-  get _isNone() {
-    return getUint16(0, this) === 0;
-  }
-  set none(_) {
-    setUint16(0, 0, this);
-  }
-  /**
-  * The ID of a capability in the sender's export table (receiver's import table).  It may be a
-  * newly allocated table entry, or an existing entry (increments the reference count).
-  *
-  */
-  get senderHosted() {
-    testWhich("senderHosted", getUint16(0, this), 1, this);
-    return getUint32(4, this);
-  }
-  get _isSenderHosted() {
-    return getUint16(0, this) === 1;
-  }
-  set senderHosted(value) {
-    setUint16(0, 1, this);
-    setUint32(4, value, this);
-  }
-  /**
-  * A promise that the sender will resolve later.  The sender will send exactly one Resolve
-  * message at a future point in time to replace this promise.  Note that even if the same
-  * `senderPromise` is received multiple times, only one `Resolve` is sent to cover all of
-  * them.  If `senderPromise` is released before the `Resolve` is sent, the sender (of this
-  * `CapDescriptor`) may choose not to send the `Resolve` at all.
-  *
-  */
-  get senderPromise() {
-    testWhich("senderPromise", getUint16(0, this), 2, this);
-    return getUint32(4, this);
-  }
-  get _isSenderPromise() {
-    return getUint16(0, this) === 2;
-  }
-  set senderPromise(value) {
-    setUint16(0, 2, this);
-    setUint32(4, value, this);
-  }
-  /**
-  * A capability (or promise) previously exported by the receiver (imported by the sender).
-  *
-  */
-  get receiverHosted() {
-    testWhich("receiverHosted", getUint16(0, this), 3, this);
-    return getUint32(4, this);
-  }
-  get _isReceiverHosted() {
-    return getUint16(0, this) === 3;
-  }
-  set receiverHosted(value) {
-    setUint16(0, 3, this);
-    setUint32(4, value, this);
-  }
-  _adoptReceiverAnswer(value) {
-    setUint16(0, 4, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownReceiverAnswer() {
-    return disown(this.receiverAnswer);
-  }
-  /**
-  * A capability expected to be returned in the results of a currently-outstanding call posed
-  * by the sender.
-  *
-  */
-  get receiverAnswer() {
-    testWhich("receiverAnswer", getUint16(0, this), 4, this);
-    return getStruct(0, PromisedAnswer, this);
-  }
-  _hasReceiverAnswer() {
-    return !isNull(getPointer(0, this));
-  }
-  _initReceiverAnswer() {
-    setUint16(0, 4, this);
-    return initStructAt(0, PromisedAnswer, this);
-  }
-  get _isReceiverAnswer() {
-    return getUint16(0, this) === 4;
-  }
-  set receiverAnswer(value) {
-    setUint16(0, 4, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  _adoptThirdPartyHosted(value) {
-    setUint16(0, 5, this);
-    adopt(value, getPointer(0, this));
-  }
-  _disownThirdPartyHosted() {
-    return disown(this.thirdPartyHosted);
-  }
-  /**
-  * **(level 3)**
-  *
-  * A capability that lives in neither the sender's nor the receiver's vat.  The sender needs
-  * to form a direct connection to a third party to pick up the capability.
-  *
-  * Level 1 and 2 implementations that receive a `thirdPartyHosted` may simply send calls to its
-  * `vine` instead.
-  *
-  */
-  get thirdPartyHosted() {
-    testWhich("thirdPartyHosted", getUint16(0, this), 5, this);
-    return getStruct(0, ThirdPartyCapDescriptor, this);
-  }
-  _hasThirdPartyHosted() {
-    return !isNull(getPointer(0, this));
-  }
-  _initThirdPartyHosted() {
-    setUint16(0, 5, this);
-    return initStructAt(0, ThirdPartyCapDescriptor, this);
-  }
-  get _isThirdPartyHosted() {
-    return getUint16(0, this) === 5;
-  }
-  set thirdPartyHosted(value) {
-    setUint16(0, 5, this);
-    copyFrom(value, getPointer(0, this));
-  }
-  /**
-  * If the RPC message in which this CapDescriptor was delivered also had file descriptors
-  * attached, and `fd` is a valid index into the list of attached file descriptors, then
-  * that file descriptor should be attached to this capability. If `attachedFd` is out-of-bounds
-  * for said list, then no FD is attached.
-  *
-  * For example, if the RPC message arrived over a Unix socket, then file descriptors may be
-  * attached by sending an SCM_RIGHTS ancillary message attached to the data bytes making up the
-  * raw message. Receivers who wish to opt into FD passing should arrange to receive SCM_RIGHTS
-  * whenever receiving an RPC message. Senders who wish to send FDs need not verify whether the
-  * receiver knows how to receive them, because the operating system will automatically discard
-  * ancillary messages like SCM_RIGHTS if the receiver doesn't ask to receive them, including
-  * automatically closing any FDs.
-  *
-  * It is up to the application protocol to define what capabilities are expected to have file
-  * descriptors attached, and what those FDs mean. But, for example, an application could use this
-  * to open a file on disk and then transmit the open file descriptor to a sandboxed process that
-  * does not otherwise have permission to access the filesystem directly. This is usually an
-  * optimization: the sending process could instead provide an RPC interface supporting all the
-  * operations needed (such as reading and writing a file), but by passing the file descriptor
-  * directly, the recipient can often perform operations much more efficiently. Application
-  * designers are encouraged to provide such RPC interfaces and automatically fall back to them
-  * when FD passing is not available, so that the application can still work when the parties are
-  * remote over a network.
-  *
-  * An attached FD is most often associated with a `senderHosted` descriptor. It could also make
-  * sense in the case of `thirdPartyHosted`: in this case, the sender is forwarding the FD that
-  * they received from the third party, so that the receiver can start using it without first
-  * interacting with the third party. This is an optional optimization -- the middleman may choose
-  * not to forward capabilities, in which case the receiver will need to complete the handshake
-  * with the third party directly before receiving the FD. If an implementation receives a second
-  * attached FD after having already received one previously (e.g. both in a `thirdPartyHosted`
-  * CapDescriptor and then later again when receiving the final capability directly from the
-  * third party), the implementation should discard the later FD and stick with the original. At
-  * present, there is no known reason why other capability types (e.g. `receiverHosted`) would want
-  * to carry an attached FD, but we reserve the right to define a meaning for this in the future.
-  *
-  * Each file descriptor attached to the message must be used in no more than one CapDescriptor,
-  * so that the receiver does not need to use dup() or refcounting to handle the possibility of
-  * multiple capabilities using the same descriptor. If multiple CapDescriptors do point to the
-  * same FD index, then the receiver can arbitrarily choose which capability ends up having the
-  * FD attached.
-  *
-  * To mitigate DoS attacks, RPC implementations should limit the number of FDs they are willing to
-  * receive in a single message to a small value. If a message happens to contain more than that,
-  * the list is truncated. Moreover, in some cases, FD passing needs to be blocked entirely for
-  * security or implementation reasons, in which case the list may be truncated to zero. Hence,
-  * `attachedFd` might point past the end of the list, which the implementation should treat as if
-  * no FD was attached at all.
-  *
-  * The type of this field was chosen to be UInt8 because Linux supports sending only a maximum
-  * of 253 file descriptors in an SCM_RIGHTS message anyway, and CapDescriptor had two bytes of
-  * padding left -- so after adding this, there is still one byte for a future feature.
-  * Conveniently, this also means we're able to use 0xff as the default value, which will always
-  * be out-of-range (of course, the implementation should explicitly enforce that 255 descriptors
-  * cannot be sent at once, rather than relying on Linux to do so).
-  *
-  */
-  get attachedFd() {
-    return getUint8(2, this, _CapDescriptor._capnp.defaultAttachedFd);
-  }
-  set attachedFd(value) {
-    setUint8(2, value, this, _CapDescriptor._capnp.defaultAttachedFd);
-  }
-  toString() {
-    return "CapDescriptor_" + super.toString();
-  }
-  which() {
-    return getUint16(0, this);
-  }
-};
-var PromisedAnswer_Op_Which = {
-  /**
-  * Does nothing.  This member is mostly defined so that we can make `Op` a union even
-  * though (as of this writing) only one real operation is defined.
-  *
-  */
-  NOOP: 0,
-  /**
-  * Get a pointer field within a struct.  The number is an index into the pointer section, NOT
-  * a field ordinal, so that the receiver does not need to understand the schema.
-  *
-  */
-  GET_POINTER_FIELD: 1
-};
-var PromisedAnswer_Op = class extends Struct {
-  static {
-    __name(this, "PromisedAnswer_Op");
-  }
-  static NOOP = PromisedAnswer_Op_Which.NOOP;
-  static GET_POINTER_FIELD = PromisedAnswer_Op_Which.GET_POINTER_FIELD;
-  static _capnp = {
-    displayName: "Op",
-    id: "f316944415569081",
-    size: new ObjectSize(8, 0)
-  };
-  get _isNoop() {
-    return getUint16(0, this) === 0;
-  }
-  set noop(_) {
-    setUint16(0, 0, this);
-  }
-  /**
-  * Get a pointer field within a struct.  The number is an index into the pointer section, NOT
-  * a field ordinal, so that the receiver does not need to understand the schema.
-  *
-  */
-  get getPointerField() {
-    testWhich("getPointerField", getUint16(0, this), 1, this);
-    return getUint16(2, this);
-  }
-  get _isGetPointerField() {
-    return getUint16(0, this) === 1;
-  }
-  set getPointerField(value) {
-    setUint16(0, 1, this);
-    setUint16(2, value, this);
-  }
-  toString() {
-    return "PromisedAnswer_Op_" + super.toString();
-  }
-  which() {
-    return getUint16(0, this);
-  }
-};
-var PromisedAnswer = class _PromisedAnswer extends Struct {
-  static {
-    __name(this, "PromisedAnswer");
-  }
-  static Op = PromisedAnswer_Op;
-  static _capnp = {
-    displayName: "PromisedAnswer",
-    id: "d800b1d6cd6f1ca0",
-    size: new ObjectSize(8, 1)
-  };
-  static _Transform;
-  /**
-  * ID of the question (in the sender's question table / receiver's answer table) whose answer is
-  * expected to contain the capability.
-  *
-  */
-  get questionId() {
-    return getUint32(0, this);
-  }
-  set questionId(value) {
-    setUint32(0, value, this);
-  }
-  _adoptTransform(value) {
-    adopt(value, getPointer(0, this));
-  }
-  _disownTransform() {
-    return disown(this.transform);
-  }
-  /**
-  * Operations / transformations to apply to the result in order to get the capability actually
-  * being addressed.  E.g. if the result is a struct and you want to call a method on a capability
-  * pointed to by a field of the struct, you need a `getPointerField` op.
-  *
-  */
-  get transform() {
-    return getList(0, _PromisedAnswer._Transform, this);
-  }
-  _hasTransform() {
-    return !isNull(getPointer(0, this));
-  }
-  _initTransform(length) {
-    return initList(0, _PromisedAnswer._Transform, length, this);
-  }
-  set transform(value) {
-    copyFrom(value, getPointer(0, this));
-  }
-  toString() {
-    return "PromisedAnswer_" + super.toString();
-  }
-};
-var ThirdPartyCapDescriptor = class extends Struct {
-  static {
-    __name(this, "ThirdPartyCapDescriptor");
-  }
-  static _capnp = {
-    displayName: "ThirdPartyCapDescriptor",
-    id: "d37007fde1f0027d",
-    size: new ObjectSize(8, 1)
-  };
-  _adoptId(value) {
-    adopt(value, getPointer(0, this));
-  }
-  _disownId() {
-    return disown(this.id);
-  }
-  /**
-  * Identifies the third-party host and the specific capability to accept from it.
-  *
-  */
-  get id() {
-    return getPointer(0, this);
-  }
-  _hasId() {
-    return !isNull(getPointer(0, this));
-  }
-  set id(value) {
-    copyFrom(value, getPointer(0, this));
-  }
-  /**
-  * A proxy for the third-party object exported by the sender.  In CapTP terminology this is called
-  * a "vine", because it is an indirect reference to the third-party object that snakes through the
-  * sender vat.  This serves two purposes:
-  *
-  * * Level 1 and 2 implementations that don't understand how to connect to a third party may
-  *   simply send calls to the vine.  Such calls will be forwarded to the third-party by the
-  *   sender.
-  *
-  * * Level 3 implementations must release the vine only once they have successfully picked up the
-  *   object from the third party.  This ensures that the capability is not released by the sender
-  *   prematurely.
-  *
-  * The sender will close the `Provide` request that it has sent to the third party as soon as
-  * it receives either a `Call` or a `Release` message directed at the vine.
-  *
-  */
-  get vineId() {
-    return getUint32(0, this);
-  }
-  set vineId(value) {
-    setUint32(0, value, this);
-  }
-  toString() {
-    return "ThirdPartyCapDescriptor_" + super.toString();
-  }
-};
-var Exception_Type = {
-  /**
-  * A generic problem occurred, and it is believed that if the operation were repeated without
-  * any change in the state of the world, the problem would occur again.
-  *
-  * A client might respond to this error by logging it for investigation by the developer and/or
-  * displaying it to the user.
-  *
-  */
-  FAILED: 0,
-  /**
-  * The request was rejected due to a temporary lack of resources.
-  *
-  * Examples include:
-  * - There's not enough CPU time to keep up with incoming requests, so some are rejected.
-  * - The server ran out of RAM or disk space during the request.
-  * - The operation timed out (took significantly longer than it should have).
-  *
-  * A client might respond to this error by scheduling to retry the operation much later. The
-  * client should NOT retry again immediately since this would likely exacerbate the problem.
-  *
-  */
-  OVERLOADED: 1,
-  /**
-  * The method failed because a connection to some necessary capability was lost.
-  *
-  * Examples include:
-  * - The client introduced the server to a third-party capability, the connection to that third
-  *   party was subsequently lost, and then the client requested that the server use the dead
-  *   capability for something.
-  * - The client previously requested that the server obtain a capability from some third party.
-  *   The server returned a capability to an object wrapping the third-party capability. Later,
-  *   the server's connection to the third party was lost.
-  * - The capability has been revoked. Revocation does not necessarily mean that the client is
-  *   no longer authorized to use the capability; it is often used simply as a way to force the
-  *   client to repeat the setup process, perhaps to efficiently move them to a new back-end or
-  *   get them to recognize some other change that has occurred.
-  *
-  * A client should normally respond to this error by releasing all capabilities it is currently
-  * holding related to the one it called and then re-creating them by restoring SturdyRefs and/or
-  * repeating the method calls used to create them originally. In other words, disconnect and
-  * start over. This should in turn cause the server to obtain a new copy of the capability that
-  * it lost, thus making everything work.
-  *
-  * If the client receives another `disconnected` error in the process of rebuilding the
-  * capability and retrying the call, it should treat this as an `overloaded` error: the network
-  * is currently unreliable, possibly due to load or other temporary issues.
-  *
-  */
-  DISCONNECTED: 2,
-  /**
-  * The server doesn't implement the requested method. If there is some other method that the
-  * client could call (perhaps an older and/or slower interface), it should try that instead.
-  * Otherwise, this should be treated like `failed`.
-  *
-  */
-  UNIMPLEMENTED: 3
-};
-var Exception = class extends Struct {
-  static {
-    __name(this, "Exception");
-  }
-  static Type = Exception_Type;
-  static _capnp = {
-    displayName: "Exception",
-    id: "d625b7063acf691a",
-    size: new ObjectSize(8, 2)
-  };
-  /**
-  * Human-readable failure description.
-  *
-  */
-  get reason() {
-    return getText(0, this);
-  }
-  set reason(value) {
-    setText(0, value, this);
-  }
-  /**
-  * The type of the error. The purpose of this enum is not to describe the error itself, but
-  * rather to describe how the client might want to respond to the error.
-  *
-  */
-  get type() {
-    return getUint16(4, this);
-  }
-  set type(value) {
-    setUint16(4, value, this);
-  }
-  /**
-  * OBSOLETE. Ignore.
-  *
-  */
-  get obsoleteIsCallersFault() {
-    return getBit(0, this);
-  }
-  set obsoleteIsCallersFault(value) {
-    setBit(0, value, this);
-  }
-  /**
-  * OBSOLETE. See `type` instead.
-  *
-  */
-  get obsoleteDurability() {
-    return getUint16(2, this);
-  }
-  set obsoleteDurability(value) {
-    setUint16(2, value, this);
-  }
-  /**
-  * Stack trace text from the remote server. The format is not specified. By default,
-  * implementations do not provide stack traces; the application must explicitly enable them
-  * when desired.
-  *
-  */
-  get trace() {
-    return getText(1, this);
-  }
-  set trace(value) {
-    setText(1, value, this);
-  }
-  toString() {
-    return "Exception_" + super.toString();
-  }
-};
-Payload._CapTable = CompositeList(CapDescriptor);
-PromisedAnswer._Transform = CompositeList(PromisedAnswer_Op);
-
-// ../../node_modules/.pnpm/capnp-es@0.0.11_patch_hash=53996ae63a1465953815fff49405f2224c85d26eeeff469d2b1f87e1c2af451d_typescript@5.8.3/node_modules/capnp-es/dist/index.mjs
-var Void = class extends Struct {
-  static {
-    __name(this, "Void");
-  }
-  static _capnp = {
-    displayName: "Void",
-    id: "0",
-    size: new ObjectSize(0, 0)
-  };
-};
-function PointerList(PointerClass) {
-  return class extends List {
-    static _capnp = {
-      displayName: `List<${PointerClass._capnp.displayName}>`,
-      size: ListElementSize.POINTER
-    };
-    get(index) {
-      const c = getContent(this);
-      return new PointerClass(
-        c.segment,
-        c.byteOffset + index * 8,
-        this._capnp.depthLimit - 1
-      );
-    }
-    set(index, value) {
-      copyFrom(value, this.get(index));
-    }
-    [Symbol.toStringTag]() {
-      return `Pointer_${super.toString()},cls:${PointerClass.toString()}`;
-    }
-  };
-}
-__name(PointerList, "PointerList");
-var AnyPointerList = PointerList(Pointer);
-var BoolList = class extends List {
-  static {
-    __name(this, "BoolList");
-  }
-  static _capnp = {
-    displayName: "List<boolean>",
-    size: ListElementSize.BIT
-  };
-  get(index) {
-    const bitMask = 1 << index % 8;
-    const byteOffset = index >>> 3;
-    const c = getContent(this);
-    const v = c.segment.getUint8(c.byteOffset + byteOffset);
-    return (v & bitMask) !== 0;
-  }
-  set(index, value) {
-    const bitMask = 1 << index % 8;
-    const c = getContent(this);
-    const byteOffset = c.byteOffset + (index >>> 3);
-    const v = c.segment.getUint8(byteOffset);
-    c.segment.setUint8(byteOffset, value ? v | bitMask : v & ~bitMask);
-  }
-  [Symbol.toStringTag]() {
-    return `Bool_${super.toString()}`;
-  }
-};
-var DataList = PointerList(Data);
-var Float32List = class extends List {
-  static {
-    __name(this, "Float32List");
-  }
-  static _capnp = {
-    displayName: "List<Float32>",
-    size: ListElementSize.BYTE_4
-  };
-  get(index) {
-    const c = getContent(this);
-    return c.segment.getFloat32(c.byteOffset + index * 4);
-  }
-  set(index, value) {
-    const c = getContent(this);
-    c.segment.setFloat32(c.byteOffset + index * 4, value);
-  }
-  [Symbol.toStringTag]() {
-    return `Float32_${super.toString()}`;
-  }
-};
-var Float64List = class extends List {
-  static {
-    __name(this, "Float64List");
-  }
-  static _capnp = {
-    displayName: "List<Float64>",
-    size: ListElementSize.BYTE_8
-  };
-  get(index) {
-    const c = getContent(this);
-    return c.segment.getFloat64(c.byteOffset + index * 8);
-  }
-  set(index, value) {
-    const c = getContent(this);
-    c.segment.setFloat64(c.byteOffset + index * 8, value);
-  }
-  [Symbol.toStringTag]() {
-    return `Float64_${super.toString()}`;
-  }
-};
-var Int8List = class extends List {
-  static {
-    __name(this, "Int8List");
-  }
-  static _capnp = {
-    displayName: "List<Int8>",
-    size: ListElementSize.BYTE
-  };
-  get(index) {
-    const c = getContent(this);
-    return c.segment.getInt8(c.byteOffset + index);
-  }
-  set(index, value) {
-    const c = getContent(this);
-    c.segment.setInt8(c.byteOffset + index, value);
-  }
-  [Symbol.toStringTag]() {
-    return `Int8_${super.toString()}`;
-  }
-};
-var Int16List = class extends List {
-  static {
-    __name(this, "Int16List");
-  }
-  static _capnp = {
-    displayName: "List<Int16>",
-    size: ListElementSize.BYTE_2
-  };
-  get(index) {
-    const c = getContent(this);
-    return c.segment.getInt16(c.byteOffset + index * 2);
-  }
-  set(index, value) {
-    const c = getContent(this);
-    c.segment.setInt16(c.byteOffset + index * 2, value);
-  }
-  [Symbol.toStringTag]() {
-    return `Int16_${super.toString()}`;
-  }
-};
-var Int32List = class extends List {
-  static {
-    __name(this, "Int32List");
-  }
-  static _capnp = {
-    displayName: "List<Int32>",
-    size: ListElementSize.BYTE_4
-  };
-  get(index) {
-    const c = getContent(this);
-    return c.segment.getInt32(c.byteOffset + index * 4);
-  }
-  set(index, value) {
-    const c = getContent(this);
-    c.segment.setInt32(c.byteOffset + index * 4, value);
-  }
-  [Symbol.toStringTag]() {
-    return `Int32_${super.toString()}`;
-  }
-};
-var Int64List = class extends List {
-  static {
-    __name(this, "Int64List");
-  }
-  static _capnp = {
-    displayName: "List<Int64>",
-    size: ListElementSize.BYTE_8
-  };
-  get(index) {
-    const c = getContent(this);
-    return c.segment.getInt64(c.byteOffset + index * 8);
-  }
-  set(index, value) {
-    const c = getContent(this);
-    c.segment.setInt64(c.byteOffset + index * 8, value);
-  }
-  [Symbol.toStringTag]() {
-    return `Int64_${super.toString()}`;
-  }
-};
-var InterfaceList = PointerList(Interface);
-var TextList = class extends List {
-  static {
-    __name(this, "TextList");
-  }
-  static _capnp = {
-    displayName: "List<Text>",
-    size: ListElementSize.POINTER
-  };
-  get(index) {
-    const c = getContent(this);
-    c.byteOffset += index * 8;
-    return Text.fromPointer(c).get(0);
-  }
-  set(index, value) {
-    const c = getContent(this);
-    c.byteOffset += index * 8;
-    Text.fromPointer(c).set(0, value);
-  }
-  [Symbol.toStringTag]() {
-    return `Text_${super.toString()}`;
-  }
-};
-var Uint8List = class extends List {
-  static {
-    __name(this, "Uint8List");
-  }
-  static _capnp = {
-    displayName: "List<Uint8>",
-    size: ListElementSize.BYTE
-  };
-  get(index) {
-    const c = getContent(this);
-    return c.segment.getUint8(c.byteOffset + index);
-  }
-  set(index, value) {
-    const c = getContent(this);
-    c.segment.setUint8(c.byteOffset + index, value);
-  }
-  [Symbol.toStringTag]() {
-    return `Uint8_${super.toString()}`;
-  }
-};
-var Uint16List = class extends List {
-  static {
-    __name(this, "Uint16List");
-  }
-  static _capnp = {
-    displayName: "List<Uint16>",
-    size: ListElementSize.BYTE_2
-  };
-  get(index) {
-    const c = getContent(this);
-    return c.segment.getUint16(c.byteOffset + index * 2);
-  }
-  set(index, value) {
-    const c = getContent(this);
-    c.segment.setUint16(c.byteOffset + index * 2, value);
-  }
-  [Symbol.toStringTag]() {
-    return `Uint16_${super.toString()}`;
-  }
-};
-var Uint32List = class extends List {
-  static {
-    __name(this, "Uint32List");
-  }
-  static _capnp = {
-    displayName: "List<Uint32>",
-    size: ListElementSize.BYTE_4
-  };
-  get(index) {
-    const c = getContent(this);
-    return c.segment.getUint32(c.byteOffset + index * 4);
-  }
-  set(index, value) {
-    const c = getContent(this);
-    c.segment.setUint32(c.byteOffset + index * 4, value);
-  }
-  [Symbol.toStringTag]() {
-    return `Uint32_${super.toString()}`;
-  }
-};
-var Uint64List = class extends List {
-  static {
-    __name(this, "Uint64List");
-  }
-  static _capnp = {
-    displayName: "List<Uint64>",
-    size: ListElementSize.BYTE_8
-  };
-  get(index) {
-    const c = getContent(this);
-    return c.segment.getUint64(c.byteOffset + index * 8);
-  }
-  set(index, value) {
-    const c = getContent(this);
-    c.segment.setUint64(c.byteOffset + index * 8, value);
-  }
-  [Symbol.toStringTag]() {
-    return `Uint64_${super.toString()}`;
-  }
-};
-var VoidList = PointerList(Void);
-function isSameClient(c, d) {
-  const norm = /* @__PURE__ */ __name((c2) => {
-    return c2;
-  }, "norm");
-  return norm(c) === norm(d);
-}
-__name(isSameClient, "isSameClient");
-function clientFromResolution(transform, obj, err) {
-  if (err) {
-    return new ErrorClient(err);
-  }
-  if (!obj) {
-    return new ErrorClient(new Error(`null obj!`));
-  }
-  const out = transformPtr(obj, transform);
-  return getInterfaceClientOrNull(out);
-}
-__name(clientFromResolution, "clientFromResolution");
-var IDGen = class {
-  static {
-    __name(this, "IDGen");
-  }
-  i = 0;
-  free = [];
-  next() {
-    return this.free.pop() ?? this.i++;
-  }
-  remove(i) {
-    this.free.push(i);
-  }
-};
-var Ref = class {
-  static {
-    __name(this, "Ref");
-  }
-  constructor(rc, finalize) {
-    this.rc = rc;
-    const closeState = { closed: false };
-    this.closeState = closeState;
-    finalize(this, () => {
-      if (!closeState.closed) {
-        closeState.closed = true;
-        rc.decref();
-      }
-    });
-  }
-  closeState;
-  call(cl) {
-    return this.rc.call(cl);
-  }
-  client() {
-    return this.rc._client;
-  }
-  close() {
-    if (!this.closeState.closed) {
-      this.closeState.closed = true;
-      this.rc.decref();
-    }
-  }
-};
-var RefCount = class _RefCount {
-  static {
-    __name(this, "RefCount");
-  }
-  refs;
-  finalize;
-  _client;
-  constructor(c, _finalize) {
-    this._client = c;
-    this.finalize = _finalize;
-    this.refs = 1;
-  }
-  // New creates a reference counter and the first client reference.
-  static new(c, finalize) {
-    const rc = new _RefCount(c, finalize);
-    const ref = rc.newRef();
-    return [rc, ref];
-  }
-  call(cl) {
-    return this._client.call(cl);
-  }
-  client() {
-    return this._client;
-  }
-  close() {
-    this._client.close();
-  }
-  ref() {
-    if (this.refs <= 0) {
-      return new ErrorClient(new Error(RPC_ZERO_REF));
-    }
-    this.refs++;
-    return this.newRef();
-  }
-  newRef() {
-    return new Ref(this, this.finalize);
-  }
-  decref() {
-    this.refs--;
-    if (this.refs === 0) {
-      this._client.close();
-    }
-  }
-};
-var RPCError = class extends Error {
-  static {
-    __name(this, "RPCError");
-  }
-  constructor(exception) {
-    super(format(RPC_ERROR, exception.reason));
-    this.exception = exception;
-  }
-};
-function toException(exc, err) {
-  if (err instanceof RPCError) {
-    exc.reason = err.exception.reason;
-    exc.type = err.exception.type;
-    return;
-  }
-  exc.reason = err.message;
-  exc.type = Exception.Type.FAILED;
-}
-__name(toException, "toException");
-function newMessage() {
-  return new Message().initRoot(Message2);
-}
-__name(newMessage, "newMessage");
-function newFinishMessage(questionID, release) {
-  const m = newMessage();
-  const f = m._initFinish();
-  f.questionId = questionID;
-  f.releaseResultCaps = release;
-  return m;
-}
-__name(newFinishMessage, "newFinishMessage");
-function newUnimplementedMessage(m) {
-  const n = newMessage();
-  n.unimplemented = m;
-  return n;
-}
-__name(newUnimplementedMessage, "newUnimplementedMessage");
-function newReturnMessage(id) {
-  const m = newMessage();
-  const ret = m._initReturn();
-  ret.answerId = id;
-  return m;
-}
-__name(newReturnMessage, "newReturnMessage");
-function setReturnException(ret, err) {
-  const exc = ret._initException();
-  toException(exc, err);
-  return exc;
-}
-__name(setReturnException, "setReturnException");
-function newDisembargoMessage(which, id) {
-  const m = newMessage();
-  const dis = m._initDisembargo();
-  const ctx = dis._initContext();
-  switch (which) {
-    case Disembargo_Context_Which.SENDER_LOOPBACK: {
-      ctx.senderLoopback = id;
-      break;
-    }
-    case Disembargo_Context_Which.RECEIVER_LOOPBACK: {
-      ctx.receiverLoopback = id;
-      break;
-    }
-    default: {
-      throw new Error(INVARIANT_UNREACHABLE_CODE);
-    }
-  }
-  return m;
-}
-__name(newDisembargoMessage, "newDisembargoMessage");
-function transformToPromisedAnswer(answer, transform) {
-  const opList = answer._initTransform(transform.length);
-  for (const [i, op] of transform.entries()) {
-    opList.get(i).getPointerField = op.field;
-  }
-}
-__name(transformToPromisedAnswer, "transformToPromisedAnswer");
-function promisedAnswerOpsToTransform(list) {
-  const transform = [];
-  for (const op of list) {
-    switch (op.which()) {
-      case PromisedAnswer_Op.GET_POINTER_FIELD: {
-        transform.push({
-          field: op.getPointerField
-        });
-        break;
-      }
-      case PromisedAnswer_Op.NOOP: {
-        break;
-      }
-    }
-  }
-  return transform;
-}
-__name(promisedAnswerOpsToTransform, "promisedAnswerOpsToTransform");
-var QuestionState = /* @__PURE__ */ ((QuestionState2) => {
-  QuestionState2[QuestionState2["IN_PROGRESS"] = 0] = "IN_PROGRESS";
-  QuestionState2[QuestionState2["RESOLVED"] = 1] = "RESOLVED";
-  QuestionState2[QuestionState2["CANCELED"] = 2] = "CANCELED";
-  return QuestionState2;
-})(QuestionState || {});
-var Question = class {
-  static {
-    __name(this, "Question");
-  }
-  constructor(conn, id, method) {
-    this.conn = conn;
-    this.id = id;
-    this.method = method;
-  }
-  paramCaps = [];
-  state = 0;
-  obj;
-  err;
-  derived = [];
-  deferred = new Deferred();
-  async struct() {
-    return await this.deferred.promise;
-  }
-  // start signals the question has been sent
-  start() {
-  }
-  // fulfill is called to resolve a question successfully.
-  // The caller must be holding onto q.conn.mu.
-  fulfill(obj) {
-    if (this.state !== 0) {
-      throw new Error(RPC_FULFILL_ALREADY_CALLED);
-    }
-    if (this.method) {
-      this.obj = getAs(this.method.ResultsClass, obj);
-    } else {
-      this.obj = obj;
-    }
-    this.state = 1;
-    this.deferred.resolve(this.obj);
-  }
-  // reject is called to resolve a question with failure
-  reject(err) {
-    if (!err) {
-      throw new Error(`Question.reject called with null`);
-    }
-    if (this.state !== 0) {
-      throw new Error(`Question.reject called more than once`);
-    }
-    this.err = err;
-    this.state = 1;
-    this.deferred.reject(err);
-  }
-  // cancel is called to resolve a question with cancellation.
-  cancel(err) {
-    if (this.state === 0) {
-      this.err = err;
-      this.state = 2;
-      this.deferred.reject(err);
-      return true;
-    }
-    return false;
-  }
-  pipelineCall(transform, call) {
-    if (this.conn.findQuestion(this.id) !== this) {
-      if (this.state === 0) {
-        throw new Error(`question popped but not done`);
-      }
-      const client = clientFromResolution(transform, this.obj, this.err);
-      return client.call(call);
-    }
-    const pipeq = this.conn.newQuestion(call.method);
-    const msg = newMessage();
-    const msgCall = msg._initCall();
-    msgCall.questionId = pipeq.id;
-    msgCall.interfaceId = call.method.interfaceId;
-    msgCall.methodId = call.method.methodId;
-    const target = msgCall._initTarget();
-    const a = target._initPromisedAnswer();
-    a.questionId = this.id;
-    transformToPromisedAnswer(a, transform);
-    const payload = msgCall._initParams();
-    this.conn.fillParams(payload, call);
-    this.conn.sendMessage(msg);
-    this.addPromise(transform);
-    return pipeq;
-  }
-  addPromise(transform) {
-    for (const d of this.derived) {
-      if (transformsEqual(transform, d)) {
-        return;
-      }
-    }
-    this.derived.push(transform);
-  }
-  pipelineClose() {
-    throw new Error(NOT_IMPLEMENTED);
-  }
-};
-function transformsEqual(t, u) {
-  if (t.length !== u.length) {
-    return false;
-  }
-  for (const [i, element_] of t.entries()) {
-    if (element_.field !== u[i].field) {
-      return false;
-    }
-  }
-  return true;
-}
-__name(transformsEqual, "transformsEqual");
-var Qcalls = class _Qcalls {
-  static {
-    __name(this, "Qcalls");
-  }
-  constructor(data) {
-    this.data = data;
-  }
-  static copyOf(data) {
-    return new _Qcalls([...data]);
-  }
-  len() {
-    return this.data.length;
-  }
-  clear(i) {
-    this.data[i] = null;
-  }
-  copy() {
-    return _Qcalls.copyOf(this.data);
-  }
-};
-function joinAnswer(fl, answer) {
-  answer.struct().then((obj) => {
-    fl.fulfill(obj);
-  }).catch((error_) => {
-    fl.reject(error_);
-  });
-}
-__name(joinAnswer, "joinAnswer");
-var callQueueSize2 = 64;
-var QueueClient = class {
-  static {
-    __name(this, "QueueClient");
-  }
-  constructor(conn, client, calls) {
-    this.conn = conn;
-    this._client = client;
-    this.calls = Qcalls.copyOf(calls);
-    this.q = new Queue(this.calls, callQueueSize2);
-  }
-  _client;
-  calls;
-  q;
-  pushCall(call) {
-    const f = new Fulfiller();
-    try {
-      call = copyCall(call);
-    } catch (error_) {
-      return new ErrorAnswer(error_);
-    }
-    const i = this.q.push();
-    if (i === -1) {
-      return new ErrorAnswer(new Error(RPC_CALL_QUEUE_FULL));
-    }
-    this.calls.data[i] = {
-      call,
-      f
-    };
-    return f;
-  }
-  pushEmbargo(id, tgt) {
-    const i = this.q.push();
-    if (i === -1) {
-      throw new Error(RPC_CALL_QUEUE_FULL);
-    }
-    this.calls.data[i] = {
-      embargoID: id,
-      embargoTarget: tgt
-    };
-  }
-  flushQueue() {
-    let c = null;
-    {
-      const i = this.q.front();
-      if (i !== -1) {
-        c = this.calls.data[i];
-      }
-    }
-    while (c) {
-      this.handle(c);
-      this.q.pop();
-      {
-        const i = this.q.front();
-        c = i === -1 ? null : this.calls.data[i];
-      }
-    }
-  }
-  handle(c) {
-    if (!c) {
-      return;
-    }
-    if (isRemoteCall(c)) {
-      const answer = this._client.call(c.call);
-      joinAnswer(c.a, answer);
-    } else if (isLocalCall(c)) {
-      const answer = this._client.call(c.call);
-      joinAnswer(c.f, answer);
-    } else if (isDisembargo(c)) {
-      const msg = newDisembargoMessage(
-        Disembargo_Context_Which.RECEIVER_LOOPBACK,
-        c.embargoID
-      );
-      msg.disembargo.target = c.embargoTarget;
-      this.conn.sendMessage(msg);
-    }
-  }
-  isPassthrough() {
-    return this.q.len() === 0;
-  }
-  call(call) {
-    if (this.isPassthrough()) {
-      return this._client.call(call);
-    }
-    return this.pushCall(call);
-  }
-  // close releases any resources associated with this client.
-  // No further calls to the client should be made after calling Close.
-  close() {
-  }
-};
-var AnswerEntry = class {
-  static {
-    __name(this, "AnswerEntry");
-  }
-  id;
-  conn;
-  resultCaps = [];
-  done = false;
-  obj;
-  err;
-  deferred = new Deferred();
-  queue = [];
-  constructor(conn, id) {
-    this.conn = conn;
-    this.id = id;
-  }
-  // fulfill is called to resolve an answer successfully.
-  fulfill(obj) {
-    if (this.done) {
-      throw new Error(`answer.fulfill called more than once`);
-    }
-    this.done = true;
-    this.obj = obj;
-    const retmsg = newReturnMessage(this.id);
-    const ret = retmsg.return;
-    const payload = ret._initResults();
-    payload.content = obj;
-    let firstErr;
-    try {
-      this.conn.makeCapTable(ret.segment, (len) => payload._initCapTable(len));
-      this.deferred.resolve(obj);
-      this.conn.sendMessage(retmsg);
-    } catch (error_) {
-      if (!firstErr) {
-        firstErr = error_;
-      }
-    }
-    const [queues, queuesErr] = this.emptyQueue(obj);
-    if (queuesErr && !firstErr) {
-      firstErr = queuesErr;
-    }
-    const objcap = obj.segment.message._capnp;
-    if (!objcap.capTable) {
-      objcap.capTable = [];
-    }
-    for (const capIdxStr of Object.keys(queues)) {
-      const capIdx = Number(capIdxStr);
-      const q = queues[capIdx];
-      if (objcap.capTable === null) throw new Error(INVARIANT_UNREACHABLE_CODE);
-      objcap.capTable[capIdx] = new QueueClient(
-        this.conn,
-        objcap.capTable[capIdx],
-        q
-      );
-    }
-    if (firstErr) {
-      throw firstErr;
-    }
-  }
-  // reject is called to resolve an answer with failure.
-  reject(err) {
-    if (!err) {
-      throw new Error(`answer.reject called with nil`);
-    }
-    if (this.done) {
-      throw new Error(`answer.reject claled more than once`);
-    }
-    const m = newReturnMessage(this.id);
-    const mret = m.return;
-    setReturnException(mret, err);
-    this.err = err;
-    this.done = true;
-    this.deferred.reject(err);
-    let firstErr;
-    try {
-      this.conn.sendMessage(m);
-    } catch (error_) {
-      firstErr = error_;
-    }
-    for (let i = 0; i < this.queue.length; i++) {
-      const qa = this.queue[i];
-      try {
-        if (qa.qcall && isRemoteCall(qa.qcall)) {
-          qa.qcall.a.reject(err);
-        }
-      } catch (error_) {
-        if (!firstErr) {
-          firstErr = error_;
-        }
-      }
-    }
-    this.queue = [];
-    if (firstErr) {
-      throw firstErr;
-    }
-  }
-  // emptyQueue splits the queue by which capability it targets
-  // and drops any invalid calls. Once this function returns,
-  // this.queue will be empty.
-  emptyQueue(obj) {
-    let firstErr;
-    const qs = {};
-    for (let i = 0; i < this.queue.length; i++) {
-      const pc = this.queue[i];
-      if (!isRemoteCall(pc.qcall)) {
-        continue;
-      }
-      if (!pc.qcall.a) {
-        continue;
-      }
-      let c;
-      try {
-        c = transformPtr(obj, pc.transform);
-      } catch (error_) {
-        try {
-          pc.qcall.a.reject(error_);
-        } catch (error_2) {
-          if (!firstErr) {
-            firstErr = error_2;
-          }
-        }
-        continue;
-      }
-      const ci = Interface.fromPointer(c);
-      if (!ci) {
-        try {
-          pc.qcall.a.reject(new Error(RPC_NULL_CLIENT));
-        } catch (error_) {
-          if (!firstErr) {
-            firstErr = error_;
-          }
-        }
-        continue;
-      }
-      const cn = ci.getCapId();
-      if (!qs[cn]) {
-        qs[cn] = [];
-      }
-      qs[cn].push(pc.qcall);
-    }
-    this.queue = [];
-    return [qs, firstErr];
-  }
-  queueCall(call, transform, a) {
-    if (this.queue.length >= callQueueSize2) {
-      throw new Error(RPC_CALL_QUEUE_FULL);
-    }
-    const qcall = {
-      a,
-      call: copyCall(call)
-    };
-    const pcall = {
-      qcall,
-      transform
-    };
-    this.queue.push(pcall);
-  }
-};
-function isRemoteCall(a) {
-  return !!a.a;
-}
-__name(isRemoteCall, "isRemoteCall");
-function isLocalCall(a) {
-  return !!a.f;
-}
-__name(isLocalCall, "isLocalCall");
-function isDisembargo(a) {
-  return !!a.embargoTarget;
-}
-__name(isDisembargo, "isDisembargo");
-var ImportClient = class {
-  static {
-    __name(this, "ImportClient");
-  }
-  constructor(conn, id) {
-    this.conn = conn;
-    this.id = id;
-  }
-  closed = false;
-  call(cl) {
-    if (this.closed) {
-      return new ErrorAnswer(new Error(RPC_IMPORT_CLOSED));
-    }
-    const q = this.conn.newQuestion(cl.method);
-    const msg = newMessage();
-    const msgCall = msg._initCall();
-    msgCall.questionId = q.id;
-    msgCall.interfaceId = cl.method.interfaceId;
-    msgCall.methodId = cl.method.methodId;
-    const target = msgCall._initTarget();
-    target.importedCap = this.id;
-    const payload = msgCall._initParams();
-    this.conn.fillParams(payload, cl);
-    this.conn.sendMessage(msg);
-    return q;
-  }
-  close() {
-  }
-};
-var LocalAnswerClient = class {
-  static {
-    __name(this, "LocalAnswerClient");
-  }
-  constructor(a, transform) {
-    this.a = a;
-    this.transform = transform;
-  }
-  call(call) {
-    if (this.a.done) {
-      return clientFromResolution(this.transform, this.a.obj, this.a.err).call(
-        call
-      );
-    }
-    return new Fulfiller();
-  }
-  close() {
-    throw new Error(NOT_IMPLEMENTED);
-  }
-};
-var ConnWeakRefRegistry = globalThis.FinalizationRegistry ? new FinalizationRegistry((cb) => cb()) : void 0;
-var ConDefaultFinalize = /* @__PURE__ */ __name((obj, finalizer) => {
-  ConnWeakRefRegistry?.register(obj, finalizer);
-}, "ConDefaultFinalize");
-var Conn = class {
-  static {
-    __name(this, "Conn");
-  }
-  /**
-   * Create a new connection
-   * @param transport The transport used to receive/send messages.
-   * @param finalize Weak reference implementation. Compatible with
-   * the 'weak' module on node.js (just add weak as a dependency and pass
-   * require("weak")), but alternative implementations can be provided for
-   * other platforms like Electron. Defaults to using FinalizationRegistry if
-   * available.
-   * @returns A new connection.
-   */
-  constructor(transport, finalize = ConDefaultFinalize) {
-    this.transport = transport;
-    this.finalize = finalize;
-    this.startWork();
-  }
-  questionID = new IDGen();
-  questions = [];
-  answers = {};
-  exportID = new IDGen();
-  exports = [];
-  imports = {};
-  onError;
-  main;
-  working = false;
-  bootstrap(InterfaceClass) {
-    const q = this.newQuestion();
-    const msg = newMessage();
-    const boot = msg._initBootstrap();
-    boot.questionId = q.id;
-    this.sendMessage(msg);
-    return new InterfaceClass.Client(new Pipeline(AnyStruct, q).client());
-  }
-  initMain(InterfaceClass, target) {
-    this.main = new InterfaceClass.Server(target);
-    this.addExport(this.main);
-  }
-  startWork() {
-    this.work().catch((error_) => {
-      if (this.onError) {
-        this.onError(error_);
-      } else if (error_ !== void 0) {
-        throw error_;
-      }
-    });
-  }
-  sendReturnException(id, err) {
-    const m = newReturnMessage(id);
-    setReturnException(m.return, err);
-    this.sendMessage(m);
-  }
-  handleBootstrapMessage(m) {
-    const boot = m.bootstrap;
-    const id = boot.questionId;
-    const ret = newReturnMessage(id);
-    ret.return.releaseParamCaps = false;
-    const a = this.insertAnswer(id);
-    if (a === null) {
-      return this.sendReturnException(id, new Error(RPC_QUESTION_ID_REUSED));
-    }
-    if (this.main === void 0) {
-      return a.reject(new Error(RPC_NO_MAIN_INTERFACE));
-    }
-    const msg = new Message();
-    msg.addCap(this.main);
-    a.fulfill(new Interface(msg.getSegment(0), 0));
-  }
-  handleFinishMessage(m) {
-    const { finish } = m;
-    const id = finish.questionId;
-    const a = this.popAnswer(id);
-    if (a === null) {
-      throw new Error(format(RPC_FINISH_UNKNOWN_ANSWER, id));
-    }
-    if (finish.releaseResultCaps) {
-      const caps = a.resultCaps;
-      let i = caps.length;
-      while (--i >= 0) {
-        this.releaseExport(i, 1);
-      }
-    }
-  }
-  handleMessage(m) {
-    switch (m.which()) {
-      case Message2.UNIMPLEMENTED: {
-        break;
-      }
-      case Message2.BOOTSTRAP: {
-        this.handleBootstrapMessage(m);
-        break;
-      }
-      case Message2.ABORT: {
-        this.shutdown(new RPCError(m.abort));
-        break;
-      }
-      case Message2.FINISH: {
-        this.handleFinishMessage(m);
-        break;
-      }
-      case Message2.RETURN: {
-        this.handleReturnMessage(m);
-        break;
-      }
-      case Message2.CALL: {
-        this.handleCallMessage(m);
-        break;
-      }
-    }
-  }
-  handleReturnMessage(m) {
-    const ret = m.return;
-    const id = ret.answerId;
-    const q = this.popQuestion(id);
-    if (!q) {
-      throw new Error(format(RPC_RETURN_FOR_UNKNOWN_QUESTION, id));
-    }
-    if (ret.releaseParamCaps) {
-      for (let i = 0; i < q.paramCaps.length; i++) {
-        this.releaseExport(id, 1);
-      }
-    }
-    let releaseResultCaps = true;
-    switch (ret.which()) {
-      case Return.RESULTS: {
-        releaseResultCaps = false;
-        const { results } = ret;
-        this.populateMessageCapTable(results);
-        const { content } = results;
-        q.fulfill(content);
-        break;
-      }
-      case Return.EXCEPTION: {
-        const exc = ret.exception;
-        const err = q.method ? new MethodError(q.method, exc.reason) : new RPCError(exc);
-        q.reject(err);
-        break;
-      }
-    }
-    const fin = newFinishMessage(id, releaseResultCaps);
-    this.sendMessage(fin);
-  }
-  handleCallMessage(m) {
-    const mcall = m.call;
-    const mt = mcall.target;
-    if (mt.which() !== MessageTarget.IMPORTED_CAP && mt.which() !== MessageTarget.PROMISED_ANSWER) {
-      const um = newUnimplementedMessage(m);
-      this.sendMessage(um);
-      return;
-    }
-    const mparams = mcall.params;
-    try {
-      this.populateMessageCapTable(mparams);
-    } catch {
-      const um = newUnimplementedMessage(m);
-      this.sendMessage(um);
-      return;
-    }
-    const id = mcall.questionId;
-    const a = this.insertAnswer(id);
-    if (!a) {
-      throw new Error(format(RPC_QUESTION_ID_REUSED, id));
-    }
-    const interfaceDef = Registry.lookup(mcall.interfaceId);
-    if (!interfaceDef) {
-      const um = newUnimplementedMessage(m);
-      this.sendMessage(um);
-      return;
-    }
-    const method = interfaceDef.methods[mcall.methodId];
-    if (!method) {
-      const um = newUnimplementedMessage(m);
-      this.sendMessage(um);
-      return;
-    }
-    const paramContent = mparams.content;
-    const call = {
-      method,
-      params: getAs(method.ParamsClass, paramContent)
-    };
-    try {
-      this.routeCallMessage(a, mt, call);
-    } catch (error_) {
-      a.reject(error_);
-    }
-  }
-  routeCallMessage(result, mt, cl) {
-    switch (mt.which()) {
-      case MessageTarget.IMPORTED_CAP: {
-        const id = mt.importedCap;
-        const e = this.findExport(id);
-        if (!e) {
-          throw new Error(RPC_BAD_TARGET);
-        }
-        const answer = this.call(e.client, cl);
-        joinAnswer(result, answer);
-        break;
-      }
-      case MessageTarget.PROMISED_ANSWER: {
-        const mpromise = mt.promisedAnswer;
-        const id = mpromise.questionId;
-        if (id === result.id) {
-          throw new Error(RPC_BAD_TARGET);
-        }
-        const pa = this.answers[id];
-        if (!pa) {
-          throw new Error(RPC_BAD_TARGET);
-        }
-        const mtrans = mpromise.transform;
-        const transform = promisedAnswerOpsToTransform(mtrans);
-        if (pa.done) {
-          const { obj, err } = pa;
-          const client = clientFromResolution(transform, obj, err);
-          const answer = this.call(client, cl);
-          joinAnswer(result, answer);
-        } else {
-          pa.queueCall(cl, transform, result);
-        }
-        break;
-      }
-      default: {
-        throw new Error(INVARIANT_UNREACHABLE_CODE);
-      }
-    }
-  }
-  populateMessageCapTable(payload) {
-    const msg = payload.segment.message;
-    const ctab = payload.capTable;
-    for (const desc of ctab) {
-      switch (desc.which()) {
-        case CapDescriptor.NONE: {
-          msg.addCap(null);
-          break;
-        }
-        case CapDescriptor.SENDER_HOSTED: {
-          const id = desc.senderHosted;
-          const client = this.addImport(id);
-          msg.addCap(client);
-          break;
-        }
-        case CapDescriptor.SENDER_PROMISE: {
-          const id = desc.senderPromise;
-          const client = this.addImport(id);
-          msg.addCap(client);
-          break;
-        }
-        case CapDescriptor.RECEIVER_HOSTED: {
-          const id = desc.receiverHosted;
-          const e = this.findExport(id);
-          if (!e) {
-            throw new Error(format(RPC_UNKNOWN_EXPORT_ID, id));
-          }
-          msg.addCap(e.rc.ref());
-          break;
-        }
-        case CapDescriptor.RECEIVER_ANSWER: {
-          const recvAns = desc.receiverAnswer;
-          const id = recvAns.questionId;
-          const a = this.answers[id];
-          if (!a) {
-            throw new Error(format(RPC_UNKNOWN_ANSWER_ID, id));
-          }
-          const recvTransform = recvAns.transform;
-          const transform = promisedAnswerOpsToTransform(recvTransform);
-          msg.addCap(answerPipelineClient(a, transform));
-          break;
-        }
-        default: {
-          throw new Error(format(RPC_UNKNOWN_CAP_DESCRIPTOR, desc.which()));
-        }
-      }
-    }
-  }
-  addImport(id) {
-    const importEntry = this.imports[id];
-    if (importEntry) {
-      importEntry.refs++;
-      return importEntry.rc.ref();
-    }
-    const client = new ImportClient(this, id);
-    const [rc, ref] = RefCount.new(client, this.finalize);
-    this.imports[id] = {
-      rc,
-      refs: 1
-    };
-    return ref;
-  }
-  findExport(id) {
-    if (id > this.exports.length) {
-      return null;
-    }
-    return this.exports[id];
-  }
-  addExport(client) {
-    for (let i = 0; i < this.exports.length; i++) {
-      const e = this.exports[i];
-      if (e && isSameClient(e.rc._client, client)) {
-        e.wireRefs++;
-        return i;
-      }
-    }
-    const id = this.exportID.next();
-    const [rc, ref] = RefCount.new(client, this.finalize);
-    const _export = {
-      client: ref,
-      id,
-      rc,
-      wireRefs: 1
-    };
-    if (id === this.exports.length) {
-      this.exports.push(_export);
-    } else {
-      this.exports[id] = _export;
-    }
-    return id;
-  }
-  releaseExport(id, refs) {
-    const e = this.findExport(id);
-    if (!e) {
-      return;
-    }
-    e.wireRefs -= refs;
-    if (e.wireRefs > 0) {
-      return;
-    }
-    if (e.wireRefs < 0) {
-      this.error(`warning: export ${id} has negative refcount (${e.wireRefs})`);
-    }
-    e.client.close();
-    this.exports[id] = null;
-    this.exportID.remove(id);
-  }
-  error(s) {
-    console.error(s);
-  }
-  newQuestion(method) {
-    const id = this.questionID.next();
-    const q = new Question(this, id, method);
-    if (id === this.questions.length) {
-      this.questions.push(q);
-    } else {
-      this.questions[id] = q;
-    }
-    return q;
-  }
-  findQuestion(id) {
-    if (id > this.questions.length) {
-      return null;
-    }
-    return this.questions[id];
-  }
-  popQuestion(id) {
-    const q = this.findQuestion(id);
-    if (!q) {
-      return q;
-    }
-    this.questions[id] = null;
-    this.questionID.remove(id);
-    return q;
-  }
-  // TODO: cancel context?
-  insertAnswer(id) {
-    if (this.answers[id]) {
-      return null;
-    }
-    const a = new AnswerEntry(this, id);
-    this.answers[id] = a;
-    return a;
-  }
-  popAnswer(id) {
-    const a = this.answers[id];
-    delete this.answers[id];
-    return a;
-  }
-  shutdown(_err) {
-    this.transport.close();
-  }
-  call(client, call) {
-    return client.call(call);
-  }
-  fillParams(payload, cl) {
-    const params = placeParams(cl, payload.content);
-    payload.content = params;
-    this.makeCapTable(
-      payload.segment,
-      (length) => payload._initCapTable(length)
-    );
-  }
-  makeCapTable(s, init) {
-    const msgtab = s.message._capnp.capTable;
-    if (!msgtab) {
-      return;
-    }
-    const t = init(msgtab.length);
-    for (const [i, client] of msgtab.entries()) {
-      const desc = t.get(i);
-      if (!client) {
-        desc.none = true;
-        continue;
-      }
-      this.descriptorForClient(desc, client);
-    }
-  }
-  // descriptorForClient fills desc for client, adding it to the export
-  // table if necessary.  The caller must be holding onto c.mu.
-  descriptorForClient(desc, _client) {
-    {
-      dig: for (let client = _client; ; ) {
-        if (client instanceof ImportClient) {
-          if (client.conn !== this) {
-            break dig;
-          }
-          desc.receiverHosted = client.id;
-          return;
-        } else if (client instanceof Ref) {
-          client = client.client();
-        } else if (client instanceof PipelineClient) {
-          const p = client.pipeline;
-          const ans = p.answer;
-          const transform = p.transform();
-          if (ans instanceof FixedAnswer) {
-            let s;
-            let err;
-            try {
-              s = ans.structSync();
-            } catch (error_) {
-              err = error_;
-            }
-            client = clientFromResolution(transform, s, err);
-          } else if (ans instanceof Question) {
-            if (ans.state !== QuestionState.IN_PROGRESS) {
-              client = clientFromResolution(transform, ans.obj, ans.err);
-              continue;
-            }
-            if (ans.conn !== this) {
-              break dig;
-            }
-            const a = desc._initReceiverAnswer();
-            a.questionId = ans.id;
-            transformToPromisedAnswer(a, p.transform());
-            return;
-          } else {
-            break dig;
-          }
-        } else {
-          break dig;
-        }
-      }
-    }
-    const id = this.addExport(_client);
-    desc.senderHosted = id;
-  }
-  sendMessage(msg) {
-    this.transport.sendMessage(msg);
-  }
-  async work() {
-    this.working = true;
-    while (this.working) {
-      try {
-        const m = await this.transport.recvMessage();
-        this.handleMessage(m);
-      } catch (error_) {
-        if (error_ !== void 0) {
-          throw error_;
-        }
-        this.working = false;
-      }
-    }
-  }
-};
-function answerPipelineClient(a, transform) {
-  return new LocalAnswerClient(a, transform);
-}
-__name(answerPipelineClient, "answerPipelineClient");
-var DeferredTransport = class {
-  static {
-    __name(this, "DeferredTransport");
-  }
-  d;
-  closed = false;
-  close() {
-    this.closed = true;
-    this.d?.reject();
-  }
-  recvMessage() {
-    if (this.closed) {
-      return Promise.reject();
-    }
-    if (this.d) {
-      this.d.reject();
-    }
-    this.d = new Deferred();
-    return this.d.promise;
-  }
-  reject = /* @__PURE__ */ __name((err) => {
-    this.d?.reject(err);
-  }, "reject");
-  resolve = /* @__PURE__ */ __name((buf) => {
-    try {
-      this.d?.resolve(new Message(buf, false).getRoot(Message2));
-    } catch (error_) {
-      this.d?.reject(error_);
-    }
-  }, "resolve");
-};
+  __name
+} from "./chunk-UHN7QD4F.js";
 
 // src/rpc.ts
 import { MessageChannel } from "node:worker_threads";