@stryke/capnp 0.8.2 → 0.9.0

package/schemas/chunk-SHUYVCID.js

@@ -0,0 +1,6 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+export {
+  __name
+};

package/schemas/chunk-USNT2KNT.cjs

@@ -0,0 +1,6 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+
+
+exports.__name = __name;

package/schemas/cpp.cjs

@@ -0,0 +1,7 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('./chunk-USNT2KNT.cjs');
+
+// schemas/cpp.ts
+var _capnpFileId = BigInt("0xbdf87d7bb8304e82");
+
+
+exports._capnpFileId = _capnpFileId;

package/schemas/cpp.d.cts

@@ -0,0 +1,3 @@
+declare const _capnpFileId: bigint;
+
+export { _capnpFileId };

package/schemas/cpp.d.ts

@@ -0,0 +1,3 @@
+declare const _capnpFileId: bigint;
+
+export { _capnpFileId };

package/schemas/cpp.js

@@ -0,0 +1,7 @@
+import "./chunk-SHUYVCID.js";
+
+// schemas/cpp.ts
+var _capnpFileId = BigInt("0xbdf87d7bb8304e82");
+export {
+  _capnpFileId
+};

package/schemas/persistent.cjs

@@ -0,0 +1,171 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class; var _class2; var _class3; var _class4;
+
+
+
+
+
+
+
+var _chunkGX6VRR3Gcjs = require('./chunk-GX6VRR3G.cjs');
+
+
+var _chunkUSNT2KNTcjs = require('./chunk-USNT2KNT.cjs');
+
+// schemas/persistent.ts
+var _capnpFileId = BigInt("0xb8630836983feed7");
+var Persistent_SaveParams = (_class = class extends _chunkGX6VRR3Gcjs.Struct {
+  static {
+    _chunkUSNT2KNTcjs.__name.call(void 0, this, "Persistent_SaveParams");
+  }
+  static __initStatic() {this._capnp = {
+    displayName: "SaveParams",
+    id: "f76fba59183073a5",
+    size: new (0, _chunkGX6VRR3Gcjs.ObjectSize)(0, 1)
+  }}
+  _adoptSealFor(value) {
+    _chunkGX6VRR3Gcjs.utils.adopt(value, _chunkGX6VRR3Gcjs.utils.getPointer(0, this));
+  }
+  _disownSealFor() {
+    return _chunkGX6VRR3Gcjs.utils.disown(this.sealFor);
+  }
+  /**
+  * Seal the SturdyRef so that it can only be restored by the specified Owner. This is meant
+  * to mitigate damage when a SturdyRef is leaked. See comments above.
+  *
+  * Leaving this value null may or may not be allowed; it is up to the realm to decide. If a
+  * realm does allow a null owner, this should indicate that anyone is allowed to restore the
+  * ref.
+  *
+  */
+  get sealFor() {
+    return _chunkGX6VRR3Gcjs.utils.getPointer(0, this);
+  }
+  _hasSealFor() {
+    return !_chunkGX6VRR3Gcjs.utils.isNull(_chunkGX6VRR3Gcjs.utils.getPointer(0, this));
+  }
+  set sealFor(value) {
+    _chunkGX6VRR3Gcjs.utils.copyFrom(value, _chunkGX6VRR3Gcjs.utils.getPointer(0, this));
+  }
+  toString() {
+    return "Persistent_SaveParams_" + super.toString();
+  }
+}, _class.__initStatic(), _class);
+var Persistent_SaveResults = (_class2 = class extends _chunkGX6VRR3Gcjs.Struct {
+  static {
+    _chunkUSNT2KNTcjs.__name.call(void 0, this, "Persistent_SaveResults");
+  }
+  static __initStatic2() {this._capnp = {
+    displayName: "SaveResults",
+    id: "b76848c18c40efbf",
+    size: new (0, _chunkGX6VRR3Gcjs.ObjectSize)(0, 1)
+  }}
+  _adoptSturdyRef(value) {
+    _chunkGX6VRR3Gcjs.utils.adopt(value, _chunkGX6VRR3Gcjs.utils.getPointer(0, this));
+  }
+  _disownSturdyRef() {
+    return _chunkGX6VRR3Gcjs.utils.disown(this.sturdyRef);
+  }
+  get sturdyRef() {
+    return _chunkGX6VRR3Gcjs.utils.getPointer(0, this);
+  }
+  _hasSturdyRef() {
+    return !_chunkGX6VRR3Gcjs.utils.isNull(_chunkGX6VRR3Gcjs.utils.getPointer(0, this));
+  }
+  set sturdyRef(value) {
+    _chunkGX6VRR3Gcjs.utils.copyFrom(value, _chunkGX6VRR3Gcjs.utils.getPointer(0, this));
+  }
+  toString() {
+    return "Persistent_SaveResults_" + super.toString();
+  }
+}, _class2.__initStatic2(), _class2);
+var Persistent_SaveResults$Promise = class {
+  static {
+    _chunkUSNT2KNTcjs.__name.call(void 0, this, "Persistent_SaveResults$Promise");
+  }
+  
+  constructor(pipeline) {
+    this.pipeline = pipeline;
+  }
+  async promise() {
+    return await this.pipeline.struct();
+  }
+};
+var Persistent$Client = (_class3 = class _Persistent$Client {
+  static {
+    _chunkUSNT2KNTcjs.__name.call(void 0, this, "Persistent$Client");
+  }
+  
+  static __initStatic3() {this.interfaceId = BigInt("0xc8cb212fcd9f5691")}
+  constructor(client) {
+    this.client = client;
+  }
+  static __initStatic4() {this.methods = [
+    {
+      ParamsClass: Persistent_SaveParams,
+      ResultsClass: Persistent_SaveResults,
+      interfaceId: _Persistent$Client.interfaceId,
+      methodId: 0,
+      interfaceName: "packages/capnp/schemas/persistent.capnp:Persistent",
+      methodName: "save"
+    }
+  ]}
+  /**
+  * Save a capability persistently so that it can be restored by a future connection.  Not all
+  * capabilities can be saved -- application interfaces should define which capabilities support
+  * this and which do not.
+  *
+  */
+  save(paramsFunc) {
+    const answer = this.client.call({
+      method: _Persistent$Client.methods[0],
+      paramsFunc
+    });
+    const pipeline = new (0, _chunkGX6VRR3Gcjs.Pipeline)(Persistent_SaveResults, answer);
+    return new Persistent_SaveResults$Promise(pipeline);
+  }
+}, _class3.__initStatic3(), _class3.__initStatic4(), _class3);
+_chunkGX6VRR3Gcjs.Registry.register(Persistent$Client.interfaceId, Persistent$Client);
+var Persistent$Server = class extends _chunkGX6VRR3Gcjs.Server {
+  static {
+    _chunkUSNT2KNTcjs.__name.call(void 0, this, "Persistent$Server");
+  }
+  
+  constructor(target) {
+    super(target, [
+      {
+        ...Persistent$Client.methods[0],
+        impl: target.save
+      }
+    ]);
+    this.target = target;
+  }
+  client() {
+    return new Persistent$Client(this);
+  }
+};
+var Persistent = (_class4 = class extends _chunkGX6VRR3Gcjs.Interface {
+  static {
+    _chunkUSNT2KNTcjs.__name.call(void 0, this, "Persistent");
+  }
+  static __initStatic5() {this.SaveParams = Persistent_SaveParams}
+  static __initStatic6() {this.SaveResults = Persistent_SaveResults}
+  static __initStatic7() {this.Client = Persistent$Client}
+  static __initStatic8() {this.Server = Persistent$Server}
+  static __initStatic9() {this._capnp = {
+    displayName: "Persistent",
+    id: "c8cb212fcd9f5691",
+    size: new (0, _chunkGX6VRR3Gcjs.ObjectSize)(0, 0)
+  }}
+  toString() {
+    return "Persistent_" + super.toString();
+  }
+}, _class4.__initStatic5(), _class4.__initStatic6(), _class4.__initStatic7(), _class4.__initStatic8(), _class4.__initStatic9(), _class4);
+
+
+
+
+
+
+
+
+exports.Persistent = Persistent; exports.Persistent$Client = Persistent$Client; exports.Persistent$Server = Persistent$Server; exports.Persistent_SaveParams = Persistent_SaveParams; exports.Persistent_SaveResults = Persistent_SaveResults; exports.Persistent_SaveResults$Promise = Persistent_SaveResults$Promise; exports._capnpFileId = _capnpFileId;

