@stryke/capnp 0.12.57 → 0.12.59

package/dist/dist-Qno9L0HI.mjs

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