@stryke/capnp 0.4.5 → 0.6.0

package/dist/chunk-YOA3BS5Q.cjs

@@ -0,0 +1,4758 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18; var _class19; var _class20; var _class21; var _class22; var _class23; var _class24; var _class25; var _class26; var _class27; var _class28; var _class29; var _class30; var _class31; var _class32; var _class33; var _class34; var _class35; var _class36; var _class37; var _class38; var _class39; var _class40; var _class41; var _class42; var _class43; var _class44;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkIVTBYMMNcjs = require('./chunk-IVTBYMMN.cjs');
+
+// ../../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 = class extends _chunkIVTBYMMNcjs.Pointer {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Interface");
+  }
+  static __initStatic() {this._capnp = {
+    displayName: "Interface"
+  }}
+  static __initStatic2() {this.getCapID = getCapID}
+  static __initStatic3() {this.getAsInterface = getAsInterface}
+  static __initStatic4() {this.isInterface = isInterface}
+  static __initStatic5() {this.getClient = getClient}
+  constructor(segment, byteOffset, depthLimit = _chunkIVTBYMMNcjs.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 _chunkIVTBYMMNcjs.format.call(void 0, 
+      "Interface_%d@%a,%d,limit:%x",
+      this.segment.id,
+      this.byteOffset,
+      this.getCapId(),
+      this._capnp.depthLimit
+    );
+  }
+}, _class.__initStatic(), _class.__initStatic2(), _class.__initStatic3(), _class.__initStatic4(), _class.__initStatic5(), _class);
+function getAsInterface(p) {
+  if (_chunkIVTBYMMNcjs.getTargetPointerType.call(void 0, p) === _chunkIVTBYMMNcjs.PointerType.OTHER) {
+    return new Interface(p.segment, p.byteOffset, p._capnp.depthLimit);
+  }
+  return null;
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, getAsInterface, "getAsInterface");
+function isInterface(p) {
+  return _chunkIVTBYMMNcjs.getTargetPointerType.call(void 0, p) === _chunkIVTBYMMNcjs.PointerType.OTHER;
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, isInterface, "isInterface");
+function getCapID(i) {
+  if (i.segment.getUint32(i.byteOffset) !== _chunkIVTBYMMNcjs.PointerType.OTHER) {
+    return -1;
+  }
+  return i.segment.getUint32(i.byteOffset + 4);
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, getCapID, "getCapID");
+function getClient(i) {
+  const capID = getCapID(i);
+  const { capTable } = i.segment.message._capnp;
+  if (!capTable) {
+    return null;
+  }
+  return capTable[capID];
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, getClient, "getClient");
+function isFuncCall(call) {
+  return !isDataCall(call);
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, isFuncCall, "isFuncCall");
+function isDataCall(call) {
+  return !!call.params;
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, isDataCall, "isDataCall");
+function copyCall(call) {
+  if (isDataCall(call)) {
+    return call;
+  }
+  return {
+    method: call.method,
+    params: placeParams(call, void 0)
+  };
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, 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 (0, _chunkIVTBYMMNcjs.Message)();
+    p = new call.method.ParamsClass(msg.getSegment(0), 0);
+  }
+  _chunkIVTBYMMNcjs.initStruct.call(void 0, call.method.ParamsClass._capnp.size, p);
+  if (call.paramsFunc) {
+    call.paramsFunc(p);
+  }
+  return p;
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, placeParams, "placeParams");
+function pointerToStruct(p) {
+  if (_chunkIVTBYMMNcjs.getTargetPointerType.call(void 0, p) === _chunkIVTBYMMNcjs.PointerType.STRUCT) {
+    return new (0, _chunkIVTBYMMNcjs.Struct)(
+      p.segment,
+      p.byteOffset,
+      p._capnp.depthLimit,
+      p._capnp.compositeIndex
+    );
+  }
+  return null;
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, 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 = _chunkIVTBYMMNcjs.getPointer.call(void 0, op.field, s);
+  }
+  return s;
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, transformPtr, "transformPtr");
+var Deferred = class _Deferred {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Deferred");
+  }
+  static fromPromise(p) {
+    const d = new _Deferred();
+    p.then(d.resolve, d.reject);
+    return d;
+  }
+  
+  
+  
+  constructor() {
+    this.promise = new Promise((a, b) => {
+      this.resolve = a;
+      this.reject = b;
+    });
+  }
+};
+var ImmediateAnswer = class extends _chunkIVTBYMMNcjs.FixedAnswer {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "ImmediateAnswer");
+  }
+  constructor(s) {
+    super();
+    this.s = s;
+  }
+  structSync() {
+    return this.s;
+  }
+  findClient(transform) {
+    const p = transformPtr(this.s, transform);
+    return _chunkIVTBYMMNcjs.getInterfaceClientOrNull.call(void 0, p);
+  }
+  pipelineCall(transform, call) {
+    return this.findClient(transform).call(call);
+  }
+  pipelineClose(transform) {
+    this.findClient(transform).close();
+  }
+};
+var Queue = (_class2 = class {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, 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) {;_class2.prototype.__init.call(this);
+    this.q = q;
+    this.n = n;
+    this.cap = q.len();
+  }
+  __init() {this.start = 0}
+  
+  // 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;
+  }
+}, _class2);
+var EmbargoClient = class {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "EmbargoClient");
+  }
+  
+  
+  
+  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 (0, _chunkIVTBYMMNcjs.ErrorAnswer)(new Error(_chunkIVTBYMMNcjs.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(_chunkIVTBYMMNcjs.INVARIANT_UNREACHABLE_CODE);
+      }
+      first.f.reject(new Error(_chunkIVTBYMMNcjs.RPC_QUEUE_CALL_CANCEL));
+      this.q.pop();
+    }
+    this._client.close();
+  }
+};
+var Ecalls = class _Ecalls {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Ecalls");
+  }
+  
+  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 = (_class3 = class _Fulfiller {constructor() { _class3.prototype.__init2.call(this);_class3.prototype.__init3.call(this);_class3.prototype.__init4.call(this);_class3.prototype.__init5.call(this); }
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Fulfiller");
+  }
+  __init2() {this.resolved = false}
+  
+  __init3() {this.queue = []}
+  __init4() {this.queueCap = callQueueSize}
+  __init5() {this.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(_chunkIVTBYMMNcjs.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 (0, _chunkIVTBYMMNcjs.ErrorAnswer)(new Error(_chunkIVTBYMMNcjs.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__ */ _chunkIVTBYMMNcjs.__name.call(void 0, () => {
+      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(_chunkIVTBYMMNcjs.RPC_NULL_CLIENT));
+        continue;
+      }
+      const cn = iface.getCapId();
+      if (!qs[cn]) {
+        qs[cn] = new Ecalls([]);
+      }
+      qs[cn].data.push(pc);
+    }
+    this.queue = [];
+    return qs;
+  }
+}, _class3);
+var PipelineClient = class {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, 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 {
+    _chunkIVTBYMMNcjs.__name.call(void 0, 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 };
+  }
+  
+  
+  // 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) {
+        _chunkIVTBYMMNcjs.copyFrom.call(void 0, this.op.defaultValue, t);
+      } else {
+        _chunkIVTBYMMNcjs.initStruct.call(void 0, this.ResultsClass._capnp.size, t);
+      }
+    }
+    return _chunkIVTBYMMNcjs.getAs.call(void 0, 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 {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "MethodError");
+  }
+  constructor(method, message) {
+    super(
+      _chunkIVTBYMMNcjs.format.call(void 0, 
+        _chunkIVTBYMMNcjs.RPC_METHOD_ERROR,
+        method.interfaceName,
+        method.methodName,
+        message
+      )
+    );
+    this.method = method;
+  }
+};
+var Registry = (_class4 = class {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Registry");
+  }
+  static __initStatic6() {this.interfaces = /* @__PURE__ */ new Map()}
+  static register(id, def) {
+    this.interfaces.set(id, def);
+  }
+  static lookup(id) {
+    return this.interfaces.get(id);
+  }
+}, _class4.__initStatic6(), _class4);
+var Server = class {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Server");
+  }
+  constructor(target, methods) {
+    this.target = target;
+    this.methods = methods;
+  }
+  startCall(call) {
+    const msg = new (0, _chunkIVTBYMMNcjs.Message)();
+    const results = msg.initRoot(call.method.ResultsClass);
+    call.serverMethod.impl.call(this.target, call.params, results).then(() => call.answer.fulfill(results)).catch((error_) => call.answer.reject(error_));
+  }
+  call(call) {
+    const serverMethod = this.methods[call.method.methodId];
+    if (!serverMethod) {
+      return new (0, _chunkIVTBYMMNcjs.ErrorAnswer)(
+        new MethodError(call.method, _chunkIVTBYMMNcjs.RPC_METHOD_NOT_IMPLEMENTED)
+      );
+    }
+    const serverCall = {
+      ...copyCall(call),
+      answer: new Fulfiller(),
+      serverMethod
+    };
+    this.startCall(serverCall);
+    return serverCall.answer;
+  }
+  close() {
+  }
+};
+
+// ../../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 = (_class5 = class _Message extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Message");
+  }
+  static __initStatic7() {this.UNIMPLEMENTED = Message_Which.UNIMPLEMENTED}
+  static __initStatic8() {this.ABORT = Message_Which.ABORT}
+  static __initStatic9() {this.BOOTSTRAP = Message_Which.BOOTSTRAP}
+  static __initStatic10() {this.CALL = Message_Which.CALL}
+  static __initStatic11() {this.RETURN = Message_Which.RETURN}
+  static __initStatic12() {this.FINISH = Message_Which.FINISH}
+  static __initStatic13() {this.RESOLVE = Message_Which.RESOLVE}
+  static __initStatic14() {this.RELEASE = Message_Which.RELEASE}
+  static __initStatic15() {this.DISEMBARGO = Message_Which.DISEMBARGO}
+  static __initStatic16() {this.OBSOLETE_SAVE = Message_Which.OBSOLETE_SAVE}
+  static __initStatic17() {this.OBSOLETE_DELETE = Message_Which.OBSOLETE_DELETE}
+  static __initStatic18() {this.PROVIDE = Message_Which.PROVIDE}
+  static __initStatic19() {this.ACCEPT = Message_Which.ACCEPT}
+  static __initStatic20() {this.JOIN = Message_Which.JOIN}
+  static __initStatic21() {this._capnp = {
+    displayName: "Message",
+    id: "91b79f1f808db032",
+    size: new (0, _chunkIVTBYMMNcjs.ObjectSize)(8, 1)
+  }}
+  _adoptUnimplemented(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 0, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownUnimplemented() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, 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() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "unimplemented", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 0, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, _Message, this);
+  }
+  _hasUnimplemented() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initUnimplemented() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 0, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, _Message, this);
+  }
+  get _isUnimplemented() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 0;
+  }
+  set unimplemented(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 0, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptAbort(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 1, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownAbort() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, 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() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "abort", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 1, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, Exception, this);
+  }
+  _hasAbort() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initAbort() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 1, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, Exception, this);
+  }
+  get _isAbort() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 1;
+  }
+  set abort(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 1, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptBootstrap(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 8, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownBootstrap() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.bootstrap);
+  }
+  /**
+  * Request the peer's bootstrap interface.
+  *
+  */
+  get bootstrap() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "bootstrap", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 8, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, Bootstrap, this);
+  }
+  _hasBootstrap() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initBootstrap() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 8, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, Bootstrap, this);
+  }
+  get _isBootstrap() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 8;
+  }
+  set bootstrap(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 8, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptCall(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 2, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownCall() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.call);
+  }
+  /**
+  * Begin a method call.
+  *
+  */
+  get call() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "call", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 2, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, Call, this);
+  }
+  _hasCall() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initCall() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 2, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, Call, this);
+  }
+  get _isCall() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 2;
+  }
+  set call(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 2, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptReturn(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 3, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownReturn() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.return);
+  }
+  /**
+  * Complete a method call.
+  *
+  */
+  get return() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "return", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 3, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, Return, this);
+  }
+  _hasReturn() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initReturn() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 3, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, Return, this);
+  }
+  get _isReturn() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 3;
+  }
+  set return(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 3, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptFinish(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 4, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownFinish() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.finish);
+  }
+  /**
+  * Release a returned answer / cancel a call.
+  *
+  */
+  get finish() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "finish", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 4, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, Finish, this);
+  }
+  _hasFinish() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initFinish() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 4, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, Finish, this);
+  }
+  get _isFinish() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 4;
+  }
+  set finish(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 4, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptResolve(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 5, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownResolve() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.resolve);
+  }
+  /**
+  * Resolve a previously-sent promise.
+  *
+  */
+  get resolve() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "resolve", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 5, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, Resolve, this);
+  }
+  _hasResolve() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initResolve() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 5, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, Resolve, this);
+  }
+  get _isResolve() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 5;
+  }
+  set resolve(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 5, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptRelease(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 6, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownRelease() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.release);
+  }
+  /**
+  * Release a capability so that the remote object can be deallocated.
+  *
+  */
+  get release() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "release", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 6, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, Release, this);
+  }
+  _hasRelease() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initRelease() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 6, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, Release, this);
+  }
+  get _isRelease() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 6;
+  }
+  set release(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 6, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptDisembargo(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 13, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownDisembargo() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.disembargo);
+  }
+  /**
+  * Lift an embargo used to enforce E-order over promise resolution.
+  *
+  */
+  get disembargo() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "disembargo", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 13, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, Disembargo, this);
+  }
+  _hasDisembargo() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initDisembargo() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 13, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, Disembargo, this);
+  }
+  get _isDisembargo() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 13;
+  }
+  set disembargo(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 13, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptObsoleteSave(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 7, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownObsoleteSave() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, 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() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "obsoleteSave", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 7, this);
+    return _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this);
+  }
+  _hasObsoleteSave() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  get _isObsoleteSave() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 7;
+  }
+  set obsoleteSave(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 7, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptObsoleteDelete(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 9, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownObsoleteDelete() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.obsoleteDelete);
+  }
+  /**
+  * Obsolete way to delete a SturdyRef. This operation was never implemented.
+  *
+  */
+  get obsoleteDelete() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "obsoleteDelete", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 9, this);
+    return _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this);
+  }
+  _hasObsoleteDelete() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  get _isObsoleteDelete() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 9;
+  }
+  set obsoleteDelete(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 9, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptProvide(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 10, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownProvide() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.provide);
+  }
+  /**
+  * Provide a capability to a third party.
+  *
+  */
+  get provide() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "provide", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 10, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, Provide, this);
+  }
+  _hasProvide() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initProvide() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 10, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, Provide, this);
+  }
+  get _isProvide() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 10;
+  }
+  set provide(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 10, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptAccept(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 11, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownAccept() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.accept);
+  }
+  /**
+  * Accept a capability provided by a third party.
+  *
+  */
+  get accept() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "accept", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 11, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, Accept, this);
+  }
+  _hasAccept() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initAccept() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 11, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, Accept, this);
+  }
+  get _isAccept() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 11;
+  }
+  set accept(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 11, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptJoin(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 12, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownJoin() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.join);
+  }
+  /**
+  * Directly connect to the common root of two or more proxied caps.
+  *
+  */
+  get join() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "join", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 12, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, Join, this);
+  }
+  _hasJoin() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initJoin() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 12, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, Join, this);
+  }
+  get _isJoin() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 12;
+  }
+  set join(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 12, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  toString() {
+    return "Message_" + super.toString();
+  }
+  which() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this);
+  }
+}, _class5.__initStatic7(), _class5.__initStatic8(), _class5.__initStatic9(), _class5.__initStatic10(), _class5.__initStatic11(), _class5.__initStatic12(), _class5.__initStatic13(), _class5.__initStatic14(), _class5.__initStatic15(), _class5.__initStatic16(), _class5.__initStatic17(), _class5.__initStatic18(), _class5.__initStatic19(), _class5.__initStatic20(), _class5.__initStatic21(), _class5);
+var Bootstrap = (_class6 = class extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Bootstrap");
+  }
+  static __initStatic22() {this._capnp = {
+    displayName: "Bootstrap",
+    id: "e94ccf8031176ec4",
+    size: new (0, _chunkIVTBYMMNcjs.ObjectSize)(8, 1)
+  }}
+  /**
+  * A new question ID identifying this request, which will eventually receive a Return message
+  * containing the restored capability.
+  *
+  */
+  get questionId() {
+    return _chunkIVTBYMMNcjs.getUint32.call(void 0, 0, this);
+  }
+  set questionId(value) {
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 0, value, this);
+  }
+  _adoptDeprecatedObjectId(value) {
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownDeprecatedObjectId() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, 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 _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this);
+  }
+  _hasDeprecatedObjectId() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  set deprecatedObjectId(value) {
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  toString() {
+    return "Bootstrap_" + super.toString();
+  }
+}, _class6.__initStatic22(), _class6);
+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 = (_class7 = class extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Call_SendResultsTo");
+  }
+  static __initStatic23() {this.CALLER = Call_SendResultsTo_Which.CALLER}
+  static __initStatic24() {this.YOURSELF = Call_SendResultsTo_Which.YOURSELF}
+  static __initStatic25() {this.THIRD_PARTY = Call_SendResultsTo_Which.THIRD_PARTY}
+  static __initStatic26() {this._capnp = {
+    displayName: "sendResultsTo",
+    id: "dae8b0f61aab5f99",
+    size: new (0, _chunkIVTBYMMNcjs.ObjectSize)(24, 3)
+  }}
+  get _isCaller() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 6, this) === 0;
+  }
+  set caller(_) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 6, 0, this);
+  }
+  get _isYourself() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 6, this) === 1;
+  }
+  set yourself(_) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 6, 1, this);
+  }
+  _adoptThirdParty(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 6, 2, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 2, this));
+  }
+  _disownThirdParty() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, 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() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "thirdParty", _chunkIVTBYMMNcjs.getUint16.call(void 0, 6, this), 2, this);
+    return _chunkIVTBYMMNcjs.getPointer.call(void 0, 2, this);
+  }
+  _hasThirdParty() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 2, this));
+  }
+  get _isThirdParty() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 6, this) === 2;
+  }
+  set thirdParty(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 6, 2, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 2, this));
+  }
+  toString() {
+    return "Call_SendResultsTo_" + super.toString();
+  }
+  which() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 6, this);
+  }
+}, _class7.__initStatic23(), _class7.__initStatic24(), _class7.__initStatic25(), _class7.__initStatic26(), _class7);
+var Call = (_class8 = class _Call extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Call");
+  }
+  static __initStatic27() {this._capnp = {
+    displayName: "Call",
+    id: "836a53ce789d4cd4",
+    size: new (0, _chunkIVTBYMMNcjs.ObjectSize)(24, 3),
+    defaultAllowThirdPartyTailCall: _chunkIVTBYMMNcjs.getBitMask.call(void 0, false, 0),
+    defaultNoPromisePipelining: _chunkIVTBYMMNcjs.getBitMask.call(void 0, false, 1),
+    defaultOnlyPromisePipeline: _chunkIVTBYMMNcjs.getBitMask.call(void 0, 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 _chunkIVTBYMMNcjs.getUint32.call(void 0, 0, this);
+  }
+  set questionId(value) {
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 0, value, this);
+  }
+  _adoptTarget(value) {
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownTarget() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.target);
+  }
+  /**
+  * The object that should receive this call.
+  *
+  */
+  get target() {
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, MessageTarget, this);
+  }
+  _hasTarget() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initTarget() {
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, MessageTarget, this);
+  }
+  set target(value) {
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  /**
+  * The type ID of the interface being called.  Each capability may implement multiple interfaces.
+  *
+  */
+  get interfaceId() {
+    return _chunkIVTBYMMNcjs.getUint64.call(void 0, 8, this);
+  }
+  set interfaceId(value) {
+    _chunkIVTBYMMNcjs.setUint64.call(void 0, 8, value, this);
+  }
+  /**
+  * The ordinal number of the method to call within the requested interface.
+  *
+  */
+  get methodId() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this);
+  }
+  set methodId(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 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 _chunkIVTBYMMNcjs.getBit.call(void 0, 128, this, _Call._capnp.defaultAllowThirdPartyTailCall);
+  }
+  set allowThirdPartyTailCall(value) {
+    _chunkIVTBYMMNcjs.setBit.call(void 0, 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 _chunkIVTBYMMNcjs.getBit.call(void 0, 129, this, _Call._capnp.defaultNoPromisePipelining);
+  }
+  set noPromisePipelining(value) {
+    _chunkIVTBYMMNcjs.setBit.call(void 0, 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 _chunkIVTBYMMNcjs.getBit.call(void 0, 130, this, _Call._capnp.defaultOnlyPromisePipeline);
+  }
+  set onlyPromisePipeline(value) {
+    _chunkIVTBYMMNcjs.setBit.call(void 0, 130, value, this, _Call._capnp.defaultOnlyPromisePipeline);
+  }
+  _adoptParams(value) {
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 1, this));
+  }
+  _disownParams() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.params);
+  }
+  /**
+  * The call parameters.  `params.content` is a struct whose fields correspond to the parameters of
+  * the method.
+  *
+  */
+  get params() {
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 1, Payload, this);
+  }
+  _hasParams() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 1, this));
+  }
+  _initParams() {
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 1, Payload, this);
+  }
+  set params(value) {
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 1, this));
+  }
+  /**
+  * Where should the return message be sent?
+  *
+  */
+  get sendResultsTo() {
+    return _chunkIVTBYMMNcjs.getAs.call(void 0, Call_SendResultsTo, this);
+  }
+  _initSendResultsTo() {
+    return _chunkIVTBYMMNcjs.getAs.call(void 0, Call_SendResultsTo, this);
+  }
+  toString() {
+    return "Call_" + super.toString();
+  }
+}, _class8.__initStatic27(), _class8);
+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 = (_class9 = class _Return extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Return");
+  }
+  static __initStatic28() {this.RESULTS = Return_Which.RESULTS}
+  static __initStatic29() {this.EXCEPTION = Return_Which.EXCEPTION}
+  static __initStatic30() {this.CANCELED = Return_Which.CANCELED}
+  static __initStatic31() {this.RESULTS_SENT_ELSEWHERE = Return_Which.RESULTS_SENT_ELSEWHERE}
+  static __initStatic32() {this.TAKE_FROM_OTHER_QUESTION = Return_Which.TAKE_FROM_OTHER_QUESTION}
+  static __initStatic33() {this.ACCEPT_FROM_THIRD_PARTY = Return_Which.ACCEPT_FROM_THIRD_PARTY}
+  static __initStatic34() {this._capnp = {
+    displayName: "Return",
+    id: "9e19b28d3db3573a",
+    size: new (0, _chunkIVTBYMMNcjs.ObjectSize)(16, 1),
+    defaultReleaseParamCaps: _chunkIVTBYMMNcjs.getBitMask.call(void 0, true, 0),
+    defaultNoFinishNeeded: _chunkIVTBYMMNcjs.getBitMask.call(void 0, false, 1)
+  }}
+  /**
+  * Equal to the QuestionId of the corresponding `Call` message.
+  *
+  */
+  get answerId() {
+    return _chunkIVTBYMMNcjs.getUint32.call(void 0, 0, this);
+  }
+  set answerId(value) {
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 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 _chunkIVTBYMMNcjs.getBit.call(void 0, 32, this, _Return._capnp.defaultReleaseParamCaps);
+  }
+  set releaseParamCaps(value) {
+    _chunkIVTBYMMNcjs.setBit.call(void 0, 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 _chunkIVTBYMMNcjs.getBit.call(void 0, 33, this, _Return._capnp.defaultNoFinishNeeded);
+  }
+  set noFinishNeeded(value) {
+    _chunkIVTBYMMNcjs.setBit.call(void 0, 33, value, this, _Return._capnp.defaultNoFinishNeeded);
+  }
+  _adoptResults(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 6, 0, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownResults() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, 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() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "results", _chunkIVTBYMMNcjs.getUint16.call(void 0, 6, this), 0, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, Payload, this);
+  }
+  _hasResults() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initResults() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 6, 0, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, Payload, this);
+  }
+  get _isResults() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 6, this) === 0;
+  }
+  set results(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 6, 0, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptException(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 6, 1, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownException() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.exception);
+  }
+  /**
+  * Indicates that the call failed and explains why.
+  *
+  */
+  get exception() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "exception", _chunkIVTBYMMNcjs.getUint16.call(void 0, 6, this), 1, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, Exception, this);
+  }
+  _hasException() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initException() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 6, 1, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, Exception, this);
+  }
+  get _isException() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 6, this) === 1;
+  }
+  set exception(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 6, 1, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  get _isCanceled() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 6, this) === 2;
+  }
+  set canceled(_) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 6, 2, this);
+  }
+  get _isResultsSentElsewhere() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 6, this) === 3;
+  }
+  set resultsSentElsewhere(_) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 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() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "takeFromOtherQuestion", _chunkIVTBYMMNcjs.getUint16.call(void 0, 6, this), 4, this);
+    return _chunkIVTBYMMNcjs.getUint32.call(void 0, 8, this);
+  }
+  get _isTakeFromOtherQuestion() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 6, this) === 4;
+  }
+  set takeFromOtherQuestion(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 6, 4, this);
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 8, value, this);
+  }
+  _adoptAcceptFromThirdParty(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 6, 5, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownAcceptFromThirdParty() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, 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() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "acceptFromThirdParty", _chunkIVTBYMMNcjs.getUint16.call(void 0, 6, this), 5, this);
+    return _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this);
+  }
+  _hasAcceptFromThirdParty() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  get _isAcceptFromThirdParty() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 6, this) === 5;
+  }
+  set acceptFromThirdParty(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 6, 5, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  toString() {
+    return "Return_" + super.toString();
+  }
+  which() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 6, this);
+  }
+}, _class9.__initStatic28(), _class9.__initStatic29(), _class9.__initStatic30(), _class9.__initStatic31(), _class9.__initStatic32(), _class9.__initStatic33(), _class9.__initStatic34(), _class9);
+var Finish = (_class10 = class _Finish extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Finish");
+  }
+  static __initStatic35() {this._capnp = {
+    displayName: "Finish",
+    id: "d37d2eb2c2f80e63",
+    size: new (0, _chunkIVTBYMMNcjs.ObjectSize)(8, 0),
+    defaultReleaseResultCaps: _chunkIVTBYMMNcjs.getBitMask.call(void 0, true, 0),
+    defaultRequireEarlyCancellationWorkaround: _chunkIVTBYMMNcjs.getBitMask.call(void 0, true, 1)
+  }}
+  /**
+  * ID of the call whose result is to be released.
+  *
+  */
+  get questionId() {
+    return _chunkIVTBYMMNcjs.getUint32.call(void 0, 0, this);
+  }
+  set questionId(value) {
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 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 _chunkIVTBYMMNcjs.getBit.call(void 0, 32, this, _Finish._capnp.defaultReleaseResultCaps);
+  }
+  set releaseResultCaps(value) {
+    _chunkIVTBYMMNcjs.setBit.call(void 0, 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 _chunkIVTBYMMNcjs.getBit.call(void 0, 33, this, _Finish._capnp.defaultRequireEarlyCancellationWorkaround);
+  }
+  set requireEarlyCancellationWorkaround(value) {
+    _chunkIVTBYMMNcjs.setBit.call(void 0, 33, value, this, _Finish._capnp.defaultRequireEarlyCancellationWorkaround);
+  }
+  toString() {
+    return "Finish_" + super.toString();
+  }
+}, _class10.__initStatic35(), _class10);
+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 = (_class11 = class extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Resolve");
+  }
+  static __initStatic36() {this.CAP = Resolve_Which.CAP}
+  static __initStatic37() {this.EXCEPTION = Resolve_Which.EXCEPTION}
+  static __initStatic38() {this._capnp = {
+    displayName: "Resolve",
+    id: "bbc29655fa89086e",
+    size: new (0, _chunkIVTBYMMNcjs.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 _chunkIVTBYMMNcjs.getUint32.call(void 0, 0, this);
+  }
+  set promiseId(value) {
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 0, value, this);
+  }
+  _adoptCap(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 4, 0, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownCap() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, 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() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "cap", _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this), 0, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, CapDescriptor, this);
+  }
+  _hasCap() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initCap() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 4, 0, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, CapDescriptor, this);
+  }
+  get _isCap() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this) === 0;
+  }
+  set cap(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 4, 0, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptException(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 4, 1, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownException() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.exception);
+  }
+  /**
+  * Indicates that the promise was broken.
+  *
+  */
+  get exception() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "exception", _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this), 1, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, Exception, this);
+  }
+  _hasException() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initException() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 4, 1, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, Exception, this);
+  }
+  get _isException() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this) === 1;
+  }
+  set exception(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 4, 1, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  toString() {
+    return "Resolve_" + super.toString();
+  }
+  which() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this);
+  }
+}, _class11.__initStatic36(), _class11.__initStatic37(), _class11.__initStatic38(), _class11);
+var Release = (_class12 = class extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Release");
+  }
+  static __initStatic39() {this._capnp = {
+    displayName: "Release",
+    id: "ad1a6c0d7dd07497",
+    size: new (0, _chunkIVTBYMMNcjs.ObjectSize)(8, 0)
+  }}
+  /**
+  * What to release.
+  *
+  */
+  get id() {
+    return _chunkIVTBYMMNcjs.getUint32.call(void 0, 0, this);
+  }
+  set id(value) {
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 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 _chunkIVTBYMMNcjs.getUint32.call(void 0, 4, this);
+  }
+  set referenceCount(value) {
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 4, value, this);
+  }
+  toString() {
+    return "Release_" + super.toString();
+  }
+}, _class12.__initStatic39(), _class12);
+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 = (_class13 = class extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Disembargo_Context");
+  }
+  static __initStatic40() {this.SENDER_LOOPBACK = Disembargo_Context_Which.SENDER_LOOPBACK}
+  static __initStatic41() {this.RECEIVER_LOOPBACK = Disembargo_Context_Which.RECEIVER_LOOPBACK}
+  static __initStatic42() {this.ACCEPT = Disembargo_Context_Which.ACCEPT}
+  static __initStatic43() {this.PROVIDE = Disembargo_Context_Which.PROVIDE}
+  static __initStatic44() {this._capnp = {
+    displayName: "context",
+    id: "d562b4df655bdd4d",
+    size: new (0, _chunkIVTBYMMNcjs.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() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "senderLoopback", _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this), 0, this);
+    return _chunkIVTBYMMNcjs.getUint32.call(void 0, 0, this);
+  }
+  get _isSenderLoopback() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this) === 0;
+  }
+  set senderLoopback(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 4, 0, this);
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 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() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "receiverLoopback", _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this), 1, this);
+    return _chunkIVTBYMMNcjs.getUint32.call(void 0, 0, this);
+  }
+  get _isReceiverLoopback() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this) === 1;
+  }
+  set receiverLoopback(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 4, 1, this);
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 0, value, this);
+  }
+  get _isAccept() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this) === 2;
+  }
+  set accept(_) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 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() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "provide", _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this), 3, this);
+    return _chunkIVTBYMMNcjs.getUint32.call(void 0, 0, this);
+  }
+  get _isProvide() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this) === 3;
+  }
+  set provide(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 4, 3, this);
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 0, value, this);
+  }
+  toString() {
+    return "Disembargo_Context_" + super.toString();
+  }
+  which() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this);
+  }
+}, _class13.__initStatic40(), _class13.__initStatic41(), _class13.__initStatic42(), _class13.__initStatic43(), _class13.__initStatic44(), _class13);
+var Disembargo = (_class14 = class extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Disembargo");
+  }
+  static __initStatic45() {this._capnp = {
+    displayName: "Disembargo",
+    id: "f964368b0fbd3711",
+    size: new (0, _chunkIVTBYMMNcjs.ObjectSize)(8, 1)
+  }}
+  _adoptTarget(value) {
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownTarget() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.target);
+  }
+  /**
+  * What is to be disembargoed.
+  *
+  */
+  get target() {
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, MessageTarget, this);
+  }
+  _hasTarget() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initTarget() {
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, MessageTarget, this);
+  }
+  set target(value) {
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  get context() {
+    return _chunkIVTBYMMNcjs.getAs.call(void 0, Disembargo_Context, this);
+  }
+  _initContext() {
+    return _chunkIVTBYMMNcjs.getAs.call(void 0, Disembargo_Context, this);
+  }
+  toString() {
+    return "Disembargo_" + super.toString();
+  }
+}, _class14.__initStatic45(), _class14);
+var Provide = (_class15 = class extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Provide");
+  }
+  static __initStatic46() {this._capnp = {
+    displayName: "Provide",
+    id: "9c6a046bfbc1ac5a",
+    size: new (0, _chunkIVTBYMMNcjs.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 _chunkIVTBYMMNcjs.getUint32.call(void 0, 0, this);
+  }
+  set questionId(value) {
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 0, value, this);
+  }
+  _adoptTarget(value) {
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownTarget() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.target);
+  }
+  /**
+  * What is to be provided to the third party.
+  *
+  */
+  get target() {
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, MessageTarget, this);
+  }
+  _hasTarget() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initTarget() {
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, MessageTarget, this);
+  }
+  set target(value) {
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptRecipient(value) {
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 1, this));
+  }
+  _disownRecipient() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.recipient);
+  }
+  /**
+  * Identity of the third party that is expected to pick up the capability.
+  *
+  */
+  get recipient() {
+    return _chunkIVTBYMMNcjs.getPointer.call(void 0, 1, this);
+  }
+  _hasRecipient() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 1, this));
+  }
+  set recipient(value) {
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 1, this));
+  }
+  toString() {
+    return "Provide_" + super.toString();
+  }
+}, _class15.__initStatic46(), _class15);
+var Accept = (_class16 = class extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Accept");
+  }
+  static __initStatic47() {this._capnp = {
+    displayName: "Accept",
+    id: "d4c9b56290554016",
+    size: new (0, _chunkIVTBYMMNcjs.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 _chunkIVTBYMMNcjs.getUint32.call(void 0, 0, this);
+  }
+  set questionId(value) {
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 0, value, this);
+  }
+  _adoptProvision(value) {
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownProvision() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.provision);
+  }
+  /**
+  * Identifies the provided object to be picked up.
+  *
+  */
+  get provision() {
+    return _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this);
+  }
+  _hasProvision() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  set provision(value) {
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 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 _chunkIVTBYMMNcjs.getBit.call(void 0, 32, this);
+  }
+  set embargo(value) {
+    _chunkIVTBYMMNcjs.setBit.call(void 0, 32, value, this);
+  }
+  toString() {
+    return "Accept_" + super.toString();
+  }
+}, _class16.__initStatic47(), _class16);
+var Join = (_class17 = class extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Join");
+  }
+  static __initStatic48() {this._capnp = {
+    displayName: "Join",
+    id: "fbe1980490e001af",
+    size: new (0, _chunkIVTBYMMNcjs.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 _chunkIVTBYMMNcjs.getUint32.call(void 0, 0, this);
+  }
+  set questionId(value) {
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 0, value, this);
+  }
+  _adoptTarget(value) {
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownTarget() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.target);
+  }
+  /**
+  * The capability to join.
+  *
+  */
+  get target() {
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, MessageTarget, this);
+  }
+  _hasTarget() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initTarget() {
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, MessageTarget, this);
+  }
+  set target(value) {
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptKeyPart(value) {
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 1, this));
+  }
+  _disownKeyPart() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, 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 _chunkIVTBYMMNcjs.getPointer.call(void 0, 1, this);
+  }
+  _hasKeyPart() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 1, this));
+  }
+  set keyPart(value) {
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 1, this));
+  }
+  toString() {
+    return "Join_" + super.toString();
+  }
+}, _class17.__initStatic48(), _class17);
+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 = (_class18 = class extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "MessageTarget");
+  }
+  static __initStatic49() {this.IMPORTED_CAP = MessageTarget_Which.IMPORTED_CAP}
+  static __initStatic50() {this.PROMISED_ANSWER = MessageTarget_Which.PROMISED_ANSWER}
+  static __initStatic51() {this._capnp = {
+    displayName: "MessageTarget",
+    id: "95bc14545813fbc1",
+    size: new (0, _chunkIVTBYMMNcjs.ObjectSize)(8, 1)
+  }}
+  /**
+  * This message is to a capability or promise previously imported by the caller (exported by
+  * the receiver).
+  *
+  */
+  get importedCap() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "importedCap", _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this), 0, this);
+    return _chunkIVTBYMMNcjs.getUint32.call(void 0, 0, this);
+  }
+  get _isImportedCap() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this) === 0;
+  }
+  set importedCap(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 4, 0, this);
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 0, value, this);
+  }
+  _adoptPromisedAnswer(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 4, 1, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownPromisedAnswer() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, 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() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "promisedAnswer", _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this), 1, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, PromisedAnswer, this);
+  }
+  _hasPromisedAnswer() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initPromisedAnswer() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 4, 1, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, PromisedAnswer, this);
+  }
+  get _isPromisedAnswer() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this) === 1;
+  }
+  set promisedAnswer(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 4, 1, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  toString() {
+    return "MessageTarget_" + super.toString();
+  }
+  which() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this);
+  }
+}, _class18.__initStatic49(), _class18.__initStatic50(), _class18.__initStatic51(), _class18);
+var Payload = (_class19 = class _Payload extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Payload");
+  }
+  static __initStatic52() {this._capnp = {
+    displayName: "Payload",
+    id: "9a0e61223d96743b",
+    size: new (0, _chunkIVTBYMMNcjs.ObjectSize)(0, 2)
+  }}
+  
+  _adoptContent(value) {
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownContent() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.content);
+  }
+  /**
+  * Some Cap'n Proto data structure.  Capability pointers embedded in this structure index into
+  * `capTable`.
+  *
+  */
+  get content() {
+    return _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this);
+  }
+  _hasContent() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  set content(value) {
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptCapTable(value) {
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 1, this));
+  }
+  _disownCapTable() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.capTable);
+  }
+  /**
+  * Descriptors corresponding to the cap pointers in `content`.
+  *
+  */
+  get capTable() {
+    return _chunkIVTBYMMNcjs.getList.call(void 0, 1, _Payload._CapTable, this);
+  }
+  _hasCapTable() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 1, this));
+  }
+  _initCapTable(length) {
+    return _chunkIVTBYMMNcjs.initList.call(void 0, 1, _Payload._CapTable, length, this);
+  }
+  set capTable(value) {
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 1, this));
+  }
+  toString() {
+    return "Payload_" + super.toString();
+  }
+}, _class19.__initStatic52(), _class19);
+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 = (_class20 = class _CapDescriptor extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "CapDescriptor");
+  }
+  static __initStatic53() {this.NONE = CapDescriptor_Which.NONE}
+  static __initStatic54() {this.SENDER_HOSTED = CapDescriptor_Which.SENDER_HOSTED}
+  static __initStatic55() {this.SENDER_PROMISE = CapDescriptor_Which.SENDER_PROMISE}
+  static __initStatic56() {this.RECEIVER_HOSTED = CapDescriptor_Which.RECEIVER_HOSTED}
+  static __initStatic57() {this.RECEIVER_ANSWER = CapDescriptor_Which.RECEIVER_ANSWER}
+  static __initStatic58() {this.THIRD_PARTY_HOSTED = CapDescriptor_Which.THIRD_PARTY_HOSTED}
+  static __initStatic59() {this._capnp = {
+    displayName: "CapDescriptor",
+    id: "8523ddc40b86b8b0",
+    size: new (0, _chunkIVTBYMMNcjs.ObjectSize)(8, 1),
+    defaultAttachedFd: _chunkIVTBYMMNcjs.getUint8Mask.call(void 0, 255)
+  }}
+  get _isNone() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 0;
+  }
+  set none(_) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 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() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "senderHosted", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 1, this);
+    return _chunkIVTBYMMNcjs.getUint32.call(void 0, 4, this);
+  }
+  get _isSenderHosted() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 1;
+  }
+  set senderHosted(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 1, this);
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 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() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "senderPromise", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 2, this);
+    return _chunkIVTBYMMNcjs.getUint32.call(void 0, 4, this);
+  }
+  get _isSenderPromise() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 2;
+  }
+  set senderPromise(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 2, this);
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 4, value, this);
+  }
+  /**
+  * A capability (or promise) previously exported by the receiver (imported by the sender).
+  *
+  */
+  get receiverHosted() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "receiverHosted", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 3, this);
+    return _chunkIVTBYMMNcjs.getUint32.call(void 0, 4, this);
+  }
+  get _isReceiverHosted() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 3;
+  }
+  set receiverHosted(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 3, this);
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 4, value, this);
+  }
+  _adoptReceiverAnswer(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 4, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownReceiverAnswer() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.receiverAnswer);
+  }
+  /**
+  * A capability expected to be returned in the results of a currently-outstanding call posed
+  * by the sender.
+  *
+  */
+  get receiverAnswer() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "receiverAnswer", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 4, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, PromisedAnswer, this);
+  }
+  _hasReceiverAnswer() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initReceiverAnswer() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 4, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, PromisedAnswer, this);
+  }
+  get _isReceiverAnswer() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 4;
+  }
+  set receiverAnswer(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 4, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _adoptThirdPartyHosted(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 5, this);
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownThirdPartyHosted() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, 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() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "thirdPartyHosted", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 5, this);
+    return _chunkIVTBYMMNcjs.getStruct.call(void 0, 0, ThirdPartyCapDescriptor, this);
+  }
+  _hasThirdPartyHosted() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initThirdPartyHosted() {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 5, this);
+    return _chunkIVTBYMMNcjs.initStructAt.call(void 0, 0, ThirdPartyCapDescriptor, this);
+  }
+  get _isThirdPartyHosted() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 5;
+  }
+  set thirdPartyHosted(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 5, this);
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 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 _chunkIVTBYMMNcjs.getUint8.call(void 0, 2, this, _CapDescriptor._capnp.defaultAttachedFd);
+  }
+  set attachedFd(value) {
+    _chunkIVTBYMMNcjs.setUint8.call(void 0, 2, value, this, _CapDescriptor._capnp.defaultAttachedFd);
+  }
+  toString() {
+    return "CapDescriptor_" + super.toString();
+  }
+  which() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this);
+  }
+}, _class20.__initStatic53(), _class20.__initStatic54(), _class20.__initStatic55(), _class20.__initStatic56(), _class20.__initStatic57(), _class20.__initStatic58(), _class20.__initStatic59(), _class20);
+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 = (_class21 = class extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "PromisedAnswer_Op");
+  }
+  static __initStatic60() {this.NOOP = PromisedAnswer_Op_Which.NOOP}
+  static __initStatic61() {this.GET_POINTER_FIELD = PromisedAnswer_Op_Which.GET_POINTER_FIELD}
+  static __initStatic62() {this._capnp = {
+    displayName: "Op",
+    id: "f316944415569081",
+    size: new (0, _chunkIVTBYMMNcjs.ObjectSize)(8, 0)
+  }}
+  get _isNoop() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 0;
+  }
+  set noop(_) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 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() {
+    _chunkIVTBYMMNcjs.testWhich.call(void 0, "getPointerField", _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this), 1, this);
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 2, this);
+  }
+  get _isGetPointerField() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this) === 1;
+  }
+  set getPointerField(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 0, 1, this);
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 2, value, this);
+  }
+  toString() {
+    return "PromisedAnswer_Op_" + super.toString();
+  }
+  which() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 0, this);
+  }
+}, _class21.__initStatic60(), _class21.__initStatic61(), _class21.__initStatic62(), _class21);
+var PromisedAnswer = (_class22 = class _PromisedAnswer extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "PromisedAnswer");
+  }
+  static __initStatic63() {this.Op = PromisedAnswer_Op}
+  static __initStatic64() {this._capnp = {
+    displayName: "PromisedAnswer",
+    id: "d800b1d6cd6f1ca0",
+    size: new (0, _chunkIVTBYMMNcjs.ObjectSize)(8, 1)
+  }}
+  
+  /**
+  * 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 _chunkIVTBYMMNcjs.getUint32.call(void 0, 0, this);
+  }
+  set questionId(value) {
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 0, value, this);
+  }
+  _adoptTransform(value) {
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownTransform() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, 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 _chunkIVTBYMMNcjs.getList.call(void 0, 0, _PromisedAnswer._Transform, this);
+  }
+  _hasTransform() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _initTransform(length) {
+    return _chunkIVTBYMMNcjs.initList.call(void 0, 0, _PromisedAnswer._Transform, length, this);
+  }
+  set transform(value) {
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  toString() {
+    return "PromisedAnswer_" + super.toString();
+  }
+}, _class22.__initStatic63(), _class22.__initStatic64(), _class22);
+var ThirdPartyCapDescriptor = (_class23 = class extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "ThirdPartyCapDescriptor");
+  }
+  static __initStatic65() {this._capnp = {
+    displayName: "ThirdPartyCapDescriptor",
+    id: "d37007fde1f0027d",
+    size: new (0, _chunkIVTBYMMNcjs.ObjectSize)(8, 1)
+  }}
+  _adoptId(value) {
+    _chunkIVTBYMMNcjs.adopt.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  _disownId() {
+    return _chunkIVTBYMMNcjs.disown.call(void 0, this.id);
+  }
+  /**
+  * Identifies the third-party host and the specific capability to accept from it.
+  *
+  */
+  get id() {
+    return _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this);
+  }
+  _hasId() {
+    return !_chunkIVTBYMMNcjs.isNull.call(void 0, _chunkIVTBYMMNcjs.getPointer.call(void 0, 0, this));
+  }
+  set id(value) {
+    _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, _chunkIVTBYMMNcjs.getPointer.call(void 0, 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 _chunkIVTBYMMNcjs.getUint32.call(void 0, 0, this);
+  }
+  set vineId(value) {
+    _chunkIVTBYMMNcjs.setUint32.call(void 0, 0, value, this);
+  }
+  toString() {
+    return "ThirdPartyCapDescriptor_" + super.toString();
+  }
+}, _class23.__initStatic65(), _class23);
+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 = (_class24 = class extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Exception");
+  }
+  static __initStatic66() {this.Type = Exception_Type}
+  static __initStatic67() {this._capnp = {
+    displayName: "Exception",
+    id: "d625b7063acf691a",
+    size: new (0, _chunkIVTBYMMNcjs.ObjectSize)(8, 2)
+  }}
+  /**
+  * Human-readable failure description.
+  *
+  */
+  get reason() {
+    return _chunkIVTBYMMNcjs.getText.call(void 0, 0, this);
+  }
+  set reason(value) {
+    _chunkIVTBYMMNcjs.setText.call(void 0, 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 _chunkIVTBYMMNcjs.getUint16.call(void 0, 4, this);
+  }
+  set type(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 4, value, this);
+  }
+  /**
+  * OBSOLETE. Ignore.
+  *
+  */
+  get obsoleteIsCallersFault() {
+    return _chunkIVTBYMMNcjs.getBit.call(void 0, 0, this);
+  }
+  set obsoleteIsCallersFault(value) {
+    _chunkIVTBYMMNcjs.setBit.call(void 0, 0, value, this);
+  }
+  /**
+  * OBSOLETE. See `type` instead.
+  *
+  */
+  get obsoleteDurability() {
+    return _chunkIVTBYMMNcjs.getUint16.call(void 0, 2, this);
+  }
+  set obsoleteDurability(value) {
+    _chunkIVTBYMMNcjs.setUint16.call(void 0, 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 _chunkIVTBYMMNcjs.getText.call(void 0, 1, this);
+  }
+  set trace(value) {
+    _chunkIVTBYMMNcjs.setText.call(void 0, 1, value, this);
+  }
+  toString() {
+    return "Exception_" + super.toString();
+  }
+}, _class24.__initStatic66(), _class24.__initStatic67(), _class24);
+Payload._CapTable = _chunkIVTBYMMNcjs.CompositeList.call(void 0, CapDescriptor);
+PromisedAnswer._Transform = _chunkIVTBYMMNcjs.CompositeList.call(void 0, 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 = (_class25 = class extends _chunkIVTBYMMNcjs.Struct {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Void");
+  }
+  static __initStatic68() {this._capnp = {
+    displayName: "Void",
+    id: "0",
+    size: new (0, _chunkIVTBYMMNcjs.ObjectSize)(0, 0)
+  }}
+}, _class25.__initStatic68(), _class25);
+var utils = {
+  __proto__: null,
+  PointerAllocationResult: _chunkIVTBYMMNcjs.PointerAllocationResult,
+  add: _chunkIVTBYMMNcjs.add,
+  adopt: _chunkIVTBYMMNcjs.adopt,
+  checkDataBounds: _chunkIVTBYMMNcjs.checkDataBounds,
+  checkPointerBounds: _chunkIVTBYMMNcjs.checkPointerBounds,
+  copyFrom: _chunkIVTBYMMNcjs.copyFrom,
+  copyFromInterface: _chunkIVTBYMMNcjs.copyFromInterface,
+  copyFromList: _chunkIVTBYMMNcjs.copyFromList,
+  copyFromStruct: _chunkIVTBYMMNcjs.copyFromStruct,
+  disown: _chunkIVTBYMMNcjs.disown,
+  dump: _chunkIVTBYMMNcjs.dump,
+  erase: _chunkIVTBYMMNcjs.erase,
+  erasePointer: _chunkIVTBYMMNcjs.erasePointer,
+  followFar: _chunkIVTBYMMNcjs.followFar,
+  followFars: _chunkIVTBYMMNcjs.followFars,
+  getAs: _chunkIVTBYMMNcjs.getAs,
+  getBit: _chunkIVTBYMMNcjs.getBit,
+  getCapabilityId: _chunkIVTBYMMNcjs.getCapabilityId,
+  getContent: _chunkIVTBYMMNcjs.getContent,
+  getData: _chunkIVTBYMMNcjs.getData,
+  getDataSection: _chunkIVTBYMMNcjs.getDataSection,
+  getFarSegmentId: _chunkIVTBYMMNcjs.getFarSegmentId,
+  getFloat32: _chunkIVTBYMMNcjs.getFloat32,
+  getFloat64: _chunkIVTBYMMNcjs.getFloat64,
+  getInt16: _chunkIVTBYMMNcjs.getInt16,
+  getInt32: _chunkIVTBYMMNcjs.getInt32,
+  getInt64: _chunkIVTBYMMNcjs.getInt64,
+  getInt8: _chunkIVTBYMMNcjs.getInt8,
+  getInterfaceClientOrNull: _chunkIVTBYMMNcjs.getInterfaceClientOrNull,
+  getInterfaceClientOrNullAt: _chunkIVTBYMMNcjs.getInterfaceClientOrNullAt,
+  getInterfacePointer: _chunkIVTBYMMNcjs.getInterfacePointer,
+  getList: _chunkIVTBYMMNcjs.getList,
+  getListByteLength: _chunkIVTBYMMNcjs.getListByteLength,
+  getListElementByteLength: _chunkIVTBYMMNcjs.getListElementByteLength,
+  getListElementSize: _chunkIVTBYMMNcjs.getListElementSize,
+  getListLength: _chunkIVTBYMMNcjs.getListLength,
+  getOffsetWords: _chunkIVTBYMMNcjs.getOffsetWords,
+  getPointer: _chunkIVTBYMMNcjs.getPointer,
+  getPointerAs: _chunkIVTBYMMNcjs.getPointerAs,
+  getPointerSection: _chunkIVTBYMMNcjs.getPointerSection,
+  getPointerType: _chunkIVTBYMMNcjs.getPointerType,
+  getSize: _chunkIVTBYMMNcjs.getSize,
+  getStruct: _chunkIVTBYMMNcjs.getStruct,
+  getStructDataWords: _chunkIVTBYMMNcjs.getStructDataWords,
+  getStructPointerLength: _chunkIVTBYMMNcjs.getStructPointerLength,
+  getStructSize: _chunkIVTBYMMNcjs.getStructSize,
+  getTargetCompositeListSize: _chunkIVTBYMMNcjs.getTargetCompositeListSize,
+  getTargetCompositeListTag: _chunkIVTBYMMNcjs.getTargetCompositeListTag,
+  getTargetListElementSize: _chunkIVTBYMMNcjs.getTargetListElementSize,
+  getTargetListLength: _chunkIVTBYMMNcjs.getTargetListLength,
+  getTargetPointerType: _chunkIVTBYMMNcjs.getTargetPointerType,
+  getTargetStructSize: _chunkIVTBYMMNcjs.getTargetStructSize,
+  getText: _chunkIVTBYMMNcjs.getText,
+  getUint16: _chunkIVTBYMMNcjs.getUint16,
+  getUint32: _chunkIVTBYMMNcjs.getUint32,
+  getUint64: _chunkIVTBYMMNcjs.getUint64,
+  getUint8: _chunkIVTBYMMNcjs.getUint8,
+  initData: _chunkIVTBYMMNcjs.initData,
+  initList: _chunkIVTBYMMNcjs.initList,
+  initPointer: _chunkIVTBYMMNcjs.initPointer,
+  initStruct: _chunkIVTBYMMNcjs.initStruct,
+  initStructAt: _chunkIVTBYMMNcjs.initStructAt,
+  isDoubleFar: _chunkIVTBYMMNcjs.isDoubleFar,
+  isNull: _chunkIVTBYMMNcjs.isNull,
+  relocateTo: _chunkIVTBYMMNcjs.relocateTo,
+  resize: _chunkIVTBYMMNcjs.resize,
+  setBit: _chunkIVTBYMMNcjs.setBit,
+  setFarPointer: _chunkIVTBYMMNcjs.setFarPointer,
+  setFloat32: _chunkIVTBYMMNcjs.setFloat32,
+  setFloat64: _chunkIVTBYMMNcjs.setFloat64,
+  setInt16: _chunkIVTBYMMNcjs.setInt16,
+  setInt32: _chunkIVTBYMMNcjs.setInt32,
+  setInt64: _chunkIVTBYMMNcjs.setInt64,
+  setInt8: _chunkIVTBYMMNcjs.setInt8,
+  setInterfacePointer: _chunkIVTBYMMNcjs.setInterfacePointer,
+  setListPointer: _chunkIVTBYMMNcjs.setListPointer,
+  setStructPointer: _chunkIVTBYMMNcjs.setStructPointer,
+  setText: _chunkIVTBYMMNcjs.setText,
+  setUint16: _chunkIVTBYMMNcjs.setUint16,
+  setUint32: _chunkIVTBYMMNcjs.setUint32,
+  setUint64: _chunkIVTBYMMNcjs.setUint64,
+  setUint8: _chunkIVTBYMMNcjs.setUint8,
+  testWhich: _chunkIVTBYMMNcjs.testWhich,
+  trackPointerAllocation: _chunkIVTBYMMNcjs.trackPointerAllocation,
+  validate: _chunkIVTBYMMNcjs.validate
+};
+function PointerList(PointerClass) {
+  return (_class26 = class extends _chunkIVTBYMMNcjs.List {
+    static __initStatic69() {this._capnp = {
+      displayName: `List<${PointerClass._capnp.displayName}>`,
+      size: _chunkIVTBYMMNcjs.ListElementSize.POINTER
+    }}
+    get(index) {
+      const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+      return new PointerClass(
+        c.segment,
+        c.byteOffset + index * 8,
+        this._capnp.depthLimit - 1
+      );
+    }
+    set(index, value) {
+      _chunkIVTBYMMNcjs.copyFrom.call(void 0, value, this.get(index));
+    }
+    [Symbol.toStringTag]() {
+      return `Pointer_${super.toString()},cls:${PointerClass.toString()}`;
+    }
+  }, _class26.__initStatic69(), _class26);
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, PointerList, "PointerList");
+var AnyPointerList = PointerList(_chunkIVTBYMMNcjs.Pointer);
+var BoolList = (_class27 = class extends _chunkIVTBYMMNcjs.List {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "BoolList");
+  }
+  static __initStatic70() {this._capnp = {
+    displayName: "List<boolean>",
+    size: _chunkIVTBYMMNcjs.ListElementSize.BIT
+  }}
+  get(index) {
+    const bitMask = 1 << index % 8;
+    const byteOffset = index >>> 3;
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    const v = c.segment.getUint8(c.byteOffset + byteOffset);
+    return (v & bitMask) !== 0;
+  }
+  set(index, value) {
+    const bitMask = 1 << index % 8;
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, 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()}`;
+  }
+}, _class27.__initStatic70(), _class27);
+var DataList = PointerList(_chunkIVTBYMMNcjs.Data);
+var Float32List = (_class28 = class extends _chunkIVTBYMMNcjs.List {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Float32List");
+  }
+  static __initStatic71() {this._capnp = {
+    displayName: "List<Float32>",
+    size: _chunkIVTBYMMNcjs.ListElementSize.BYTE_4
+  }}
+  get(index) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    return c.segment.getFloat32(c.byteOffset + index * 4);
+  }
+  set(index, value) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    c.segment.setFloat32(c.byteOffset + index * 4, value);
+  }
+  [Symbol.toStringTag]() {
+    return `Float32_${super.toString()}`;
+  }
+}, _class28.__initStatic71(), _class28);
+var Float64List = (_class29 = class extends _chunkIVTBYMMNcjs.List {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Float64List");
+  }
+  static __initStatic72() {this._capnp = {
+    displayName: "List<Float64>",
+    size: _chunkIVTBYMMNcjs.ListElementSize.BYTE_8
+  }}
+  get(index) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    return c.segment.getFloat64(c.byteOffset + index * 8);
+  }
+  set(index, value) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    c.segment.setFloat64(c.byteOffset + index * 8, value);
+  }
+  [Symbol.toStringTag]() {
+    return `Float64_${super.toString()}`;
+  }
+}, _class29.__initStatic72(), _class29);
+var Int8List = (_class30 = class extends _chunkIVTBYMMNcjs.List {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Int8List");
+  }
+  static __initStatic73() {this._capnp = {
+    displayName: "List<Int8>",
+    size: _chunkIVTBYMMNcjs.ListElementSize.BYTE
+  }}
+  get(index) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    return c.segment.getInt8(c.byteOffset + index);
+  }
+  set(index, value) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    c.segment.setInt8(c.byteOffset + index, value);
+  }
+  [Symbol.toStringTag]() {
+    return `Int8_${super.toString()}`;
+  }
+}, _class30.__initStatic73(), _class30);
+var Int16List = (_class31 = class extends _chunkIVTBYMMNcjs.List {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Int16List");
+  }
+  static __initStatic74() {this._capnp = {
+    displayName: "List<Int16>",
+    size: _chunkIVTBYMMNcjs.ListElementSize.BYTE_2
+  }}
+  get(index) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    return c.segment.getInt16(c.byteOffset + index * 2);
+  }
+  set(index, value) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    c.segment.setInt16(c.byteOffset + index * 2, value);
+  }
+  [Symbol.toStringTag]() {
+    return `Int16_${super.toString()}`;
+  }
+}, _class31.__initStatic74(), _class31);
+var Int32List = (_class32 = class extends _chunkIVTBYMMNcjs.List {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Int32List");
+  }
+  static __initStatic75() {this._capnp = {
+    displayName: "List<Int32>",
+    size: _chunkIVTBYMMNcjs.ListElementSize.BYTE_4
+  }}
+  get(index) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    return c.segment.getInt32(c.byteOffset + index * 4);
+  }
+  set(index, value) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    c.segment.setInt32(c.byteOffset + index * 4, value);
+  }
+  [Symbol.toStringTag]() {
+    return `Int32_${super.toString()}`;
+  }
+}, _class32.__initStatic75(), _class32);
+var Int64List = (_class33 = class extends _chunkIVTBYMMNcjs.List {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Int64List");
+  }
+  static __initStatic76() {this._capnp = {
+    displayName: "List<Int64>",
+    size: _chunkIVTBYMMNcjs.ListElementSize.BYTE_8
+  }}
+  get(index) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    return c.segment.getInt64(c.byteOffset + index * 8);
+  }
+  set(index, value) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    c.segment.setInt64(c.byteOffset + index * 8, value);
+  }
+  [Symbol.toStringTag]() {
+    return `Int64_${super.toString()}`;
+  }
+}, _class33.__initStatic76(), _class33);
+var InterfaceList = PointerList(Interface);
+var TextList = (_class34 = class extends _chunkIVTBYMMNcjs.List {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "TextList");
+  }
+  static __initStatic77() {this._capnp = {
+    displayName: "List<Text>",
+    size: _chunkIVTBYMMNcjs.ListElementSize.POINTER
+  }}
+  get(index) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    c.byteOffset += index * 8;
+    return _chunkIVTBYMMNcjs.Text.fromPointer(c).get(0);
+  }
+  set(index, value) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    c.byteOffset += index * 8;
+    _chunkIVTBYMMNcjs.Text.fromPointer(c).set(0, value);
+  }
+  [Symbol.toStringTag]() {
+    return `Text_${super.toString()}`;
+  }
+}, _class34.__initStatic77(), _class34);
+var Uint8List = (_class35 = class extends _chunkIVTBYMMNcjs.List {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Uint8List");
+  }
+  static __initStatic78() {this._capnp = {
+    displayName: "List<Uint8>",
+    size: _chunkIVTBYMMNcjs.ListElementSize.BYTE
+  }}
+  get(index) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    return c.segment.getUint8(c.byteOffset + index);
+  }
+  set(index, value) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    c.segment.setUint8(c.byteOffset + index, value);
+  }
+  [Symbol.toStringTag]() {
+    return `Uint8_${super.toString()}`;
+  }
+}, _class35.__initStatic78(), _class35);
+var Uint16List = (_class36 = class extends _chunkIVTBYMMNcjs.List {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Uint16List");
+  }
+  static __initStatic79() {this._capnp = {
+    displayName: "List<Uint16>",
+    size: _chunkIVTBYMMNcjs.ListElementSize.BYTE_2
+  }}
+  get(index) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    return c.segment.getUint16(c.byteOffset + index * 2);
+  }
+  set(index, value) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    c.segment.setUint16(c.byteOffset + index * 2, value);
+  }
+  [Symbol.toStringTag]() {
+    return `Uint16_${super.toString()}`;
+  }
+}, _class36.__initStatic79(), _class36);
+var Uint32List = (_class37 = class extends _chunkIVTBYMMNcjs.List {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Uint32List");
+  }
+  static __initStatic80() {this._capnp = {
+    displayName: "List<Uint32>",
+    size: _chunkIVTBYMMNcjs.ListElementSize.BYTE_4
+  }}
+  get(index) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    return c.segment.getUint32(c.byteOffset + index * 4);
+  }
+  set(index, value) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    c.segment.setUint32(c.byteOffset + index * 4, value);
+  }
+  [Symbol.toStringTag]() {
+    return `Uint32_${super.toString()}`;
+  }
+}, _class37.__initStatic80(), _class37);
+var Uint64List = (_class38 = class extends _chunkIVTBYMMNcjs.List {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Uint64List");
+  }
+  static __initStatic81() {this._capnp = {
+    displayName: "List<Uint64>",
+    size: _chunkIVTBYMMNcjs.ListElementSize.BYTE_8
+  }}
+  get(index) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    return c.segment.getUint64(c.byteOffset + index * 8);
+  }
+  set(index, value) {
+    const c = _chunkIVTBYMMNcjs.getContent.call(void 0, this);
+    c.segment.setUint64(c.byteOffset + index * 8, value);
+  }
+  [Symbol.toStringTag]() {
+    return `Uint64_${super.toString()}`;
+  }
+}, _class38.__initStatic81(), _class38);
+var VoidList = PointerList(Void);
+function isSameClient(c, d) {
+  const norm = /* @__PURE__ */ _chunkIVTBYMMNcjs.__name.call(void 0, (c2) => {
+    return c2;
+  }, "norm");
+  return norm(c) === norm(d);
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, isSameClient, "isSameClient");
+function clientFromResolution(transform, obj, err) {
+  if (err) {
+    return new (0, _chunkIVTBYMMNcjs.ErrorClient)(err);
+  }
+  if (!obj) {
+    return new (0, _chunkIVTBYMMNcjs.ErrorClient)(new Error(`null obj!`));
+  }
+  const out = transformPtr(obj, transform);
+  return _chunkIVTBYMMNcjs.getInterfaceClientOrNull.call(void 0, out);
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, clientFromResolution, "clientFromResolution");
+var IDGen = (_class39 = class {constructor() { _class39.prototype.__init6.call(this);_class39.prototype.__init7.call(this); }
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "IDGen");
+  }
+  __init6() {this.i = 0}
+  __init7() {this.free = []}
+  next() {
+    return _nullishCoalesce(this.free.pop(), () => ( this.i++));
+  }
+  remove(i) {
+    this.free.push(i);
+  }
+}, _class39);
+var Ref = class {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, 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();
+      }
+    });
+  }
+  
+  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 {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "RefCount");
+  }
+  
+  
+  
+  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 (0, _chunkIVTBYMMNcjs.ErrorClient)(new Error(_chunkIVTBYMMNcjs.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 {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "RPCError");
+  }
+  constructor(exception) {
+    super(_chunkIVTBYMMNcjs.format.call(void 0, _chunkIVTBYMMNcjs.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;
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, toException, "toException");
+function newMessage() {
+  return new (0, _chunkIVTBYMMNcjs.Message)().initRoot(Message2);
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, newMessage, "newMessage");
+function newFinishMessage(questionID, release) {
+  const m = newMessage();
+  const f = m._initFinish();
+  f.questionId = questionID;
+  f.releaseResultCaps = release;
+  return m;
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, newFinishMessage, "newFinishMessage");
+function newUnimplementedMessage(m) {
+  const n = newMessage();
+  n.unimplemented = m;
+  return n;
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, newUnimplementedMessage, "newUnimplementedMessage");
+function newReturnMessage(id) {
+  const m = newMessage();
+  const ret = m._initReturn();
+  ret.answerId = id;
+  return m;
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, newReturnMessage, "newReturnMessage");
+function setReturnException(ret, err) {
+  const exc = ret._initException();
+  toException(exc, err);
+  return exc;
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, 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(_chunkIVTBYMMNcjs.INVARIANT_UNREACHABLE_CODE);
+    }
+  }
+  return m;
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, 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;
+  }
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, 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;
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, 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 = (_class40 = class {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "Question");
+  }
+  constructor(conn, id, method) {;_class40.prototype.__init8.call(this);_class40.prototype.__init9.call(this);_class40.prototype.__init10.call(this);_class40.prototype.__init11.call(this);
+    this.conn = conn;
+    this.id = id;
+    this.method = method;
+  }
+  __init8() {this.paramCaps = []}
+  __init9() {this.state = 0}
+  
+  
+  __init10() {this.derived = []}
+  __init11() {this.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(_chunkIVTBYMMNcjs.RPC_FULFILL_ALREADY_CALLED);
+    }
+    if (this.method) {
+      this.obj = _chunkIVTBYMMNcjs.getAs.call(void 0, 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(_chunkIVTBYMMNcjs.NOT_IMPLEMENTED);
+  }
+}, _class40);
+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;
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, transformsEqual, "transformsEqual");
+var Qcalls = class _Qcalls {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, 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_);
+  });
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, joinAnswer, "joinAnswer");
+var callQueueSize2 = 64;
+var QueueClient = class {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "QueueClient");
+  }
+  constructor(conn, client, calls) {
+    this.conn = conn;
+    this._client = client;
+    this.calls = Qcalls.copyOf(calls);
+    this.q = new Queue(this.calls, callQueueSize2);
+  }
+  
+  
+  
+  pushCall(call) {
+    const f = new Fulfiller();
+    try {
+      call = copyCall(call);
+    } catch (error_) {
+      return new (0, _chunkIVTBYMMNcjs.ErrorAnswer)(error_);
+    }
+    const i = this.q.push();
+    if (i === -1) {
+      return new (0, _chunkIVTBYMMNcjs.ErrorAnswer)(new Error(_chunkIVTBYMMNcjs.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(_chunkIVTBYMMNcjs.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 = (_class41 = class {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "AnswerEntry");
+  }
+  
+  
+  __init12() {this.resultCaps = []}
+  __init13() {this.done = false}
+  
+  
+  __init14() {this.deferred = new Deferred()}
+  __init15() {this.queue = []}
+  constructor(conn, id) {;_class41.prototype.__init12.call(this);_class41.prototype.__init13.call(this);_class41.prototype.__init14.call(this);_class41.prototype.__init15.call(this);
+    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(_chunkIVTBYMMNcjs.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(_chunkIVTBYMMNcjs.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(_chunkIVTBYMMNcjs.RPC_CALL_QUEUE_FULL);
+    }
+    const qcall = {
+      a,
+      call: copyCall(call)
+    };
+    const pcall = {
+      qcall,
+      transform
+    };
+    this.queue.push(pcall);
+  }
+}, _class41);
+function isRemoteCall(a) {
+  return !!a.a;
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, isRemoteCall, "isRemoteCall");
+function isLocalCall(a) {
+  return !!a.f;
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, isLocalCall, "isLocalCall");
+function isDisembargo(a) {
+  return !!a.embargoTarget;
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, isDisembargo, "isDisembargo");
+var ImportClient = (_class42 = class {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "ImportClient");
+  }
+  constructor(conn, id) {;_class42.prototype.__init16.call(this);
+    this.conn = conn;
+    this.id = id;
+  }
+  __init16() {this.closed = false}
+  call(cl) {
+    if (this.closed) {
+      return new (0, _chunkIVTBYMMNcjs.ErrorAnswer)(new Error(_chunkIVTBYMMNcjs.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() {
+  }
+}, _class42);
+var LocalAnswerClient = class {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, 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(_chunkIVTBYMMNcjs.NOT_IMPLEMENTED);
+  }
+};
+var ConnWeakRefRegistry = globalThis.FinalizationRegistry ? new FinalizationRegistry((cb) => cb()) : void 0;
+var ConDefaultFinalize = /* @__PURE__ */ _chunkIVTBYMMNcjs.__name.call(void 0, (obj, finalizer) => {
+  _optionalChain([ConnWeakRefRegistry, 'optionalAccess', _2 => _2.register, 'call', _3 => _3(obj, finalizer)]);
+}, "ConDefaultFinalize");
+var Conn = (_class43 = class {
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, 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) {;_class43.prototype.__init17.call(this);_class43.prototype.__init18.call(this);_class43.prototype.__init19.call(this);_class43.prototype.__init20.call(this);_class43.prototype.__init21.call(this);_class43.prototype.__init22.call(this);_class43.prototype.__init23.call(this);
+    this.transport = transport;
+    this.finalize = finalize;
+    this.startWork();
+  }
+  __init17() {this.questionID = new IDGen()}
+  __init18() {this.questions = []}
+  __init19() {this.answers = {}}
+  __init20() {this.exportID = new IDGen()}
+  __init21() {this.exports = []}
+  __init22() {this.imports = {}}
+  
+  
+  __init23() {this.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(_chunkIVTBYMMNcjs.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(_chunkIVTBYMMNcjs.RPC_QUESTION_ID_REUSED));
+    }
+    if (this.main === void 0) {
+      return a.reject(new Error(_chunkIVTBYMMNcjs.RPC_NO_MAIN_INTERFACE));
+    }
+    const msg = new (0, _chunkIVTBYMMNcjs.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(_chunkIVTBYMMNcjs.format.call(void 0, _chunkIVTBYMMNcjs.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(_chunkIVTBYMMNcjs.format.call(void 0, _chunkIVTBYMMNcjs.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 (e2) {
+      const um = newUnimplementedMessage(m);
+      this.sendMessage(um);
+      return;
+    }
+    const id = mcall.questionId;
+    const a = this.insertAnswer(id);
+    if (!a) {
+      throw new Error(_chunkIVTBYMMNcjs.format.call(void 0, _chunkIVTBYMMNcjs.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: _chunkIVTBYMMNcjs.getAs.call(void 0, 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(_chunkIVTBYMMNcjs.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(_chunkIVTBYMMNcjs.RPC_BAD_TARGET);
+        }
+        const pa = this.answers[id];
+        if (!pa) {
+          throw new Error(_chunkIVTBYMMNcjs.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(_chunkIVTBYMMNcjs.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(_chunkIVTBYMMNcjs.format.call(void 0, _chunkIVTBYMMNcjs.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(_chunkIVTBYMMNcjs.format.call(void 0, _chunkIVTBYMMNcjs.RPC_UNKNOWN_ANSWER_ID, id));
+          }
+          const recvTransform = recvAns.transform;
+          const transform = promisedAnswerOpsToTransform(recvTransform);
+          msg.addCap(answerPipelineClient(a, transform));
+          break;
+        }
+        default: {
+          throw new Error(_chunkIVTBYMMNcjs.format.call(void 0, _chunkIVTBYMMNcjs.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 _chunkIVTBYMMNcjs.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;
+      }
+    }
+  }
+}, _class43);
+function answerPipelineClient(a, transform) {
+  return new LocalAnswerClient(a, transform);
+}
+_chunkIVTBYMMNcjs.__name.call(void 0, answerPipelineClient, "answerPipelineClient");
+var DeferredTransport = (_class44 = class {constructor() { _class44.prototype.__init24.call(this);_class44.prototype.__init25.call(this);_class44.prototype.__init26.call(this); }
+  static {
+    _chunkIVTBYMMNcjs.__name.call(void 0, this, "DeferredTransport");
+  }
+  
+  __init24() {this.closed = false}
+  close() {
+    this.closed = true;
+    _optionalChain([this, 'access', _13 => _13.d, 'optionalAccess', _14 => _14.reject, 'call', _15 => _15()]);
+  }
+  recvMessage() {
+    if (this.closed) {
+      return Promise.reject();
+    }
+    if (this.d) {
+      this.d.reject();
+    }
+    this.d = new Deferred();
+    return this.d.promise;
+  }
+  __init25() {this.reject = /* @__PURE__ */ _chunkIVTBYMMNcjs.__name.call(void 0, (err) => {
+    _optionalChain([this, 'access', _16 => _16.d, 'optionalAccess', _17 => _17.reject, 'call', _18 => _18(err)]);
+  }, "reject")}
+  __init26() {this.resolve = /* @__PURE__ */ _chunkIVTBYMMNcjs.__name.call(void 0, (buf) => {
+    try {
+      _optionalChain([this, 'access', _19 => _19.d, 'optionalAccess', _20 => _20.resolve, 'call', _21 => _21(new (0, _chunkIVTBYMMNcjs.Message)(buf, false).getRoot(Message2))]);
+    } catch (error_) {
+      _optionalChain([this, 'access', _22 => _22.d, 'optionalAccess', _23 => _23.reject, 'call', _24 => _24(error_)]);
+    }
+  }, "resolve")}
+}, _class44);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.Interface = Interface; exports.isFuncCall = isFuncCall; exports.isDataCall = isDataCall; exports.copyCall = copyCall; exports.placeParams = placeParams; exports.Deferred = Deferred; exports.Pipeline = Pipeline; exports.Registry = Registry; exports.Server = Server; exports.Void = Void; exports.utils = utils; exports.PointerList = PointerList; exports.AnyPointerList = AnyPointerList; exports.BoolList = BoolList; exports.DataList = DataList; exports.Float32List = Float32List; exports.Float64List = Float64List; exports.Int8List = Int8List; exports.Int16List = Int16List; exports.Int32List = Int32List; exports.Int64List = Int64List; exports.InterfaceList = InterfaceList; exports.TextList = TextList; exports.Uint8List = Uint8List; exports.Uint16List = Uint16List; exports.Uint32List = Uint32List; exports.Uint64List = Uint64List; exports.VoidList = VoidList; exports.isSameClient = isSameClient; exports.clientFromResolution = clientFromResolution; exports.Conn = Conn; exports.answerPipelineClient = answerPipelineClient; exports.DeferredTransport = DeferredTransport;