package/schemas/persistent.d.cts

@@ -0,0 +1,147 @@
+import { Struct, ObjectSize, Orphan, Pointer, Pipeline, Client, Method, Server, Interface } from 'capnp-es';
+
+declare const _capnpFileId: bigint;
+declare class Persistent_SaveParams extends Struct {
+    static readonly _capnp: {
+        displayName: string;
+        id: string;
+        size: ObjectSize;
+    };
+    _adoptSealFor(value: Orphan<Pointer>): void;
+    _disownSealFor(): Orphan<Pointer>;
+    /**
+  * Seal the SturdyRef so that it can only be restored by the specified Owner. This is meant
+  * to mitigate damage when a SturdyRef is leaked. See comments above.
+  *
+  * Leaving this value null may or may not be allowed; it is up to the realm to decide. If a
+  * realm does allow a null owner, this should indicate that anyone is allowed to restore the
+  * ref.
+  *
+  */
+    get sealFor(): Pointer;
+    _hasSealFor(): boolean;
+    set sealFor(value: Pointer);
+    toString(): string;
+}
+declare class Persistent_SaveResults extends Struct {
+    static readonly _capnp: {
+        displayName: string;
+        id: string;
+        size: ObjectSize;
+    };
+    _adoptSturdyRef(value: Orphan<Pointer>): void;
+    _disownSturdyRef(): Orphan<Pointer>;
+    get sturdyRef(): Pointer;
+    _hasSturdyRef(): boolean;
+    set sturdyRef(value: Pointer);
+    toString(): string;
+}
+declare class Persistent_SaveResults$Promise {
+    pipeline: Pipeline<any, any, Persistent_SaveResults>;
+    constructor(pipeline: Pipeline<any, any, Persistent_SaveResults>);
+    promise(): Promise<Persistent_SaveResults>;
+}
+declare class Persistent$Client {
+    client: Client;
+    static readonly interfaceId: bigint;
+    constructor(client: Client);
+    static readonly methods: [
+        Method<Persistent_SaveParams, Persistent_SaveResults>
+    ];
+    /**
+  * Save a capability persistently so that it can be restored by a future connection.  Not all
+  * capabilities can be saved -- application interfaces should define which capabilities support
+  * this and which do not.
+  *
+  */
+    save(paramsFunc?: (params: Persistent_SaveParams) => void): Persistent_SaveResults$Promise;
+}
+interface Persistent$Server$Target {
+    save(params: Persistent_SaveParams, results: Persistent_SaveResults): Promise<void>;
+}
+declare class Persistent$Server extends Server {
+    readonly target: Persistent$Server$Target;
+    constructor(target: Persistent$Server$Target);
+    client(): Persistent$Client;
+}
+/**
+* Interface implemented by capabilities that outlive a single connection. A client may save()
+* the capability, producing a SturdyRef. The SturdyRef can be stored to disk, then later used to
+* obtain a new reference to the capability on a future connection.
+*
+* The exact format of SturdyRef depends on the "realm" in which the SturdyRef appears. A "realm"
+* is an abstract space in which all SturdyRefs have the same format and refer to the same set of
+* resources. Every vat is in exactly one realm. All capability clients within that vat must
+* produce SturdyRefs of the format appropriate for the realm.
+*
+* Similarly, every VatNetwork also resides in a particular realm. Usually, a vat's "realm"
+* corresponds to the realm of its main VatNetwork. However, a Vat can in fact communicate over
+* a VatNetwork in a different realm -- in this case, all SturdyRefs need to be transformed when
+* coming or going through said VatNetwork. The RPC system has hooks for registering
+* transformation callbacks for this purpose.
+*
+* Since the format of SturdyRef is realm-dependent, it is not defined here. An application should
+* choose an appropriate realm for itself as part of its design. Note that under Sandstorm, every
+* application exists in its own realm and is therefore free to define its own SturdyRef format;
+* the Sandstorm platform handles translating between realms.
+*
+* Note that whether a capability is persistent is often orthogonal to its type. In these cases,
+* the capability's interface should NOT inherit `Persistent`; instead, just perform a cast at
+* runtime. It's not type-safe, but trying to be type-safe in these cases will likely lead to
+* tears. In cases where a particular interface only makes sense on persistent capabilities, it
+* still should not explicitly inherit Persistent because the `SturdyRef` and `Owner` types will
+* vary between realms (they may even be different at the call site than they are on the
+* implementation). Instead, mark persistent interfaces with the $persistent annotation (defined
+* below).
+*
+* Sealing
+* -------
+*
+* As an added security measure, SturdyRefs may be "sealed" to a particular owner, such that
+* if the SturdyRef itself leaks to a third party, that party cannot actually restore it because
+* they are not the owner. To restore a sealed capability, you must first prove to its host that
+* you are the rightful owner. The precise mechanism for this authentication is defined by the
+* realm.
+*
+* Sealing is a defense-in-depth mechanism meant to mitigate damage in the case of catastrophic
+* attacks. For example, say an attacker temporarily gains read access to a database full of
+* SturdyRefs: it would be unfortunate if it were then necessary to revoke every single reference
+* in the database to prevent the attacker from using them.
+*
+* In general, an "owner" is a course-grained identity. Because capability-based security is still
+* the primary mechanism of security, it is not necessary nor desirable to have a separate "owner"
+* identity for every single process or object; that is exactly what capabilities are supposed to
+* avoid! Instead, it makes sense for an "owner" to literally identify the owner of the machines
+* where the capability is stored. If untrusted third parties are able to run arbitrary code on
+* said machines, then the sandbox for that code should be designed using Distributed Confinement
+* such that the third-party code never sees the bits of the SturdyRefs and cannot directly
+* exercise the owner's power to restore refs. See:
+*
+*     http://www.erights.org/elib/capability/dist-confine.html
+*
+* Resist the urge to represent an Owner as a simple public key. The whole point of sealing is to
+* defend against leaked-storage attacks. Such attacks can easily result in the owner's private
+* key being stolen as well. A better solution is for `Owner` to contain a simple globally unique
+* identifier for the owner, and for everyone to separately maintain a mapping of owner IDs to
+* public keys. If an owner's private key is compromised, then humans will need to communicate
+* and agree on a replacement public key, then update the mapping.
+*
+* As a concrete example, an `Owner` could simply contain a domain name, and restoring a SturdyRef
+* would require signing a request using the domain's private key. Authenticating this key could
+* be accomplished through certificate authorities or web-of-trust techniques.
+*
+*/
+declare class Persistent extends Interface {
+    static readonly SaveParams: typeof Persistent_SaveParams;
+    static readonly SaveResults: typeof Persistent_SaveResults;
+    static readonly Client: typeof Persistent$Client;
+    static readonly Server: typeof Persistent$Server;
+    static readonly _capnp: {
+        displayName: string;
+        id: string;
+        size: ObjectSize;
+    };
+    toString(): string;
+}
+
+export { Persistent, Persistent$Client, Persistent$Server, type Persistent$Server$Target, Persistent_SaveParams, Persistent_SaveResults, Persistent_SaveResults$Promise, _capnpFileId };

