@stryke/capnp 0.12.95 → 0.12.97

package/schemas/rpc-twoparty.d.mts

@@ -1,4 +1,4 @@
-import { t as index_d_exports } from "./index-BAJMwFip.mjs";
+import { c as ObjectSize, d as Pointer, l as Orphan, p as Struct } from "./index-DprjZUdT.mjs";
 
 //#region schemas/rpc-twoparty.d.ts
 declare const _capnpFileId: bigint;
@@ -25,11 +25,11 @@ declare const Side: {
   readonly CLIENT: 1;
 };
 type Side = (typeof Side)[keyof typeof Side];
-declare class VatId extends index_d_exports.Struct {
+declare class VatId extends Struct {
   static readonly _capnp: {
     displayName: string;
     id: string;
-    size: index_d_exports.ObjectSize;
+    size: ObjectSize;
   };
   get side(): Side;
   set side(value: Side);
@@ -39,11 +39,11 @@ declare class VatId extends index_d_exports.Struct {
 * Only used for joins, since three-way introductions never happen on a two-party network.
 *
 */
-declare class ProvisionId extends index_d_exports.Struct {
+declare class ProvisionId extends Struct {
   static readonly _capnp: {
     displayName: string;
     id: string;
-    size: index_d_exports.ObjectSize;
+    size: ObjectSize;
   };
   /**
   * The ID from `JoinKeyPart`.
@@ -57,11 +57,11 @@ declare class ProvisionId extends index_d_exports.Struct {
 * Never used, because there are only two parties.
 *
 */
-declare class RecipientId extends index_d_exports.Struct {
+declare class RecipientId extends Struct {
   static readonly _capnp: {
     displayName: string;
     id: string;
-    size: index_d_exports.ObjectSize;
+    size: ObjectSize;
   };
   toString(): string;
 }
@@ -69,11 +69,11 @@ declare class RecipientId extends index_d_exports.Struct {
 * Never used, because there is no third party.
 *
 */
-declare class ThirdPartyCapId extends index_d_exports.Struct {
+declare class ThirdPartyCapId extends Struct {
   static readonly _capnp: {
     displayName: string;
     id: string;
-    size: index_d_exports.ObjectSize;
+    size: ObjectSize;
   };
   toString(): string;
 }
@@ -110,11 +110,11 @@ declare class ThirdPartyCapId extends index_d_exports.Struct {
 * as if it had been requested locally.
 *
 */
-declare class JoinKeyPart extends index_d_exports.Struct {
+declare class JoinKeyPart extends Struct {
   static readonly _capnp: {
     displayName: string;
     id: string;
-    size: index_d_exports.ObjectSize;
+    size: ObjectSize;
   };
   /**
   * A number identifying this join, chosen by the sender.  May be reused once `Finish` messages are
@@ -137,11 +137,11 @@ declare class JoinKeyPart extends index_d_exports.Struct {
   set partNum(value: number);
   toString(): string;
 }
-declare class JoinResult extends index_d_exports.Struct {
+declare class JoinResult extends Struct {
   static readonly _capnp: {
     displayName: string;
     id: string;
-    size: index_d_exports.ObjectSize;
+    size: ObjectSize;
   };
   /**
   * Matches `JoinKeyPart`.
@@ -157,15 +157,15 @@ declare class JoinResult extends index_d_exports.Struct {
   */
   get succeeded(): boolean;
   set succeeded(value: boolean);
-  _adoptCap(value: index_d_exports.Orphan<index_d_exports.Pointer>): void;
-  _disownCap(): index_d_exports.Orphan<index_d_exports.Pointer>;
+  _adoptCap(value: Orphan<Pointer>): void;
+  _disownCap(): Orphan<Pointer>;
   /**
   * One of the JoinResults will have a non-null `cap` which is the joined capability.
   *
   */
-  get cap(): index_d_exports.Pointer;
+  get cap(): Pointer;
   _hasCap(): boolean;
-  set cap(value: index_d_exports.Pointer);
+  set cap(value: Pointer);
   toString(): string;
 }
 //#endregion

package/schemas/rpc-twoparty.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc-twoparty.d.mts","names":[],"sources":["../../schemas/rpc-twoparty.ts"],"sourcesContent":[],"mappings":";;;cAKa;cACA;EADA;AACb;AAsBA;AACA;;;;;;AAkBA;AAsBA;AAYA;EAyCa,SAAA,MAAY,EAAA,CAAA;EAuCZ;;;;;;EAsCA,SAAA,MAAE,EAAA,CAAA;CAME;AA5Ce,KArIpB,IAAA,GAqIsB,CAAA,OArIP,IAqIO,CAAA,CAAA,MAAA,OArIY,IAqIZ,CAAA;AAAM,cApI3B,KAAA,SAAc,eAAA,CAAE,MAAA,CAoIW;;;;;;cA9H1B;kBAGI;;;;;;;cASL,WAAA,SAAoB,eAAA,CAAE,MAAA;;;;UAAV,eAAA,CAAA;;;;;;;;;;;;;;cAsBZ,WAAA,SAAoB,eAAA,CAAE,MAAA;;;;UAAV,eAAA,CAAA;;;;;;;;cAYZ,eAAA,SAAwB,eAAA,CAAE,MAAA;;;;UAAV,eAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyChB,WAAA,SAAoB,eAAA,CAAE,MAAA;;;;UAAV,eAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;cAuCZ,UAAA,SAAmB,eAAA,CAAE,MAAA;;;;;;;;;;;;;;;;;;;;mBA4Bf,eAAA,CAAE,OAAO,eAAA,CAAE;gBAGd,eAAA,CAAE,OAAO,eAAA,CAAE;;;;;aAOd,eAAA,CAAE;;iBAME,eAAA,CAAE"}
+{"version":3,"file":"rpc-twoparty.d.mts","names":[],"sources":["../../schemas/rpc-twoparty.ts"],"mappings":";;;cAKa,YAAA;AAAA,cACA,IAAA;EADA;;;;;AACb;;;;;AAsBA;;EAvBa,SAsBH,MAAA;EACiB;;AAC3B;;;;EAD2B,SADjB,MAAA;AAAA;AAAA,KACE,IAAA,WAAe,IAAA,eAAmB,IAAA;AAAA,cACjC,KAAA,SAAc,MAAA;EAAA,gBACO,MAAA;;;;;MAK5B,IAAA,CAAA,GAAQ,IAAA;EAAA,IAGR,IAAA,CAAK,KAAA,EAAO,IAAA;EAGA,QAAA,CAAA;AAAA;;;;;cAML,WAAA,SAAoB,MAAA;EAAA,gBACC,MAAA;;;UADT,UAAA;EAAA;;;;;MAUnB,MAAA,CAAA;EAAA,IAGA,MAAA,CAAO,KAAA;EAGK,QAAA,CAAA;AAAA;;;;;cAML,WAAA,SAAoB,MAAA;EAAA,gBACC,MAAA;;;UADT,UAAA;EAAA;EAMP,QAAA,CAAA;AAAA;;;;;cAML,eAAA,SAAwB,MAAA;EAAA,gBACH,MAAA;;;UADL,UAAA;EAAA;EAMX,QAAA,CAAA;AAAA;;;;;;;;;;;;;;;AAmClB;;;;;;;;;;;;;;;;;;;cAAa,WAAA,SAAoB,MAAA;EAAA,gBACC,MAAA;;;UADT,UAAA;EAAA;EAuCD;;;;;EAAA,IA5BlB,MAAA,CAAA;EAAA,IAGA,MAAA,CAAO,KAAA;EA+DA;;;;EAAA,IAxDP,SAAA,CAAA;EAAA,IAGA,SAAA,CAAU,KAAA;EAekB;;;;EAAA,IAR5B,OAAA,CAAA;EAAA,IAGA,OAAA,CAAQ,KAAA;EAGI,QAAA,CAAA;AAAA;AAAA,cAEL,UAAA,SAAmB,MAAA;EAAA,gBACE,MAAA;;;;;EA2Bf;;;;EAAA,IAlBb,MAAA,CAAA;EAAA,IAGA,MAAA,CAAO,KAAA;EAkBG;;;;;;EAAA,IATV,SAAA,CAAA;EAAA,IAGA,SAAA,CAAU,KAAA;EAGd,SAAA,CAAU,KAAA,EAAO,MAAA,CAAS,OAAA;EAG1B,UAAA,CAAA,GAAc,MAAA,CAAS,OAAA;EAaN;;;;EAAA,IANb,GAAA,CAAA,GAAO,OAAA;EAGX,OAAA,CAAA;EAAA,IAGI,GAAA,CAAI,KAAA,EAAO,OAAA;EAGC,QAAA,CAAA;AAAA"}

package/schemas/rpc-twoparty.mjs

@@ -1,9 +1,27 @@
-import { d as Struct, t as utils, u as ObjectSize } from "./src-s2pCu2mc.mjs";
+import { d as Struct, t as utils, u as ObjectSize } from "./src-B97sIXSw.mjs";
 
 //#region schemas/rpc-twoparty.ts
 const _capnpFileId = BigInt("0xa184c7885cdaf2a1");
 const Side = {
+	/**
+	* The object lives on the "server" or "supervisor" end of the connection. Only the
+	* server/supervisor knows how to interpret the ref; to the client, it is opaque.
+	*
+	* Note that containers intending to implement strong confinement should rewrite SturdyRefs
+	* received from the external network before passing them on to the confined app. The confined
+	* app thus does not ever receive the raw bits of the SturdyRef (which it could perhaps
+	* maliciously leak), but instead receives only a thing that it can pass back to the container
+	* later to restore the ref. See:
+	* http://www.erights.org/elib/capability/dist-confine.html
+	*
+	*/
 	SERVER: 0,
+	/**
+	* The object lives on the "client" or "confined app" end of the connection. Only the client
+	* knows how to interpret the ref; to the server/supervisor, it is opaque. Most clients do not
+	* actually know how to persist capabilities at all, so use of this is unusual.
+	*
+	*/
 	CLIENT: 1
 };
 var VatId = class extends Struct {

package/schemas/rpc-twoparty.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"rpc-twoparty.mjs","names":["$.Struct","$.ObjectSize"],"sources":["../../schemas/rpc-twoparty.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(\"0xa184c7885cdaf2a1\");\nexport const Side = {\n  /**\n* The object lives on the \"server\" or \"supervisor\" end of the connection. Only the\n* server/supervisor knows how to interpret the ref; to the client, it is opaque.\n*\n* Note that containers intending to implement strong confinement should rewrite SturdyRefs\n* received from the external network before passing them on to the confined app. The confined\n* app thus does not ever receive the raw bits of the SturdyRef (which it could perhaps\n* maliciously leak), but instead receives only a thing that it can pass back to the container\n* later to restore the ref. See:\n* http://www.erights.org/elib/capability/dist-confine.html\n*\n*/\n  SERVER: 0,\n  /**\n* The object lives on the \"client\" or \"confined app\" end of the connection. Only the client\n* knows how to interpret the ref; to the server/supervisor, it is opaque. Most clients do not\n* actually know how to persist capabilities at all, so use of this is unusual.\n*\n*/\n  CLIENT: 1\n} as const;\nexport type Side = (typeof Side)[keyof typeof Side];\nexport class VatId extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"VatId\",\n    id: \"d20b909fee733a8e\",\n    size: new $.ObjectSize(8, 0),\n  };\n  get side(): Side {\n    return $.utils.getUint16(0, this) as Side;\n  }\n  set side(value: Side) {\n    $.utils.setUint16(0, value, this);\n  }\n  public override toString(): string { return \"VatId_\" + super.toString(); }\n}\n/**\n* Only used for joins, since three-way introductions never happen on a two-party network.\n*\n*/\nexport class ProvisionId extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"ProvisionId\",\n    id: \"b88d09a9c5f39817\",\n    size: new $.ObjectSize(8, 0),\n  };\n  /**\n* The ID from `JoinKeyPart`.\n*\n*/\n  get joinId(): number {\n    return $.utils.getUint32(0, this);\n  }\n  set joinId(value: number) {\n    $.utils.setUint32(0, value, this);\n  }\n  public override toString(): string { return \"ProvisionId_\" + super.toString(); }\n}\n/**\n* Never used, because there are only two parties.\n*\n*/\nexport class RecipientId extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"RecipientId\",\n    id: \"89f389b6fd4082c1\",\n    size: new $.ObjectSize(0, 0),\n  };\n  public override toString(): string { return \"RecipientId_\" + super.toString(); }\n}\n/**\n* Never used, because there is no third party.\n*\n*/\nexport class ThirdPartyCapId extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"ThirdPartyCapId\",\n    id: \"b47f4979672cb59d\",\n    size: new $.ObjectSize(0, 0),\n  };\n  public override toString(): string { return \"ThirdPartyCapId_\" + super.toString(); }\n}\n/**\n* Joins in the two-party case are simplified by a few observations.\n*\n* First, on a two-party network, a Join only ever makes sense if the receiving end is also\n* connected to other networks.  A vat which is not connected to any other network can safely\n* reject all joins.\n*\n* Second, since a two-party connection bisects the network -- there can be no other connections\n* between the networks at either end of the connection -- if one part of a join crosses the\n* connection, then _all_ parts must cross it.  Therefore, a vat which is receiving a Join request\n* off some other network which needs to be forwarded across the two-party connection can\n* collect all the parts on its end and only forward them across the two-party connection when all\n* have been received.\n*\n* For example, imagine that Alice and Bob are vats connected over a two-party connection, and\n* each is also connected to other networks.  At some point, Alice receives one part of a Join\n* request off her network.  The request is addressed to a capability that Alice received from\n* Bob and is proxying to her other network.  Alice goes ahead and responds to the Join part as\n* if she hosted the capability locally (this is important so that if not all the Join parts end\n* up at Alice, the original sender can detect the failed Join without hanging).  As other parts\n* trickle in, Alice verifies that each part is addressed to a capability from Bob and continues\n* to respond to each one.  Once the complete set of join parts is received, Alice checks if they\n* were all for the exact same capability.  If so, she doesn't need to send anything to Bob at\n* all.  Otherwise, she collects the set of capabilities (from Bob) to which the join parts were\n* addressed and essentially initiates a _new_ Join request on those capabilities to Bob.  Alice\n* does not forward the Join parts she received herself, but essentially forwards the Join as a\n* whole.\n*\n* On Bob's end, since he knows that Alice will always send all parts of a Join together, he\n* simply waits until he's received them all, then performs a join on the respective capabilities\n* as if it had been requested locally.\n*\n*/\nexport class JoinKeyPart extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"JoinKeyPart\",\n    id: \"95b29059097fca83\",\n    size: new $.ObjectSize(8, 0),\n  };\n  /**\n* A number identifying this join, chosen by the sender.  May be reused once `Finish` messages are\n* sent corresponding to all of the `Join` messages.\n*\n*/\n  get joinId(): number {\n    return $.utils.getUint32(0, this);\n  }\n  set joinId(value: number) {\n    $.utils.setUint32(0, value, this);\n  }\n  /**\n* The number of capabilities to be joined.\n*\n*/\n  get partCount(): number {\n    return $.utils.getUint16(4, this);\n  }\n  set partCount(value: number) {\n    $.utils.setUint16(4, value, this);\n  }\n  /**\n* Which part this request targets -- a number in the range [0, partCount).\n*\n*/\n  get partNum(): number {\n    return $.utils.getUint16(6, this);\n  }\n  set partNum(value: number) {\n    $.utils.setUint16(6, value, this);\n  }\n  public override toString(): string { return \"JoinKeyPart_\" + super.toString(); }\n}\nexport class JoinResult extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"JoinResult\",\n    id: \"9d263a3630b7ebee\",\n    size: new $.ObjectSize(8, 1),\n  };\n  /**\n* Matches `JoinKeyPart`.\n*\n*/\n  get joinId(): number {\n    return $.utils.getUint32(0, this);\n  }\n  set joinId(value: number) {\n    $.utils.setUint32(0, value, this);\n  }\n  /**\n* All JoinResults in the set will have the same value for `succeeded`.  The receiver actually\n* implements the join by waiting for all the `JoinKeyParts` and then performing its own join on\n* them, then going back and answering all the join requests afterwards.\n*\n*/\n  get succeeded(): boolean {\n    return $.utils.getBit(32, this);\n  }\n  set succeeded(value: boolean) {\n    $.utils.setBit(32, value, this);\n  }\n  _adoptCap(value: $.Orphan<$.Pointer>): void {\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownCap(): $.Orphan<$.Pointer> {\n    return $.utils.disown(this.cap);\n  }\n  /**\n* One of the JoinResults will have a non-null `cap` which is the joined capability.\n*\n*/\n  get cap(): $.Pointer {\n    return $.utils.getPointer(0, this);\n  }\n  _hasCap(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  set cap(value: $.Pointer) {\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  public override toString(): string { return \"JoinResult_\" + super.toString(); }\n}\n"],"mappings":";;;AAKA,MAAa,eAAe,OAAO,qBAAqB;AACxD,MAAa,OAAO;CAalB,QAAQ;CAOR,QAAQ;CACT;AAED,IAAa,QAAb,cAA2BA,OAAS;CAClC,OAAgC,SAAS;EACvC,aAAa;EACb,IAAI;EACJ,MAAM,IAAIC,WAAa,GAAG,EAAE;EAC7B;CACD,IAAI,OAAa;AACf,eAAe,UAAU,GAAG,KAAK;;CAEnC,IAAI,KAAK,OAAa;AACpB,QAAQ,UAAU,GAAG,OAAO,KAAK;;CAEnC,AAAgB,WAAmB;AAAE,SAAO,WAAW,MAAM,UAAU;;;;;;;AAMzE,IAAa,cAAb,cAAiCD,OAAS;CACxC,OAAgC,SAAS;EACvC,aAAa;EACb,IAAI;EACJ,MAAM,IAAIC,WAAa,GAAG,EAAE;EAC7B;;;;;CAKD,IAAI,SAAiB;AACnB,eAAe,UAAU,GAAG,KAAK;;CAEnC,IAAI,OAAO,OAAe;AACxB,QAAQ,UAAU,GAAG,OAAO,KAAK;;CAEnC,AAAgB,WAAmB;AAAE,SAAO,iBAAiB,MAAM,UAAU;;;;;;;AAM/E,IAAa,cAAb,cAAiCD,OAAS;CACxC,OAAgC,SAAS;EACvC,aAAa;EACb,IAAI;EACJ,MAAM,IAAIC,WAAa,GAAG,EAAE;EAC7B;CACD,AAAgB,WAAmB;AAAE,SAAO,iBAAiB,MAAM,UAAU;;;;;;;AAM/E,IAAa,kBAAb,cAAqCD,OAAS;CAC5C,OAAgC,SAAS;EACvC,aAAa;EACb,IAAI;EACJ,MAAM,IAAIC,WAAa,GAAG,EAAE;EAC7B;CACD,AAAgB,WAAmB;AAAE,SAAO,qBAAqB,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCnF,IAAa,cAAb,cAAiCD,OAAS;CACxC,OAAgC,SAAS;EACvC,aAAa;EACb,IAAI;EACJ,MAAM,IAAIC,WAAa,GAAG,EAAE;EAC7B;;;;;;CAMD,IAAI,SAAiB;AACnB,eAAe,UAAU,GAAG,KAAK;;CAEnC,IAAI,OAAO,OAAe;AACxB,QAAQ,UAAU,GAAG,OAAO,KAAK;;;;;;CAMnC,IAAI,YAAoB;AACtB,eAAe,UAAU,GAAG,KAAK;;CAEnC,IAAI,UAAU,OAAe;AAC3B,QAAQ,UAAU,GAAG,OAAO,KAAK;;;;;;CAMnC,IAAI,UAAkB;AACpB,eAAe,UAAU,GAAG,KAAK;;CAEnC,IAAI,QAAQ,OAAe;AACzB,QAAQ,UAAU,GAAG,OAAO,KAAK;;CAEnC,AAAgB,WAAmB;AAAE,SAAO,iBAAiB,MAAM,UAAU;;;AAE/E,IAAa,aAAb,cAAgCD,OAAS;CACvC,OAAgC,SAAS;EACvC,aAAa;EACb,IAAI;EACJ,MAAM,IAAIC,WAAa,GAAG,EAAE;EAC7B;;;;;CAKD,IAAI,SAAiB;AACnB,eAAe,UAAU,GAAG,KAAK;;CAEnC,IAAI,OAAO,OAAe;AACxB,QAAQ,UAAU,GAAG,OAAO,KAAK;;;;;;;;CAQnC,IAAI,YAAqB;AACvB,eAAe,OAAO,IAAI,KAAK;;CAEjC,IAAI,UAAU,OAAgB;AAC5B,QAAQ,OAAO,IAAI,OAAO,KAAK;;CAEjC,UAAU,OAAkC;AAC1C,QAAQ,MAAM,aAAe,WAAW,GAAG,KAAK,CAAC;;CAEnD,aAAkC;AAChC,eAAe,OAAO,KAAK,IAAI;;;;;;CAMjC,IAAI,MAAiB;AACnB,eAAe,WAAW,GAAG,KAAK;;CAEpC,UAAmB;AACjB,SAAO,OAAS,aAAe,WAAW,GAAG,KAAK,CAAC;;CAErD,IAAI,IAAI,OAAkB;AACxB,QAAQ,SAAS,aAAe,WAAW,GAAG,KAAK,CAAC;;CAEtD,AAAgB,WAAmB;AAAE,SAAO,gBAAgB,MAAM,UAAU"}
+{"version":3,"file":"rpc-twoparty.mjs","names":["$.Struct","$.ObjectSize"],"sources":["../../schemas/rpc-twoparty.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(\"0xa184c7885cdaf2a1\");\nexport const Side = {\n  /**\n* The object lives on the \"server\" or \"supervisor\" end of the connection. Only the\n* server/supervisor knows how to interpret the ref; to the client, it is opaque.\n*\n* Note that containers intending to implement strong confinement should rewrite SturdyRefs\n* received from the external network before passing them on to the confined app. The confined\n* app thus does not ever receive the raw bits of the SturdyRef (which it could perhaps\n* maliciously leak), but instead receives only a thing that it can pass back to the container\n* later to restore the ref. See:\n* http://www.erights.org/elib/capability/dist-confine.html\n*\n*/\n  SERVER: 0,\n  /**\n* The object lives on the \"client\" or \"confined app\" end of the connection. Only the client\n* knows how to interpret the ref; to the server/supervisor, it is opaque. Most clients do not\n* actually know how to persist capabilities at all, so use of this is unusual.\n*\n*/\n  CLIENT: 1\n} as const;\nexport type Side = (typeof Side)[keyof typeof Side];\nexport class VatId extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"VatId\",\n    id: \"d20b909fee733a8e\",\n    size: new $.ObjectSize(8, 0),\n  };\n  get side(): Side {\n    return $.utils.getUint16(0, this) as Side;\n  }\n  set side(value: Side) {\n    $.utils.setUint16(0, value, this);\n  }\n  public override toString(): string { return \"VatId_\" + super.toString(); }\n}\n/**\n* Only used for joins, since three-way introductions never happen on a two-party network.\n*\n*/\nexport class ProvisionId extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"ProvisionId\",\n    id: \"b88d09a9c5f39817\",\n    size: new $.ObjectSize(8, 0),\n  };\n  /**\n* The ID from `JoinKeyPart`.\n*\n*/\n  get joinId(): number {\n    return $.utils.getUint32(0, this);\n  }\n  set joinId(value: number) {\n    $.utils.setUint32(0, value, this);\n  }\n  public override toString(): string { return \"ProvisionId_\" + super.toString(); }\n}\n/**\n* Never used, because there are only two parties.\n*\n*/\nexport class RecipientId extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"RecipientId\",\n    id: \"89f389b6fd4082c1\",\n    size: new $.ObjectSize(0, 0),\n  };\n  public override toString(): string { return \"RecipientId_\" + super.toString(); }\n}\n/**\n* Never used, because there is no third party.\n*\n*/\nexport class ThirdPartyCapId extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"ThirdPartyCapId\",\n    id: \"b47f4979672cb59d\",\n    size: new $.ObjectSize(0, 0),\n  };\n  public override toString(): string { return \"ThirdPartyCapId_\" + super.toString(); }\n}\n/**\n* Joins in the two-party case are simplified by a few observations.\n*\n* First, on a two-party network, a Join only ever makes sense if the receiving end is also\n* connected to other networks.  A vat which is not connected to any other network can safely\n* reject all joins.\n*\n* Second, since a two-party connection bisects the network -- there can be no other connections\n* between the networks at either end of the connection -- if one part of a join crosses the\n* connection, then _all_ parts must cross it.  Therefore, a vat which is receiving a Join request\n* off some other network which needs to be forwarded across the two-party connection can\n* collect all the parts on its end and only forward them across the two-party connection when all\n* have been received.\n*\n* For example, imagine that Alice and Bob are vats connected over a two-party connection, and\n* each is also connected to other networks.  At some point, Alice receives one part of a Join\n* request off her network.  The request is addressed to a capability that Alice received from\n* Bob and is proxying to her other network.  Alice goes ahead and responds to the Join part as\n* if she hosted the capability locally (this is important so that if not all the Join parts end\n* up at Alice, the original sender can detect the failed Join without hanging).  As other parts\n* trickle in, Alice verifies that each part is addressed to a capability from Bob and continues\n* to respond to each one.  Once the complete set of join parts is received, Alice checks if they\n* were all for the exact same capability.  If so, she doesn't need to send anything to Bob at\n* all.  Otherwise, she collects the set of capabilities (from Bob) to which the join parts were\n* addressed and essentially initiates a _new_ Join request on those capabilities to Bob.  Alice\n* does not forward the Join parts she received herself, but essentially forwards the Join as a\n* whole.\n*\n* On Bob's end, since he knows that Alice will always send all parts of a Join together, he\n* simply waits until he's received them all, then performs a join on the respective capabilities\n* as if it had been requested locally.\n*\n*/\nexport class JoinKeyPart extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"JoinKeyPart\",\n    id: \"95b29059097fca83\",\n    size: new $.ObjectSize(8, 0),\n  };\n  /**\n* A number identifying this join, chosen by the sender.  May be reused once `Finish` messages are\n* sent corresponding to all of the `Join` messages.\n*\n*/\n  get joinId(): number {\n    return $.utils.getUint32(0, this);\n  }\n  set joinId(value: number) {\n    $.utils.setUint32(0, value, this);\n  }\n  /**\n* The number of capabilities to be joined.\n*\n*/\n  get partCount(): number {\n    return $.utils.getUint16(4, this);\n  }\n  set partCount(value: number) {\n    $.utils.setUint16(4, value, this);\n  }\n  /**\n* Which part this request targets -- a number in the range [0, partCount).\n*\n*/\n  get partNum(): number {\n    return $.utils.getUint16(6, this);\n  }\n  set partNum(value: number) {\n    $.utils.setUint16(6, value, this);\n  }\n  public override toString(): string { return \"JoinKeyPart_\" + super.toString(); }\n}\nexport class JoinResult extends $.Struct {\n  public static override readonly _capnp = {\n    displayName: \"JoinResult\",\n    id: \"9d263a3630b7ebee\",\n    size: new $.ObjectSize(8, 1),\n  };\n  /**\n* Matches `JoinKeyPart`.\n*\n*/\n  get joinId(): number {\n    return $.utils.getUint32(0, this);\n  }\n  set joinId(value: number) {\n    $.utils.setUint32(0, value, this);\n  }\n  /**\n* All JoinResults in the set will have the same value for `succeeded`.  The receiver actually\n* implements the join by waiting for all the `JoinKeyParts` and then performing its own join on\n* them, then going back and answering all the join requests afterwards.\n*\n*/\n  get succeeded(): boolean {\n    return $.utils.getBit(32, this);\n  }\n  set succeeded(value: boolean) {\n    $.utils.setBit(32, value, this);\n  }\n  _adoptCap(value: $.Orphan<$.Pointer>): void {\n    $.utils.adopt(value, $.utils.getPointer(0, this));\n  }\n  _disownCap(): $.Orphan<$.Pointer> {\n    return $.utils.disown(this.cap);\n  }\n  /**\n* One of the JoinResults will have a non-null `cap` which is the joined capability.\n*\n*/\n  get cap(): $.Pointer {\n    return $.utils.getPointer(0, this);\n  }\n  _hasCap(): boolean {\n    return !$.utils.isNull($.utils.getPointer(0, this));\n  }\n  set cap(value: $.Pointer) {\n    $.utils.copyFrom(value, $.utils.getPointer(0, this));\n  }\n  public override toString(): string { return \"JoinResult_\" + super.toString(); }\n}\n"],"mappings":";;;AAKA,MAAa,eAAe,OAAO,qBAAqB;AACxD,MAAa,OAAO;;;;;;;;;;;;;CAalB,QAAQ;;;;;;;CAOR,QAAQ;CACT;AAED,IAAa,QAAb,cAA2BA,OAAS;CAClC,OAAgC,SAAS;EACvC,aAAa;EACb,IAAI;EACJ,MAAM,IAAIC,WAAa,GAAG,EAAE;EAC7B;CACD,IAAI,OAAa;AACf,eAAe,UAAU,GAAG,KAAK;;CAEnC,IAAI,KAAK,OAAa;AACpB,QAAQ,UAAU,GAAG,OAAO,KAAK;;CAEnC,AAAgB,WAAmB;AAAE,SAAO,WAAW,MAAM,UAAU;;;;;;;AAMzE,IAAa,cAAb,cAAiCD,OAAS;CACxC,OAAgC,SAAS;EACvC,aAAa;EACb,IAAI;EACJ,MAAM,IAAIC,WAAa,GAAG,EAAE;EAC7B;;;;;CAKD,IAAI,SAAiB;AACnB,eAAe,UAAU,GAAG,KAAK;;CAEnC,IAAI,OAAO,OAAe;AACxB,QAAQ,UAAU,GAAG,OAAO,KAAK;;CAEnC,AAAgB,WAAmB;AAAE,SAAO,iBAAiB,MAAM,UAAU;;;;;;;AAM/E,IAAa,cAAb,cAAiCD,OAAS;CACxC,OAAgC,SAAS;EACvC,aAAa;EACb,IAAI;EACJ,MAAM,IAAIC,WAAa,GAAG,EAAE;EAC7B;CACD,AAAgB,WAAmB;AAAE,SAAO,iBAAiB,MAAM,UAAU;;;;;;;AAM/E,IAAa,kBAAb,cAAqCD,OAAS;CAC5C,OAAgC,SAAS;EACvC,aAAa;EACb,IAAI;EACJ,MAAM,IAAIC,WAAa,GAAG,EAAE;EAC7B;CACD,AAAgB,WAAmB;AAAE,SAAO,qBAAqB,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCnF,IAAa,cAAb,cAAiCD,OAAS;CACxC,OAAgC,SAAS;EACvC,aAAa;EACb,IAAI;EACJ,MAAM,IAAIC,WAAa,GAAG,EAAE;EAC7B;;;;;;CAMD,IAAI,SAAiB;AACnB,eAAe,UAAU,GAAG,KAAK;;CAEnC,IAAI,OAAO,OAAe;AACxB,QAAQ,UAAU,GAAG,OAAO,KAAK;;;;;;CAMnC,IAAI,YAAoB;AACtB,eAAe,UAAU,GAAG,KAAK;;CAEnC,IAAI,UAAU,OAAe;AAC3B,QAAQ,UAAU,GAAG,OAAO,KAAK;;;;;;CAMnC,IAAI,UAAkB;AACpB,eAAe,UAAU,GAAG,KAAK;;CAEnC,IAAI,QAAQ,OAAe;AACzB,QAAQ,UAAU,GAAG,OAAO,KAAK;;CAEnC,AAAgB,WAAmB;AAAE,SAAO,iBAAiB,MAAM,UAAU;;;AAE/E,IAAa,aAAb,cAAgCD,OAAS;CACvC,OAAgC,SAAS;EACvC,aAAa;EACb,IAAI;EACJ,MAAM,IAAIC,WAAa,GAAG,EAAE;EAC7B;;;;;CAKD,IAAI,SAAiB;AACnB,eAAe,UAAU,GAAG,KAAK;;CAEnC,IAAI,OAAO,OAAe;AACxB,QAAQ,UAAU,GAAG,OAAO,KAAK;;;;;;;;CAQnC,IAAI,YAAqB;AACvB,eAAe,OAAO,IAAI,KAAK;;CAEjC,IAAI,UAAU,OAAgB;AAC5B,QAAQ,OAAO,IAAI,OAAO,KAAK;;CAEjC,UAAU,OAAkC;AAC1C,QAAQ,MAAM,aAAe,WAAW,GAAG,KAAK,CAAC;;CAEnD,aAAkC;AAChC,eAAe,OAAO,KAAK,IAAI;;;;;;CAMjC,IAAI,MAAiB;AACnB,eAAe,WAAW,GAAG,KAAK;;CAEpC,UAAmB;AACjB,SAAO,OAAS,aAAe,WAAW,GAAG,KAAK,CAAC;;CAErD,IAAI,IAAI,OAAkB;AACxB,QAAQ,SAAS,aAAe,WAAW,GAAG,KAAK,CAAC;;CAEtD,AAAgB,WAAmB;AAAE,SAAO,gBAAgB,MAAM,UAAU"}

package/schemas/rpc.cjs

@@ -1,21 +1,100 @@
-const require_src = require('./src-2eLj6yCr.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_src = require('./src-B6FhDNiV.cjs');
 
 //#region schemas/rpc.ts
 const _capnpFileId = BigInt("0xb312981b2552a250");
 const Message_Which = {
+	/**
+	* The sender previously received this message from the peer but didn't understand it or doesn't
+	* yet implement the functionality that was requested.  So, the sender is echoing the message
+	* back.  In some cases, the receiver may be able to recover from this by pretending the sender
+	* had taken some appropriate "null" action.
+	*
+	* For example, say `resolve` is received by a level 0 implementation (because a previous call
+	* or return happened to contain a promise).  The level 0 implementation will echo it back as
+	* `unimplemented`.  The original sender can then simply release the cap to which the promise
+	* had resolved, thus avoiding a leak.
+	*
+	* For any message type that introduces a question, if the message comes back unimplemented,
+	* the original sender may simply treat it as if the question failed with an exception.
+	*
+	* In cases where there is no sensible way to react to an `unimplemented` message (without
+	* resource leaks or other serious problems), the connection may need to be aborted.  This is
+	* a gray area; different implementations may take different approaches.
+	*
+	*/
 	UNIMPLEMENTED: 0,
+	/**
+	* Sent when a connection is being aborted due to an unrecoverable error.  This could be e.g.
+	* because the sender received an invalid or nonsensical message or because the sender had an
+	* internal error.  The sender will shut down the outgoing half of the connection after `abort`
+	* and will completely close the connection shortly thereafter (it's up to the sender how much
+	* of a time buffer they want to offer for the client to receive the `abort` before the
+	* connection is reset).
+	*
+	*/
 	ABORT: 1,
+	/**
+	* Request the peer's bootstrap interface.
+	*
+	*/
 	BOOTSTRAP: 8,
+	/**
+	* Begin a method call.
+	*
+	*/
 	CALL: 2,
+	/**
+	* Complete a method call.
+	*
+	*/
 	RETURN: 3,
+	/**
+	* Release a returned answer / cancel a call.
+	*
+	*/
 	FINISH: 4,
+	/**
+	* Resolve a previously-sent promise.
+	*
+	*/
 	RESOLVE: 5,
+	/**
+	* Release a capability so that the remote object can be deallocated.
+	*
+	*/
 	RELEASE: 6,
+	/**
+	* Lift an embargo used to enforce E-order over promise resolution.
+	*
+	*/
 	DISEMBARGO: 13,
+	/**
+	* Obsolete request to save a capability, resulting in a SturdyRef. This has been replaced
+	* by the `Persistent` interface defined in `persistent.capnp`. This operation was never
+	* implemented.
+	*
+	*/
 	OBSOLETE_SAVE: 7,
+	/**
+	* Obsolete way to delete a SturdyRef. This operation was never implemented.
+	*
+	*/
 	OBSOLETE_DELETE: 9,
+	/**
+	* Provide a capability to a third party.
+	*
+	*/
 	PROVIDE: 10,
+	/**
+	* Accept a capability provided by a third party.
+	*
+	*/
 	ACCEPT: 11,
+	/**
+	* Directly connect to the common root of two or more proxied caps.
+	*
+	*/
 	JOIN: 12
 };
 /**
@@ -614,8 +693,65 @@ var Bootstrap = class extends require_src.Struct {
 	}
 };
 const Call_SendResultsTo_Which = {
+	/**
+	* Send the return message back to the caller (the usual).
+	*
+	*/
 	CALLER: 0,
+	/**
+	* **(level 1)**
+	*
+	* Don't actually return the results to the sender.  Instead, hold on to them and await
+	* instructions from the sender regarding what to do with them.  In particular, the sender
+	* may subsequently send a `Return` for some other call (which the receiver had previously made
+	* to the sender) with `takeFromOtherQuestion` set.  The results from this call are then used
+	* as the results of the other call.
+	*
+	* When `yourself` is used, the receiver must still send a `Return` for the call, but sets the
+	* field `resultsSentElsewhere` in that `Return` rather than including the results.
+	*
+	* This feature can be used to implement tail calls in which a call from Vat A to Vat B ends up
+	* returning the result of a call from Vat B back to Vat A.
+	*
+	* In particular, the most common use case for this feature is when Vat A makes a call to a
+	* promise in Vat B, and then that promise ends up resolving to a capability back in Vat A.
+	* Vat B must forward all the queued calls on that promise back to Vat A, but can set `yourself`
+	* in the calls so that the results need not pass back through Vat B.
+	*
+	* For example:
+	* - Alice, in Vat A, calls foo() on Bob in Vat B.
+	* - Alice makes a pipelined call bar() on the promise returned by foo().
+	* - Later on, Bob resolves the promise from foo() to point at Carol, who lives in Vat A (next
+	*   to Alice).
+	* - Vat B dutifully forwards the bar() call to Carol.  Let us call this forwarded call bar'().
+	*   Notice that bar() and bar'() are travelling in opposite directions on the same network
+	*   link.
+	* - The `Call` for bar'() has `sendResultsTo` set to `yourself`.
+	* - Vat B sends a `Return` for bar() with `takeFromOtherQuestion` set in place of the results,
+	*   with the value set to the question ID of bar'().  Vat B does not wait for bar'() to return,
+	*   as doing so would introduce unnecessary round trip latency.
+	* - Vat A receives bar'() and delivers it to Carol.
+	* - When bar'() returns, Vat A sends a `Return` for bar'() to Vat B, with `resultsSentElsewhere`
+	*   set in place of results.
+	* - Vat A sends a `Finish` for the bar() call to Vat B.
+	* - Vat B receives the `Finish` for bar() and sends a `Finish` for bar'().
+	*
+	*/
 	YOURSELF: 1,
+	/**
+	* **(level 3)**
+	*
+	* The call's result should be returned to a different vat.  The receiver (the callee) expects
+	* to receive an `Accept` message from the indicated vat, and should return the call's result
+	* to it, rather than to the sender of the `Call`.
+	*
+	* This operates much like `yourself`, above, except that Carol is in a separate Vat C.  `Call`
+	* messages are sent from Vat A -> Vat B and Vat B -> Vat C.  A `Return` message is sent from
+	* Vat B -> Vat A that contains `acceptFromThirdParty` in place of results.  When Vat A sends
+	* an `Accept` to Vat C, it receives back a `Return` containing the call's actual result.  Vat C
+	* also sends a `Return` to Vat B with `resultsSentElsewhere`.
+	*
+	*/
 	THIRD_PARTY: 2
 };
 /**
@@ -847,11 +983,54 @@ var Call = class Call extends require_src.Struct {
 	}
 };
 const Return_Which = {
+	/**
+	* Equal to the QuestionId of the corresponding `Call` message.
+	*
+	*/
 	RESULTS: 0,
+	/**
+	* If true, all capabilities that were in the params should be considered released.  The sender
+	* must not send separate `Release` messages for them.  Level 0 implementations in particular
+	* should always set this true.  This defaults true because if level 0 implementations forget to
+	* set it they'll never notice (just silently leak caps), but if level >=1 implementations forget
+	* to set it to false they'll quickly get errors.
+	*
+	* The receiver should act as if the sender had sent a release message with count=1 for each
+	* CapDescriptor in the original Call message.
+	*
+	*/
 	EXCEPTION: 1,
+	/**
+	* The result.
+	*
+	* For regular method calls, `results.content` points to the result struct.
+	*
+	* For a `Return` in response to an `Accept` or `Bootstrap`, `results` contains a single
+	* capability (rather than a struct), and `results.content` is just a capability pointer with
+	* index 0.  A `Finish` is still required in this case.
+	*
+	*/
 	CANCELED: 2,
+	/**
+	* Indicates that the call failed and explains why.
+	*
+	*/
 	RESULTS_SENT_ELSEWHERE: 3,
+	/**
+	* Indicates that the call was canceled due to the caller sending a Finish message
+	* before the call had completed.
+	*
+	*/
 	TAKE_FROM_OTHER_QUESTION: 4,
+	/**
+	* This is set when returning from a `Call` that had `sendResultsTo` set to something other
+	* than `caller`.
+	*
+	* It doesn't matter too much when this is sent, as the receiver doesn't need to do anything
+	* with it, but the C++ implementation appears to wait for the call to finish before sending
+	* this.
+	*
+	*/
 	ACCEPT_FROM_THIRD_PARTY: 5
 };
 /**
@@ -1123,7 +1302,43 @@ var Finish = class Finish extends require_src.Struct {
 	}
 };
 const Resolve_Which = {
+	/**
+	* The ID of the promise to be resolved.
+	*
+	* Unlike all other instances of `ExportId` sent from the exporter, the `Resolve` message does
+	* _not_ increase the reference count of `promiseId`.  In fact, it is expected that the receiver
+	* will release the export soon after receiving `Resolve`, and the sender will not send this
+	* `ExportId` again until it has been released and recycled.
+	*
+	* When an export ID sent over the wire (e.g. in a `CapDescriptor`) is indicated to be a promise,
+	* this indicates that the sender will follow up at some point with a `Resolve` message.  If the
+	* same `promiseId` is sent again before `Resolve`, still only one `Resolve` is sent.  If the
+	* same ID is sent again later _after_ a `Resolve`, it can only be because the export's
+	* reference count hit zero in the meantime and the ID was re-assigned to a new export, therefore
+	* this later promise does _not_ correspond to the earlier `Resolve`.
+	*
+	* If a promise ID's reference count reaches zero before a `Resolve` is sent, the `Resolve`
+	* message may or may not still be sent (the `Resolve` may have already been in-flight when
+	* `Release` was sent, but if the `Release` is received before `Resolve` then there is no longer
+	* any reason to send a `Resolve`).  Thus a `Resolve` may be received for a promise of which
+	* the receiver has no knowledge, because it already released it earlier.  In this case, the
+	* receiver should simply release the capability to which the promise resolved.
+	*
+	*/
 	CAP: 0,
+	/**
+	* The object to which the promise resolved.
+	*
+	* The sender promises that from this point forth, until `promiseId` is released, it shall
+	* simply forward all messages to the capability designated by `cap`.  This is true even if
+	* `cap` itself happens to designate another promise, and that other promise later resolves --
+	* messages sent to `promiseId` shall still go to that other promise, not to its resolution.
+	* This is important in the case that the receiver of the `Resolve` ends up sending a
+	* `Disembargo` message towards `promiseId` in order to control message ordering -- that
+	* `Disembargo` really needs to reflect back to exactly the object designated by `cap` even
+	* if that object is itself a promise.
+	*
+	*/
 	EXCEPTION: 1
 };
 /**
@@ -1295,9 +1510,48 @@ var Release = class extends require_src.Struct {
 	}
 };
 const Disembargo_Context_Which = {
+	/**
+	* The sender is requesting a disembargo on a promise that is known to resolve back to a
+	* capability hosted by the sender.  As soon as the receiver has echoed back all pipelined calls
+	* on this promise, it will deliver the Disembargo back to the sender with `receiverLoopback`
+	* set to the same value as `senderLoopback`.  This value is chosen by the sender, and since
+	* it is also consumed be the sender, the sender can use whatever strategy it wants to make sure
+	* the value is unambiguous.
+	*
+	* The receiver must verify that the target capability actually resolves back to the sender's
+	* vat.  Otherwise, the sender has committed a protocol error and should be disconnected.
+	*
+	*/
 	SENDER_LOOPBACK: 0,
+	/**
+	* The receiver previously sent a `senderLoopback` Disembargo towards a promise resolving to
+	* this capability, and that Disembargo is now being echoed back.
+	*
+	*/
 	RECEIVER_LOOPBACK: 1,
+	/**
+	* **(level 3)**
+	*
+	* The sender is requesting a disembargo on a promise that is known to resolve to a third-party
+	* capability that the sender is currently in the process of accepting (using `Accept`).
+	* The receiver of this `Disembargo` has an outstanding `Provide` on said capability.  The
+	* receiver should now send a `Disembargo` with `provide` set to the question ID of that
+	* `Provide` message.
+	*
+	* See `Accept.embargo` for an example.
+	*
+	*/
 	ACCEPT: 2,
+	/**
+	* **(level 3)**
+	*
+	* The sender is requesting a disembargo on a capability currently being provided to a third
+	* party.  The question ID identifies the `Provide` message previously sent by the sender to
+	* this capability.  On receipt, the receiver (the capability host) shall release the embargo
+	* on the `Accept` message that it has received from the third party.  See `Accept.embargo` for
+	* an example.
+	*
+	*/
 	PROVIDE: 3
 };
 var Disembargo_Context = class extends require_src.Struct {
@@ -1777,7 +2031,20 @@ var Join = class extends require_src.Struct {
 	}
 };
 const MessageTarget_Which = {
+	/**
+	* This message is to a capability or promise previously imported by the caller (exported by
+	* the receiver).
+	*
+	*/
 	IMPORTED_CAP: 0,
+	/**
+	* This message is to a capability that is expected to be returned by another call that has not
+	* yet been completed.
+	*
+	* At level 0, this is supported only for addressing the result of a previous `Bootstrap`, so
+	* that initial startup doesn't require a round trip.
+	*
+	*/
 	PROMISED_ANSWER: 1
 };
 /**
@@ -1906,11 +2173,52 @@ var Payload = class Payload extends require_src.Struct {
 	}
 };
 const CapDescriptor_Which = {
+	/**
+	* There is no capability here.  This `CapDescriptor` should not appear in the payload content.
+	* A `none` CapDescriptor can be generated when an application inserts a capability into a
+	* message and then later changes its mind and removes it -- rewriting all of the other
+	* capability pointers may be hard, so instead a tombstone is left, similar to the way a removed
+	* struct or list instance is zeroed out of the message but the space is not reclaimed.
+	* Hopefully this is unusual.
+	*
+	*/
 	NONE: 0,
+	/**
+	* The ID of a capability in the sender's export table (receiver's import table).  It may be a
+	* newly allocated table entry, or an existing entry (increments the reference count).
+	*
+	*/
 	SENDER_HOSTED: 1,
+	/**
+	* A promise that the sender will resolve later.  The sender will send exactly one Resolve
+	* message at a future point in time to replace this promise.  Note that even if the same
+	* `senderPromise` is received multiple times, only one `Resolve` is sent to cover all of
+	* them.  If `senderPromise` is released before the `Resolve` is sent, the sender (of this
+	* `CapDescriptor`) may choose not to send the `Resolve` at all.
+	*
+	*/
 	SENDER_PROMISE: 2,
+	/**
+	* A capability (or promise) previously exported by the receiver (imported by the sender).
+	*
+	*/
 	RECEIVER_HOSTED: 3,
+	/**
+	* A capability expected to be returned in the results of a currently-outstanding call posed
+	* by the sender.
+	*
+	*/
 	RECEIVER_ANSWER: 4,
+	/**
+	* **(level 3)**
+	*
+	* A capability that lives in neither the sender's nor the receiver's vat.  The sender needs
+	* to form a direct connection to a third party to pick up the capability.
+	*
+	* Level 1 and 2 implementations that receive a `thirdPartyHosted` may simply send calls to its
+	* `vine` instead.
+	*
+	*/
 	THIRD_PARTY_HOSTED: 5
 };
 /**
@@ -2137,7 +2445,17 @@ var CapDescriptor = class CapDescriptor extends require_src.Struct {
 	}
 };
 const PromisedAnswer_Op_Which = {
+	/**
+	* Does nothing.  This member is mostly defined so that we can make `Op` a union even
+	* though (as of this writing) only one real operation is defined.
+	*
+	*/
 	NOOP: 0,
+	/**
+	* Get a pointer field within a struct.  The number is an index into the pointer section, NOT
+	* a field ordinal, so that the receiver does not need to understand the schema.
+	*
+	*/
 	GET_POINTER_FIELD: 1
 };
 var PromisedAnswer_Op = class extends require_src.Struct {
@@ -2296,9 +2614,61 @@ var ThirdPartyCapDescriptor = class extends require_src.Struct {
 	}
 };
 const Exception_Type = {
+	/**
+	* A generic problem occurred, and it is believed that if the operation were repeated without
+	* any change in the state of the world, the problem would occur again.
+	*
+	* A client might respond to this error by logging it for investigation by the developer and/or
+	* displaying it to the user.
+	*
+	*/
 	FAILED: 0,
+	/**
+	* The request was rejected due to a temporary lack of resources.
+	*
+	* Examples include:
+	* - There's not enough CPU time to keep up with incoming requests, so some are rejected.
+	* - The server ran out of RAM or disk space during the request.
+	* - The operation timed out (took significantly longer than it should have).
+	*
+	* A client might respond to this error by scheduling to retry the operation much later. The
+	* client should NOT retry again immediately since this would likely exacerbate the problem.
+	*
+	*/
 	OVERLOADED: 1,
+	/**
+	* The method failed because a connection to some necessary capability was lost.
+	*
+	* Examples include:
+	* - The client introduced the server to a third-party capability, the connection to that third
+	*   party was subsequently lost, and then the client requested that the server use the dead
+	*   capability for something.
+	* - The client previously requested that the server obtain a capability from some third party.
+	*   The server returned a capability to an object wrapping the third-party capability. Later,
+	*   the server's connection to the third party was lost.
+	* - The capability has been revoked. Revocation does not necessarily mean that the client is
+	*   no longer authorized to use the capability; it is often used simply as a way to force the
+	*   client to repeat the setup process, perhaps to efficiently move them to a new back-end or
+	*   get them to recognize some other change that has occurred.
+	*
+	* A client should normally respond to this error by releasing all capabilities it is currently
+	* holding related to the one it called and then re-creating them by restoring SturdyRefs and/or
+	* repeating the method calls used to create them originally. In other words, disconnect and
+	* start over. This should in turn cause the server to obtain a new copy of the capability that
+	* it lost, thus making everything work.
+	*
+	* If the client receives another `disconnected` error in the process of rebuilding the
+	* capability and retrying the call, it should treat this as an `overloaded` error: the network
+	* is currently unreliable, possibly due to load or other temporary issues.
+	*
+	*/
 	DISCONNECTED: 2,
+	/**
+	* The server doesn't implement the requested method. If there is some other method that the
+	* client could call (perhaps an older and/or slower interface), it should try that instead.
+	* Otherwise, this should be treated like `failed`.
+	*
+	*/
 	UNIMPLEMENTED: 3
 };
 /**