{"version":3,"file":"rpc.mjs","names":["$.Struct","$.ObjectSize","$.getBitMask","$.getUint8Mask","$.CompositeList"],"sources":["../../schemas/rpc.ts"],"sourcesContent":["/* eslint-disable */\n// biome-ignore lint: disable\n// Generated by storm-capnpc\n// Note: Do not edit this file manually - it will be overwritten automatically\nimport * as $ from \"@stryke/capnp\";\nexport const _capnpFileId = BigInt(\"0xb312981b2552a250\");\nexport const Message_Which = {\n  /**\n* The sender previously received this message from the peer but didn't understand it or doesn't\n* yet implement the functionality that was requested.  So, the sender is echoing the message\n* back.  In some cases, the receiver may be able to recover from this by pretending the sender\n* had taken some appropriate \"null\" action.\n*\n* For example, say `resolve` is received by a level 0 implementation (because a previous call\n* or return happened to contain a promise).  The level 0 implementation will echo it back as\n* `unimplemented`.  The original sender can then simply release the cap to which the promise\n* had resolved, thus avoiding a leak.\n*\n* For any message type that introduces a question, if the message comes back unimplemented,\n* the original sender may simply treat it as if the question failed with an exception.\n*\n* In cases where there is no sensible way to react to an `unimplemented` message (without\n* resource leaks or other serious problems), the connection may need to be aborted.  This is\n* a gray area; different implementations may take different approaches.\n*\n*/\n  UNIMPLEMENTED: 0,\n  /**\n* Sent when a connection is being aborted due to an unrecoverable error.  This could be e.g.\n* because the sender received an invalid or nonsensical message or because the sender had an\n* internal error.  The sender will shut down the outgoing half of the connection after `abort`\n* and will completely close the connection shortly thereafter (it's up to the sender how much\n* of a time buffer they want to offer for the client to receive the `abort` before the\n* connection is reset).\n*\n*/\n  ABORT: 1,\n  /**\n* Request the peer's bootstrap interface.\n*\n*/\n  BOOTSTRAP: 8,\n  /**\n* Begin a method call.\n*\n*/\n  CALL: 2,\n  /**\n* Complete a method call.\n*\n*/\n  RETURN: 3,\n  /**\n* Release a returned answer / cancel a call.\n*\n*/\n  FINISH: 4,\n  /**\n* Resolve a previously-sent promise.\n*\n*/\n  RESOLVE: 5,\n  /**\n* Release a capability so that the remote object can be deallocated.\n*\n*/\n  RELEASE: 6,\n  /**\n* Lift an embargo used to enforce E-order over promise resolution.\n*\n*/\n  DISEMBARGO: 13,\n  /**\n* Obsolete request to save a capability, resulting in a SturdyRef. This has been replaced\n* by the `Persistent` interface defined in `persistent.capnp`. This operation was never\n* implemented.\n*\n*/\n  OBSOLETE_SAVE: 7,\n  /**\n* Obsolete way to delete a SturdyRef. This operation was never implemented.\n*\n*/\n  OBSOLETE_DELETE: 9,\n  /**\n* Provide a capability to a third party.\n*\n*/\n  PROVIDE: 10,\n  /**\n* Accept a capability provided by a third party.\n*\n*/\n  ACCEPT: 11,\n  /**\n* Directly connect to the common root of two or more proxied caps.\n*\n*/\n  JOIN: 12\n} as const;\nexport type Message_Which = (typeof Message_Which)[keyof typeof Message_Which];\n/**\n* An RPC connection is a bi-directional stream of Messages.\n*\n*/\nexport class Message extends $.Struct {\n  static readonly UNIMPLEMENTED = Message_Which.UNIMPLEMENTED;\n  static readonly ABORT = Message_Which.ABORT;\n  static readonly BOOTSTRAP = Message_Which.BOOTSTRAP;\n  static readonly CALL = Message_Which.CALL;\n  static readonly RETURN = Message_Which.RETURN;\n  static readonly FINISH = Message_Which.FINISH;\n  static readonly RESOLVE = Message_Which.RESOLVE;\n  static readonly RELEASE = Message_Which.RELEASE;\n  static readonly DISEMBARGO = Message_Which.DISEMBARGO;\n  static readonly OBSOLETE_SAVE = Message_Which.OBSOLETE_SAVE;\n  static readonly OBSOLETE_DELETE = Message_Which.OBSOLETE_DELETE;\n  static readonly PROVIDE = Message_Which.PROVIDE;\n  static readonly ACCEPT = Message_Which.ACCEPT;\n  static readonly JOIN = Message_Which.JOIN;\n  public static override readonly _capnp = {\n    displayName: \"Message\",\n    id: \"91b79f1f808db032\",\n    size: new $.ObjectSize(8, 1),\n  };\n  _adoptUnimplemented(value: $.Orphan<Message>): void {\n    $.utils.setUint16(0, 0, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownUnimplemented(): $.Orphan<Message> {\n    return $.utils.disown(this.unimplemented);\n  }\n  /**\n* The sender previously received this message from the peer but didn't understand it or doesn't\n* yet implement the functionality that was requested.  So, the sender is echoing the message\n* back.  In some cases, the receiver may be able to recover from this by pretending the sender\n* had taken some appropriate \"null\" action.\n*\n* For example, say `resolve` is received by a level 0 implementation (because a previous call\n* or return happened to contain a promise).  The level 0 implementation will echo it back as\n* `unimplemented`.  The original sender can then simply release the cap to which the promise\n* had resolved, thus avoiding a leak.\n*\n* For any message type that introduces a question, if the message comes back unimplemented,\n* the original sender may simply treat it as if the question failed with an exception.\n*\n* In cases where there is no sensible way to react to an `unimplemented` message (without\n* resource leaks or other serious problems), the connection may need to be aborted.  This is\n* a gray area; different implementations may take different approaches.\n*\n*/\n  get unimplemented(): Message {\n    $.utils.testWhich(\"unimplemented\", $.utils.getUint16(0, this), 0, this);\n    return $.utils.getStruct(0, Message, this);\n  }\n  _hasUnimplemented(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initUnimplemented(): Message {\n    $.utils.setUint16(0, 0, this);\n    return $.utils.initStructAt(0, Message, this);\n  }\n  get _isUnimplemented(): boolean {\n    return $.utils.getUint16(0, this) === 0;\n  }\n  set unimplemented(value: Message) {\n    $.utils.setUint16(0, 0, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptAbort(value: $.Orphan<Exception>): void {\n    $.utils.setUint16(0, 1, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownAbort(): $.Orphan<Exception> {\n    return $.utils.disown(this.abort);\n  }\n  /**\n* Sent when a connection is being aborted due to an unrecoverable error.  This could be e.g.\n* because the sender received an invalid or nonsensical message or because the sender had an\n* internal error.  The sender will shut down the outgoing half of the connection after `abort`\n* and will completely close the connection shortly thereafter (it's up to the sender how much\n* of a time buffer they want to offer for the client to receive the `abort` before the\n* connection is reset).\n*\n*/\n  get abort(): Exception {\n    $.utils.testWhich(\"abort\", $.utils.getUint16(0, this), 1, this);\n    return $.utils.getStruct(0, Exception, this);\n  }\n  _hasAbort(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initAbort(): Exception {\n    $.utils.setUint16(0, 1, this);\n    return $.utils.initStructAt(0, Exception, this);\n  }\n  get _isAbort(): boolean {\n    return $.utils.getUint16(0, this) === 1;\n  }\n  set abort(value: Exception) {\n    $.utils.setUint16(0, 1, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptBootstrap(value: $.Orphan<Bootstrap>): void {\n    $.utils.setUint16(0, 8, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownBootstrap(): $.Orphan<Bootstrap> {\n    return $.utils.disown(this.bootstrap);\n  }\n  /**\n* Request the peer's bootstrap interface.\n*\n*/\n  get bootstrap(): Bootstrap {\n    $.utils.testWhich(\"bootstrap\", $.utils.getUint16(0, this), 8, this);\n    return $.utils.getStruct(0, Bootstrap, this);\n  }\n  _hasBootstrap(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initBootstrap(): Bootstrap {\n    $.utils.setUint16(0, 8, this);\n    return $.utils.initStructAt(0, Bootstrap, this);\n  }\n  get _isBootstrap(): boolean {\n    return $.utils.getUint16(0, this) === 8;\n  }\n  set bootstrap(value: Bootstrap) {\n    $.utils.setUint16(0, 8, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptCall(value: $.Orphan<Call>): void {\n    $.utils.setUint16(0, 2, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownCall(): $.Orphan<Call> {\n    return $.utils.disown(this.call);\n  }\n  /**\n* Begin a method call.\n*\n*/\n  get call(): Call {\n    $.utils.testWhich(\"call\", $.utils.getUint16(0, this), 2, this);\n    return $.utils.getStruct(0, Call, this);\n  }\n  _hasCall(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initCall(): Call {\n    $.utils.setUint16(0, 2, this);\n    return $.utils.initStructAt(0, Call, this);\n  }\n  get _isCall(): boolean {\n    return $.utils.getUint16(0, this) === 2;\n  }\n  set call(value: Call) {\n    $.utils.setUint16(0, 2, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptReturn(value: $.Orphan<Return>): void {\n    $.utils.setUint16(0, 3, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownReturn(): $.Orphan<Return> {\n    return $.utils.disown(this.return);\n  }\n  /**\n* Complete a method call.\n*\n*/\n  get return(): Return {\n    $.utils.testWhich(\"return\", $.utils.getUint16(0, this), 3, this);\n    return $.utils.getStruct(0, Return, this);\n  }\n  _hasReturn(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initReturn(): Return {\n    $.utils.setUint16(0, 3, this);\n    return $.utils.initStructAt(0, Return, this);\n  }\n  get _isReturn(): boolean {\n    return $.utils.getUint16(0, this) === 3;\n  }\n  set return(value: Return) {\n    $.utils.setUint16(0, 3, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptFinish(value: $.Orphan<Finish>): void {\n    $.utils.setUint16(0, 4, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownFinish(): $.Orphan<Finish> {\n    return $.utils.disown(this.finish);\n  }\n  /**\n* Release a returned answer / cancel a call.\n*\n*/\n  get finish(): Finish {\n    $.utils.testWhich(\"finish\", $.utils.getUint16(0, this), 4, this);\n    return $.utils.getStruct(0, Finish, this);\n  }\n  _hasFinish(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initFinish(): Finish {\n    $.utils.setUint16(0, 4, this);\n    return $.utils.initStructAt(0, Finish, this);\n  }\n  get _isFinish(): boolean {\n    return $.utils.getUint16(0, this) === 4;\n  }\n  set finish(value: Finish) {\n    $.utils.setUint16(0, 4, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptResolve(value: $.Orphan<Resolve>): void {\n    $.utils.setUint16(0, 5, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownResolve(): $.Orphan<Resolve> {\n    return $.utils.disown(this.resolve);\n  }\n  /**\n* Resolve a previously-sent promise.\n*\n*/\n  get resolve(): Resolve {\n    $.utils.testWhich(\"resolve\", $.utils.getUint16(0, this), 5, this);\n    return $.utils.getStruct(0, Resolve, this);\n  }\n  _hasResolve(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initResolve(): Resolve {\n    $.utils.setUint16(0, 5, this);\n    return $.utils.initStructAt(0, Resolve, this);\n  }\n  get _isResolve(): boolean {\n    return $.utils.getUint16(0, this) === 5;\n  }\n  set resolve(value: Resolve) {\n    $.utils.setUint16(0, 5, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptRelease(value: $.Orphan<Release>): void {\n    $.utils.setUint16(0, 6, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownRelease(): $.Orphan<Release> {\n    return $.utils.disown(this.release);\n  }\n  /**\n* Release a capability so that the remote object can be deallocated.\n*\n*/\n  get release(): Release {\n    $.utils.testWhich(\"release\", $.utils.getUint16(0, this), 6, this);\n    return $.utils.getStruct(0, Release, this);\n  }\n  _hasRelease(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initRelease(): Release {\n    $.utils.setUint16(0, 6, this);\n    return $.utils.initStructAt(0, Release, this);\n  }\n  get _isRelease(): boolean {\n    return $.utils.getUint16(0, this) === 6;\n  }\n  set release(value: Release) {\n    $.utils.setUint16(0, 6, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptDisembargo(value: $.Orphan<Disembargo>): void {\n    $.utils.setUint16(0, 13, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownDisembargo(): $.Orphan<Disembargo> {\n    return $.utils.disown(this.disembargo);\n  }\n  /**\n* Lift an embargo used to enforce E-order over promise resolution.\n*\n*/\n  get disembargo(): Disembargo {\n    $.utils.testWhich(\"disembargo\", $.utils.getUint16(0, this), 13, this);\n    return $.utils.getStruct(0, Disembargo, this);\n  }\n  _hasDisembargo(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initDisembargo(): Disembargo {\n    $.utils.setUint16(0, 13, this);\n    return $.utils.initStructAt(0, Disembargo, this);\n  }\n  get _isDisembargo(): boolean {\n    return $.utils.getUint16(0, this) === 13;\n  }\n  set disembargo(value: Disembargo) {\n    $.utils.setUint16(0, 13, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptObsoleteSave(value: $.Orphan<$.Pointer>): void {\n    $.utils.setUint16(0, 7, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownObsoleteSave(): $.Orphan<$.Pointer> {\n    return $.utils.disown(this.obsoleteSave);\n  }\n  /**\n* Obsolete request to save a capability, resulting in a SturdyRef. This has been replaced\n* by the `Persistent` interface defined in `persistent.capnp`. This operation was never\n* implemented.\n*\n*/\n  get obsoleteSave(): $.Pointer {\n    $.utils.testWhich(\"obsoleteSave\", $.utils.getUint16(0, this), 7, this);\n    return $.utils.getPointer(0, this);\n  }\n  _hasObsoleteSave(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  get _isObsoleteSave(): boolean {\n    return $.utils.getUint16(0, this) === 7;\n  }\n  set obsoleteSave(value: $.Pointer) {\n    $.utils.setUint16(0, 7, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptObsoleteDelete(value: $.Orphan<$.Pointer>): void {\n    $.utils.setUint16(0, 9, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownObsoleteDelete(): $.Orphan<$.Pointer> {\n    return $.utils.disown(this.obsoleteDelete);\n  }\n  /**\n* Obsolete way to delete a SturdyRef. This operation was never implemented.\n*\n*/\n  get obsoleteDelete(): $.Pointer {\n    $.utils.testWhich(\"obsoleteDelete\", $.utils.getUint16(0, this), 9, this);\n    return $.utils.getPointer(0, this);\n  }\n  _hasObsoleteDelete(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  get _isObsoleteDelete(): boolean {\n    return $.utils.getUint16(0, this) === 9;\n  }\n  set obsoleteDelete(value: $.Pointer) {\n    $.utils.setUint16(0, 9, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptProvide(value: $.Orphan<Provide>): void {\n    $.utils.setUint16(0, 10, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownProvide(): $.Orphan<Provide> {\n    return $.utils.disown(this.provide);\n  }\n  /**\n* Provide a capability to a third party.\n*\n*/\n  get provide(): Provide {\n    $.utils.testWhich(\"provide\", $.utils.getUint16(0, this), 10, this);\n    return $.utils.getStruct(0, Provide, this);\n  }\n  _hasProvide(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initProvide(): Provide {\n    $.utils.setUint16(0, 10, this);\n    return $.utils.initStructAt(0, Provide, this);\n  }\n  get _isProvide(): boolean {\n    return $.utils.getUint16(0, this) === 10;\n  }\n  set provide(value: Provide) {\n    $.utils.setUint16(0, 10, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptAccept(value: $.Orphan<Accept>): void {\n    $.utils.setUint16(0, 11, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownAccept(): $.Orphan<Accept> {\n    return $.utils.disown(this.accept);\n  }\n  /**\n* Accept a capability provided by a third party.\n*\n*/\n  get accept(): Accept {\n    $.utils.testWhich(\"accept\", $.utils.getUint16(0, this), 11, this);\n    return $.utils.getStruct(0, Accept, this);\n  }\n  _hasAccept(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initAccept(): Accept {\n    $.utils.setUint16(0, 11, this);\n    return $.utils.initStructAt(0, Accept, this);\n  }\n  get _isAccept(): boolean {\n    return $.utils.getUint16(0, this) === 11;\n  }\n  set accept(value: Accept) {\n    $.utils.setUint16(0, 11, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptJoin(value: $.Orphan<Join>): void {\n    $.utils.setUint16(0, 12, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownJoin(): $.Orphan<Join> {\n    return $.utils.disown(this.join);\n  }\n  /**\n* Directly connect to the common root of two or more proxied caps.\n*\n*/\n  get join(): Join {\n    $.utils.testWhich(\"join\", $.utils.getUint16(0, this), 12, this);\n    return $.utils.getStruct(0, Join, this);\n  }\n  _hasJoin(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initJoin(): Join {\n    $.utils.setUint16(0, 12, this);\n    return $.utils.initStructAt(0, Join, this);\n  }\n  get _isJoin(): boolean {\n    return $.utils.getUint16(0, this) === 12;\n  }\n  set join(value: Join) {\n    $.utils.setUint16(0, 12, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  public override toString(): string { return \"Message_\" + super.toString(); }\n  which(): Message_Which {\n    return $.utils.getUint16(0, this) as Message_Which;\n  }\n}\n/**\n* **(level 0)**\n*\n* Get the \"bootstrap\" interface exported by the remote vat.\n*\n* For level 0, 1, and 2 implementations, the \"bootstrap\" interface is simply the main interface\n* exported by a vat. If the vat acts as a server fielding connections from clients, then the\n* bootstrap interface defines the basic functionality available to a client when it connects.\n* The exact interface definition obviously depends on the application.\n*\n* We call this a \"bootstrap\" because in an ideal Cap'n Proto world, bootstrap interfaces would\n* never be used. In such a world, any time you connect to a new vat, you do so because you\n* received an introduction from some other vat (see `ThirdPartyCapId`). Thus, the first message\n* you send is `Accept`, and further communications derive from there. `Bootstrap` is not used.\n*\n* In such an ideal world, DNS itself would support Cap'n Proto -- performing a DNS lookup would\n* actually return a new Cap'n Proto capability, thus introducing you to the target system via\n* level 3 RPC. Applications would receive the capability to talk to DNS in the first place as\n* an initial endowment or part of a Powerbox interaction. Therefore, an app can form arbitrary\n* connections without ever using `Bootstrap`.\n*\n* Of course, in the real world, DNS is not Cap'n-Proto-based, and we don't want Cap'n Proto to\n* require a whole new internet infrastructure to be useful. Therefore, we offer bootstrap\n* interfaces as a way to get up and running without a level 3 introduction. Thus, bootstrap\n* interfaces are used to \"bootstrap\" from other, non-Cap'n-Proto-based means of service discovery,\n* such as legacy DNS.\n*\n* Note that a vat need not provide a bootstrap interface, and in fact many vats (especially those\n* acting as clients) do not. In this case, the vat should either reply to `Bootstrap` with a\n* `Return` indicating an exception, or should return a dummy capability with no methods.\n*\n*/\nexport class Bootstrap extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"Bootstrap\",\n    id: \"e94ccf8031176ec4\",\n    size: new $.ObjectSize(8, 1),\n  };\n  /**\n* A new question ID identifying this request, which will eventually receive a Return message\n* containing the restored capability.\n*\n*/\n  get questionId(): number {\n    return $.utils.getUint32(0, this);\n  }\n  set questionId(value: number) {\n    $.utils.setUint32(0, value, this);\n  }\n  _adoptDeprecatedObjectId(value: $.Orphan<$.Pointer>): void {\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownDeprecatedObjectId(): $.Orphan<$.Pointer> {\n    return $.utils.disown(this.deprecatedObjectId);\n  }\n  /**\n* ** DEPRECATED **\n*\n* A Vat may export multiple bootstrap interfaces. In this case, `deprecatedObjectId` specifies\n* which one to return. If this pointer is null, then the default bootstrap interface is returned.\n*\n* As of version 0.5, use of this field is deprecated. If a service wants to export multiple\n* bootstrap interfaces, it should instead define a single bootstrap interface that has methods\n* that return each of the other interfaces.\n*\n* **History**\n*\n* In the first version of Cap'n Proto RPC (0.4.x) the `Bootstrap` message was called `Restore`.\n* At the time, it was thought that this would eventually serve as the way to restore SturdyRefs\n* (level 2). Meanwhile, an application could offer its \"main\" interface on a well-known\n* (non-secret) SturdyRef.\n*\n* Since level 2 RPC was not implemented at the time, the `Restore` message was in practice only\n* used to obtain the main interface. Since most applications had only one main interface that\n* they wanted to restore, they tended to designate this with a null `objectId`.\n*\n* Unfortunately, the earliest version of the EZ RPC interfaces set a precedent of exporting\n* multiple main interfaces by allowing them to be exported under string names. In this case,\n* `objectId` was a Text value specifying the name.\n*\n* All of this proved problematic for several reasons:\n*\n* - The arrangement assumed that a client wishing to restore a SturdyRef would know exactly what\n*   machine to connect to and would be able to immediately restore a SturdyRef on connection.\n*   However, in practice, the ability to restore SturdyRefs is itself a capability that may\n*   require going through an authentication process to obtain. Thus, it makes more sense to\n*   define a \"restorer service\" as a full Cap'n Proto interface. If this restorer interface is\n*   offered as the vat's bootstrap interface, then this is equivalent to the old arrangement.\n*\n* - Overloading \"Restore\" for the purpose of obtaining well-known capabilities encouraged the\n*   practice of exporting singleton services with string names. If singleton services are desired,\n*   it is better to have one main interface that has methods that can be used to obtain each\n*   service, in order to get all the usual benefits of schemas and type checking.\n*\n* - Overloading \"Restore\" also had a security problem: Often, \"main\" or \"well-known\"\n*   capabilities exported by a vat are in fact not public: they are intended to be accessed only\n*   by clients who are capable of forming a connection to the vat. This can lead to trouble if\n*   the client itself has other clients and wishes to forward some `Restore` requests from those\n*   external clients -- it has to be very careful not to allow through `Restore` requests\n*   addressing the default capability.\n*\n*   For example, consider the case of a sandboxed Sandstorm application and its supervisor. The\n*   application exports a default capability to its supervisor that provides access to\n*   functionality that only the supervisor is supposed to access. Meanwhile, though, applications\n*   may publish other capabilities that may be persistent, in which case the application needs\n*   to field `Restore` requests that could come from anywhere. These requests of course have to\n*   pass through the supervisor, as all communications with the outside world must. But, the\n*   supervisor has to be careful not to honor an external request addressing the application's\n*   default capability, since this capability is privileged. Unfortunately, the default\n*   capability cannot be given an unguessable name, because then the supervisor itself would not\n*   be able to address it!\n*\n* As of Cap'n Proto 0.5, `Restore` has been renamed to `Bootstrap` and is no longer planned for\n* use in restoring SturdyRefs.\n*\n* Note that 0.4 also defined a message type called `Delete` that, like `Restore`, addressed a\n* SturdyRef, but indicated that the client would not restore the ref again in the future. This\n* operation was never implemented, so it was removed entirely. If a \"delete\" operation is desired,\n* it should exist as a method on the same interface that handles restoring SturdyRefs. However,\n* the utility of such an operation is questionable. You wouldn't be able to rely on it for\n* garbage collection since a client could always disappear permanently without remembering to\n* delete all its SturdyRefs, thus leaving them dangling forever. Therefore, it is advisable to\n* design systems such that SturdyRefs never represent \"owned\" pointers.\n*\n* For example, say a SturdyRef points to an image file hosted on some server. That image file\n* should also live inside a collection (a gallery, perhaps) hosted on the same server, owned by\n* a user who can delete the image at any time. If the user deletes the image, the SturdyRef\n* stops working. On the other hand, if the SturdyRef is discarded, this has no effect on the\n* existence of the image in its collection.\n*\n*/\n  get deprecatedObjectId(): $.Pointer {\n    return $.utils.getPointer(0, this);\n  }\n  _hasDeprecatedObjectId(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  set deprecatedObjectId(value: $.Pointer) {\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  public override toString(): string { return \"Bootstrap_\" + super.toString(); }\n}\nexport const Call_SendResultsTo_Which = {\n  /**\n* Send the return message back to the caller (the usual).\n*\n*/\n  CALLER: 0,\n  /**\n* **(level 1)**\n*\n* Don't actually return the results to the sender.  Instead, hold on to them and await\n* instructions from the sender regarding what to do with them.  In particular, the sender\n* may subsequently send a `Return` for some other call (which the receiver had previously made\n* to the sender) with `takeFromOtherQuestion` set.  The results from this call are then used\n* as the results of the other call.\n*\n* When `yourself` is used, the receiver must still send a `Return` for the call, but sets the\n* field `resultsSentElsewhere` in that `Return` rather than including the results.\n*\n* This feature can be used to implement tail calls in which a call from Vat A to Vat B ends up\n* returning the result of a call from Vat B back to Vat A.\n*\n* In particular, the most common use case for this feature is when Vat A makes a call to a\n* promise in Vat B, and then that promise ends up resolving to a capability back in Vat A.\n* Vat B must forward all the queued calls on that promise back to Vat A, but can set `yourself`\n* in the calls so that the results need not pass back through Vat B.\n*\n* For example:\n* - Alice, in Vat A, calls foo() on Bob in Vat B.\n* - Alice makes a pipelined call bar() on the promise returned by foo().\n* - Later on, Bob resolves the promise from foo() to point at Carol, who lives in Vat A (next\n*   to Alice).\n* - Vat B dutifully forwards the bar() call to Carol.  Let us call this forwarded call bar'().\n*   Notice that bar() and bar'() are travelling in opposite directions on the same network\n*   link.\n* - The `Call` for bar'() has `sendResultsTo` set to `yourself`.\n* - Vat B sends a `Return` for bar() with `takeFromOtherQuestion` set in place of the results,\n*   with the value set to the question ID of bar'().  Vat B does not wait for bar'() to return,\n*   as doing so would introduce unnecessary round trip latency.\n* - Vat A receives bar'() and delivers it to Carol.\n* - When bar'() returns, Vat A sends a `Return` for bar'() to Vat B, with `resultsSentElsewhere`\n*   set in place of results.\n* - Vat A sends a `Finish` for the bar() call to Vat B.\n* - Vat B receives the `Finish` for bar() and sends a `Finish` for bar'().\n*\n*/\n  YOURSELF: 1,\n  /**\n* **(level 3)**\n*\n* The call's result should be returned to a different vat.  The receiver (the callee) expects\n* to receive an `Accept` message from the indicated vat, and should return the call's result\n* to it, rather than to the sender of the `Call`.\n*\n* This operates much like `yourself`, above, except that Carol is in a separate Vat C.  `Call`\n* messages are sent from Vat A -> Vat B and Vat B -> Vat C.  A `Return` message is sent from\n* Vat B -> Vat A that contains `acceptFromThirdParty` in place of results.  When Vat A sends\n* an `Accept` to Vat C, it receives back a `Return` containing the call's actual result.  Vat C\n* also sends a `Return` to Vat B with `resultsSentElsewhere`.\n*\n*/\n  THIRD_PARTY: 2\n} as const;\nexport type Call_SendResultsTo_Which = (typeof Call_SendResultsTo_Which)[keyof typeof Call_SendResultsTo_Which];\n/**\n* Where should the return message be sent?\n*\n*/\nexport class Call_SendResultsTo extends $.Struct {\n  static readonly CALLER = Call_SendResultsTo_Which.CALLER;\n  static readonly YOURSELF = Call_SendResultsTo_Which.YOURSELF;\n  static readonly THIRD_PARTY = Call_SendResultsTo_Which.THIRD_PARTY;\n  public static override readonly _capnp = {\n    displayName: \"sendResultsTo\",\n    id: \"dae8b0f61aab5f99\",\n    size: new $.ObjectSize(24, 3),\n  };\n  get _isCaller(): boolean {\n    return $.utils.getUint16(6, this) === 0;\n  }\n  set caller(_: true) {\n    $.utils.setUint16(6, 0, this);\n  }\n  get _isYourself(): boolean {\n    return $.utils.getUint16(6, this) === 1;\n  }\n  set yourself(_: true) {\n    $.utils.setUint16(6, 1, this);\n  }\n  _adoptThirdParty(value: $.Orphan<$.Pointer>): void {\n    $.utils.setUint16(6, 2, this);\n    $.utils.adopt(value, $.utils.getPointer(2, this));\n  }\n  _disownThirdParty(): $.Orphan<$.Pointer> {\n    return $.utils.disown(this.thirdParty);\n  }\n  /**\n* **(level 3)**\n*\n* The call's result should be returned to a different vat.  The receiver (the callee) expects\n* to receive an `Accept` message from the indicated vat, and should return the call's result\n* to it, rather than to the sender of the `Call`.\n*\n* This operates much like `yourself`, above, except that Carol is in a separate Vat C.  `Call`\n* messages are sent from Vat A -> Vat B and Vat B -> Vat C.  A `Return` message is sent from\n* Vat B -> Vat A that contains `acceptFromThirdParty` in place of results.  When Vat A sends\n* an `Accept` to Vat C, it receives back a `Return` containing the call's actual result.  Vat C\n* also sends a `Return` to Vat B with `resultsSentElsewhere`.\n*\n*/\n  get thirdParty(): $.Pointer {\n    $.utils.testWhich(\"thirdParty\", $.utils.getUint16(6, this), 2, this);\n    return $.utils.getPointer(2, this);\n  }\n  _hasThirdParty(): boolean {\n    return !$.utils.isNull($.utils.getPointer(2, this));\n  }\n  get _isThirdParty(): boolean {\n    return $.utils.getUint16(6, this) === 2;\n  }\n  set thirdParty(value: $.Pointer) {\n    $.utils.setUint16(6, 2, this);\n    $.utils.copyFrom(value, $.utils.getPointer(2, this));\n  }\n  public override toString(): string { return \"Call_SendResultsTo_\" + super.toString(); }\n  which(): Call_SendResultsTo_Which {\n    return $.utils.getUint16(6, this) as Call_SendResultsTo_Which;\n  }\n}\n/**\n* **(level 0)**\n*\n* Message type initiating a method call on a capability.\n*\n*/\nexport class Call extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"Call\",\n    id: \"836a53ce789d4cd4\",\n    size: new $.ObjectSize(24, 3),\n    defaultAllowThirdPartyTailCall: $.getBitMask(false, 0),\n    defaultNoPromisePipelining: $.getBitMask(false, 1),\n    defaultOnlyPromisePipeline: $.getBitMask(false, 2)\n  };\n  /**\n* A number, chosen by the caller, that identifies this call in future messages.  This number\n* must be different from all other calls originating from the same end of the connection (but\n* may overlap with question IDs originating from the opposite end).  A fine strategy is to use\n* sequential question IDs, but the recipient should not assume this.\n*\n* A question ID can be reused once both:\n* - A matching Return has been received from the callee.\n* - A matching Finish has been sent from the caller.\n*\n*/\n  get questionId(): number {\n    return $.utils.getUint32(0, this);\n  }\n  set questionId(value: number) {\n    $.utils.setUint32(0, value, this);\n  }\n  _adoptTarget(value: $.Orphan<MessageTarget>): void {\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownTarget(): $.Orphan<MessageTarget> {\n    return $.utils.disown(this.target);\n  }\n  /**\n* The object that should receive this call.\n*\n*/\n  get target(): MessageTarget {\n    return $.utils.getStruct(0, MessageTarget, this);\n  }\n  _hasTarget(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initTarget(): MessageTarget {\n    return $.utils.initStructAt(0, MessageTarget, this);\n  }\n  set target(value: MessageTarget) {\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  /**\n* The type ID of the interface being called.  Each capability may implement multiple interfaces.\n*\n*/\n  get interfaceId(): bigint {\n    return $.utils.getUint64(8, this);\n  }\n  set interfaceId(value: bigint) {\n    $.utils.setUint64(8, value, this);\n  }\n  /**\n* The ordinal number of the method to call within the requested interface.\n*\n*/\n  get methodId(): number {\n    return $.utils.getUint16(4, this);\n  }\n  set methodId(value: number) {\n    $.utils.setUint16(4, value, this);\n  }\n  /**\n* Indicates whether or not the receiver is allowed to send a `Return` containing\n* `acceptFromThirdParty`.  Level 3 implementations should set this true.  Otherwise, the callee\n* will have to proxy the return in the case of a tail call to a third-party vat.\n*\n*/\n  get allowThirdPartyTailCall(): boolean {\n    return $.utils.getBit(128, this, Call._capnp.defaultAllowThirdPartyTailCall);\n  }\n  set allowThirdPartyTailCall(value: boolean) {\n    $.utils.setBit(128, value, this, Call._capnp.defaultAllowThirdPartyTailCall);\n  }\n  /**\n* If true, the sender promises that it won't make any promise-pipelined calls on the results of\n* this call. If it breaks this promise, the receiver may throw an arbitrary error from such\n* calls.\n*\n* The receiver may use this as an optimization, by skipping the bookkeeping needed for pipelining\n* when no pipelined calls are expected. The sender typically sets this to false when the method's\n* schema does not specify any return capabilities.\n*\n*/\n  get noPromisePipelining(): boolean {\n    return $.utils.getBit(129, this, Call._capnp.defaultNoPromisePipelining);\n  }\n  set noPromisePipelining(value: boolean) {\n    $.utils.setBit(129, value, this, Call._capnp.defaultNoPromisePipelining);\n  }\n  /**\n* If true, the sender only plans to use this call to make pipelined calls. The receiver need not\n* send a `Return` message (but is still allowed to do so).\n*\n* Since the sender does not know whether a `Return` will be sent, it must release all state\n* related to the call when it sends `Finish`. However, in the case that the callee does not\n* recognize this hint and chooses to send a `Return`, then technically the caller is not allowed\n* to reuse the question ID until it receives said `Return`. This creates a conundrum: How does\n* the caller decide when it's OK to reuse the ID? To sidestep the problem, the C++ implementation\n* uses high-numbered IDs (with the high-order bit set) for such calls, and cycles through the\n* IDs in order. If all 2^31 IDs in this space are used without ever seeing a `Return`, then the\n* implementation assumes that the other end is in fact honoring the hint, and the ID counter is\n* allowed to loop around. If a `Return` is ever seen when `onlyPromisePipeline` was set, then\n* the implementation stops using this hint.\n*\n*/\n  get onlyPromisePipeline(): boolean {\n    return $.utils.getBit(130, this, Call._capnp.defaultOnlyPromisePipeline);\n  }\n  set onlyPromisePipeline(value: boolean) {\n    $.utils.setBit(130, value, this, Call._capnp.defaultOnlyPromisePipeline);\n  }\n  _adoptParams(value: $.Orphan<Payload>): void {\n    $.utils.adopt(value, $.utils.getPointer(1, this));\n  }\n  _disownParams(): $.Orphan<Payload> {\n    return $.utils.disown(this.params);\n  }\n  /**\n* The call parameters.  `params.content` is a struct whose fields correspond to the parameters of\n* the method.\n*\n*/\n  get params(): Payload {\n    return $.utils.getStruct(1, Payload, this);\n  }\n  _hasParams(): boolean {\n    return !$.utils.isNull($.utils.getPointer(1, this));\n  }\n  _initParams(): Payload {\n    return $.utils.initStructAt(1, Payload, this);\n  }\n  set params(value: Payload) {\n    $.utils.copyFrom(value, $.utils.getPointer(1, this));\n  }\n  /**\n* Where should the return message be sent?\n*\n*/\n  get sendResultsTo(): Call_SendResultsTo {\n    return $.utils.getAs(Call_SendResultsTo, this);\n  }\n  _initSendResultsTo(): Call_SendResultsTo {\n    return $.utils.getAs(Call_SendResultsTo, this);\n  }\n  public override toString(): string { return \"Call_\" + super.toString(); }\n}\nexport const Return_Which = {\n  /**\n* Equal to the QuestionId of the corresponding `Call` message.\n*\n*/\n  RESULTS: 0,\n  /**\n* If true, all capabilities that were in the params should be considered released.  The sender\n* must not send separate `Release` messages for them.  Level 0 implementations in particular\n* should always set this true.  This defaults true because if level 0 implementations forget to\n* set it they'll never notice (just silently leak caps), but if level >=1 implementations forget\n* to set it to false they'll quickly get errors.\n*\n* The receiver should act as if the sender had sent a release message with count=1 for each\n* CapDescriptor in the original Call message.\n*\n*/\n  EXCEPTION: 1,\n  /**\n* The result.\n*\n* For regular method calls, `results.content` points to the result struct.\n*\n* For a `Return` in response to an `Accept` or `Bootstrap`, `results` contains a single\n* capability (rather than a struct), and `results.content` is just a capability pointer with\n* index 0.  A `Finish` is still required in this case.\n*\n*/\n  CANCELED: 2,\n  /**\n* Indicates that the call failed and explains why.\n*\n*/\n  RESULTS_SENT_ELSEWHERE: 3,\n  /**\n* Indicates that the call was canceled due to the caller sending a Finish message\n* before the call had completed.\n*\n*/\n  TAKE_FROM_OTHER_QUESTION: 4,\n  /**\n* This is set when returning from a `Call` that had `sendResultsTo` set to something other\n* than `caller`.\n*\n* It doesn't matter too much when this is sent, as the receiver doesn't need to do anything\n* with it, but the C++ implementation appears to wait for the call to finish before sending\n* this.\n*\n*/\n  ACCEPT_FROM_THIRD_PARTY: 5\n} as const;\nexport type Return_Which = (typeof Return_Which)[keyof typeof Return_Which];\n/**\n* **(level 0)**\n*\n* Message type sent from callee to caller indicating that the call has completed.\n*\n*/\nexport class Return extends $.Struct {\n  static readonly RESULTS = Return_Which.RESULTS;\n  static readonly EXCEPTION = Return_Which.EXCEPTION;\n  static readonly CANCELED = Return_Which.CANCELED;\n  static readonly RESULTS_SENT_ELSEWHERE = Return_Which.RESULTS_SENT_ELSEWHERE;\n  static readonly TAKE_FROM_OTHER_QUESTION = Return_Which.TAKE_FROM_OTHER_QUESTION;\n  static readonly ACCEPT_FROM_THIRD_PARTY = Return_Which.ACCEPT_FROM_THIRD_PARTY;\n  public static override readonly _capnp = {\n    displayName: \"Return\",\n    id: \"9e19b28d3db3573a\",\n    size: new $.ObjectSize(16, 1),\n    defaultReleaseParamCaps: $.getBitMask(true, 0),\n    defaultNoFinishNeeded: $.getBitMask(false, 1)\n  };\n  /**\n* Equal to the QuestionId of the corresponding `Call` message.\n*\n*/\n  get answerId(): number {\n    return $.utils.getUint32(0, this);\n  }\n  set answerId(value: number) {\n    $.utils.setUint32(0, value, this);\n  }\n  /**\n* If true, all capabilities that were in the params should be considered released.  The sender\n* must not send separate `Release` messages for them.  Level 0 implementations in particular\n* should always set this true.  This defaults true because if level 0 implementations forget to\n* set it they'll never notice (just silently leak caps), but if level >=1 implementations forget\n* to set it to false they'll quickly get errors.\n*\n* The receiver should act as if the sender had sent a release message with count=1 for each\n* CapDescriptor in the original Call message.\n*\n*/\n  get releaseParamCaps(): boolean {\n    return $.utils.getBit(32, this, Return._capnp.defaultReleaseParamCaps);\n  }\n  set releaseParamCaps(value: boolean) {\n    $.utils.setBit(32, value, this, Return._capnp.defaultReleaseParamCaps);\n  }\n  /**\n* If true, the sender does not need the receiver to send a `Finish` message; its answer table\n* entry has already been cleaned up. This implies that the results do not contain any\n* capabilities, since the `Finish` message would normally release those capabilities from\n* promise pipelining responsibility. The caller may still send a `Finish` message if it wants,\n* which will be silently ignored by the callee.\n*\n*/\n  get noFinishNeeded(): boolean {\n    return $.utils.getBit(33, this, Return._capnp.defaultNoFinishNeeded);\n  }\n  set noFinishNeeded(value: boolean) {\n    $.utils.setBit(33, value, this, Return._capnp.defaultNoFinishNeeded);\n  }\n  _adoptResults(value: $.Orphan<Payload>): void {\n    $.utils.setUint16(6, 0, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownResults(): $.Orphan<Payload> {\n    return $.utils.disown(this.results);\n  }\n  /**\n* The result.\n*\n* For regular method calls, `results.content` points to the result struct.\n*\n* For a `Return` in response to an `Accept` or `Bootstrap`, `results` contains a single\n* capability (rather than a struct), and `results.content` is just a capability pointer with\n* index 0.  A `Finish` is still required in this case.\n*\n*/\n  get results(): Payload {\n    $.utils.testWhich(\"results\", $.utils.getUint16(6, this), 0, this);\n    return $.utils.getStruct(0, Payload, this);\n  }\n  _hasResults(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initResults(): Payload {\n    $.utils.setUint16(6, 0, this);\n    return $.utils.initStructAt(0, Payload, this);\n  }\n  get _isResults(): boolean {\n    return $.utils.getUint16(6, this) === 0;\n  }\n  set results(value: Payload) {\n    $.utils.setUint16(6, 0, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptException(value: $.Orphan<Exception>): void {\n    $.utils.setUint16(6, 1, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownException(): $.Orphan<Exception> {\n    return $.utils.disown(this.exception);\n  }\n  /**\n* Indicates that the call failed and explains why.\n*\n*/\n  get exception(): Exception {\n    $.utils.testWhich(\"exception\", $.utils.getUint16(6, this), 1, this);\n    return $.utils.getStruct(0, Exception, this);\n  }\n  _hasException(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initException(): Exception {\n    $.utils.setUint16(6, 1, this);\n    return $.utils.initStructAt(0, Exception, this);\n  }\n  get _isException(): boolean {\n    return $.utils.getUint16(6, this) === 1;\n  }\n  set exception(value: Exception) {\n    $.utils.setUint16(6, 1, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  get _isCanceled(): boolean {\n    return $.utils.getUint16(6, this) === 2;\n  }\n  set canceled(_: true) {\n    $.utils.setUint16(6, 2, this);\n  }\n  get _isResultsSentElsewhere(): boolean {\n    return $.utils.getUint16(6, this) === 3;\n  }\n  set resultsSentElsewhere(_: true) {\n    $.utils.setUint16(6, 3, this);\n  }\n  /**\n* The sender has also sent (before this message) a `Call` with the given question ID and with\n* `sendResultsTo.yourself` set, and the results of that other call should be used as the\n* results here.  `takeFromOtherQuestion` can only used once per question.\n*\n*/\n  get takeFromOtherQuestion(): number {\n    $.utils.testWhich(\"takeFromOtherQuestion\", $.utils.getUint16(6, this), 4, this);\n    return $.utils.getUint32(8, this);\n  }\n  get _isTakeFromOtherQuestion(): boolean {\n    return $.utils.getUint16(6, this) === 4;\n  }\n  set takeFromOtherQuestion(value: number) {\n    $.utils.setUint16(6, 4, this);\n    $.utils.setUint32(8, value, this);\n  }\n  _adoptAcceptFromThirdParty(value: $.Orphan<$.Pointer>): void {\n    $.utils.setUint16(6, 5, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownAcceptFromThirdParty(): $.Orphan<$.Pointer> {\n    return $.utils.disown(this.acceptFromThirdParty);\n  }\n  /**\n* **(level 3)**\n*\n* The caller should contact a third-party vat to pick up the results.  An `Accept` message\n* sent to the vat will return the result.  This pairs with `Call.sendResultsTo.thirdParty`.\n* It should only be used if the corresponding `Call` had `allowThirdPartyTailCall` set.\n*\n*/\n  get acceptFromThirdParty(): $.Pointer {\n    $.utils.testWhich(\"acceptFromThirdParty\", $.utils.getUint16(6, this), 5, this);\n    return $.utils.getPointer(0, this);\n  }\n  _hasAcceptFromThirdParty(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  get _isAcceptFromThirdParty(): boolean {\n    return $.utils.getUint16(6, this) === 5;\n  }\n  set acceptFromThirdParty(value: $.Pointer) {\n    $.utils.setUint16(6, 5, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  public override toString(): string { return \"Return_\" + super.toString(); }\n  which(): Return_Which {\n    return $.utils.getUint16(6, this) as Return_Which;\n  }\n}\n/**\n* **(level 0)**\n*\n* Message type sent from the caller to the callee to indicate:\n* 1) The questionId will no longer be used in any messages sent by the callee (no further\n*    pipelined requests).\n* 2) If the call has not returned yet, the caller no longer cares about the result.  If nothing\n*    else cares about the result either (e.g. there are no other outstanding calls pipelined on\n*    the result of this one) then the callee may wish to immediately cancel the operation and\n*    send back a Return message with \"canceled\" set.  However, implementations are not required\n*    to support premature cancellation -- instead, the implementation may wait until the call\n*    actually completes and send a normal `Return` message.\n*\n* TODO(someday): Should we separate (1) and implicitly releasing result capabilities?  It would be\n*   possible and useful to notify the server that it doesn't need to keep around the response to\n*   service pipeline requests even though the caller still wants to receive it / hasn't yet\n*   finished processing it.  It could also be useful to notify the server that it need not marshal\n*   the results because the caller doesn't want them anyway, even if the caller is still sending\n*   pipelined calls, although this seems less useful (just saving some bytes on the wire).\n*\n*/\nexport class Finish extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"Finish\",\n    id: \"d37d2eb2c2f80e63\",\n    size: new $.ObjectSize(8, 0),\n    defaultReleaseResultCaps: $.getBitMask(true, 0),\n    defaultRequireEarlyCancellationWorkaround: $.getBitMask(true, 1)\n  };\n  /**\n* ID of the call whose result is to be released.\n*\n*/\n  get questionId(): number {\n    return $.utils.getUint32(0, this);\n  }\n  set questionId(value: number) {\n    $.utils.setUint32(0, value, this);\n  }\n  /**\n* If true, all capabilities that were in the results should be considered released.  The sender\n* must not send separate `Release` messages for them.  Level 0 implementations in particular\n* should always set this true.  This defaults true because if level 0 implementations forget to\n* set it they'll never notice (just silently leak caps), but if level >=1 implementations forget\n* set it false they'll quickly get errors.\n*\n*/\n  get releaseResultCaps(): boolean {\n    return $.utils.getBit(32, this, Finish._capnp.defaultReleaseResultCaps);\n  }\n  set releaseResultCaps(value: boolean) {\n    $.utils.setBit(32, value, this, Finish._capnp.defaultReleaseResultCaps);\n  }\n  /**\n* If true, if the RPC system receives this Finish message before the original call has even been\n* delivered, it should defer cancellation util after delivery. In particular, this gives the\n* destination object a chance to opt out of cancellation, e.g. as controlled by the\n* `allowCancellation` annotation defined in `c++.capnp`.\n*\n* This is a work-around. Versions 1.0 and up of Cap'n Proto always set this to false. However,\n* older versions of Cap'n Proto unintentionally exhibited this errant behavior by default, and\n* as a result programs built with older versions could be inadvertently relying on their peers\n* to implement the behavior. The purpose of this flag is to let newer versions know when the\n* peer is an older version, so that it can attempt to work around the issue.\n*\n* See also comments in handleFinish() in rpc.c++ for more details.\n*\n*/\n  get requireEarlyCancellationWorkaround(): boolean {\n    return $.utils.getBit(33, this, Finish._capnp.defaultRequireEarlyCancellationWorkaround);\n  }\n  set requireEarlyCancellationWorkaround(value: boolean) {\n    $.utils.setBit(33, value, this, Finish._capnp.defaultRequireEarlyCancellationWorkaround);\n  }\n  public override toString(): string { return \"Finish_\" + super.toString(); }\n}\nexport const Resolve_Which = {\n  /**\n* The ID of the promise to be resolved.\n*\n* Unlike all other instances of `ExportId` sent from the exporter, the `Resolve` message does\n* _not_ increase the reference count of `promiseId`.  In fact, it is expected that the receiver\n* will release the export soon after receiving `Resolve`, and the sender will not send this\n* `ExportId` again until it has been released and recycled.\n*\n* When an export ID sent over the wire (e.g. in a `CapDescriptor`) is indicated to be a promise,\n* this indicates that the sender will follow up at some point with a `Resolve` message.  If the\n* same `promiseId` is sent again before `Resolve`, still only one `Resolve` is sent.  If the\n* same ID is sent again later _after_ a `Resolve`, it can only be because the export's\n* reference count hit zero in the meantime and the ID was re-assigned to a new export, therefore\n* this later promise does _not_ correspond to the earlier `Resolve`.\n*\n* If a promise ID's reference count reaches zero before a `Resolve` is sent, the `Resolve`\n* message may or may not still be sent (the `Resolve` may have already been in-flight when\n* `Release` was sent, but if the `Release` is received before `Resolve` then there is no longer\n* any reason to send a `Resolve`).  Thus a `Resolve` may be received for a promise of which\n* the receiver has no knowledge, because it already released it earlier.  In this case, the\n* receiver should simply release the capability to which the promise resolved.\n*\n*/\n  CAP: 0,\n  /**\n* The object to which the promise resolved.\n*\n* The sender promises that from this point forth, until `promiseId` is released, it shall\n* simply forward all messages to the capability designated by `cap`.  This is true even if\n* `cap` itself happens to designate another promise, and that other promise later resolves --\n* messages sent to `promiseId` shall still go to that other promise, not to its resolution.\n* This is important in the case that the receiver of the `Resolve` ends up sending a\n* `Disembargo` message towards `promiseId` in order to control message ordering -- that\n* `Disembargo` really needs to reflect back to exactly the object designated by `cap` even\n* if that object is itself a promise.\n*\n*/\n  EXCEPTION: 1\n} as const;\nexport type Resolve_Which = (typeof Resolve_Which)[keyof typeof Resolve_Which];\n/**\n* **(level 1)**\n*\n* Message type sent to indicate that a previously-sent promise has now been resolved to some other\n* object (possibly another promise) -- or broken, or canceled.\n*\n* Keep in mind that it's possible for a `Resolve` to be sent to a level 0 implementation that\n* doesn't implement it.  For example, a method call or return might contain a capability in the\n* payload.  Normally this is fine even if the receiver is level 0, because they will implicitly\n* release all such capabilities on return / finish.  But if the cap happens to be a promise, then\n* a follow-up `Resolve` may be sent regardless of this release.  The level 0 receiver will reply\n* with an `unimplemented` message, and the sender (of the `Resolve`) can respond to this as if the\n* receiver had immediately released any capability to which the promise resolved.\n*\n* When implementing promise resolution, it's important to understand how embargos work and the\n* tricky case of the Tribble 4-way race condition. See the comments for the Disembargo message,\n* below.\n*\n*/\nexport class Resolve extends $.Struct {\n  static readonly CAP = Resolve_Which.CAP;\n  static readonly EXCEPTION = Resolve_Which.EXCEPTION;\n  public static override readonly _capnp = {\n    displayName: \"Resolve\",\n    id: \"bbc29655fa89086e\",\n    size: new $.ObjectSize(8, 1),\n  };\n  /**\n* The ID of the promise to be resolved.\n*\n* Unlike all other instances of `ExportId` sent from the exporter, the `Resolve` message does\n* _not_ increase the reference count of `promiseId`.  In fact, it is expected that the receiver\n* will release the export soon after receiving `Resolve`, and the sender will not send this\n* `ExportId` again until it has been released and recycled.\n*\n* When an export ID sent over the wire (e.g. in a `CapDescriptor`) is indicated to be a promise,\n* this indicates that the sender will follow up at some point with a `Resolve` message.  If the\n* same `promiseId` is sent again before `Resolve`, still only one `Resolve` is sent.  If the\n* same ID is sent again later _after_ a `Resolve`, it can only be because the export's\n* reference count hit zero in the meantime and the ID was re-assigned to a new export, therefore\n* this later promise does _not_ correspond to the earlier `Resolve`.\n*\n* If a promise ID's reference count reaches zero before a `Resolve` is sent, the `Resolve`\n* message may or may not still be sent (the `Resolve` may have already been in-flight when\n* `Release` was sent, but if the `Release` is received before `Resolve` then there is no longer\n* any reason to send a `Resolve`).  Thus a `Resolve` may be received for a promise of which\n* the receiver has no knowledge, because it already released it earlier.  In this case, the\n* receiver should simply release the capability to which the promise resolved.\n*\n*/\n  get promiseId(): number {\n    return $.utils.getUint32(0, this);\n  }\n  set promiseId(value: number) {\n    $.utils.setUint32(0, value, this);\n  }\n  _adoptCap(value: $.Orphan<CapDescriptor>): void {\n    $.utils.setUint16(4, 0, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownCap(): $.Orphan<CapDescriptor> {\n    return $.utils.disown(this.cap);\n  }\n  /**\n* The object to which the promise resolved.\n*\n* The sender promises that from this point forth, until `promiseId` is released, it shall\n* simply forward all messages to the capability designated by `cap`.  This is true even if\n* `cap` itself happens to designate another promise, and that other promise later resolves --\n* messages sent to `promiseId` shall still go to that other promise, not to its resolution.\n* This is important in the case that the receiver of the `Resolve` ends up sending a\n* `Disembargo` message towards `promiseId` in order to control message ordering -- that\n* `Disembargo` really needs to reflect back to exactly the object designated by `cap` even\n* if that object is itself a promise.\n*\n*/\n  get cap(): CapDescriptor {\n    $.utils.testWhich(\"cap\", $.utils.getUint16(4, this), 0, this);\n    return $.utils.getStruct(0, CapDescriptor, this);\n  }\n  _hasCap(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initCap(): CapDescriptor {\n    $.utils.setUint16(4, 0, this);\n    return $.utils.initStructAt(0, CapDescriptor, this);\n  }\n  get _isCap(): boolean {\n    return $.utils.getUint16(4, this) === 0;\n  }\n  set cap(value: CapDescriptor) {\n    $.utils.setUint16(4, 0, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptException(value: $.Orphan<Exception>): void {\n    $.utils.setUint16(4, 1, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownException(): $.Orphan<Exception> {\n    return $.utils.disown(this.exception);\n  }\n  /**\n* Indicates that the promise was broken.\n*\n*/\n  get exception(): Exception {\n    $.utils.testWhich(\"exception\", $.utils.getUint16(4, this), 1, this);\n    return $.utils.getStruct(0, Exception, this);\n  }\n  _hasException(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initException(): Exception {\n    $.utils.setUint16(4, 1, this);\n    return $.utils.initStructAt(0, Exception, this);\n  }\n  get _isException(): boolean {\n    return $.utils.getUint16(4, this) === 1;\n  }\n  set exception(value: Exception) {\n    $.utils.setUint16(4, 1, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  public override toString(): string { return \"Resolve_\" + super.toString(); }\n  which(): Resolve_Which {\n    return $.utils.getUint16(4, this) as Resolve_Which;\n  }\n}\n/**\n* **(level 1)**\n*\n* Message type sent to indicate that the sender is done with the given capability and the receiver\n* can free resources allocated to it.\n*\n*/\nexport class Release extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"Release\",\n    id: \"ad1a6c0d7dd07497\",\n    size: new $.ObjectSize(8, 0),\n  };\n  /**\n* What to release.\n*\n*/\n  get id(): number {\n    return $.utils.getUint32(0, this);\n  }\n  set id(value: number) {\n    $.utils.setUint32(0, value, this);\n  }\n  /**\n* The amount by which to decrement the reference count.  The export is only actually released\n* when the reference count reaches zero.\n*\n*/\n  get referenceCount(): number {\n    return $.utils.getUint32(4, this);\n  }\n  set referenceCount(value: number) {\n    $.utils.setUint32(4, value, this);\n  }\n  public override toString(): string { return \"Release_\" + super.toString(); }\n}\nexport const Disembargo_Context_Which = {\n  /**\n* The sender is requesting a disembargo on a promise that is known to resolve back to a\n* capability hosted by the sender.  As soon as the receiver has echoed back all pipelined calls\n* on this promise, it will deliver the Disembargo back to the sender with `receiverLoopback`\n* set to the same value as `senderLoopback`.  This value is chosen by the sender, and since\n* it is also consumed be the sender, the sender can use whatever strategy it wants to make sure\n* the value is unambiguous.\n*\n* The receiver must verify that the target capability actually resolves back to the sender's\n* vat.  Otherwise, the sender has committed a protocol error and should be disconnected.\n*\n*/\n  SENDER_LOOPBACK: 0,\n  /**\n* The receiver previously sent a `senderLoopback` Disembargo towards a promise resolving to\n* this capability, and that Disembargo is now being echoed back.\n*\n*/\n  RECEIVER_LOOPBACK: 1,\n  /**\n* **(level 3)**\n*\n* The sender is requesting a disembargo on a promise that is known to resolve to a third-party\n* capability that the sender is currently in the process of accepting (using `Accept`).\n* The receiver of this `Disembargo` has an outstanding `Provide` on said capability.  The\n* receiver should now send a `Disembargo` with `provide` set to the question ID of that\n* `Provide` message.\n*\n* See `Accept.embargo` for an example.\n*\n*/\n  ACCEPT: 2,\n  /**\n* **(level 3)**\n*\n* The sender is requesting a disembargo on a capability currently being provided to a third\n* party.  The question ID identifies the `Provide` message previously sent by the sender to\n* this capability.  On receipt, the receiver (the capability host) shall release the embargo\n* on the `Accept` message that it has received from the third party.  See `Accept.embargo` for\n* an example.\n*\n*/\n  PROVIDE: 3\n} as const;\nexport type Disembargo_Context_Which = (typeof Disembargo_Context_Which)[keyof typeof Disembargo_Context_Which];\nexport class Disembargo_Context extends $.Struct {\n  static readonly SENDER_LOOPBACK = Disembargo_Context_Which.SENDER_LOOPBACK;\n  static readonly RECEIVER_LOOPBACK = Disembargo_Context_Which.RECEIVER_LOOPBACK;\n  static readonly ACCEPT = Disembargo_Context_Which.ACCEPT;\n  static readonly PROVIDE = Disembargo_Context_Which.PROVIDE;\n  public static override readonly _capnp = {\n    displayName: \"context\",\n    id: \"d562b4df655bdd4d\",\n    size: new $.ObjectSize(8, 1),\n  };\n  /**\n* The sender is requesting a disembargo on a promise that is known to resolve back to a\n* capability hosted by the sender.  As soon as the receiver has echoed back all pipelined calls\n* on this promise, it will deliver the Disembargo back to the sender with `receiverLoopback`\n* set to the same value as `senderLoopback`.  This value is chosen by the sender, and since\n* it is also consumed be the sender, the sender can use whatever strategy it wants to make sure\n* the value is unambiguous.\n*\n* The receiver must verify that the target capability actually resolves back to the sender's\n* vat.  Otherwise, the sender has committed a protocol error and should be disconnected.\n*\n*/\n  get senderLoopback(): number {\n    $.utils.testWhich(\"senderLoopback\", $.utils.getUint16(4, this), 0, this);\n    return $.utils.getUint32(0, this);\n  }\n  get _isSenderLoopback(): boolean {\n    return $.utils.getUint16(4, this) === 0;\n  }\n  set senderLoopback(value: number) {\n    $.utils.setUint16(4, 0, this);\n    $.utils.setUint32(0, value, this);\n  }\n  /**\n* The receiver previously sent a `senderLoopback` Disembargo towards a promise resolving to\n* this capability, and that Disembargo is now being echoed back.\n*\n*/\n  get receiverLoopback(): number {\n    $.utils.testWhich(\"receiverLoopback\", $.utils.getUint16(4, this), 1, this);\n    return $.utils.getUint32(0, this);\n  }\n  get _isReceiverLoopback(): boolean {\n    return $.utils.getUint16(4, this) === 1;\n  }\n  set receiverLoopback(value: number) {\n    $.utils.setUint16(4, 1, this);\n    $.utils.setUint32(0, value, this);\n  }\n  get _isAccept(): boolean {\n    return $.utils.getUint16(4, this) === 2;\n  }\n  set accept(_: true) {\n    $.utils.setUint16(4, 2, this);\n  }\n  /**\n* **(level 3)**\n*\n* The sender is requesting a disembargo on a capability currently being provided to a third\n* party.  The question ID identifies the `Provide` message previously sent by the sender to\n* this capability.  On receipt, the receiver (the capability host) shall release the embargo\n* on the `Accept` message that it has received from the third party.  See `Accept.embargo` for\n* an example.\n*\n*/\n  get provide(): number {\n    $.utils.testWhich(\"provide\", $.utils.getUint16(4, this), 3, this);\n    return $.utils.getUint32(0, this);\n  }\n  get _isProvide(): boolean {\n    return $.utils.getUint16(4, this) === 3;\n  }\n  set provide(value: number) {\n    $.utils.setUint16(4, 3, this);\n    $.utils.setUint32(0, value, this);\n  }\n  public override toString(): string { return \"Disembargo_Context_\" + super.toString(); }\n  which(): Disembargo_Context_Which {\n    return $.utils.getUint16(4, this) as Disembargo_Context_Which;\n  }\n}\n/**\n* **(level 1)**\n*\n* Message sent to indicate that an embargo on a recently-resolved promise may now be lifted.\n*\n* Embargos are used to enforce E-order in the presence of promise resolution.  That is, if an\n* application makes two calls foo() and bar() on the same capability reference, in that order,\n* the calls should be delivered in the order in which they were made.  But if foo() is called\n* on a promise, and that promise happens to resolve before bar() is called, then the two calls\n* may travel different paths over the network, and thus could arrive in the wrong order.  In\n* this case, the call to `bar()` must be embargoed, and a `Disembargo` message must be sent along\n* the same path as `foo()` to ensure that the `Disembargo` arrives after `foo()`.  Once the\n* `Disembargo` arrives, `bar()` can then be delivered.\n*\n* There are two particular cases where embargos are important.  Consider object Alice, in Vat A,\n* who holds a promise P, pointing towards Vat B, that eventually resolves to Carol.  The two\n* cases are:\n* - Carol lives in Vat A, i.e. next to Alice.  In this case, Vat A needs to send a `Disembargo`\n*   message that echos through Vat B and back, to ensure that all pipelined calls on the promise\n*   have been delivered.\n* - Carol lives in a different Vat C.  When the promise resolves, a three-party handoff occurs\n*   (see `Provide` and `Accept`, which constitute level 3 of the protocol).  In this case, we\n*   piggyback on the state that has already been set up to handle the handoff:  the `Accept`\n*   message (from Vat A to Vat C) is embargoed, as are all pipelined messages sent to it, while\n*   a `Disembargo` message is sent from Vat A through Vat B to Vat C.  See `Accept.embargo` for\n*   an example.\n*\n* Note that in the case where Carol actually lives in Vat B (i.e., the same vat that the promise\n* already pointed at), no embargo is needed, because the pipelined calls are delivered over the\n* same path as the later direct calls.\n*\n* Keep in mind that promise resolution happens both in the form of Resolve messages as well as\n* Return messages (which resolve PromisedAnswers). Embargos apply in both cases.\n*\n* An alternative strategy for enforcing E-order over promise resolution could be for Vat A to\n* implement the embargo internally.  When Vat A is notified of promise resolution, it could\n* send a dummy no-op call to promise P and wait for it to complete.  Until that call completes,\n* all calls to the capability are queued locally.  This strategy works, but is pessimistic:\n* in the three-party case, it requires an A -> B -> C -> B -> A round trip before calls can start\n* being delivered directly to from Vat A to Vat C.  The `Disembargo` message allows latency to be\n* reduced.  (In the two-party loopback case, the `Disembargo` message is just a more explicit way\n* of accomplishing the same thing as a no-op call, but isn't any faster.)\n*\n* *The Tribble 4-way Race Condition*\n*\n* Any implementation of promise resolution and embargos must be aware of what we call the\n* \"Tribble 4-way race condition\", after Dean Tribble, who explained the problem in a lively\n* Friam meeting.\n*\n* Embargos are designed to work in the case where a two-hop path is being shortened to one hop.\n* But sometimes there are more hops. Imagine that Alice has a reference to a remote promise P1\n* that eventually resolves to _another_ remote promise P2 (in a third vat), which _at the same\n* time_ happens to resolve to Bob (in a fourth vat). In this case, we're shortening from a 3-hop\n* path (with four parties) to a 1-hop path (Alice -> Bob).\n*\n* Extending the embargo/disembargo protocol to be able to shorted multiple hops at once seems\n* difficult. Instead, we make a rule that prevents this case from coming up:\n*\n* One a promise P has been resolved to a remote object reference R, then all further messages\n* received addressed to P will be forwarded strictly to R. Even if it turns out later that R is\n* itself a promise, and has resolved to some other object Q, messages sent to P will still be\n* forwarded to R, not directly to Q (R will of course further forward the messages to Q).\n*\n* This rule does not cause a significant performance burden because once P has resolved to R, it\n* is expected that people sending messages to P will shortly start sending them to R instead and\n* drop P. P is at end-of-life anyway, so it doesn't matter if it ignores chances to further\n* optimize its path.\n*\n* Note well: the Tribble 4-way race condition does not require each vat to be *distinct*; as long\n* as each resolution crosses a network boundary the race can occur -- so this concerns even level\n* 1 implementations, not just level 3 implementations.\n*\n*/\nexport class Disembargo extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"Disembargo\",\n    id: \"f964368b0fbd3711\",\n    size: new $.ObjectSize(8, 1),\n  };\n  _adoptTarget(value: $.Orphan<MessageTarget>): void {\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownTarget(): $.Orphan<MessageTarget> {\n    return $.utils.disown(this.target);\n  }\n  /**\n* What is to be disembargoed.\n*\n*/\n  get target(): MessageTarget {\n    return $.utils.getStruct(0, MessageTarget, this);\n  }\n  _hasTarget(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initTarget(): MessageTarget {\n    return $.utils.initStructAt(0, MessageTarget, this);\n  }\n  set target(value: MessageTarget) {\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  get context(): Disembargo_Context {\n    return $.utils.getAs(Disembargo_Context, this);\n  }\n  _initContext(): Disembargo_Context {\n    return $.utils.getAs(Disembargo_Context, this);\n  }\n  public override toString(): string { return \"Disembargo_\" + super.toString(); }\n}\n/**\n* **(level 3)**\n*\n* Message type sent to indicate that the sender wishes to make a particular capability implemented\n* by the receiver available to a third party for direct access (without the need for the third\n* party to proxy through the sender).\n*\n* (In CapTP, `Provide` and `Accept` are methods of the global `NonceLocator` object exported by\n* every vat.  In Cap'n Proto, we bake this into the core protocol.)\n*\n*/\nexport class Provide extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"Provide\",\n    id: \"9c6a046bfbc1ac5a\",\n    size: new $.ObjectSize(8, 2),\n  };\n  /**\n* Question ID to be held open until the recipient has received the capability.  A result will be\n* returned once the third party has successfully received the capability.  The sender must at some\n* point send a `Finish` message as with any other call, and that message can be used to cancel the\n* whole operation.\n*\n*/\n  get questionId(): number {\n    return $.utils.getUint32(0, this);\n  }\n  set questionId(value: number) {\n    $.utils.setUint32(0, value, this);\n  }\n  _adoptTarget(value: $.Orphan<MessageTarget>): void {\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownTarget(): $.Orphan<MessageTarget> {\n    return $.utils.disown(this.target);\n  }\n  /**\n* What is to be provided to the third party.\n*\n*/\n  get target(): MessageTarget {\n    return $.utils.getStruct(0, MessageTarget, this);\n  }\n  _hasTarget(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initTarget(): MessageTarget {\n    return $.utils.initStructAt(0, MessageTarget, this);\n  }\n  set target(value: MessageTarget) {\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptRecipient(value: $.Orphan<$.Pointer>): void {\n    $.utils.adopt(value, $.utils.getPointer(1, this));\n  }\n  _disownRecipient(): $.Orphan<$.Pointer> {\n    return $.utils.disown(this.recipient);\n  }\n  /**\n* Identity of the third party that is expected to pick up the capability.\n*\n*/\n  get recipient(): $.Pointer {\n    return $.utils.getPointer(1, this);\n  }\n  _hasRecipient(): boolean {\n    return !$.utils.isNull($.utils.getPointer(1, this));\n  }\n  set recipient(value: $.Pointer) {\n    $.utils.copyFrom(value, $.utils.getPointer(1, this));\n  }\n  public override toString(): string { return \"Provide_\" + super.toString(); }\n}\n/**\n* **(level 3)**\n*\n* Message type sent to pick up a capability hosted by the receiving vat and provided by a third\n* party.  The third party previously designated the capability using `Provide`.\n*\n* This message is also used to pick up a redirected return -- see `Return.acceptFromThirdParty`.\n*\n*/\nexport class Accept extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"Accept\",\n    id: \"d4c9b56290554016\",\n    size: new $.ObjectSize(8, 1),\n  };\n  /**\n* A new question ID identifying this accept message, which will eventually receive a Return\n* message containing the provided capability (or the call result in the case of a redirected\n* return).\n*\n*/\n  get questionId(): number {\n    return $.utils.getUint32(0, this);\n  }\n  set questionId(value: number) {\n    $.utils.setUint32(0, value, this);\n  }\n  _adoptProvision(value: $.Orphan<$.Pointer>): void {\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownProvision(): $.Orphan<$.Pointer> {\n    return $.utils.disown(this.provision);\n  }\n  /**\n* Identifies the provided object to be picked up.\n*\n*/\n  get provision(): $.Pointer {\n    return $.utils.getPointer(0, this);\n  }\n  _hasProvision(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  set provision(value: $.Pointer) {\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  /**\n* If true, this accept shall be temporarily embargoed.  The resulting `Return` will not be sent,\n* and any pipelined calls will not be delivered, until the embargo is released.  The receiver\n* (the capability host) will expect the provider (the vat that sent the `Provide` message) to\n* eventually send a `Disembargo` message with the field `context.provide` set to the question ID\n* of the original `Provide` message.  At that point, the embargo is released and the queued\n* messages are delivered.\n*\n* For example:\n* - Alice, in Vat A, holds a promise P, which currently points toward Vat B.\n* - Alice calls foo() on P.  The `Call` message is sent to Vat B.\n* - The promise P in Vat B ends up resolving to Carol, in Vat C.\n* - Vat B sends a `Provide` message to Vat C, identifying Vat A as the recipient.\n* - Vat B sends a `Resolve` message to Vat A, indicating that the promise has resolved to a\n*   `ThirdPartyCapId` identifying Carol in Vat C.\n* - Vat A sends an `Accept` message to Vat C to pick up the capability.  Since Vat A knows that\n*   it has an outstanding call to the promise, it sets `embargo` to `true` in the `Accept`\n*   message.\n* - Vat A sends a `Disembargo` message to Vat B on promise P, with `context.accept` set.\n* - Alice makes a call bar() to promise P, which is now pointing towards Vat C.  Alice doesn't\n*   know anything about the mechanics of promise resolution happening under the hood, but she\n*   expects that bar() will be delivered after foo() because that is the order in which she\n*   initiated the calls.\n* - Vat A sends the bar() call to Vat C, as a pipelined call on the result of the `Accept` (which\n*   hasn't returned yet, due to the embargo).  Since calls to the newly-accepted capability\n*   are embargoed, Vat C does not deliver the call yet.\n* - At some point, Vat B forwards the foo() call from the beginning of this example on to Vat C.\n* - Vat B forwards the `Disembargo` from Vat A on to vat C.  It sets `context.provide` to the\n*   question ID of the `Provide` message it had sent previously.\n* - Vat C receives foo() before `Disembargo`, thus allowing it to correctly deliver foo()\n*   before delivering bar().\n* - Vat C receives `Disembargo` from Vat B.  It can now send a `Return` for the `Accept` from\n*   Vat A, as well as deliver bar().\n*\n*/\n  get embargo(): boolean {\n    return $.utils.getBit(32, this);\n  }\n  set embargo(value: boolean) {\n    $.utils.setBit(32, value, this);\n  }\n  public override toString(): string { return \"Accept_\" + super.toString(); }\n}\n/**\n* **(level 4)**\n*\n* Message type sent to implement E.join(), which, given a number of capabilities that are\n* expected to be equivalent, finds the underlying object upon which they all agree and forms a\n* direct connection to it, skipping any proxies that may have been constructed by other vats\n* while transmitting the capability.  See:\n*     http://erights.org/elib/equality/index.html\n*\n* Note that this should only serve to bypass fully-transparent proxies -- proxies that were\n* created merely for convenience, without any intention of hiding the underlying object.\n*\n* For example, say Bob holds two capabilities hosted by Alice and Carol, but he expects that both\n* are simply proxies for a capability hosted elsewhere.  He then issues a join request, which\n* operates as follows:\n* - Bob issues Join requests on both Alice and Carol.  Each request contains a different piece\n*   of the JoinKey.\n* - Alice is proxying a capability hosted by Dana, so forwards the request to Dana's cap.\n* - Dana receives the first request and sees that the JoinKeyPart is one of two.  She notes that\n*   she doesn't have the other part yet, so she records the request and responds with a\n*   JoinResult.\n* - Alice relays the JoinAnswer back to Bob.\n* - Carol is also proxying a capability from Dana, and so forwards her Join request to Dana as\n*   well.\n* - Dana receives Carol's request and notes that she now has both parts of a JoinKey.  She\n*   combines them in order to form information needed to form a secure connection to Bob.  She\n*   also responds with another JoinResult.\n* - Bob receives the responses from Alice and Carol.  He uses the returned JoinResults to\n*   determine how to connect to Dana and attempts to form the connection.  Since Bob and Dana now\n*   agree on a secret key that neither Alice nor Carol ever saw, this connection can be made\n*   securely even if Alice or Carol is conspiring against the other.  (If Alice and Carol are\n*   conspiring _together_, they can obviously reproduce the key, but this doesn't matter because\n*   the whole point of the join is to verify that Alice and Carol agree on what capability they\n*   are proxying.)\n*\n* If the two capabilities aren't actually proxies of the same object, then the join requests\n* will come back with conflicting `hostId`s and the join will fail before attempting to form any\n* connection.\n*\n*/\nexport class Join extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"Join\",\n    id: \"fbe1980490e001af\",\n    size: new $.ObjectSize(8, 2),\n  };\n  /**\n* Question ID used to respond to this Join.  (Note that this ID only identifies one part of the\n* request for one hop; each part has a different ID and relayed copies of the request have\n* (probably) different IDs still.)\n*\n* The receiver will reply with a `Return` whose `results` is a JoinResult.  This `JoinResult`\n* is relayed from the joined object's host, possibly with transformation applied as needed\n* by the network.\n*\n* Like any return, the result must be released using a `Finish`.  However, this release\n* should not occur until the joiner has either successfully connected to the joined object.\n* Vats relaying a `Join` message similarly must not release the result they receive until the\n* return they relayed back towards the joiner has itself been released.  This allows the\n* joined object's host to detect when the Join operation is canceled before completing -- if\n* it receives a `Finish` for one of the join results before the joiner successfully\n* connects.  It can then free any resources it had allocated as part of the join.\n*\n*/\n  get questionId(): number {\n    return $.utils.getUint32(0, this);\n  }\n  set questionId(value: number) {\n    $.utils.setUint32(0, value, this);\n  }\n  _adoptTarget(value: $.Orphan<MessageTarget>): void {\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownTarget(): $.Orphan<MessageTarget> {\n    return $.utils.disown(this.target);\n  }\n  /**\n* The capability to join.\n*\n*/\n  get target(): MessageTarget {\n    return $.utils.getStruct(0, MessageTarget, this);\n  }\n  _hasTarget(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initTarget(): MessageTarget {\n    return $.utils.initStructAt(0, MessageTarget, this);\n  }\n  set target(value: MessageTarget) {\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptKeyPart(value: $.Orphan<$.Pointer>): void {\n    $.utils.adopt(value, $.utils.getPointer(1, this));\n  }\n  _disownKeyPart(): $.Orphan<$.Pointer> {\n    return $.utils.disown(this.keyPart);\n  }\n  /**\n* A part of the join key.  These combine to form the complete join key, which is used to establish\n* a direct connection.\n*\n*/\n  get keyPart(): $.Pointer {\n    return $.utils.getPointer(1, this);\n  }\n  _hasKeyPart(): boolean {\n    return !$.utils.isNull($.utils.getPointer(1, this));\n  }\n  set keyPart(value: $.Pointer) {\n    $.utils.copyFrom(value, $.utils.getPointer(1, this));\n  }\n  public override toString(): string { return \"Join_\" + super.toString(); }\n}\nexport const MessageTarget_Which = {\n  /**\n* This message is to a capability or promise previously imported by the caller (exported by\n* the receiver).\n*\n*/\n  IMPORTED_CAP: 0,\n  /**\n* This message is to a capability that is expected to be returned by another call that has not\n* yet been completed.\n*\n* At level 0, this is supported only for addressing the result of a previous `Bootstrap`, so\n* that initial startup doesn't require a round trip.\n*\n*/\n  PROMISED_ANSWER: 1\n} as const;\nexport type MessageTarget_Which = (typeof MessageTarget_Which)[keyof typeof MessageTarget_Which];\n/**\n* The target of a `Call` or other messages that target a capability.\n*\n*/\nexport class MessageTarget extends $.Struct {\n  static readonly IMPORTED_CAP = MessageTarget_Which.IMPORTED_CAP;\n  static readonly PROMISED_ANSWER = MessageTarget_Which.PROMISED_ANSWER;\n  public static override readonly _capnp = {\n    displayName: \"MessageTarget\",\n    id: \"95bc14545813fbc1\",\n    size: new $.ObjectSize(8, 1),\n  };\n  /**\n* This message is to a capability or promise previously imported by the caller (exported by\n* the receiver).\n*\n*/\n  get importedCap(): number {\n    $.utils.testWhich(\"importedCap\", $.utils.getUint16(4, this), 0, this);\n    return $.utils.getUint32(0, this);\n  }\n  get _isImportedCap(): boolean {\n    return $.utils.getUint16(4, this) === 0;\n  }\n  set importedCap(value: number) {\n    $.utils.setUint16(4, 0, this);\n    $.utils.setUint32(0, value, this);\n  }\n  _adoptPromisedAnswer(value: $.Orphan<PromisedAnswer>): void {\n    $.utils.setUint16(4, 1, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownPromisedAnswer(): $.Orphan<PromisedAnswer> {\n    return $.utils.disown(this.promisedAnswer);\n  }\n  /**\n* This message is to a capability that is expected to be returned by another call that has not\n* yet been completed.\n*\n* At level 0, this is supported only for addressing the result of a previous `Bootstrap`, so\n* that initial startup doesn't require a round trip.\n*\n*/\n  get promisedAnswer(): PromisedAnswer {\n    $.utils.testWhich(\"promisedAnswer\", $.utils.getUint16(4, this), 1, this);\n    return $.utils.getStruct(0, PromisedAnswer, this);\n  }\n  _hasPromisedAnswer(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initPromisedAnswer(): PromisedAnswer {\n    $.utils.setUint16(4, 1, this);\n    return $.utils.initStructAt(0, PromisedAnswer, this);\n  }\n  get _isPromisedAnswer(): boolean {\n    return $.utils.getUint16(4, this) === 1;\n  }\n  set promisedAnswer(value: PromisedAnswer) {\n    $.utils.setUint16(4, 1, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  public override toString(): string { return \"MessageTarget_\" + super.toString(); }\n  which(): MessageTarget_Which {\n    return $.utils.getUint16(4, this) as MessageTarget_Which;\n  }\n}\n/**\n* Represents some data structure that might contain capabilities.\n*\n*/\nexport class Payload extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"Payload\",\n    id: \"9a0e61223d96743b\",\n    size: new $.ObjectSize(0, 2),\n  };\n  static _CapTable: $.ListCtor<CapDescriptor>;\n  _adoptContent(value: $.Orphan<$.Pointer>): void {\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownContent(): $.Orphan<$.Pointer> {\n    return $.utils.disown(this.content);\n  }\n  /**\n* Some Cap'n Proto data structure.  Capability pointers embedded in this structure index into\n* `capTable`.\n*\n*/\n  get content(): $.Pointer {\n    return $.utils.getPointer(0, this);\n  }\n  _hasContent(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  set content(value: $.Pointer) {\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptCapTable(value: $.Orphan<$.List<CapDescriptor>>): void {\n    $.utils.adopt(value, $.utils.getPointer(1, this));\n  }\n  _disownCapTable(): $.Orphan<$.List<CapDescriptor>> {\n    return $.utils.disown(this.capTable);\n  }\n  /**\n* Descriptors corresponding to the cap pointers in `content`.\n*\n*/\n  get capTable(): $.List<CapDescriptor> {\n    return $.utils.getList(1, Payload._CapTable, this);\n  }\n  _hasCapTable(): boolean {\n    return !$.utils.isNull($.utils.getPointer(1, this));\n  }\n  _initCapTable(length: number): $.List<CapDescriptor> {\n    return $.utils.initList(1, Payload._CapTable, length, this);\n  }\n  set capTable(value: $.List<CapDescriptor>) {\n    $.utils.copyFrom(value, $.utils.getPointer(1, this));\n  }\n  public override toString(): string { return \"Payload_\" + super.toString(); }\n}\nexport const CapDescriptor_Which = {\n  /**\n* There is no capability here.  This `CapDescriptor` should not appear in the payload content.\n* A `none` CapDescriptor can be generated when an application inserts a capability into a\n* message and then later changes its mind and removes it -- rewriting all of the other\n* capability pointers may be hard, so instead a tombstone is left, similar to the way a removed\n* struct or list instance is zeroed out of the message but the space is not reclaimed.\n* Hopefully this is unusual.\n*\n*/\n  NONE: 0,\n  /**\n* The ID of a capability in the sender's export table (receiver's import table).  It may be a\n* newly allocated table entry, or an existing entry (increments the reference count).\n*\n*/\n  SENDER_HOSTED: 1,\n  /**\n* A promise that the sender will resolve later.  The sender will send exactly one Resolve\n* message at a future point in time to replace this promise.  Note that even if the same\n* `senderPromise` is received multiple times, only one `Resolve` is sent to cover all of\n* them.  If `senderPromise` is released before the `Resolve` is sent, the sender (of this\n* `CapDescriptor`) may choose not to send the `Resolve` at all.\n*\n*/\n  SENDER_PROMISE: 2,\n  /**\n* A capability (or promise) previously exported by the receiver (imported by the sender).\n*\n*/\n  RECEIVER_HOSTED: 3,\n  /**\n* A capability expected to be returned in the results of a currently-outstanding call posed\n* by the sender.\n*\n*/\n  RECEIVER_ANSWER: 4,\n  /**\n* **(level 3)**\n*\n* A capability that lives in neither the sender's nor the receiver's vat.  The sender needs\n* to form a direct connection to a third party to pick up the capability.\n*\n* Level 1 and 2 implementations that receive a `thirdPartyHosted` may simply send calls to its\n* `vine` instead.\n*\n*/\n  THIRD_PARTY_HOSTED: 5\n} as const;\nexport type CapDescriptor_Which = (typeof CapDescriptor_Which)[keyof typeof CapDescriptor_Which];\n/**\n* **(level 1)**\n*\n* When an application-defined type contains an interface pointer, that pointer contains an index\n* into the message's capability table -- i.e. the `capTable` part of the `Payload`.  Each\n* capability in the table is represented as a `CapDescriptor`.  The runtime API should not reveal\n* the CapDescriptor directly to the application, but should instead wrap it in some kind of\n* callable object with methods corresponding to the interface that the capability implements.\n*\n* Keep in mind that `ExportIds` in a `CapDescriptor` are subject to reference counting.  See the\n* description of `ExportId`.\n*\n* Note that it is currently not possible to include a broken capability in the CapDescriptor\n* table.  Instead, create a new export (`senderPromise`) for each broken capability and then\n* immediately follow the payload-bearing Call or Return message with one Resolve message for each\n* broken capability, resolving it to an exception.\n*\n*/\nexport class CapDescriptor extends $.Struct {\n  static readonly NONE = CapDescriptor_Which.NONE;\n  static readonly SENDER_HOSTED = CapDescriptor_Which.SENDER_HOSTED;\n  static readonly SENDER_PROMISE = CapDescriptor_Which.SENDER_PROMISE;\n  static readonly RECEIVER_HOSTED = CapDescriptor_Which.RECEIVER_HOSTED;\n  static readonly RECEIVER_ANSWER = CapDescriptor_Which.RECEIVER_ANSWER;\n  static readonly THIRD_PARTY_HOSTED = CapDescriptor_Which.THIRD_PARTY_HOSTED;\n  public static override readonly _capnp = {\n    displayName: \"CapDescriptor\",\n    id: \"8523ddc40b86b8b0\",\n    size: new $.ObjectSize(8, 1),\n    defaultAttachedFd: $.getUint8Mask(255)\n  };\n  get _isNone(): boolean {\n    return $.utils.getUint16(0, this) === 0;\n  }\n  set none(_: true) {\n    $.utils.setUint16(0, 0, this);\n  }\n  /**\n* The ID of a capability in the sender's export table (receiver's import table).  It may be a\n* newly allocated table entry, or an existing entry (increments the reference count).\n*\n*/\n  get senderHosted(): number {\n    $.utils.testWhich(\"senderHosted\", $.utils.getUint16(0, this), 1, this);\n    return $.utils.getUint32(4, this);\n  }\n  get _isSenderHosted(): boolean {\n    return $.utils.getUint16(0, this) === 1;\n  }\n  set senderHosted(value: number) {\n    $.utils.setUint16(0, 1, this);\n    $.utils.setUint32(4, value, this);\n  }\n  /**\n* A promise that the sender will resolve later.  The sender will send exactly one Resolve\n* message at a future point in time to replace this promise.  Note that even if the same\n* `senderPromise` is received multiple times, only one `Resolve` is sent to cover all of\n* them.  If `senderPromise` is released before the `Resolve` is sent, the sender (of this\n* `CapDescriptor`) may choose not to send the `Resolve` at all.\n*\n*/\n  get senderPromise(): number {\n    $.utils.testWhich(\"senderPromise\", $.utils.getUint16(0, this), 2, this);\n    return $.utils.getUint32(4, this);\n  }\n  get _isSenderPromise(): boolean {\n    return $.utils.getUint16(0, this) === 2;\n  }\n  set senderPromise(value: number) {\n    $.utils.setUint16(0, 2, this);\n    $.utils.setUint32(4, value, this);\n  }\n  /**\n* A capability (or promise) previously exported by the receiver (imported by the sender).\n*\n*/\n  get receiverHosted(): number {\n    $.utils.testWhich(\"receiverHosted\", $.utils.getUint16(0, this), 3, this);\n    return $.utils.getUint32(4, this);\n  }\n  get _isReceiverHosted(): boolean {\n    return $.utils.getUint16(0, this) === 3;\n  }\n  set receiverHosted(value: number) {\n    $.utils.setUint16(0, 3, this);\n    $.utils.setUint32(4, value, this);\n  }\n  _adoptReceiverAnswer(value: $.Orphan<PromisedAnswer>): void {\n    $.utils.setUint16(0, 4, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownReceiverAnswer(): $.Orphan<PromisedAnswer> {\n    return $.utils.disown(this.receiverAnswer);\n  }\n  /**\n* A capability expected to be returned in the results of a currently-outstanding call posed\n* by the sender.\n*\n*/\n  get receiverAnswer(): PromisedAnswer {\n    $.utils.testWhich(\"receiverAnswer\", $.utils.getUint16(0, this), 4, this);\n    return $.utils.getStruct(0, PromisedAnswer, this);\n  }\n  _hasReceiverAnswer(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initReceiverAnswer(): PromisedAnswer {\n    $.utils.setUint16(0, 4, this);\n    return $.utils.initStructAt(0, PromisedAnswer, this);\n  }\n  get _isReceiverAnswer(): boolean {\n    return $.utils.getUint16(0, this) === 4;\n  }\n  set receiverAnswer(value: PromisedAnswer) {\n    $.utils.setUint16(0, 4, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  _adoptThirdPartyHosted(value: $.Orphan<ThirdPartyCapDescriptor>): void {\n    $.utils.setUint16(0, 5, this);\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownThirdPartyHosted(): $.Orphan<ThirdPartyCapDescriptor> {\n    return $.utils.disown(this.thirdPartyHosted);\n  }\n  /**\n* **(level 3)**\n*\n* A capability that lives in neither the sender's nor the receiver's vat.  The sender needs\n* to form a direct connection to a third party to pick up the capability.\n*\n* Level 1 and 2 implementations that receive a `thirdPartyHosted` may simply send calls to its\n* `vine` instead.\n*\n*/\n  get thirdPartyHosted(): ThirdPartyCapDescriptor {\n    $.utils.testWhich(\"thirdPartyHosted\", $.utils.getUint16(0, this), 5, this);\n    return $.utils.getStruct(0, ThirdPartyCapDescriptor, this);\n  }\n  _hasThirdPartyHosted(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initThirdPartyHosted(): ThirdPartyCapDescriptor {\n    $.utils.setUint16(0, 5, this);\n    return $.utils.initStructAt(0, ThirdPartyCapDescriptor, this);\n  }\n  get _isThirdPartyHosted(): boolean {\n    return $.utils.getUint16(0, this) === 5;\n  }\n  set thirdPartyHosted(value: ThirdPartyCapDescriptor) {\n    $.utils.setUint16(0, 5, this);\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  /**\n* If the RPC message in which this CapDescriptor was delivered also had file descriptors\n* attached, and `fd` is a valid index into the list of attached file descriptors, then\n* that file descriptor should be attached to this capability. If `attachedFd` is out-of-bounds\n* for said list, then no FD is attached.\n*\n* For example, if the RPC message arrived over a Unix socket, then file descriptors may be\n* attached by sending an SCM_RIGHTS ancillary message attached to the data bytes making up the\n* raw message. Receivers who wish to opt into FD passing should arrange to receive SCM_RIGHTS\n* whenever receiving an RPC message. Senders who wish to send FDs need not verify whether the\n* receiver knows how to receive them, because the operating system will automatically discard\n* ancillary messages like SCM_RIGHTS if the receiver doesn't ask to receive them, including\n* automatically closing any FDs.\n*\n* It is up to the application protocol to define what capabilities are expected to have file\n* descriptors attached, and what those FDs mean. But, for example, an application could use this\n* to open a file on disk and then transmit the open file descriptor to a sandboxed process that\n* does not otherwise have permission to access the filesystem directly. This is usually an\n* optimization: the sending process could instead provide an RPC interface supporting all the\n* operations needed (such as reading and writing a file), but by passing the file descriptor\n* directly, the recipient can often perform operations much more efficiently. Application\n* designers are encouraged to provide such RPC interfaces and automatically fall back to them\n* when FD passing is not available, so that the application can still work when the parties are\n* remote over a network.\n*\n* An attached FD is most often associated with a `senderHosted` descriptor. It could also make\n* sense in the case of `thirdPartyHosted`: in this case, the sender is forwarding the FD that\n* they received from the third party, so that the receiver can start using it without first\n* interacting with the third party. This is an optional optimization -- the middleman may choose\n* not to forward capabilities, in which case the receiver will need to complete the handshake\n* with the third party directly before receiving the FD. If an implementation receives a second\n* attached FD after having already received one previously (e.g. both in a `thirdPartyHosted`\n* CapDescriptor and then later again when receiving the final capability directly from the\n* third party), the implementation should discard the later FD and stick with the original. At\n* present, there is no known reason why other capability types (e.g. `receiverHosted`) would want\n* to carry an attached FD, but we reserve the right to define a meaning for this in the future.\n*\n* Each file descriptor attached to the message must be used in no more than one CapDescriptor,\n* so that the receiver does not need to use dup() or refcounting to handle the possibility of\n* multiple capabilities using the same descriptor. If multiple CapDescriptors do point to the\n* same FD index, then the receiver can arbitrarily choose which capability ends up having the\n* FD attached.\n*\n* To mitigate DoS attacks, RPC implementations should limit the number of FDs they are willing to\n* receive in a single message to a small value. If a message happens to contain more than that,\n* the list is truncated. Moreover, in some cases, FD passing needs to be blocked entirely for\n* security or implementation reasons, in which case the list may be truncated to zero. Hence,\n* `attachedFd` might point past the end of the list, which the implementation should treat as if\n* no FD was attached at all.\n*\n* The type of this field was chosen to be UInt8 because Linux supports sending only a maximum\n* of 253 file descriptors in an SCM_RIGHTS message anyway, and CapDescriptor had two bytes of\n* padding left -- so after adding this, there is still one byte for a future feature.\n* Conveniently, this also means we're able to use 0xff as the default value, which will always\n* be out-of-range (of course, the implementation should explicitly enforce that 255 descriptors\n* cannot be sent at once, rather than relying on Linux to do so).\n*\n*/\n  get attachedFd(): number {\n    return $.utils.getUint8(2, this, CapDescriptor._capnp.defaultAttachedFd);\n  }\n  set attachedFd(value: number) {\n    $.utils.setUint8(2, value, this, CapDescriptor._capnp.defaultAttachedFd);\n  }\n  public override toString(): string { return \"CapDescriptor_\" + super.toString(); }\n  which(): CapDescriptor_Which {\n    return $.utils.getUint16(0, this) as CapDescriptor_Which;\n  }\n}\nexport const PromisedAnswer_Op_Which = {\n  /**\n* Does nothing.  This member is mostly defined so that we can make `Op` a union even\n* though (as of this writing) only one real operation is defined.\n*\n*/\n  NOOP: 0,\n  /**\n* Get a pointer field within a struct.  The number is an index into the pointer section, NOT\n* a field ordinal, so that the receiver does not need to understand the schema.\n*\n*/\n  GET_POINTER_FIELD: 1\n} as const;\nexport type PromisedAnswer_Op_Which = (typeof PromisedAnswer_Op_Which)[keyof typeof PromisedAnswer_Op_Which];\nexport class PromisedAnswer_Op extends $.Struct {\n  static readonly NOOP = PromisedAnswer_Op_Which.NOOP;\n  static readonly GET_POINTER_FIELD = PromisedAnswer_Op_Which.GET_POINTER_FIELD;\n  public static override readonly _capnp = {\n    displayName: \"Op\",\n    id: \"f316944415569081\",\n    size: new $.ObjectSize(8, 0),\n  };\n  get _isNoop(): boolean {\n    return $.utils.getUint16(0, this) === 0;\n  }\n  set noop(_: true) {\n    $.utils.setUint16(0, 0, this);\n  }\n  /**\n* Get a pointer field within a struct.  The number is an index into the pointer section, NOT\n* a field ordinal, so that the receiver does not need to understand the schema.\n*\n*/\n  get getPointerField(): number {\n    $.utils.testWhich(\"getPointerField\", $.utils.getUint16(0, this), 1, this);\n    return $.utils.getUint16(2, this);\n  }\n  get _isGetPointerField(): boolean {\n    return $.utils.getUint16(0, this) === 1;\n  }\n  set getPointerField(value: number) {\n    $.utils.setUint16(0, 1, this);\n    $.utils.setUint16(2, value, this);\n  }\n  public override toString(): string { return \"PromisedAnswer_Op_\" + super.toString(); }\n  which(): PromisedAnswer_Op_Which {\n    return $.utils.getUint16(0, this) as PromisedAnswer_Op_Which;\n  }\n}\n/**\n* **(mostly level 1)**\n*\n* Specifies how to derive a promise from an unanswered question, by specifying the path of fields\n* to follow from the root of the eventual result struct to get to the desired capability.  Used\n* to address method calls to a not-yet-returned capability or to pass such a capability as an\n* input to some other method call.\n*\n* Level 0 implementations must support `PromisedAnswer` only for the case where the answer is\n* to a `Bootstrap` message.  In this case, `path` is always empty since `Bootstrap` always returns\n* a raw capability.\n*\n*/\nexport class PromisedAnswer extends $.Struct {\n  static readonly Op = PromisedAnswer_Op;\n  public static override readonly _capnp = {\n    displayName: \"PromisedAnswer\",\n    id: \"d800b1d6cd6f1ca0\",\n    size: new $.ObjectSize(8, 1),\n  };\n  static _Transform: $.ListCtor<PromisedAnswer_Op>;\n  /**\n* ID of the question (in the sender's question table / receiver's answer table) whose answer is\n* expected to contain the capability.\n*\n*/\n  get questionId(): number {\n    return $.utils.getUint32(0, this);\n  }\n  set questionId(value: number) {\n    $.utils.setUint32(0, value, this);\n  }\n  _adoptTransform(value: $.Orphan<$.List<PromisedAnswer_Op>>): void {\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownTransform(): $.Orphan<$.List<PromisedAnswer_Op>> {\n    return $.utils.disown(this.transform);\n  }\n  /**\n* Operations / transformations to apply to the result in order to get the capability actually\n* being addressed.  E.g. if the result is a struct and you want to call a method on a capability\n* pointed to by a field of the struct, you need a `getPointerField` op.\n*\n*/\n  get transform(): $.List<PromisedAnswer_Op> {\n    return $.utils.getList(0, PromisedAnswer._Transform, this);\n  }\n  _hasTransform(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  _initTransform(length: number): $.List<PromisedAnswer_Op> {\n    return $.utils.initList(0, PromisedAnswer._Transform, length, this);\n  }\n  set transform(value: $.List<PromisedAnswer_Op>) {\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  public override toString(): string { return \"PromisedAnswer_\" + super.toString(); }\n}\n/**\n* **(level 3)**\n*\n* Identifies a capability in a third-party vat that the sender wants the receiver to pick up.\n*\n*/\nexport class ThirdPartyCapDescriptor extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"ThirdPartyCapDescriptor\",\n    id: \"d37007fde1f0027d\",\n    size: new $.ObjectSize(8, 1),\n  };\n  _adoptId(value: $.Orphan<$.Pointer>): void {\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownId(): $.Orphan<$.Pointer> {\n    return $.utils.disown(this.id);\n  }\n  /**\n* Identifies the third-party host and the specific capability to accept from it.\n*\n*/\n  get id(): $.Pointer {\n    return $.utils.getPointer(0, this);\n  }\n  _hasId(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  set id(value: $.Pointer) {\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  /**\n* A proxy for the third-party object exported by the sender.  In CapTP terminology this is called\n* a \"vine\", because it is an indirect reference to the third-party object that snakes through the\n* sender vat.  This serves two purposes:\n*\n* * Level 1 and 2 implementations that don't understand how to connect to a third party may\n*   simply send calls to the vine.  Such calls will be forwarded to the third-party by the\n*   sender.\n*\n* * Level 3 implementations must release the vine only once they have successfully picked up the\n*   object from the third party.  This ensures that the capability is not released by the sender\n*   prematurely.\n*\n* The sender will close the `Provide` request that it has sent to the third party as soon as\n* it receives either a `Call` or a `Release` message directed at the vine.\n*\n*/\n  get vineId(): number {\n    return $.utils.getUint32(0, this);\n  }\n  set vineId(value: number) {\n    $.utils.setUint32(0, value, this);\n  }\n  public override toString(): string { return \"ThirdPartyCapDescriptor_\" + super.toString(); }\n}\nexport const Exception_Type = {\n  /**\n* A generic problem occurred, and it is believed that if the operation were repeated without\n* any change in the state of the world, the problem would occur again.\n*\n* A client might respond to this error by logging it for investigation by the developer and/or\n* displaying it to the user.\n*\n*/\n  FAILED: 0,\n  /**\n* The request was rejected due to a temporary lack of resources.\n*\n* Examples include:\n* - There's not enough CPU time to keep up with incoming requests, so some are rejected.\n* - The server ran out of RAM or disk space during the request.\n* - The operation timed out (took significantly longer than it should have).\n*\n* A client might respond to this error by scheduling to retry the operation much later. The\n* client should NOT retry again immediately since this would likely exacerbate the problem.\n*\n*/\n  OVERLOADED: 1,\n  /**\n* The method failed because a connection to some necessary capability was lost.\n*\n* Examples include:\n* - The client introduced the server to a third-party capability, the connection to that third\n*   party was subsequently lost, and then the client requested that the server use the dead\n*   capability for something.\n* - The client previously requested that the server obtain a capability from some third party.\n*   The server returned a capability to an object wrapping the third-party capability. Later,\n*   the server's connection to the third party was lost.\n* - The capability has been revoked. Revocation does not necessarily mean that the client is\n*   no longer authorized to use the capability; it is often used simply as a way to force the\n*   client to repeat the setup process, perhaps to efficiently move them to a new back-end or\n*   get them to recognize some other change that has occurred.\n*\n* A client should normally respond to this error by releasing all capabilities it is currently\n* holding related to the one it called and then re-creating them by restoring SturdyRefs and/or\n* repeating the method calls used to create them originally. In other words, disconnect and\n* start over. This should in turn cause the server to obtain a new copy of the capability that\n* it lost, thus making everything work.\n*\n* If the client receives another `disconnected` error in the process of rebuilding the\n* capability and retrying the call, it should treat this as an `overloaded` error: the network\n* is currently unreliable, possibly due to load or other temporary issues.\n*\n*/\n  DISCONNECTED: 2,\n  /**\n* The server doesn't implement the requested method. If there is some other method that the\n* client could call (perhaps an older and/or slower interface), it should try that instead.\n* Otherwise, this should be treated like `failed`.\n*\n*/\n  UNIMPLEMENTED: 3\n} as const;\nexport type Exception_Type = (typeof Exception_Type)[keyof typeof Exception_Type];\n/**\n* **(level 0)**\n*\n* Describes an arbitrary error that prevented an operation (e.g. a call) from completing.\n*\n* Cap'n Proto exceptions always indicate that something went wrong. In other words, in a fantasy\n* world where everything always works as expected, no exceptions would ever be thrown. Clients\n* should only ever catch exceptions as a means to implement fault-tolerance, where \"fault\" can\n* mean:\n* - Bugs.\n* - Invalid input.\n* - Configuration errors.\n* - Network problems.\n* - Insufficient resources.\n* - Version skew (unimplemented functionality).\n* - Other logistical problems.\n*\n* Exceptions should NOT be used to flag application-specific conditions that a client is expected\n* to handle in an application-specific way. Put another way, in the Cap'n Proto world,\n* \"checked exceptions\" (where an interface explicitly defines the exceptions it throws and\n* clients are forced by the type system to handle those exceptions) do NOT make sense.\n*\n*/\nexport class Exception extends $.Struct {\n  static readonly Type = Exception_Type;\n  public static override readonly _capnp = {\n    displayName: \"Exception\",\n    id: \"d625b7063acf691a\",\n    size: new $.ObjectSize(8, 2),\n  };\n  /**\n* Human-readable failure description.\n*\n*/\n  get reason(): string {\n    return $.utils.getText(0, this);\n  }\n  set reason(value: string) {\n    $.utils.setText(0, value, this);\n  }\n  /**\n* The type of the error. The purpose of this enum is not to describe the error itself, but\n* rather to describe how the client might want to respond to the error.\n*\n*/\n  get type(): Exception_Type {\n    return $.utils.getUint16(4, this) as Exception_Type;\n  }\n  set type(value: Exception_Type) {\n    $.utils.setUint16(4, value, this);\n  }\n  /**\n* OBSOLETE. Ignore.\n*\n*/\n  get obsoleteIsCallersFault(): boolean {\n    return $.utils.getBit(0, this);\n  }\n  set obsoleteIsCallersFault(value: boolean) {\n    $.utils.setBit(0, value, this);\n  }\n  /**\n* OBSOLETE. See `type` instead.\n*\n*/\n  get obsoleteDurability(): number {\n    return $.utils.getUint16(2, this);\n  }\n  set obsoleteDurability(value: number) {\n    $.utils.setUint16(2, value, this);\n  }\n  /**\n* Stack trace text from the remote server. The format is not specified. By default,\n* implementations do not provide stack traces; the application must explicitly enable them\n* when desired.\n*\n*/\n  get trace(): string {\n    return $.utils.getText(1, this);\n  }\n  set trace(value: string) {\n    $.utils.setText(1, value, this);\n  }\n  public override toString(): string { return \"Exception_\" + super.toString(); }\n}\nPayload._CapTable = $.CompositeList(CapDescriptor);\nPromisedAnswer._Transform = $.CompositeList(PromisedAnswer_Op);\n"],"mappings":"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"}