package/schemas/persistent.d.ts

@@ -0,0 +1,147 @@
+import { Struct, ObjectSize, Orphan, Pointer, Pipeline, Client, Method, Server, Interface } from 'capnp-es';
+
+declare const _capnpFileId: bigint;
+declare class Persistent_SaveParams extends Struct {
+    static readonly _capnp: {
+        displayName: string;
+        id: string;
+        size: ObjectSize;
+    };
+    _adoptSealFor(value: Orphan<Pointer>): void;
+    _disownSealFor(): Orphan<Pointer>;
+    /**
+  * Seal the SturdyRef so that it can only be restored by the specified Owner. This is meant
+  * to mitigate damage when a SturdyRef is leaked. See comments above.
+  *
+  * Leaving this value null may or may not be allowed; it is up to the realm to decide. If a
+  * realm does allow a null owner, this should indicate that anyone is allowed to restore the
+  * ref.
+  *
+  */
+    get sealFor(): Pointer;
+    _hasSealFor(): boolean;
+    set sealFor(value: Pointer);
+    toString(): string;
+}
+declare class Persistent_SaveResults extends Struct {
+    static readonly _capnp: {
+        displayName: string;
+        id: string;
+        size: ObjectSize;
+    };
+    _adoptSturdyRef(value: Orphan<Pointer>): void;
+    _disownSturdyRef(): Orphan<Pointer>;
+    get sturdyRef(): Pointer;
+    _hasSturdyRef(): boolean;
+    set sturdyRef(value: Pointer);
+    toString(): string;
+}
+declare class Persistent_SaveResults$Promise {
+    pipeline: Pipeline<any, any, Persistent_SaveResults>;
+    constructor(pipeline: Pipeline<any, any, Persistent_SaveResults>);
+    promise(): Promise<Persistent_SaveResults>;
+}
+declare class Persistent$Client {
+    client: Client;
+    static readonly interfaceId: bigint;
+    constructor(client: Client);
+    static readonly methods: [
+        Method<Persistent_SaveParams, Persistent_SaveResults>
+    ];
+    /**
+  * Save a capability persistently so that it can be restored by a future connection.  Not all
+  * capabilities can be saved -- application interfaces should define which capabilities support
+  * this and which do not.
+  *
+  */
+    save(paramsFunc?: (params: Persistent_SaveParams) => void): Persistent_SaveResults$Promise;
+}
+interface Persistent$Server$Target {
+    save(params: Persistent_SaveParams, results: Persistent_SaveResults): Promise<void>;
+}
+declare class Persistent$Server extends Server {
+    readonly target: Persistent$Server$Target;
+    constructor(target: Persistent$Server$Target);
+    client(): Persistent$Client;
+}
+/**
+* Interface implemented by capabilities that outlive a single connection. A client may save()
+* the capability, producing a SturdyRef. The SturdyRef can be stored to disk, then later used to
+* obtain a new reference to the capability on a future connection.
+*
+* The exact format of SturdyRef depends on the "realm" in which the SturdyRef appears. A "realm"
+* is an abstract space in which all SturdyRefs have the same format and refer to the same set of
+* resources. Every vat is in exactly one realm. All capability clients within that vat must
+* produce SturdyRefs of the format appropriate for the realm.
+*
+* Similarly, every VatNetwork also resides in a particular realm. Usually, a vat's "realm"
+* corresponds to the realm of its main VatNetwork. However, a Vat can in fact communicate over
+* a VatNetwork in a different realm -- in this case, all SturdyRefs need to be transformed when
+* coming or going through said VatNetwork. The RPC system has hooks for registering
+* transformation callbacks for this purpose.
+*
+* Since the format of SturdyRef is realm-dependent, it is not defined here. An application should
+* choose an appropriate realm for itself as part of its design. Note that under Sandstorm, every
+* application exists in its own realm and is therefore free to define its own SturdyRef format;
+* the Sandstorm platform handles translating between realms.
+*
+* Note that whether a capability is persistent is often orthogonal to its type. In these cases,
+* the capability's interface should NOT inherit `Persistent`; instead, just perform a cast at
+* runtime. It's not type-safe, but trying to be type-safe in these cases will likely lead to
+* tears. In cases where a particular interface only makes sense on persistent capabilities, it
+* still should not explicitly inherit Persistent because the `SturdyRef` and `Owner` types will
+* vary between realms (they may even be different at the call site than they are on the
+* implementation). Instead, mark persistent interfaces with the $persistent annotation (defined
+* below).
+*
+* Sealing
+* -------
+*
+* As an added security measure, SturdyRefs may be "sealed" to a particular owner, such that
+* if the SturdyRef itself leaks to a third party, that party cannot actually restore it because
+* they are not the owner. To restore a sealed capability, you must first prove to its host that
+* you are the rightful owner. The precise mechanism for this authentication is defined by the
+* realm.
+*
+* Sealing is a defense-in-depth mechanism meant to mitigate damage in the case of catastrophic
+* attacks. For example, say an attacker temporarily gains read access to a database full of
+* SturdyRefs: it would be unfortunate if it were then necessary to revoke every single reference
+* in the database to prevent the attacker from using them.
+*
+* In general, an "owner" is a course-grained identity. Because capability-based security is still
+* the primary mechanism of security, it is not necessary nor desirable to have a separate "owner"
+* identity for every single process or object; that is exactly what capabilities are supposed to
+* avoid! Instead, it makes sense for an "owner" to literally identify the owner of the machines
+* where the capability is stored. If untrusted third parties are able to run arbitrary code on
+* said machines, then the sandbox for that code should be designed using Distributed Confinement
+* such that the third-party code never sees the bits of the SturdyRefs and cannot directly
+* exercise the owner's power to restore refs. See:
+*
+*     http://www.erights.org/elib/capability/dist-confine.html
+*
+* Resist the urge to represent an Owner as a simple public key. The whole point of sealing is to
+* defend against leaked-storage attacks. Such attacks can easily result in the owner's private
+* key being stolen as well. A better solution is for `Owner` to contain a simple globally unique
+* identifier for the owner, and for everyone to separately maintain a mapping of owner IDs to
+* public keys. If an owner's private key is compromised, then humans will need to communicate
+* and agree on a replacement public key, then update the mapping.
+*
+* As a concrete example, an `Owner` could simply contain a domain name, and restoring a SturdyRef
+* would require signing a request using the domain's private key. Authenticating this key could
+* be accomplished through certificate authorities or web-of-trust techniques.
+*
+*/
+declare class Persistent extends Interface {
+    static readonly SaveParams: typeof Persistent_SaveParams;
+    static readonly SaveResults: typeof Persistent_SaveResults;
+    static readonly Client: typeof Persistent$Client;
+    static readonly Server: typeof Persistent$Server;
+    static readonly _capnp: {
+        displayName: string;
+        id: string;
+        size: ObjectSize;
+    };
+    toString(): string;
+}
+
+export { Persistent, Persistent$Client, Persistent$Server, type Persistent$Server$Target, Persistent_SaveParams, Persistent_SaveResults, Persistent_SaveResults$Promise, _capnpFileId };

package/schemas/persistent.js

@@ -0,0 +1,171 @@
+import {
+  Interface,
+  ObjectSize,
+  Pipeline,
+  Registry,
+  Server,
+  Struct,
+  utils
+} from "./chunk-BQI46ZE5.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// schemas/persistent.ts
+var _capnpFileId = BigInt("0xb8630836983feed7");
+var Persistent_SaveParams = class extends Struct {
+  static {
+    __name(this, "Persistent_SaveParams");
+  }
+  static _capnp = {
+    displayName: "SaveParams",
+    id: "f76fba59183073a5",
+    size: new ObjectSize(0, 1)
+  };
+  _adoptSealFor(value) {
+    utils.adopt(value, utils.getPointer(0, this));
+  }
+  _disownSealFor() {
+    return utils.disown(this.sealFor);
+  }
+  /**
+  * Seal the SturdyRef so that it can only be restored by the specified Owner. This is meant
+  * to mitigate damage when a SturdyRef is leaked. See comments above.
+  *
+  * Leaving this value null may or may not be allowed; it is up to the realm to decide. If a
+  * realm does allow a null owner, this should indicate that anyone is allowed to restore the
+  * ref.
+  *
+  */
+  get sealFor() {
+    return utils.getPointer(0, this);
+  }
+  _hasSealFor() {
+    return !utils.isNull(utils.getPointer(0, this));
+  }
+  set sealFor(value) {
+    utils.copyFrom(value, utils.getPointer(0, this));
+  }
+  toString() {
+    return "Persistent_SaveParams_" + super.toString();
+  }
+};
+var Persistent_SaveResults = class extends Struct {
+  static {
+    __name(this, "Persistent_SaveResults");
+  }
+  static _capnp = {
+    displayName: "SaveResults",
+    id: "b76848c18c40efbf",
+    size: new ObjectSize(0, 1)
+  };
+  _adoptSturdyRef(value) {
+    utils.adopt(value, utils.getPointer(0, this));
+  }
+  _disownSturdyRef() {
+    return utils.disown(this.sturdyRef);
+  }
+  get sturdyRef() {
+    return utils.getPointer(0, this);
+  }
+  _hasSturdyRef() {
+    return !utils.isNull(utils.getPointer(0, this));
+  }
+  set sturdyRef(value) {
+    utils.copyFrom(value, utils.getPointer(0, this));
+  }
+  toString() {
+    return "Persistent_SaveResults_" + super.toString();
+  }
+};
+var Persistent_SaveResults$Promise = class {
+  static {
+    __name(this, "Persistent_SaveResults$Promise");
+  }
+  pipeline;
+  constructor(pipeline) {
+    this.pipeline = pipeline;
+  }
+  async promise() {
+    return await this.pipeline.struct();
+  }
+};
+var Persistent$Client = class _Persistent$Client {
+  static {
+    __name(this, "Persistent$Client");
+  }
+  client;
+  static interfaceId = BigInt("0xc8cb212fcd9f5691");
+  constructor(client) {
+    this.client = client;
+  }
+  static methods = [
+    {
+      ParamsClass: Persistent_SaveParams,
+      ResultsClass: Persistent_SaveResults,
+      interfaceId: _Persistent$Client.interfaceId,
+      methodId: 0,
+      interfaceName: "packages/capnp/schemas/persistent.capnp:Persistent",
+      methodName: "save"
+    }
+  ];
+  /**
+  * Save a capability persistently so that it can be restored by a future connection.  Not all
+  * capabilities can be saved -- application interfaces should define which capabilities support
+  * this and which do not.
+  *
+  */
+  save(paramsFunc) {
+    const answer = this.client.call({
+      method: _Persistent$Client.methods[0],
+      paramsFunc
+    });
+    const pipeline = new Pipeline(Persistent_SaveResults, answer);
+    return new Persistent_SaveResults$Promise(pipeline);
+  }
+};
+Registry.register(Persistent$Client.interfaceId, Persistent$Client);
+var Persistent$Server = class extends Server {
+  static {
+    __name(this, "Persistent$Server");
+  }
+  target;
+  constructor(target) {
+    super(target, [
+      {
+        ...Persistent$Client.methods[0],
+        impl: target.save
+      }
+    ]);
+    this.target = target;
+  }
+  client() {
+    return new Persistent$Client(this);
+  }
+};
+var Persistent = class extends Interface {
+  static {
+    __name(this, "Persistent");
+  }
+  static SaveParams = Persistent_SaveParams;
+  static SaveResults = Persistent_SaveResults;
+  static Client = Persistent$Client;
+  static Server = Persistent$Server;
+  static _capnp = {
+    displayName: "Persistent",
+    id: "c8cb212fcd9f5691",
+    size: new ObjectSize(0, 0)
+  };
+  toString() {
+    return "Persistent_" + super.toString();
+  }
+};
+export {
+  Persistent,
+  Persistent$Client,
+  Persistent$Server,
+  Persistent_SaveParams,
+  Persistent_SaveResults,
+  Persistent_SaveResults$Promise,
+  _capnpFileId
+};