alchemy 0.76.0 → 0.77.0

package/workers/remote-binding-proxy.js

@@ -1,3 +1,1929 @@
-Symbol.dispose||(Symbol.dispose=Symbol.for("dispose"));Symbol.asyncDispose||(Symbol.asyncDispose=Symbol.for("asyncDispose"));var W=navigator.userAgent==="Cloudflare-Workers"?"cloudflare:workers":null,b;W&&(b=await import(W));var D=b?b.RpcTarget:class{};function j(t){switch(typeof t){case"boolean":case"number":case"string":return"primitive";case"undefined":return"undefined";case"object":case"function":break;case"bigint":return"bigint";default:return"unsupported"}if(t===null)return"primitive";let e=Object.getPrototypeOf(t);switch(e){case Object.prototype:return"object";case Function.prototype:return"function";case Array.prototype:return"array";case Date.prototype:return"date";case Uint8Array.prototype:return"bytes";case w.prototype:return"stub";case c.prototype:return"rpc-promise";default:if(b){if(e==b.RpcStub.prototype||t instanceof b.ServiceStub)return"rpc-target";if(e==b.RpcPromise.prototype||e==b.RpcProperty.prototype)return"rpc-thenable"}return t instanceof D?"rpc-target":t instanceof Error?"error":"unsupported"}}function z(){throw new Error("RPC map() implementation was not loaded.")}var M={applyMap:z,sendMap:z},x=class{},y=class extends x{constructor(t){super(),this.error=t}call(t,e){return this}map(t,e,r){return this}get(t){return this}dup(){return this}pull(){return Promise.reject(this.error)}ignoreUnhandledRejections(){}dispose(){}onBroken(t){try{t(this.error)}catch(e){Promise.resolve(e)}}},_=new y(new Error("Attempted to use RPC stub after it has been disposed.")),O=(t,e,r)=>t.call(e,r);function ee(t,e){let r=O;O=t;try{return e()}finally{O=r}}var f=Symbol("realStub"),te={apply(t,e,r){let s=t.raw;return new c(O(s.hook,s.pathIfPromise||[],m.fromAppParams(r)),[])},get(t,e,r){let s=t.raw;return e===f?s:e in c.prototype?s[e]:typeof e=="string"?new c(s.hook,s.pathIfPromise?[...s.pathIfPromise,e]:[e]):e===Symbol.dispose&&(!s.pathIfPromise||s.pathIfPromise.length==0)?()=>{s.hook.dispose(),s.hook=_}:void 0},has(t,e){let r=t.raw;return e===f?!0:e in c.prototype?e in r:typeof e=="string"?!0:e===Symbol.dispose&&(!r.pathIfPromise||r.pathIfPromise.length==0)},construct(t,e){throw new Error("An RPC stub cannot be used as a constructor.")},defineProperty(t,e,r){throw new Error("Can't define properties on RPC stubs.")},deleteProperty(t,e){throw new Error("Can't delete properties on RPC stubs.")},getOwnPropertyDescriptor(t,e){},getPrototypeOf(t){return Object.getPrototypeOf(t.raw)},isExtensible(t){return!1},ownKeys(t){return[]},preventExtensions(t){return!0},set(t,e,r,s){throw new Error("Can't assign properties on RPC stubs.")},setPrototypeOf(t,e){throw new Error("Can't override prototype of RPC stubs.")}},w=class L extends D{constructor(e,r){if(super(),!(e instanceof x)){let i=e;if(i instanceof D||i instanceof Function?e=I.create(i,void 0):e=new g(m.fromAppReturn(i)),r)throw new TypeError("RpcStub constructor expected one argument, received two.")}this.hook=e,this.pathIfPromise=r;let s=()=>{};return s.raw=this,new Proxy(s,te)}hook;pathIfPromise;dup(){let e=this[f];return e.pathIfPromise?new L(e.hook.get(e.pathIfPromise)):new L(e.hook.dup())}onRpcBroken(e){this[f].hook.onBroken(e)}map(e){let{hook:r,pathIfPromise:s}=this[f];return M.sendMap(r,s||[],e)}},c=class extends w{constructor(t,e){super(t,e)}then(t,e){return N(this).then(...arguments)}catch(t){return N(this).catch(...arguments)}finally(t){return N(this).finally(...arguments)}};function re(t){let{hook:e,pathIfPromise:r}=t[f];return r&&r.length>0?e.get(r):e}function se(t){let{hook:e,pathIfPromise:r}=t[f];return r?e.get(r):e.dup()}function $(t){let{hook:e,pathIfPromise:r}=t[f];if(!(r&&r.length>0))return e}function H(t){return t[f].hook}function A(t){return t[f]}async function N(t){let{hook:e,pathIfPromise:r}=t[f];return r.length>0&&(e=e.get(r)),(await e.pull()).deliverResolve()}var m=class d{constructor(e,r,s,i){this.value=e,this.source=r,this.stubs=s,this.promises=i}static fromAppParams(e){return new d(e,"params")}static fromAppReturn(e){return new d(e,"return")}static fromArray(e){let r=[],s=[],i=[];for(let o of e){o.ensureDeepCopied();for(let n of o.stubs)r.push(n);for(let n of o.promises)n.parent===o&&(n={parent:i,property:i.length,promise:n.promise}),s.push(n);i.push(o.value)}return new d(i,"owned",r,s)}static forEvaluate(e,r){return new d(null,"owned",e,r)}static deepCopyFrom(e,r,s){let i=new d(null,"owned",[],[]);return i.value=i.deepCopy(e,r,"value",i,!0,s),i}rpcTargets;getHookForRpcTarget(e,r,s=!0){if(this.source==="params")return I.create(e,r);if(this.source==="return"){let i=this.rpcTargets?.get(e);return i?s?i.dup():(this.rpcTargets?.delete(e),i):(i=I.create(e,r),s?(this.rpcTargets||(this.rpcTargets=new Map),this.rpcTargets.set(e,i),i.dup()):i)}else throw new Error("owned payload shouldn't contain raw RpcTargets")}deepCopy(e,r,s,i,o,n){switch(j(e)){case"unsupported":return e;case"primitive":case"bigint":case"date":case"bytes":case"error":case"undefined":return e;case"array":{let a=e,p=a.length,h=new Array(p);for(let u=0;u<p;u++)h[u]=this.deepCopy(a[u],a,u,h,o,n);return h}case"object":{let a={},p=e;for(let h in p)a[h]=this.deepCopy(p[h],p,h,a,o,n);return a}case"stub":case"rpc-promise":{let a=e,p;if(o?p=se(a):p=re(a),a instanceof c){let h=new c(p,[]);return this.promises.push({parent:i,property:s,promise:h}),h}else{let h=new w(p);return this.stubs.push(h),h}}case"function":case"rpc-target":{let a=e,p;return n?p=new w(n.getHookForRpcTarget(a,r,o)):p=new w(I.create(a,r)),this.stubs.push(p),p}case"rpc-thenable":{let a=e,p;return n?p=new c(n.getHookForRpcTarget(a,r,o),[]):p=new c(I.create(a,r),[]),this.promises.push({parent:i,property:s,promise:p}),p}default:throw new Error("unreachable")}}ensureDeepCopied(){if(this.source!=="owned"){let e=this.source==="params";this.stubs=[],this.promises=[];try{this.value=this.deepCopy(this.value,void 0,"value",this,e,this)}catch(r){throw this.stubs=void 0,this.promises=void 0,r}if(this.source="owned",this.rpcTargets&&this.rpcTargets.size>0)throw new Error("Not all rpcTargets were accounted for in deep-copy?");this.rpcTargets=void 0}}deliverTo(e,r,s){if(this.ensureDeepCopied(),this.value instanceof c)d.deliverRpcPromiseTo(this.value,e,r,s);else{e[r]=this.value;for(let i of this.promises)d.deliverRpcPromiseTo(i.promise,i.parent,i.property,s)}}static deliverRpcPromiseTo(e,r,s,i){let o=$(e);if(!o)throw new Error("property promises should have been resolved earlier");let n=o.pull();n instanceof d?n.deliverTo(r,s,i):i.push(n.then(l=>{let a=[];if(l.deliverTo(r,s,a),a.length>0)return Promise.all(a)}))}async deliverCall(e,r){try{let s=[];this.deliverTo(this,"value",s),s.length>0&&await Promise.all(s);let i=Function.prototype.apply.call(e,r,this.value);return i instanceof c?d.fromAppReturn(i):d.fromAppReturn(await i)}finally{this.dispose()}}async deliverResolve(){try{let e=[];this.deliverTo(this,"value",e),e.length>0&&await Promise.all(e);let r=this.value;return r instanceof Object&&(Symbol.dispose in r||Object.defineProperty(r,Symbol.dispose,{value:()=>this.dispose(),writable:!0,enumerable:!1,configurable:!0})),r}catch(e){throw this.dispose(),e}}dispose(){if(this.source==="owned")this.stubs.forEach(e=>e[Symbol.dispose]()),this.promises.forEach(e=>e.promise[Symbol.dispose]());else if(this.source==="return"&&(this.disposeImpl(this.value,void 0),this.rpcTargets&&this.rpcTargets.size>0))throw new Error("Not all rpcTargets were accounted for in disposeImpl()?");this.source="owned",this.stubs=[],this.promises=[]}disposeImpl(e,r){switch(j(e)){case"unsupported":case"primitive":case"bigint":case"bytes":case"date":case"error":case"undefined":return;case"array":{let i=e,o=i.length;for(let n=0;n<o;n++)this.disposeImpl(i[n],i);return}case"object":{let i=e;for(let o in i)this.disposeImpl(i[o],i);return}case"stub":case"rpc-promise":{let o=$(e);o&&o.dispose();return}case"function":case"rpc-target":{let i=e,o=this.rpcTargets?.get(i);o?(o.dispose(),this.rpcTargets.delete(i)):Q(i);return}case"rpc-thenable":return;default:return}}ignoreUnhandledRejections(){this.stubs?(this.stubs.forEach(e=>{H(e).ignoreUnhandledRejections()}),this.promises.forEach(e=>H(e.promise).ignoreUnhandledRejections())):this.ignoreUnhandledRejectionsImpl(this.value)}ignoreUnhandledRejectionsImpl(e){switch(j(e)){case"unsupported":case"primitive":case"bigint":case"bytes":case"date":case"error":case"undefined":case"function":case"rpc-target":return;case"array":{let s=e,i=s.length;for(let o=0;o<i;o++)this.ignoreUnhandledRejectionsImpl(s[o]);return}case"object":{let s=e;for(let i in s)this.ignoreUnhandledRejectionsImpl(s[i]);return}case"stub":case"rpc-promise":H(e).ignoreUnhandledRejections();return;case"rpc-thenable":e.then(s=>{},s=>{});return;default:return}}};function U(t,e,r,s){for(let i=0;i<r.length;i++){e=t;let o=r[i];if(o in Object.prototype){t=void 0;continue}switch(j(t)){case"object":case"function":Object.hasOwn(t,o)?t=t[o]:t=void 0;break;case"array":Number.isInteger(o)&&o>=0?t=t[o]:t=void 0;break;case"rpc-target":case"rpc-thenable":{Object.hasOwn(t,o)?t=void 0:t=t[o],s=null;break}case"stub":case"rpc-promise":{let{hook:l,pathIfPromise:a}=A(t);return{hook:l,remainingPath:a?a.concat(r.slice(i)):r.slice(i)}}case"primitive":case"bigint":case"bytes":case"date":case"error":t=void 0;break;case"undefined":t=t[o];break;case"unsupported":{if(i===0)throw new TypeError("RPC stub points at a non-serializable type.");{let l=r.slice(0,i).join("."),a=r.slice(0,i).join(".");throw new TypeError(`'${l}' is not a serializable type, so property ${a} cannot be accessed.`)}}default:throw new TypeError("unreachable")}}if(t instanceof c){let{hook:i,pathIfPromise:o}=A(t);return{hook:i,remainingPath:o||[]}}return{value:t,parent:e,owner:s}}var V=class extends x{call(t,e){try{let{value:r,owner:s}=this.getValue(),i=U(r,void 0,t,s);if(i.hook)return i.hook.call(i.remainingPath,e);if(typeof i.value!="function")throw new TypeError(`'${t.join(".")}' is not a function.`);let o=e.deliverCall(i.value,i.parent);return new ie(o.then(n=>new g(n)))}catch(r){return new y(r)}}map(t,e,r){try{let s;try{let{value:i,owner:o}=this.getValue();s=U(i,void 0,t,o)}catch(i){for(let o of e)o.dispose();throw i}return s.hook?s.hook.map(s.remainingPath,e,r):M.applyMap(s.value,s.parent,s.owner,e,r)}catch(s){return new y(s)}}get(t){try{let{value:e,owner:r}=this.getValue();if(t.length===0&&r===null)throw new Error("Can't dup an RpcTarget stub as a promise.");let s=U(e,void 0,t,r);return s.hook?s.hook.get(s.remainingPath):new g(m.deepCopyFrom(s.value,s.parent,s.owner))}catch(e){return new y(e)}}},g=class G extends V{constructor(e){super(),this.payload=e}payload;getPayload(){if(this.payload)return this.payload;throw new Error("Attempted to use an RPC StubHook after it was disposed.")}getValue(){let e=this.getPayload();return{value:e.value,owner:e}}dup(){let e=this.getPayload();return new G(m.deepCopyFrom(e.value,void 0,e))}pull(){return this.getPayload()}ignoreUnhandledRejections(){this.payload&&this.payload.ignoreUnhandledRejections()}dispose(){this.payload&&(this.payload.dispose(),this.payload=void 0)}onBroken(e){this.payload&&this.payload.value instanceof w&&this.payload.value.onRpcBroken(e)}};function Q(t){if(Symbol.dispose in t)try{t[Symbol.dispose]()}catch(e){Promise.reject(e)}}var I=class F extends V{static create(e,r){return typeof e!="function"&&(r=void 0),new F(e,r)}constructor(e,r,s){super(),this.target=e,this.parent=r,s?s.refcount&&(this.refcount=s.refcount,++this.refcount.count):Symbol.dispose in e&&(this.refcount={count:1})}target;parent;refcount;getTarget(){if(this.target)return this.target;throw new Error("Attempted to use an RPC StubHook after it was disposed.")}getValue(){return{value:this.getTarget(),owner:null}}dup(){return new F(this.getTarget(),this.parent,this)}pull(){let e=this.getTarget();return"then"in e?Promise.resolve(e).then(r=>m.fromAppReturn(r)):Promise.reject(new Error("Tried to resolve a non-promise stub."))}ignoreUnhandledRejections(){}dispose(){this.target&&(this.refcount&&--this.refcount.count==0&&Q(this.target),this.target=void 0)}onBroken(e){}},ie=class B extends x{promise;resolution;constructor(e){super(),this.promise=e.then(r=>(this.resolution=r,r))}call(e,r){return r.ensureDeepCopied(),new B(this.promise.then(s=>s.call(e,r)))}map(e,r,s){return new B(this.promise.then(i=>i.map(e,r,s),i=>{for(let o of r)o.dispose();throw i}))}get(e){return new B(this.promise.then(r=>r.get(e)))}dup(){return this.resolution?this.resolution.dup():new B(this.promise.then(e=>e.dup()))}pull(){return this.resolution?this.resolution.pull():this.promise.then(e=>e.pull())}ignoreUnhandledRejections(){this.resolution?this.resolution.ignoreUnhandledRejections():this.promise.then(e=>{e.ignoreUnhandledRejections()},e=>{})}dispose(){this.resolution?this.resolution.dispose():this.promise.then(e=>{e.dispose()},e=>{})}onBroken(e){this.resolution?this.resolution.onBroken(e):this.promise.then(r=>{r.onBroken(e)},e)}},oe=class{exportStub(t){throw new Error("Cannot serialize RPC stubs without an RPC session.")}exportPromise(t){throw new Error("Cannot serialize RPC stubs without an RPC session.")}getImport(t){}unexport(t){}onSendError(t){}},ne=new oe,ae={Error,EvalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError,AggregateError},R=class K{constructor(e,r){this.exporter=e,this.source=r}static devaluate(e,r,s=ne,i){let o=new K(s,i);try{return o.devaluateImpl(e,r,0)}catch(n){if(o.exports)try{s.unexport(o.exports)}catch{}throw n}}exports;devaluateImpl(e,r,s){if(s>=64)throw new Error("Serialization exceeded maximum allowed depth. (Does the message contain cycles?)");switch(j(e)){case"unsupported":{let o;try{o=`Cannot serialize value: ${e}`}catch{o="Cannot serialize value: (couldn't stringify value)"}throw new TypeError(o)}case"primitive":return e;case"object":{let o=e,n={};for(let l in o)n[l]=this.devaluateImpl(o[l],o,s+1);return n}case"array":{let o=e,n=o.length,l=new Array(n);for(let a=0;a<n;a++)l[a]=this.devaluateImpl(o[a],o,s+1);return[l]}case"bigint":return["bigint",e.toString()];case"date":return["date",e.getTime()];case"bytes":{let o=e;return o.toBase64?["bytes",o.toBase64({omitPadding:!0})]:["bytes",btoa(String.fromCharCode.apply(null,o).replace(/=*$/,""))]}case"error":{let o=e,n=this.exporter.onSendError(o);n&&(o=n);let l=["error",o.name,o.message];return n&&n.stack&&l.push(n.stack),l}case"undefined":return["undefined"];case"stub":case"rpc-promise":{if(!this.source)throw new Error("Can't serialize RPC stubs in this context.");let{hook:o,pathIfPromise:n}=A(e),l=this.exporter.getImport(o);return l!==void 0?n?n.length>0?["pipeline",l,n]:["pipeline",l]:["import",l]:(n?o=o.get(n):o=o.dup(),this.devaluateHook(n?"promise":"export",o))}case"function":case"rpc-target":{if(!this.source)throw new Error("Can't serialize RPC stubs in this context.");let o=this.source.getHookForRpcTarget(e,r);return this.devaluateHook("export",o)}case"rpc-thenable":{if(!this.source)throw new Error("Can't serialize RPC stubs in this context.");let o=this.source.getHookForRpcTarget(e,r);return this.devaluateHook("promise",o)}default:throw new Error("unreachable")}}devaluateHook(e,r){this.exports||(this.exports=[]);let s=e==="promise"?this.exporter.exportPromise(r):this.exporter.exportStub(r);return this.exports.push(s),[e,s]}};var le=class{importStub(t){throw new Error("Cannot deserialize RPC stubs without an RPC session.")}importPromise(t){throw new Error("Cannot deserialize RPC stubs without an RPC session.")}getExport(t){}},ke=new le,v=class X{constructor(e){this.importer=e}stubs=[];promises=[];evaluate(e){let r=m.forEvaluate(this.stubs,this.promises);try{return r.value=this.evaluateImpl(e,r,"value"),r}catch(s){throw r.dispose(),s}}evaluateCopy(e){return this.evaluate(structuredClone(e))}evaluateImpl(e,r,s){if(e instanceof Array){if(e.length==1&&e[0]instanceof Array){let i=e[0];for(let o=0;o<i.length;o++)i[o]=this.evaluateImpl(i[o],i,o);return i}else switch(e[0]){case"bigint":if(typeof e[1]=="string")return BigInt(e[1]);break;case"date":if(typeof e[1]=="number")return new Date(e[1]);break;case"bytes":{let i=Uint8Array;if(typeof e[1]=="string"){if(i.fromBase64)return i.fromBase64(e[1]);{let o=atob(e[1]),n=o.length,l=new Uint8Array(n);for(let a=0;a<n;a++)l[a]=o.charCodeAt(a);return l}}break}case"error":if(e.length>=3&&typeof e[1]=="string"&&typeof e[2]=="string"){let i=ae[e[1]]||Error,o=new i(e[2]);return typeof e[3]=="string"&&(o.stack=e[3]),o}break;case"undefined":if(e.length===1)return;break;case"import":case"pipeline":{if(e.length<2||e.length>4||typeof e[1]!="number")break;let i=this.importer.getExport(e[1]);if(!i)throw new Error(`no such entry on exports table: ${e[1]}`);let o=e[0]=="pipeline",n=h=>{if(o){let u=new c(h,[]);return this.promises.push({promise:u,parent:r,property:s}),u}else{let u=new c(h,[]);return this.stubs.push(u),u}};if(e.length==2)return n(o?i.get([]):i.dup());let l=e[2];if(!(l instanceof Array)||!l.every(h=>typeof h=="string"||typeof h=="number"))break;if(e.length==3)return n(i.get(l));let a=e[3];if(!(a instanceof Array))break;return a=new X(this.importer).evaluate([a]),n(i.call(l,a))}case"remap":{if(e.length!==5||typeof e[1]!="number"||!(e[2]instanceof Array)||!(e[3]instanceof Array)||!(e[4]instanceof Array))break;let i=this.importer.getExport(e[1]);if(!i)throw new Error(`no such entry on exports table: ${e[1]}`);let o=e[2];if(!o.every(h=>typeof h=="string"||typeof h=="number"))break;let n=e[3].map(h=>{if(!(h instanceof Array)||h.length!==2||h[0]!=="import"&&h[0]!=="export"||typeof h[1]!="number")throw new TypeError(`unknown map capture: ${JSON.stringify(h)}`);if(h[0]==="export")return this.importer.importStub(h[1]);{let u=this.importer.getExport(h[1]);if(!u)throw new Error(`no such entry on exports table: ${h[1]}`);return u.dup()}}),l=e[4],a=i.map(o,n,l),p=new c(a,[]);return this.promises.push({promise:p,parent:r,property:s}),p}case"export":case"promise":if(typeof e[1]=="number")if(e[0]=="promise"){let i=this.importer.importPromise(e[1]),o=new c(i,[]);return this.promises.push({parent:r,property:s,promise:o}),o}else{let i=this.importer.importStub(e[1]),o=new w(i);return this.stubs.push(o),o}break}throw new TypeError(`unknown special value: ${JSON.stringify(e)}`)}else if(e instanceof Object){let i=e;for(let o in i)o in Object.prototype||o==="toJSON"?(this.evaluateImpl(i[o],i,o),delete i[o]):i[o]=this.evaluateImpl(i[o],i,o);return i}else return e}};var S=class{constructor(t,e,r){this.session=t,this.importId=e,r&&(this.activePull=Promise.withResolvers())}localRefcount=0;remoteRefcount=1;activePull;resolution;onBrokenRegistrations;resolve(t){if(this.localRefcount==0){t.dispose();return}if(this.resolution=t,this.sendRelease(),this.onBrokenRegistrations){for(let e of this.onBrokenRegistrations){let r=this.session.onBrokenCallbacks[e],s=this.session.onBrokenCallbacks.length;t.onBroken(r),this.session.onBrokenCallbacks[s]===r?delete this.session.onBrokenCallbacks[s]:delete this.session.onBrokenCallbacks[e]}this.onBrokenRegistrations=void 0}this.activePull&&(this.activePull.resolve(),this.activePull=void 0)}async awaitResolution(){return this.activePull||(this.session.sendPull(this.importId),this.activePull=Promise.withResolvers()),await this.activePull.promise,this.resolution.pull()}dispose(){this.resolution?this.resolution.dispose():(this.abort(new Error("RPC was canceled because the RpcPromise was disposed.")),this.sendRelease())}abort(t){this.resolution||(this.resolution=new y(t),this.activePull&&(this.activePull.reject(t),this.activePull=void 0),this.onBrokenRegistrations=void 0)}onBroken(t){if(this.resolution)this.resolution.onBroken(t);else{let e=this.session.onBrokenCallbacks.length;this.session.onBrokenCallbacks.push(t),this.onBrokenRegistrations||(this.onBrokenRegistrations=[]),this.onBrokenRegistrations.push(e)}}sendRelease(){this.remoteRefcount>0&&(this.session.sendRelease(this.importId,this.remoteRefcount),this.remoteRefcount=0)}},E=class Y extends x{constructor(e,r){super(),this.isPromise=e,++r.localRefcount,this.entry=r}entry;collectPath(e){return this}getEntry(){if(this.entry)return this.entry;throw new Error("This RpcImportHook was already disposed.")}call(e,r){let s=this.getEntry();return s.resolution?s.resolution.call(e,r):s.session.sendCall(s.importId,e,r)}map(e,r,s){let i;try{i=this.getEntry()}catch(o){for(let n of r)n.dispose();throw o}return i.resolution?i.resolution.map(e,r,s):i.session.sendMap(i.importId,e,r,s)}get(e){let r=this.getEntry();return r.resolution?r.resolution.get(e):r.session.sendCall(r.importId,e)}dup(){return new Y(!1,this.getEntry())}pull(){let e=this.getEntry();if(!this.isPromise)throw new Error("Can't pull this hook because it's not a promise hook.");return e.resolution?e.resolution.pull():e.awaitResolution()}ignoreUnhandledRejections(){}dispose(){let e=this.entry;this.entry=void 0,e&&--e.localRefcount===0&&e.dispose()}onBroken(e){this.entry&&this.entry.onBroken(e)}},he=class extends E{session;constructor(t){super(!1,t),this.session=t.session}dispose(){if(this.session){let t=this.session;this.session=void 0,t.shutdown()}}},pe=class{constructor(t,e,r){this.transport=t,this.options=r,this.exports.push({hook:e,refcount:1}),this.imports.push(new S(this,0,!1));let s,i=new Promise((o,n)=>{s=n});this.cancelReadLoop=s,this.readLoop(i).catch(o=>this.abort(o))}exports=[];reverseExports=new Map;imports=[];abortReason;cancelReadLoop;nextExportId=-1;onBatchDone;pullCount=0;onBrokenCallbacks=[];getMainImport(){return new he(this.imports[0])}shutdown(){this.abort(new Error("RPC session was shut down by disposing the main stub"),!1)}exportStub(t){if(this.abortReason)throw this.abortReason;let e=this.reverseExports.get(t);if(e!==void 0)return++this.exports[e].refcount,e;{let r=this.nextExportId--;return this.exports[r]={hook:t,refcount:1},this.reverseExports.set(t,r),r}}exportPromise(t){if(this.abortReason)throw this.abortReason;let e=this.nextExportId--;return this.exports[e]={hook:t,refcount:1},this.reverseExports.set(t,e),this.ensureResolvingExport(e),e}unexport(t){for(let e of t)this.releaseExport(e,1)}releaseExport(t,e){let r=this.exports[t];if(!r)throw new Error(`no such export ID: ${t}`);if(r.refcount<e)throw new Error(`refcount would go negative: ${r.refcount} < ${e}`);r.refcount-=e,r.refcount===0&&(delete this.exports[t],this.reverseExports.delete(r.hook),r.hook.dispose())}onSendError(t){if(this.options.onSendError)return this.options.onSendError(t)}ensureResolvingExport(t){let e=this.exports[t];if(!e)throw new Error(`no such export ID: ${t}`);if(!e.pull){let r=async()=>{let s=e.hook;for(;;){let i=await s.pull();if(i.value instanceof w){let{hook:o,pathIfPromise:n}=A(i.value);if(n&&n.length==0&&this.getImport(s)===void 0){s=o;continue}}return i}};++this.pullCount,e.pull=r().then(s=>{let i=R.devaluate(s.value,void 0,this,s);this.send(["resolve",t,i])},s=>{this.send(["reject",t,R.devaluate(s,void 0,this)])}).catch(s=>{try{this.send(["reject",t,R.devaluate(s,void 0,this)])}catch(i){this.abort(i)}}).finally(()=>{--this.pullCount===0&&this.onBatchDone&&this.onBatchDone.resolve()})}}getImport(t){if(t instanceof E&&t.entry&&t.entry.session===this)return t.entry.importId}importStub(t){if(this.abortReason)throw this.abortReason;let e=this.imports[t];return e||(e=new S(this,t,!1),this.imports[t]=e),new E(!1,e)}importPromise(t){if(this.abortReason)throw this.abortReason;if(this.imports[t])return new y(new Error("Bug in RPC system: The peer sent a promise reusing an existing export ID."));let e=new S(this,t,!0);return this.imports[t]=e,new E(!0,e)}getExport(t){return this.exports[t]?.hook}send(t){if(this.abortReason!==void 0)return;let e;try{e=JSON.stringify(t)}catch(r){try{this.abort(r)}catch{}throw r}this.transport.send(e).catch(r=>this.abort(r,!1))}sendCall(t,e,r){if(this.abortReason)throw this.abortReason;let s=["pipeline",t,e];if(r){let o=R.devaluate(r.value,void 0,this,r);s.push(o[0])}this.send(["push",s]);let i=new S(this,this.imports.length,!1);return this.imports.push(i),new E(!0,i)}sendMap(t,e,r,s){if(this.abortReason){for(let l of r)l.dispose();throw this.abortReason}let i=r.map(l=>{let a=this.getImport(l);return a!==void 0?["import",a]:["export",this.exportStub(l)]}),o=["remap",t,e,i,s];this.send(["push",o]);let n=new S(this,this.imports.length,!1);return this.imports.push(n),new E(!0,n)}sendPull(t){if(this.abortReason)throw this.abortReason;this.send(["pull",t])}sendRelease(t,e){this.abortReason||(this.send(["release",t,e]),delete this.imports[t])}abort(t,e=!0){if(this.abortReason===void 0){if(this.cancelReadLoop(t),e)try{this.transport.send(JSON.stringify(["abort",R.devaluate(t,void 0,this)])).catch(r=>{})}catch{}if(t===void 0&&(t="undefined"),this.abortReason=t,this.onBatchDone&&this.onBatchDone.reject(t),this.transport.abort)try{this.transport.abort(t)}catch(r){Promise.resolve(r)}for(let r in this.onBrokenCallbacks)try{this.onBrokenCallbacks[r](t)}catch(s){Promise.resolve(s)}for(let r in this.imports)this.imports[r].abort(t);for(let r in this.exports)this.exports[r].hook.dispose()}}async readLoop(t){for(;!this.abortReason;){let e=JSON.parse(await Promise.race([this.transport.receive(),t]));if(this.abortReason)break;if(e instanceof Array)switch(e[0]){case"push":if(e.length>1){let r=new v(this).evaluate(e[1]),s=new g(r);s.ignoreUnhandledRejections(),this.exports.push({hook:s,refcount:1});continue}break;case"pull":{let r=e[1];if(typeof r=="number"){this.ensureResolvingExport(r);continue}break}case"resolve":case"reject":{let r=e[1];if(typeof r=="number"&&e.length>2){let s=this.imports[r];if(s)if(e[0]=="resolve")s.resolve(new g(new v(this).evaluate(e[2])));else{let i=new v(this).evaluate(e[2]);i.dispose(),s.resolve(new y(i.value))}else e[0]=="resolve"&&new v(this).evaluate(e[2]).dispose();continue}break}case"release":{let r=e[1],s=e[2];if(typeof r=="number"&&typeof s=="number"){this.releaseExport(r,s);continue}break}case"abort":{let r=new v(this).evaluate(e[1]);r.dispose(),this.abort(r,!1);break}}throw new Error(`bad RPC message: ${JSON.stringify(e)}`)}}async drain(){if(this.abortReason)throw this.abortReason;if(this.pullCount>0){let{promise:t,resolve:e,reject:r}=Promise.withResolvers();this.onBatchDone={resolve:e,reject:r},await t}}getStats(){let t={imports:0,exports:0};for(let e in this.imports)++t.imports;for(let e in this.exports)++t.exports;return t}},Z=class{#e;#t;constructor(t,e,r={}){let s;e?s=new g(m.fromAppReturn(e)):s=new y(new Error("This connection has no main object.")),this.#e=new pe(t,s,r),this.#t=new w(this.#e.getMainImport())}getRemoteMain(){return this.#t}getStats(){return this.#e.getStats()}drain(){return this.#e.drain()}};function ce(t,e,r){typeof t=="string"&&(t=new WebSocket(t));let s=new de(t);return new Z(s,e,r).getRemoteMain()}function ue(t,e,r){if(t.headers.get("Upgrade")?.toLowerCase()!=="websocket")return new Response("This endpoint only accepts WebSocket requests.",{status:400});let s=new WebSocketPair,i=s[0];return i.accept(),ce(i,e,r),new Response(null,{status:101,webSocket:s[1]})}var de=class{constructor(t){this.#e=t,t.readyState===WebSocket.CONNECTING&&(this.#t=[],t.addEventListener("open",e=>{try{for(let r of this.#t)t.send(r)}catch(r){this.#o(r)}this.#t=void 0})),t.addEventListener("message",e=>{this.#s||(typeof e.data=="string"?this.#r?(this.#r(e.data),this.#r=void 0,this.#i=void 0):this.#n.push(e.data):this.#o(new TypeError("Received non-string message from WebSocket.")))}),t.addEventListener("close",e=>{this.#o(new Error(`Peer closed WebSocket: ${e.code} ${e.reason}`))}),t.addEventListener("error",e=>{this.#o(new Error("WebSocket connection failed."))})}#e;#t;#r;#i;#n=[];#s;async send(t){this.#t===void 0?this.#e.send(t):this.#t.push(t)}async receive(){if(this.#n.length>0)return this.#n.shift();if(this.#s)throw this.#s;return new Promise((t,e)=>{this.#r=t,this.#i=e})}abort(t){let e;t instanceof Error?e=t.message:e=`${t}`,this.#e.close(3e3,e),this.#s||(this.#s=t)}#o(t){this.#s||(this.#s=t,this.#i&&(this.#i(t),this.#r=void 0,this.#i=void 0))}};var fe=class{constructor(t){this.#t=t}#e=[];#t;#r=Promise.withResolvers();async send(t){this.#e.push(t)}async receive(){let t=this.#t.shift();return t!==void 0?t:(this.#r.resolve(),new Promise(e=>{}))}abort(t){this.#r.reject(t)}whenAllReceived(){return this.#r.promise}getResponseBody(){return this.#e.join(`
-`)}};async function me(t,e,r){if(t.method!=="POST")return new Response("This endpoint only accepts POST requests.",{status:405});let s=await t.text(),i=s===""?[]:s.split(`
-`),o=new fe(i),n=new Z(o,e,r);return await o.whenAllReceived(),await n.drain(),new Response(o.getResponseBody())}var k,we=class{context;captureMap=new Map;instructions=[];constructor(t,e){k?this.context={parent:k,captures:[],subject:k.capture(t),path:e}:this.context={parent:void 0,captures:[],subject:t,path:e},k=this}unregister(){k=this.context.parent}makeInput(){return new T(this,0)}makeOutput(t){let e;try{e=R.devaluate(t.value,void 0,this,t)}finally{t.dispose()}return this.instructions.push(e),this.context.parent?(this.context.parent.instructions.push(["remap",this.context.subject,this.context.path,this.context.captures.map(r=>["import",r]),this.instructions]),new T(this.context.parent,this.context.parent.instructions.length)):this.context.subject.map(this.context.path,this.context.captures,this.instructions)}pushCall(t,e,r){let s=R.devaluate(r.value,void 0,this,r);s=s[0];let i=this.capture(t.dup());return this.instructions.push(["pipeline",i,e,s]),new T(this,this.instructions.length)}pushGet(t,e){let r=this.capture(t.dup());return this.instructions.push(["pipeline",r,e]),new T(this,this.instructions.length)}capture(t){if(t instanceof T&&t.mapper===this)return t.idx;let e=this.captureMap.get(t);if(e===void 0){if(this.context.parent){let r=this.context.parent.capture(t);this.context.captures.push(r)}else this.context.captures.push(t);e=-this.context.captures.length,this.captureMap.set(t,e)}return e}exportStub(t){throw new Error("Can't construct an RpcTarget or RPC callback inside a mapper function. Try creating a new RpcStub outside the callback first, then using it inside the callback.")}exportPromise(t){return this.exportStub(t)}getImport(t){return this.capture(t)}unexport(t){}onSendError(t){}};M.sendMap=(t,e,r)=>{let s=new we(t,e),i;try{i=m.fromAppReturn(ee(s.pushCall.bind(s),()=>r(new c(s.makeInput(),[]))))}finally{s.unregister()}if(i instanceof Promise)throw i.catch(o=>{}),new Error("RPC map() callbacks cannot be async.");return new c(s.makeOutput(i),[])};function C(){throw new Error("Attempted to use an abstract placeholder from a mapper function. Please make sure your map function has no side effects.")}var T=class extends x{constructor(t,e){super(),this.mapper=t,this.idx=e}dup(){return this}dispose(){}get(t){if(t.length==0)return this;if(k)return k.pushGet(this,t);C()}call(t,e){C()}map(t,e,r){C()}pull(){C()}ignoreUnhandledRejections(){}onBroken(t){C()}},ge=class{constructor(t,e){this.captures=t,this.variables=[e]}variables;dispose(){for(let t of this.variables)t.dispose()}apply(t){try{if(t.length<1)throw new Error("Invalid empty mapper function.");for(let e of t.slice(0,-1)){let r=new v(this).evaluateCopy(e);if(r.value instanceof w){let s=$(r.value);if(s){this.variables.push(s);continue}}this.variables.push(new g(r))}return new v(this).evaluateCopy(t[t.length-1])}finally{for(let e of this.variables)e.dispose()}}importStub(t){throw new Error("A mapper function cannot refer to exports.")}importPromise(t){return this.importStub(t)}getExport(t){return t<0?this.captures[-t-1]:this.variables[t]}};function J(t,e,r,s,i){let o=new g(m.deepCopyFrom(t,e,r)),n=new ge(s,o);try{return n.apply(i)}finally{n.dispose()}}M.applyMap=(t,e,r,s,i)=>{try{let o;if(t instanceof c)throw new Error("applyMap() can't be called on RpcPromise");if(t instanceof Array){let n=[];try{for(let l of t)n.push(J(l,t,r,s,i))}catch(l){for(let a of n)a.dispose();throw l}o=m.fromArray(n)}else t==null?o=m.fromAppReturn(t):o=J(t,e,r,s,i);return new g(o)}finally{for(let o of s)o.dispose()}};async function q(t,e){if(t.method==="POST"){let r=await me(t,e);return r.headers.set("Access-Control-Allow-Origin","*"),r}else return t.headers.get("Upgrade")?.toLowerCase()==="websocket"?ue(t,e):new Response("This endpoint only accepts POST or WebSocket requests.",{status:400})}import{EmailMessage as be}from"cloudflare:email";var P=class extends Error{constructor(e){super(`Binding ${e?`"${e}"`:""} not found`)}};function ye(t,e){let r=new URL(t.url),s=r.searchParams.get("MF-Binding");if(!s)throw new P;let i=e[s];if(!i)throw new P(s);if(i.constructor.name==="SendEmail")return{async send(o){let n=new be(o.from,o.to,o["EmailMessage::raw"]);return i.send(n)}};if(r.searchParams.has("MF-Dispatch-Namespace-Options")){let{name:o,args:n,options:l}=JSON.parse(r.searchParams.get("MF-Dispatch-Namespace-Options"));return i.get(o,n,l)}return i}function Re(t,e){let r=t.headers.get("MF-Binding");if(!r)throw new P;let s=e[r];if(!s)throw new P(r);let i=t.headers.get("MF-Dispatch-Namespace-Options");if(i){let{name:o,args:n,options:l}=JSON.parse(i);return s.get(o,n,l)}return s}function ve(t){let e=new URL(t.url);return t.headers.has("Upgrade")&&e.searchParams.has("MF-Binding")}var We={async fetch(t,e){try{if(ve(t))return q(t,ye(t,e));{let r=Re(t,e),s=new Headers;for(let[i,o]of t.headers)i.startsWith("mf-header-")?s.set(i.slice(10),o):i==="upgrade"&&s.set(i,o);return r.fetch(t.headers.get("MF-URL")??"http://example.com",new Request(t,{redirect:"manual",headers:s}))}}catch(r){return r instanceof P?new Response(r.message,{status:400}):new Response(r.message,{status:500})}}};export{We as default};
+import { EmailMessage } from "cloudflare:email";
+
+//#region ../node_modules/.bun/capnweb@0.1.0/node_modules/capnweb/dist/index.js
+if (!Symbol.dispose) Symbol.dispose = Symbol.for("dispose");
+if (!Symbol.asyncDispose) Symbol.asyncDispose = Symbol.for("asyncDispose");
+var workersModuleName = navigator.userAgent === "Cloudflare-Workers" ? "cloudflare:workers" : null;
+var workersModule;
+if (workersModuleName) workersModule = await import(
+	/* @vite-ignore */
+	workersModuleName
+);
+var RpcTarget = workersModule ? workersModule.RpcTarget : class {};
+function typeForRpc(value) {
+	switch (typeof value) {
+		case "boolean":
+		case "number":
+		case "string": return "primitive";
+		case "undefined": return "undefined";
+		case "object":
+		case "function": break;
+		case "bigint": return "bigint";
+		default: return "unsupported";
+	}
+	if (value === null) return "primitive";
+	let prototype = Object.getPrototypeOf(value);
+	switch (prototype) {
+		case Object.prototype: return "object";
+		case Function.prototype: return "function";
+		case Array.prototype: return "array";
+		case Date.prototype: return "date";
+		case Uint8Array.prototype: return "bytes";
+		case RpcStub.prototype: return "stub";
+		case RpcPromise.prototype: return "rpc-promise";
+		default:
+			if (workersModule) {
+				if (prototype == workersModule.RpcStub.prototype || value instanceof workersModule.ServiceStub) return "rpc-target";
+				else if (prototype == workersModule.RpcPromise.prototype || prototype == workersModule.RpcProperty.prototype) return "rpc-thenable";
+			}
+			if (value instanceof RpcTarget) return "rpc-target";
+			if (value instanceof Error) return "error";
+			return "unsupported";
+	}
+}
+function mapNotLoaded() {
+	throw new Error("RPC map() implementation was not loaded.");
+}
+var mapImpl = {
+	applyMap: mapNotLoaded,
+	sendMap: mapNotLoaded
+};
+var StubHook = class {};
+var ErrorStubHook = class extends StubHook {
+	constructor(error) {
+		super();
+		this.error = error;
+	}
+	call(path, args) {
+		return this;
+	}
+	map(path, captures, instructions) {
+		return this;
+	}
+	get(path) {
+		return this;
+	}
+	dup() {
+		return this;
+	}
+	pull() {
+		return Promise.reject(this.error);
+	}
+	ignoreUnhandledRejections() {}
+	dispose() {}
+	onBroken(callback) {
+		try {
+			callback(this.error);
+		} catch (err) {
+			Promise.resolve(err);
+		}
+	}
+};
+var DISPOSED_HOOK = new ErrorStubHook(/* @__PURE__ */ new Error("Attempted to use RPC stub after it has been disposed."));
+var doCall = (hook, path, params) => {
+	return hook.call(path, params);
+};
+function withCallInterceptor(interceptor, callback) {
+	let oldValue = doCall;
+	doCall = interceptor;
+	try {
+		return callback();
+	} finally {
+		doCall = oldValue;
+	}
+}
+var RAW_STUB = Symbol("realStub");
+var PROXY_HANDLERS = {
+	apply(target, thisArg, argumentsList) {
+		let stub = target.raw;
+		return new RpcPromise(doCall(stub.hook, stub.pathIfPromise || [], RpcPayload.fromAppParams(argumentsList)), []);
+	},
+	get(target, prop, receiver) {
+		let stub = target.raw;
+		if (prop === RAW_STUB) return stub;
+		else if (prop in RpcPromise.prototype) return stub[prop];
+		else if (typeof prop === "string") return new RpcPromise(stub.hook, stub.pathIfPromise ? [...stub.pathIfPromise, prop] : [prop]);
+		else if (prop === Symbol.dispose && (!stub.pathIfPromise || stub.pathIfPromise.length == 0)) return () => {
+			stub.hook.dispose();
+			stub.hook = DISPOSED_HOOK;
+		};
+		else return;
+	},
+	has(target, prop) {
+		let stub = target.raw;
+		if (prop === RAW_STUB) return true;
+		else if (prop in RpcPromise.prototype) return prop in stub;
+		else if (typeof prop === "string") return true;
+		else if (prop === Symbol.dispose && (!stub.pathIfPromise || stub.pathIfPromise.length == 0)) return true;
+		else return false;
+	},
+	construct(target, args) {
+		throw new Error("An RPC stub cannot be used as a constructor.");
+	},
+	defineProperty(target, property, attributes) {
+		throw new Error("Can't define properties on RPC stubs.");
+	},
+	deleteProperty(target, p) {
+		throw new Error("Can't delete properties on RPC stubs.");
+	},
+	getOwnPropertyDescriptor(target, p) {},
+	getPrototypeOf(target) {
+		return Object.getPrototypeOf(target.raw);
+	},
+	isExtensible(target) {
+		return false;
+	},
+	ownKeys(target) {
+		return [];
+	},
+	preventExtensions(target) {
+		return true;
+	},
+	set(target, p, newValue, receiver) {
+		throw new Error("Can't assign properties on RPC stubs.");
+	},
+	setPrototypeOf(target, v) {
+		throw new Error("Can't override prototype of RPC stubs.");
+	}
+};
+var RpcStub = class _RpcStub extends RpcTarget {
+	constructor(hook, pathIfPromise) {
+		super();
+		if (!(hook instanceof StubHook)) {
+			let value = hook;
+			if (value instanceof RpcTarget || value instanceof Function) hook = TargetStubHook.create(value, void 0);
+			else hook = new PayloadStubHook(RpcPayload.fromAppReturn(value));
+			if (pathIfPromise) throw new TypeError("RpcStub constructor expected one argument, received two.");
+		}
+		this.hook = hook;
+		this.pathIfPromise = pathIfPromise;
+		let func = () => {};
+		func.raw = this;
+		return new Proxy(func, PROXY_HANDLERS);
+	}
+	hook;
+	pathIfPromise;
+	dup() {
+		let target = this[RAW_STUB];
+		if (target.pathIfPromise) return new _RpcStub(target.hook.get(target.pathIfPromise));
+		else return new _RpcStub(target.hook.dup());
+	}
+	onRpcBroken(callback) {
+		this[RAW_STUB].hook.onBroken(callback);
+	}
+	map(func) {
+		let { hook, pathIfPromise } = this[RAW_STUB];
+		return mapImpl.sendMap(hook, pathIfPromise || [], func);
+	}
+};
+var RpcPromise = class extends RpcStub {
+	constructor(hook, pathIfPromise) {
+		super(hook, pathIfPromise);
+	}
+	then(onfulfilled, onrejected) {
+		return pullPromise(this).then(...arguments);
+	}
+	catch(onrejected) {
+		return pullPromise(this).catch(...arguments);
+	}
+	finally(onfinally) {
+		return pullPromise(this).finally(...arguments);
+	}
+};
+function unwrapStubTakingOwnership(stub) {
+	let { hook, pathIfPromise } = stub[RAW_STUB];
+	if (pathIfPromise && pathIfPromise.length > 0) return hook.get(pathIfPromise);
+	else return hook;
+}
+function unwrapStubAndDup(stub) {
+	let { hook, pathIfPromise } = stub[RAW_STUB];
+	if (pathIfPromise) return hook.get(pathIfPromise);
+	else return hook.dup();
+}
+function unwrapStubNoProperties(stub) {
+	let { hook, pathIfPromise } = stub[RAW_STUB];
+	if (pathIfPromise && pathIfPromise.length > 0) return;
+	return hook;
+}
+function unwrapStubOrParent(stub) {
+	return stub[RAW_STUB].hook;
+}
+function unwrapStubAndPath(stub) {
+	return stub[RAW_STUB];
+}
+async function pullPromise(promise) {
+	let { hook, pathIfPromise } = promise[RAW_STUB];
+	if (pathIfPromise.length > 0) hook = hook.get(pathIfPromise);
+	return (await hook.pull()).deliverResolve();
+}
+var RpcPayload = class _RpcPayload {
+	constructor(value, source, stubs, promises) {
+		this.value = value;
+		this.source = source;
+		this.stubs = stubs;
+		this.promises = promises;
+	}
+	static fromAppParams(value) {
+		return new _RpcPayload(value, "params");
+	}
+	static fromAppReturn(value) {
+		return new _RpcPayload(value, "return");
+	}
+	static fromArray(array) {
+		let stubs = [];
+		let promises = [];
+		let resultArray = [];
+		for (let payload of array) {
+			payload.ensureDeepCopied();
+			for (let stub of payload.stubs) stubs.push(stub);
+			for (let promise of payload.promises) {
+				if (promise.parent === payload) promise = {
+					parent: resultArray,
+					property: resultArray.length,
+					promise: promise.promise
+				};
+				promises.push(promise);
+			}
+			resultArray.push(payload.value);
+		}
+		return new _RpcPayload(resultArray, "owned", stubs, promises);
+	}
+	static forEvaluate(stubs, promises) {
+		return new _RpcPayload(null, "owned", stubs, promises);
+	}
+	static deepCopyFrom(value, oldParent, owner) {
+		let result = new _RpcPayload(null, "owned", [], []);
+		result.value = result.deepCopy(value, oldParent, "value", result, true, owner);
+		return result;
+	}
+	rpcTargets;
+	getHookForRpcTarget(target, parent, dupStubs = true) {
+		if (this.source === "params") return TargetStubHook.create(target, parent);
+		else if (this.source === "return") {
+			let hook = this.rpcTargets?.get(target);
+			if (hook) if (dupStubs) return hook.dup();
+			else {
+				this.rpcTargets?.delete(target);
+				return hook;
+			}
+			else {
+				hook = TargetStubHook.create(target, parent);
+				if (dupStubs) {
+					if (!this.rpcTargets) this.rpcTargets = /* @__PURE__ */ new Map();
+					this.rpcTargets.set(target, hook);
+					return hook.dup();
+				} else return hook;
+			}
+		} else throw new Error("owned payload shouldn't contain raw RpcTargets");
+	}
+	deepCopy(value, oldParent, property, parent, dupStubs, owner) {
+		switch (typeForRpc(value)) {
+			case "unsupported": return value;
+			case "primitive":
+			case "bigint":
+			case "date":
+			case "bytes":
+			case "error":
+			case "undefined": return value;
+			case "array": {
+				let array = value;
+				let len = array.length;
+				let result = new Array(len);
+				for (let i = 0; i < len; i++) result[i] = this.deepCopy(array[i], array, i, result, dupStubs, owner);
+				return result;
+			}
+			case "object": {
+				let result = {};
+				let object = value;
+				for (let i in object) result[i] = this.deepCopy(object[i], object, i, result, dupStubs, owner);
+				return result;
+			}
+			case "stub":
+			case "rpc-promise": {
+				let stub = value;
+				let hook;
+				if (dupStubs) hook = unwrapStubAndDup(stub);
+				else hook = unwrapStubTakingOwnership(stub);
+				if (stub instanceof RpcPromise) {
+					let promise = new RpcPromise(hook, []);
+					this.promises.push({
+						parent,
+						property,
+						promise
+					});
+					return promise;
+				} else {
+					let newStub = new RpcStub(hook);
+					this.stubs.push(newStub);
+					return newStub;
+				}
+			}
+			case "function":
+			case "rpc-target": {
+				let target = value;
+				let stub;
+				if (owner) stub = new RpcStub(owner.getHookForRpcTarget(target, oldParent, dupStubs));
+				else stub = new RpcStub(TargetStubHook.create(target, oldParent));
+				this.stubs.push(stub);
+				return stub;
+			}
+			case "rpc-thenable": {
+				let target = value;
+				let promise;
+				if (owner) promise = new RpcPromise(owner.getHookForRpcTarget(target, oldParent, dupStubs), []);
+				else promise = new RpcPromise(TargetStubHook.create(target, oldParent), []);
+				this.promises.push({
+					parent,
+					property,
+					promise
+				});
+				return promise;
+			}
+			default: throw new Error("unreachable");
+		}
+	}
+	ensureDeepCopied() {
+		if (this.source !== "owned") {
+			let dupStubs = this.source === "params";
+			this.stubs = [];
+			this.promises = [];
+			try {
+				this.value = this.deepCopy(this.value, void 0, "value", this, dupStubs, this);
+			} catch (err) {
+				this.stubs = void 0;
+				this.promises = void 0;
+				throw err;
+			}
+			this.source = "owned";
+			if (this.rpcTargets && this.rpcTargets.size > 0) throw new Error("Not all rpcTargets were accounted for in deep-copy?");
+			this.rpcTargets = void 0;
+		}
+	}
+	deliverTo(parent, property, promises) {
+		this.ensureDeepCopied();
+		if (this.value instanceof RpcPromise) _RpcPayload.deliverRpcPromiseTo(this.value, parent, property, promises);
+		else {
+			parent[property] = this.value;
+			for (let record of this.promises) _RpcPayload.deliverRpcPromiseTo(record.promise, record.parent, record.property, promises);
+		}
+	}
+	static deliverRpcPromiseTo(promise, parent, property, promises) {
+		let hook = unwrapStubNoProperties(promise);
+		if (!hook) throw new Error("property promises should have been resolved earlier");
+		let inner = hook.pull();
+		if (inner instanceof _RpcPayload) inner.deliverTo(parent, property, promises);
+		else promises.push(inner.then((payload) => {
+			let subPromises = [];
+			payload.deliverTo(parent, property, subPromises);
+			if (subPromises.length > 0) return Promise.all(subPromises);
+		}));
+	}
+	async deliverCall(func, thisArg) {
+		try {
+			let promises = [];
+			this.deliverTo(this, "value", promises);
+			if (promises.length > 0) await Promise.all(promises);
+			let result = Function.prototype.apply.call(func, thisArg, this.value);
+			if (result instanceof RpcPromise) return _RpcPayload.fromAppReturn(result);
+			else return _RpcPayload.fromAppReturn(await result);
+		} finally {
+			this.dispose();
+		}
+	}
+	async deliverResolve() {
+		try {
+			let promises = [];
+			this.deliverTo(this, "value", promises);
+			if (promises.length > 0) await Promise.all(promises);
+			let result = this.value;
+			if (result instanceof Object) {
+				if (!(Symbol.dispose in result)) Object.defineProperty(result, Symbol.dispose, {
+					value: () => this.dispose(),
+					writable: true,
+					enumerable: false,
+					configurable: true
+				});
+			}
+			return result;
+		} catch (err) {
+			this.dispose();
+			throw err;
+		}
+	}
+	dispose() {
+		if (this.source === "owned") {
+			this.stubs.forEach((stub) => stub[Symbol.dispose]());
+			this.promises.forEach((promise) => promise.promise[Symbol.dispose]());
+		} else if (this.source === "return") {
+			this.disposeImpl(this.value, void 0);
+			if (this.rpcTargets && this.rpcTargets.size > 0) throw new Error("Not all rpcTargets were accounted for in disposeImpl()?");
+		}
+		this.source = "owned";
+		this.stubs = [];
+		this.promises = [];
+	}
+	disposeImpl(value, parent) {
+		switch (typeForRpc(value)) {
+			case "unsupported":
+			case "primitive":
+			case "bigint":
+			case "bytes":
+			case "date":
+			case "error":
+			case "undefined": return;
+			case "array": {
+				let array = value;
+				let len = array.length;
+				for (let i = 0; i < len; i++) this.disposeImpl(array[i], array);
+				return;
+			}
+			case "object": {
+				let object = value;
+				for (let i in object) this.disposeImpl(object[i], object);
+				return;
+			}
+			case "stub":
+			case "rpc-promise": {
+				let hook = unwrapStubNoProperties(value);
+				if (hook) hook.dispose();
+				return;
+			}
+			case "function":
+			case "rpc-target": {
+				let target = value;
+				let hook = this.rpcTargets?.get(target);
+				if (hook) {
+					hook.dispose();
+					this.rpcTargets.delete(target);
+				} else disposeRpcTarget(target);
+				return;
+			}
+			case "rpc-thenable": return;
+			default: return;
+		}
+	}
+	ignoreUnhandledRejections() {
+		if (this.stubs) {
+			this.stubs.forEach((stub) => {
+				unwrapStubOrParent(stub).ignoreUnhandledRejections();
+			});
+			this.promises.forEach((promise) => unwrapStubOrParent(promise.promise).ignoreUnhandledRejections());
+		} else this.ignoreUnhandledRejectionsImpl(this.value);
+	}
+	ignoreUnhandledRejectionsImpl(value) {
+		switch (typeForRpc(value)) {
+			case "unsupported":
+			case "primitive":
+			case "bigint":
+			case "bytes":
+			case "date":
+			case "error":
+			case "undefined":
+			case "function":
+			case "rpc-target": return;
+			case "array": {
+				let array = value;
+				let len = array.length;
+				for (let i = 0; i < len; i++) this.ignoreUnhandledRejectionsImpl(array[i]);
+				return;
+			}
+			case "object": {
+				let object = value;
+				for (let i in object) this.ignoreUnhandledRejectionsImpl(object[i]);
+				return;
+			}
+			case "stub":
+			case "rpc-promise":
+				unwrapStubOrParent(value).ignoreUnhandledRejections();
+				return;
+			case "rpc-thenable":
+				value.then((_) => {}, (_) => {});
+				return;
+			default: return;
+		}
+	}
+};
+function followPath(value, parent, path, owner) {
+	for (let i = 0; i < path.length; i++) {
+		parent = value;
+		let part = path[i];
+		if (part in Object.prototype) {
+			value = void 0;
+			continue;
+		}
+		switch (typeForRpc(value)) {
+			case "object":
+			case "function":
+				if (Object.hasOwn(value, part)) value = value[part];
+				else value = void 0;
+				break;
+			case "array":
+				if (Number.isInteger(part) && part >= 0) value = value[part];
+				else value = void 0;
+				break;
+			case "rpc-target":
+			case "rpc-thenable":
+				if (Object.hasOwn(value, part)) value = void 0;
+				else value = value[part];
+				owner = null;
+				break;
+			case "stub":
+			case "rpc-promise": {
+				let { hook, pathIfPromise } = unwrapStubAndPath(value);
+				return {
+					hook,
+					remainingPath: pathIfPromise ? pathIfPromise.concat(path.slice(i)) : path.slice(i)
+				};
+			}
+			case "primitive":
+			case "bigint":
+			case "bytes":
+			case "date":
+			case "error":
+				value = void 0;
+				break;
+			case "undefined":
+				value = value[part];
+				break;
+			case "unsupported": if (i === 0) throw new TypeError(`RPC stub points at a non-serializable type.`);
+			else {
+				let prefix = path.slice(0, i).join(".");
+				let remainder = path.slice(0, i).join(".");
+				throw new TypeError(`'${prefix}' is not a serializable type, so property ${remainder} cannot be accessed.`);
+			}
+			default: throw new TypeError("unreachable");
+		}
+	}
+	if (value instanceof RpcPromise) {
+		let { hook, pathIfPromise } = unwrapStubAndPath(value);
+		return {
+			hook,
+			remainingPath: pathIfPromise || []
+		};
+	}
+	return {
+		value,
+		parent,
+		owner
+	};
+}
+var ValueStubHook = class extends StubHook {
+	call(path, args) {
+		try {
+			let { value, owner } = this.getValue();
+			let followResult = followPath(value, void 0, path, owner);
+			if (followResult.hook) return followResult.hook.call(followResult.remainingPath, args);
+			if (typeof followResult.value != "function") throw new TypeError(`'${path.join(".")}' is not a function.`);
+			return new PromiseStubHook(args.deliverCall(followResult.value, followResult.parent).then((payload) => {
+				return new PayloadStubHook(payload);
+			}));
+		} catch (err) {
+			return new ErrorStubHook(err);
+		}
+	}
+	map(path, captures, instructions) {
+		try {
+			let followResult;
+			try {
+				let { value, owner } = this.getValue();
+				followResult = followPath(value, void 0, path, owner);
+			} catch (err) {
+				for (let cap of captures) cap.dispose();
+				throw err;
+			}
+			if (followResult.hook) return followResult.hook.map(followResult.remainingPath, captures, instructions);
+			return mapImpl.applyMap(followResult.value, followResult.parent, followResult.owner, captures, instructions);
+		} catch (err) {
+			return new ErrorStubHook(err);
+		}
+	}
+	get(path) {
+		try {
+			let { value, owner } = this.getValue();
+			if (path.length === 0 && owner === null) throw new Error("Can't dup an RpcTarget stub as a promise.");
+			let followResult = followPath(value, void 0, path, owner);
+			if (followResult.hook) return followResult.hook.get(followResult.remainingPath);
+			return new PayloadStubHook(RpcPayload.deepCopyFrom(followResult.value, followResult.parent, followResult.owner));
+		} catch (err) {
+			return new ErrorStubHook(err);
+		}
+	}
+};
+var PayloadStubHook = class _PayloadStubHook extends ValueStubHook {
+	constructor(payload) {
+		super();
+		this.payload = payload;
+	}
+	payload;
+	getPayload() {
+		if (this.payload) return this.payload;
+		else throw new Error("Attempted to use an RPC StubHook after it was disposed.");
+	}
+	getValue() {
+		let payload = this.getPayload();
+		return {
+			value: payload.value,
+			owner: payload
+		};
+	}
+	dup() {
+		let thisPayload = this.getPayload();
+		return new _PayloadStubHook(RpcPayload.deepCopyFrom(thisPayload.value, void 0, thisPayload));
+	}
+	pull() {
+		return this.getPayload();
+	}
+	ignoreUnhandledRejections() {
+		if (this.payload) this.payload.ignoreUnhandledRejections();
+	}
+	dispose() {
+		if (this.payload) {
+			this.payload.dispose();
+			this.payload = void 0;
+		}
+	}
+	onBroken(callback) {
+		if (this.payload) {
+			if (this.payload.value instanceof RpcStub) this.payload.value.onRpcBroken(callback);
+		}
+	}
+};
+function disposeRpcTarget(target) {
+	if (Symbol.dispose in target) try {
+		target[Symbol.dispose]();
+	} catch (err) {
+		Promise.reject(err);
+	}
+}
+var TargetStubHook = class _TargetStubHook extends ValueStubHook {
+	static create(value, parent) {
+		if (typeof value !== "function") parent = void 0;
+		return new _TargetStubHook(value, parent);
+	}
+	constructor(target, parent, dupFrom) {
+		super();
+		this.target = target;
+		this.parent = parent;
+		if (dupFrom) {
+			if (dupFrom.refcount) {
+				this.refcount = dupFrom.refcount;
+				++this.refcount.count;
+			}
+		} else if (Symbol.dispose in target) this.refcount = { count: 1 };
+	}
+	target;
+	parent;
+	refcount;
+	getTarget() {
+		if (this.target) return this.target;
+		else throw new Error("Attempted to use an RPC StubHook after it was disposed.");
+	}
+	getValue() {
+		return {
+			value: this.getTarget(),
+			owner: null
+		};
+	}
+	dup() {
+		return new _TargetStubHook(this.getTarget(), this.parent, this);
+	}
+	pull() {
+		let target = this.getTarget();
+		if ("then" in target) return Promise.resolve(target).then((resolution) => {
+			return RpcPayload.fromAppReturn(resolution);
+		});
+		else return Promise.reject(/* @__PURE__ */ new Error("Tried to resolve a non-promise stub."));
+	}
+	ignoreUnhandledRejections() {}
+	dispose() {
+		if (this.target) {
+			if (this.refcount) {
+				if (--this.refcount.count == 0) disposeRpcTarget(this.target);
+			}
+			this.target = void 0;
+		}
+	}
+	onBroken(callback) {}
+};
+var PromiseStubHook = class _PromiseStubHook extends StubHook {
+	promise;
+	resolution;
+	constructor(promise) {
+		super();
+		this.promise = promise.then((res) => {
+			this.resolution = res;
+			return res;
+		});
+	}
+	call(path, args) {
+		args.ensureDeepCopied();
+		return new _PromiseStubHook(this.promise.then((hook) => hook.call(path, args)));
+	}
+	map(path, captures, instructions) {
+		return new _PromiseStubHook(this.promise.then((hook) => hook.map(path, captures, instructions), (err) => {
+			for (let cap of captures) cap.dispose();
+			throw err;
+		}));
+	}
+	get(path) {
+		return new _PromiseStubHook(this.promise.then((hook) => hook.get(path)));
+	}
+	dup() {
+		if (this.resolution) return this.resolution.dup();
+		else return new _PromiseStubHook(this.promise.then((hook) => hook.dup()));
+	}
+	pull() {
+		if (this.resolution) return this.resolution.pull();
+		else return this.promise.then((hook) => hook.pull());
+	}
+	ignoreUnhandledRejections() {
+		if (this.resolution) this.resolution.ignoreUnhandledRejections();
+		else this.promise.then((res) => {
+			res.ignoreUnhandledRejections();
+		}, (err) => {});
+	}
+	dispose() {
+		if (this.resolution) this.resolution.dispose();
+		else this.promise.then((hook) => {
+			hook.dispose();
+		}, (err) => {});
+	}
+	onBroken(callback) {
+		if (this.resolution) this.resolution.onBroken(callback);
+		else this.promise.then((hook) => {
+			hook.onBroken(callback);
+		}, callback);
+	}
+};
+var NullExporter = class {
+	exportStub(stub) {
+		throw new Error("Cannot serialize RPC stubs without an RPC session.");
+	}
+	exportPromise(stub) {
+		throw new Error("Cannot serialize RPC stubs without an RPC session.");
+	}
+	getImport(hook) {}
+	unexport(ids) {}
+	onSendError(error) {}
+};
+var NULL_EXPORTER = new NullExporter();
+var ERROR_TYPES = {
+	Error,
+	EvalError,
+	RangeError,
+	ReferenceError,
+	SyntaxError,
+	TypeError,
+	URIError,
+	AggregateError
+};
+var Devaluator = class _Devaluator {
+	constructor(exporter, source) {
+		this.exporter = exporter;
+		this.source = source;
+	}
+	static devaluate(value, parent, exporter = NULL_EXPORTER, source) {
+		let devaluator = new _Devaluator(exporter, source);
+		try {
+			return devaluator.devaluateImpl(value, parent, 0);
+		} catch (err) {
+			if (devaluator.exports) try {
+				exporter.unexport(devaluator.exports);
+			} catch (err2) {}
+			throw err;
+		}
+	}
+	exports;
+	devaluateImpl(value, parent, depth) {
+		if (depth >= 64) throw new Error("Serialization exceeded maximum allowed depth. (Does the message contain cycles?)");
+		switch (typeForRpc(value)) {
+			case "unsupported": {
+				let msg;
+				try {
+					msg = `Cannot serialize value: ${value}`;
+				} catch (err) {
+					msg = "Cannot serialize value: (couldn't stringify value)";
+				}
+				throw new TypeError(msg);
+			}
+			case "primitive": return value;
+			case "object": {
+				let object = value;
+				let result = {};
+				for (let key in object) result[key] = this.devaluateImpl(object[key], object, depth + 1);
+				return result;
+			}
+			case "array": {
+				let array = value;
+				let len = array.length;
+				let result = new Array(len);
+				for (let i = 0; i < len; i++) result[i] = this.devaluateImpl(array[i], array, depth + 1);
+				return [result];
+			}
+			case "bigint": return ["bigint", value.toString()];
+			case "date": return ["date", value.getTime()];
+			case "bytes": {
+				let bytes = value;
+				if (bytes.toBase64) return ["bytes", bytes.toBase64({ omitPadding: true })];
+				else return ["bytes", btoa(String.fromCharCode.apply(null, bytes).replace(/=*$/, ""))];
+			}
+			case "error": {
+				let e = value;
+				let rewritten = this.exporter.onSendError(e);
+				if (rewritten) e = rewritten;
+				let result = [
+					"error",
+					e.name,
+					e.message
+				];
+				if (rewritten && rewritten.stack) result.push(rewritten.stack);
+				return result;
+			}
+			case "undefined": return ["undefined"];
+			case "stub":
+			case "rpc-promise": {
+				if (!this.source) throw new Error("Can't serialize RPC stubs in this context.");
+				let { hook, pathIfPromise } = unwrapStubAndPath(value);
+				let importId = this.exporter.getImport(hook);
+				if (importId !== void 0) if (pathIfPromise) if (pathIfPromise.length > 0) return [
+					"pipeline",
+					importId,
+					pathIfPromise
+				];
+				else return ["pipeline", importId];
+				else return ["import", importId];
+				if (pathIfPromise) hook = hook.get(pathIfPromise);
+				else hook = hook.dup();
+				return this.devaluateHook(pathIfPromise ? "promise" : "export", hook);
+			}
+			case "function":
+			case "rpc-target": {
+				if (!this.source) throw new Error("Can't serialize RPC stubs in this context.");
+				let hook = this.source.getHookForRpcTarget(value, parent);
+				return this.devaluateHook("export", hook);
+			}
+			case "rpc-thenable": {
+				if (!this.source) throw new Error("Can't serialize RPC stubs in this context.");
+				let hook = this.source.getHookForRpcTarget(value, parent);
+				return this.devaluateHook("promise", hook);
+			}
+			default: throw new Error("unreachable");
+		}
+	}
+	devaluateHook(type, hook) {
+		if (!this.exports) this.exports = [];
+		let exportId = type === "promise" ? this.exporter.exportPromise(hook) : this.exporter.exportStub(hook);
+		this.exports.push(exportId);
+		return [type, exportId];
+	}
+};
+var NullImporter = class {
+	importStub(idx) {
+		throw new Error("Cannot deserialize RPC stubs without an RPC session.");
+	}
+	importPromise(idx) {
+		throw new Error("Cannot deserialize RPC stubs without an RPC session.");
+	}
+	getExport(idx) {}
+};
+var NULL_IMPORTER = new NullImporter();
+var Evaluator = class _Evaluator {
+	constructor(importer) {
+		this.importer = importer;
+	}
+	stubs = [];
+	promises = [];
+	evaluate(value) {
+		let payload = RpcPayload.forEvaluate(this.stubs, this.promises);
+		try {
+			payload.value = this.evaluateImpl(value, payload, "value");
+			return payload;
+		} catch (err) {
+			payload.dispose();
+			throw err;
+		}
+	}
+	evaluateCopy(value) {
+		return this.evaluate(structuredClone(value));
+	}
+	evaluateImpl(value, parent, property) {
+		if (value instanceof Array) {
+			if (value.length == 1 && value[0] instanceof Array) {
+				let result = value[0];
+				for (let i = 0; i < result.length; i++) result[i] = this.evaluateImpl(result[i], result, i);
+				return result;
+			} else switch (value[0]) {
+				case "bigint":
+					if (typeof value[1] == "string") return BigInt(value[1]);
+					break;
+				case "date":
+					if (typeof value[1] == "number") return new Date(value[1]);
+					break;
+				case "bytes": {
+					let b64 = Uint8Array;
+					if (typeof value[1] == "string") if (b64.fromBase64) return b64.fromBase64(value[1]);
+					else {
+						let bs = atob(value[1]);
+						let len = bs.length;
+						let bytes = new Uint8Array(len);
+						for (let i = 0; i < len; i++) bytes[i] = bs.charCodeAt(i);
+						return bytes;
+					}
+					break;
+				}
+				case "error":
+					if (value.length >= 3 && typeof value[1] === "string" && typeof value[2] === "string") {
+						let result = new (ERROR_TYPES[value[1]] || Error)(value[2]);
+						if (typeof value[3] === "string") result.stack = value[3];
+						return result;
+					}
+					break;
+				case "undefined":
+					if (value.length === 1) return;
+					break;
+				case "import":
+				case "pipeline": {
+					if (value.length < 2 || value.length > 4) break;
+					if (typeof value[1] != "number") break;
+					let hook = this.importer.getExport(value[1]);
+					if (!hook) throw new Error(`no such entry on exports table: ${value[1]}`);
+					let isPromise = value[0] == "pipeline";
+					let addStub = (hook2) => {
+						if (isPromise) {
+							let promise = new RpcPromise(hook2, []);
+							this.promises.push({
+								promise,
+								parent,
+								property
+							});
+							return promise;
+						} else {
+							let stub = new RpcPromise(hook2, []);
+							this.stubs.push(stub);
+							return stub;
+						}
+					};
+					if (value.length == 2) if (isPromise) return addStub(hook.get([]));
+					else return addStub(hook.dup());
+					let path = value[2];
+					if (!(path instanceof Array)) break;
+					if (!path.every((part) => {
+						return typeof part == "string" || typeof part == "number";
+					})) break;
+					if (value.length == 3) return addStub(hook.get(path));
+					let args = value[3];
+					if (!(args instanceof Array)) break;
+					args = new _Evaluator(this.importer).evaluate([args]);
+					return addStub(hook.call(path, args));
+				}
+				case "remap": {
+					if (value.length !== 5 || typeof value[1] !== "number" || !(value[2] instanceof Array) || !(value[3] instanceof Array) || !(value[4] instanceof Array)) break;
+					let hook = this.importer.getExport(value[1]);
+					if (!hook) throw new Error(`no such entry on exports table: ${value[1]}`);
+					let path = value[2];
+					if (!path.every((part) => {
+						return typeof part == "string" || typeof part == "number";
+					})) break;
+					let captures = value[3].map((cap) => {
+						if (!(cap instanceof Array) || cap.length !== 2 || cap[0] !== "import" && cap[0] !== "export" || typeof cap[1] !== "number") throw new TypeError(`unknown map capture: ${JSON.stringify(cap)}`);
+						if (cap[0] === "export") return this.importer.importStub(cap[1]);
+						else {
+							let exp = this.importer.getExport(cap[1]);
+							if (!exp) throw new Error(`no such entry on exports table: ${cap[1]}`);
+							return exp.dup();
+						}
+					});
+					let instructions = value[4];
+					let promise = new RpcPromise(hook.map(path, captures, instructions), []);
+					this.promises.push({
+						promise,
+						parent,
+						property
+					});
+					return promise;
+				}
+				case "export":
+				case "promise":
+					if (typeof value[1] == "number") if (value[0] == "promise") {
+						let promise = new RpcPromise(this.importer.importPromise(value[1]), []);
+						this.promises.push({
+							parent,
+							property,
+							promise
+						});
+						return promise;
+					} else {
+						let stub = new RpcStub(this.importer.importStub(value[1]));
+						this.stubs.push(stub);
+						return stub;
+					}
+					break;
+			}
+			throw new TypeError(`unknown special value: ${JSON.stringify(value)}`);
+		} else if (value instanceof Object) {
+			let result = value;
+			for (let key in result) if (key in Object.prototype || key === "toJSON") {
+				this.evaluateImpl(result[key], result, key);
+				delete result[key];
+			} else result[key] = this.evaluateImpl(result[key], result, key);
+			return result;
+		} else return value;
+	}
+};
+var ImportTableEntry = class {
+	constructor(session, importId, pulling) {
+		this.session = session;
+		this.importId = importId;
+		if (pulling) this.activePull = Promise.withResolvers();
+	}
+	localRefcount = 0;
+	remoteRefcount = 1;
+	activePull;
+	resolution;
+	onBrokenRegistrations;
+	resolve(resolution) {
+		if (this.localRefcount == 0) {
+			resolution.dispose();
+			return;
+		}
+		this.resolution = resolution;
+		this.sendRelease();
+		if (this.onBrokenRegistrations) {
+			for (let i of this.onBrokenRegistrations) {
+				let callback = this.session.onBrokenCallbacks[i];
+				let endIndex = this.session.onBrokenCallbacks.length;
+				resolution.onBroken(callback);
+				if (this.session.onBrokenCallbacks[endIndex] === callback) delete this.session.onBrokenCallbacks[endIndex];
+				else delete this.session.onBrokenCallbacks[i];
+			}
+			this.onBrokenRegistrations = void 0;
+		}
+		if (this.activePull) {
+			this.activePull.resolve();
+			this.activePull = void 0;
+		}
+	}
+	async awaitResolution() {
+		if (!this.activePull) {
+			this.session.sendPull(this.importId);
+			this.activePull = Promise.withResolvers();
+		}
+		await this.activePull.promise;
+		return this.resolution.pull();
+	}
+	dispose() {
+		if (this.resolution) this.resolution.dispose();
+		else {
+			this.abort(/* @__PURE__ */ new Error("RPC was canceled because the RpcPromise was disposed."));
+			this.sendRelease();
+		}
+	}
+	abort(error) {
+		if (!this.resolution) {
+			this.resolution = new ErrorStubHook(error);
+			if (this.activePull) {
+				this.activePull.reject(error);
+				this.activePull = void 0;
+			}
+			this.onBrokenRegistrations = void 0;
+		}
+	}
+	onBroken(callback) {
+		if (this.resolution) this.resolution.onBroken(callback);
+		else {
+			let index = this.session.onBrokenCallbacks.length;
+			this.session.onBrokenCallbacks.push(callback);
+			if (!this.onBrokenRegistrations) this.onBrokenRegistrations = [];
+			this.onBrokenRegistrations.push(index);
+		}
+	}
+	sendRelease() {
+		if (this.remoteRefcount > 0) {
+			this.session.sendRelease(this.importId, this.remoteRefcount);
+			this.remoteRefcount = 0;
+		}
+	}
+};
+var RpcImportHook = class _RpcImportHook extends StubHook {
+	constructor(isPromise, entry) {
+		super();
+		this.isPromise = isPromise;
+		++entry.localRefcount;
+		this.entry = entry;
+	}
+	entry;
+	collectPath(path) {
+		return this;
+	}
+	getEntry() {
+		if (this.entry) return this.entry;
+		else throw new Error("This RpcImportHook was already disposed.");
+	}
+	call(path, args) {
+		let entry = this.getEntry();
+		if (entry.resolution) return entry.resolution.call(path, args);
+		else return entry.session.sendCall(entry.importId, path, args);
+	}
+	map(path, captures, instructions) {
+		let entry;
+		try {
+			entry = this.getEntry();
+		} catch (err) {
+			for (let cap of captures) cap.dispose();
+			throw err;
+		}
+		if (entry.resolution) return entry.resolution.map(path, captures, instructions);
+		else return entry.session.sendMap(entry.importId, path, captures, instructions);
+	}
+	get(path) {
+		let entry = this.getEntry();
+		if (entry.resolution) return entry.resolution.get(path);
+		else return entry.session.sendCall(entry.importId, path);
+	}
+	dup() {
+		return new _RpcImportHook(false, this.getEntry());
+	}
+	pull() {
+		let entry = this.getEntry();
+		if (!this.isPromise) throw new Error("Can't pull this hook because it's not a promise hook.");
+		if (entry.resolution) return entry.resolution.pull();
+		return entry.awaitResolution();
+	}
+	ignoreUnhandledRejections() {}
+	dispose() {
+		let entry = this.entry;
+		this.entry = void 0;
+		if (entry) {
+			if (--entry.localRefcount === 0) entry.dispose();
+		}
+	}
+	onBroken(callback) {
+		if (this.entry) this.entry.onBroken(callback);
+	}
+};
+var RpcMainHook = class extends RpcImportHook {
+	session;
+	constructor(entry) {
+		super(false, entry);
+		this.session = entry.session;
+	}
+	dispose() {
+		if (this.session) {
+			let session = this.session;
+			this.session = void 0;
+			session.shutdown();
+		}
+	}
+};
+var RpcSessionImpl = class {
+	constructor(transport, mainHook, options) {
+		this.transport = transport;
+		this.options = options;
+		this.exports.push({
+			hook: mainHook,
+			refcount: 1
+		});
+		this.imports.push(new ImportTableEntry(this, 0, false));
+		let rejectFunc;
+		let abortPromise = new Promise((resolve, reject) => {
+			rejectFunc = reject;
+		});
+		this.cancelReadLoop = rejectFunc;
+		this.readLoop(abortPromise).catch((err) => this.abort(err));
+	}
+	exports = [];
+	reverseExports = /* @__PURE__ */ new Map();
+	imports = [];
+	abortReason;
+	cancelReadLoop;
+	nextExportId = -1;
+	onBatchDone;
+	pullCount = 0;
+	onBrokenCallbacks = [];
+	getMainImport() {
+		return new RpcMainHook(this.imports[0]);
+	}
+	shutdown() {
+		this.abort(/* @__PURE__ */ new Error("RPC session was shut down by disposing the main stub"), false);
+	}
+	exportStub(hook) {
+		if (this.abortReason) throw this.abortReason;
+		let existingExportId = this.reverseExports.get(hook);
+		if (existingExportId !== void 0) {
+			++this.exports[existingExportId].refcount;
+			return existingExportId;
+		} else {
+			let exportId = this.nextExportId--;
+			this.exports[exportId] = {
+				hook,
+				refcount: 1
+			};
+			this.reverseExports.set(hook, exportId);
+			return exportId;
+		}
+	}
+	exportPromise(hook) {
+		if (this.abortReason) throw this.abortReason;
+		let exportId = this.nextExportId--;
+		this.exports[exportId] = {
+			hook,
+			refcount: 1
+		};
+		this.reverseExports.set(hook, exportId);
+		this.ensureResolvingExport(exportId);
+		return exportId;
+	}
+	unexport(ids) {
+		for (let id of ids) this.releaseExport(id, 1);
+	}
+	releaseExport(exportId, refcount) {
+		let entry = this.exports[exportId];
+		if (!entry) throw new Error(`no such export ID: ${exportId}`);
+		if (entry.refcount < refcount) throw new Error(`refcount would go negative: ${entry.refcount} < ${refcount}`);
+		entry.refcount -= refcount;
+		if (entry.refcount === 0) {
+			delete this.exports[exportId];
+			this.reverseExports.delete(entry.hook);
+			entry.hook.dispose();
+		}
+	}
+	onSendError(error) {
+		if (this.options.onSendError) return this.options.onSendError(error);
+	}
+	ensureResolvingExport(exportId) {
+		let exp = this.exports[exportId];
+		if (!exp) throw new Error(`no such export ID: ${exportId}`);
+		if (!exp.pull) {
+			let resolve = async () => {
+				let hook = exp.hook;
+				for (;;) {
+					let payload = await hook.pull();
+					if (payload.value instanceof RpcStub) {
+						let { hook: inner, pathIfPromise } = unwrapStubAndPath(payload.value);
+						if (pathIfPromise && pathIfPromise.length == 0) {
+							if (this.getImport(hook) === void 0) {
+								hook = inner;
+								continue;
+							}
+						}
+					}
+					return payload;
+				}
+			};
+			++this.pullCount;
+			exp.pull = resolve().then((payload) => {
+				let value = Devaluator.devaluate(payload.value, void 0, this, payload);
+				this.send([
+					"resolve",
+					exportId,
+					value
+				]);
+			}, (error) => {
+				this.send([
+					"reject",
+					exportId,
+					Devaluator.devaluate(error, void 0, this)
+				]);
+			}).catch((error) => {
+				try {
+					this.send([
+						"reject",
+						exportId,
+						Devaluator.devaluate(error, void 0, this)
+					]);
+				} catch (error2) {
+					this.abort(error2);
+				}
+			}).finally(() => {
+				if (--this.pullCount === 0) {
+					if (this.onBatchDone) this.onBatchDone.resolve();
+				}
+			});
+		}
+	}
+	getImport(hook) {
+		if (hook instanceof RpcImportHook && hook.entry && hook.entry.session === this) return hook.entry.importId;
+		else return;
+	}
+	importStub(idx) {
+		if (this.abortReason) throw this.abortReason;
+		let entry = this.imports[idx];
+		if (!entry) {
+			entry = new ImportTableEntry(this, idx, false);
+			this.imports[idx] = entry;
+		}
+		return new RpcImportHook(false, entry);
+	}
+	importPromise(idx) {
+		if (this.abortReason) throw this.abortReason;
+		if (this.imports[idx]) return new ErrorStubHook(/* @__PURE__ */ new Error("Bug in RPC system: The peer sent a promise reusing an existing export ID."));
+		let entry = new ImportTableEntry(this, idx, true);
+		this.imports[idx] = entry;
+		return new RpcImportHook(true, entry);
+	}
+	getExport(idx) {
+		return this.exports[idx]?.hook;
+	}
+	send(msg) {
+		if (this.abortReason !== void 0) return;
+		let msgText;
+		try {
+			msgText = JSON.stringify(msg);
+		} catch (err) {
+			try {
+				this.abort(err);
+			} catch (err2) {}
+			throw err;
+		}
+		this.transport.send(msgText).catch((err) => this.abort(err, false));
+	}
+	sendCall(id, path, args) {
+		if (this.abortReason) throw this.abortReason;
+		let value = [
+			"pipeline",
+			id,
+			path
+		];
+		if (args) {
+			let devalue = Devaluator.devaluate(args.value, void 0, this, args);
+			value.push(devalue[0]);
+		}
+		this.send(["push", value]);
+		let entry = new ImportTableEntry(this, this.imports.length, false);
+		this.imports.push(entry);
+		return new RpcImportHook(true, entry);
+	}
+	sendMap(id, path, captures, instructions) {
+		if (this.abortReason) {
+			for (let cap of captures) cap.dispose();
+			throw this.abortReason;
+		}
+		let value = [
+			"remap",
+			id,
+			path,
+			captures.map((hook) => {
+				let importId = this.getImport(hook);
+				if (importId !== void 0) return ["import", importId];
+				else return ["export", this.exportStub(hook)];
+			}),
+			instructions
+		];
+		this.send(["push", value]);
+		let entry = new ImportTableEntry(this, this.imports.length, false);
+		this.imports.push(entry);
+		return new RpcImportHook(true, entry);
+	}
+	sendPull(id) {
+		if (this.abortReason) throw this.abortReason;
+		this.send(["pull", id]);
+	}
+	sendRelease(id, remoteRefcount) {
+		if (this.abortReason) return;
+		this.send([
+			"release",
+			id,
+			remoteRefcount
+		]);
+		delete this.imports[id];
+	}
+	abort(error, trySendAbortMessage = true) {
+		if (this.abortReason !== void 0) return;
+		this.cancelReadLoop(error);
+		if (trySendAbortMessage) try {
+			this.transport.send(JSON.stringify(["abort", Devaluator.devaluate(error, void 0, this)])).catch((err) => {});
+		} catch (err) {}
+		if (error === void 0) error = "undefined";
+		this.abortReason = error;
+		if (this.onBatchDone) this.onBatchDone.reject(error);
+		if (this.transport.abort) try {
+			this.transport.abort(error);
+		} catch (err) {
+			Promise.resolve(err);
+		}
+		for (let i in this.onBrokenCallbacks) try {
+			this.onBrokenCallbacks[i](error);
+		} catch (err) {
+			Promise.resolve(err);
+		}
+		for (let i in this.imports) this.imports[i].abort(error);
+		for (let i in this.exports) this.exports[i].hook.dispose();
+	}
+	async readLoop(abortPromise) {
+		while (!this.abortReason) {
+			let msg = JSON.parse(await Promise.race([this.transport.receive(), abortPromise]));
+			if (this.abortReason) break;
+			if (msg instanceof Array) switch (msg[0]) {
+				case "push":
+					if (msg.length > 1) {
+						let hook = new PayloadStubHook(new Evaluator(this).evaluate(msg[1]));
+						hook.ignoreUnhandledRejections();
+						this.exports.push({
+							hook,
+							refcount: 1
+						});
+						continue;
+					}
+					break;
+				case "pull": {
+					let exportId = msg[1];
+					if (typeof exportId == "number") {
+						this.ensureResolvingExport(exportId);
+						continue;
+					}
+					break;
+				}
+				case "resolve":
+				case "reject": {
+					let importId = msg[1];
+					if (typeof importId == "number" && msg.length > 2) {
+						let imp = this.imports[importId];
+						if (imp) if (msg[0] == "resolve") imp.resolve(new PayloadStubHook(new Evaluator(this).evaluate(msg[2])));
+						else {
+							let payload = new Evaluator(this).evaluate(msg[2]);
+							payload.dispose();
+							imp.resolve(new ErrorStubHook(payload.value));
+						}
+						else if (msg[0] == "resolve") new Evaluator(this).evaluate(msg[2]).dispose();
+						continue;
+					}
+					break;
+				}
+				case "release": {
+					let exportId = msg[1];
+					let refcount = msg[2];
+					if (typeof exportId == "number" && typeof refcount == "number") {
+						this.releaseExport(exportId, refcount);
+						continue;
+					}
+					break;
+				}
+				case "abort": {
+					let payload = new Evaluator(this).evaluate(msg[1]);
+					payload.dispose();
+					this.abort(payload, false);
+					break;
+				}
+			}
+			throw new Error(`bad RPC message: ${JSON.stringify(msg)}`);
+		}
+	}
+	async drain() {
+		if (this.abortReason) throw this.abortReason;
+		if (this.pullCount > 0) {
+			let { promise, resolve, reject } = Promise.withResolvers();
+			this.onBatchDone = {
+				resolve,
+				reject
+			};
+			await promise;
+		}
+	}
+	getStats() {
+		let result = {
+			imports: 0,
+			exports: 0
+		};
+		for (let i in this.imports) ++result.imports;
+		for (let i in this.exports) ++result.exports;
+		return result;
+	}
+};
+var RpcSession = class {
+	#session;
+	#mainStub;
+	constructor(transport, localMain, options = {}) {
+		let mainHook;
+		if (localMain) mainHook = new PayloadStubHook(RpcPayload.fromAppReturn(localMain));
+		else mainHook = new ErrorStubHook(/* @__PURE__ */ new Error("This connection has no main object."));
+		this.#session = new RpcSessionImpl(transport, mainHook, options);
+		this.#mainStub = new RpcStub(this.#session.getMainImport());
+	}
+	getRemoteMain() {
+		return this.#mainStub;
+	}
+	getStats() {
+		return this.#session.getStats();
+	}
+	drain() {
+		return this.#session.drain();
+	}
+};
+function newWebSocketRpcSession(webSocket, localMain, options) {
+	if (typeof webSocket === "string") webSocket = new WebSocket(webSocket);
+	return new RpcSession(new WebSocketTransport(webSocket), localMain, options).getRemoteMain();
+}
+function newWorkersWebSocketRpcResponse(request, localMain, options) {
+	if (request.headers.get("Upgrade")?.toLowerCase() !== "websocket") return new Response("This endpoint only accepts WebSocket requests.", { status: 400 });
+	let pair = new WebSocketPair();
+	let server = pair[0];
+	server.accept();
+	newWebSocketRpcSession(server, localMain, options);
+	return new Response(null, {
+		status: 101,
+		webSocket: pair[1]
+	});
+}
+var WebSocketTransport = class {
+	constructor(webSocket) {
+		this.#webSocket = webSocket;
+		if (webSocket.readyState === WebSocket.CONNECTING) {
+			this.#sendQueue = [];
+			webSocket.addEventListener("open", (event) => {
+				try {
+					for (let message of this.#sendQueue) webSocket.send(message);
+				} catch (err) {
+					this.#receivedError(err);
+				}
+				this.#sendQueue = void 0;
+			});
+		}
+		webSocket.addEventListener("message", (event) => {
+			if (this.#error);
+			else if (typeof event.data === "string") if (this.#receiveResolver) {
+				this.#receiveResolver(event.data);
+				this.#receiveResolver = void 0;
+				this.#receiveRejecter = void 0;
+			} else this.#receiveQueue.push(event.data);
+			else this.#receivedError(/* @__PURE__ */ new TypeError("Received non-string message from WebSocket."));
+		});
+		webSocket.addEventListener("close", (event) => {
+			this.#receivedError(/* @__PURE__ */ new Error(`Peer closed WebSocket: ${event.code} ${event.reason}`));
+		});
+		webSocket.addEventListener("error", (event) => {
+			this.#receivedError(/* @__PURE__ */ new Error(`WebSocket connection failed.`));
+		});
+	}
+	#webSocket;
+	#sendQueue;
+	#receiveResolver;
+	#receiveRejecter;
+	#receiveQueue = [];
+	#error;
+	async send(message) {
+		if (this.#sendQueue === void 0) this.#webSocket.send(message);
+		else this.#sendQueue.push(message);
+	}
+	async receive() {
+		if (this.#receiveQueue.length > 0) return this.#receiveQueue.shift();
+		else if (this.#error) throw this.#error;
+		else return new Promise((resolve, reject) => {
+			this.#receiveResolver = resolve;
+			this.#receiveRejecter = reject;
+		});
+	}
+	abort(reason) {
+		let message;
+		if (reason instanceof Error) message = reason.message;
+		else message = `${reason}`;
+		this.#webSocket.close(3e3, message);
+		if (!this.#error) this.#error = reason;
+	}
+	#receivedError(reason) {
+		if (!this.#error) {
+			this.#error = reason;
+			if (this.#receiveRejecter) {
+				this.#receiveRejecter(reason);
+				this.#receiveResolver = void 0;
+				this.#receiveRejecter = void 0;
+			}
+		}
+	}
+};
+var BatchServerTransport = class {
+	constructor(batch) {
+		this.#batchToReceive = batch;
+	}
+	#batchToSend = [];
+	#batchToReceive;
+	#allReceived = Promise.withResolvers();
+	async send(message) {
+		this.#batchToSend.push(message);
+	}
+	async receive() {
+		let msg = this.#batchToReceive.shift();
+		if (msg !== void 0) return msg;
+		else {
+			this.#allReceived.resolve();
+			return new Promise((r) => {});
+		}
+	}
+	abort(reason) {
+		this.#allReceived.reject(reason);
+	}
+	whenAllReceived() {
+		return this.#allReceived.promise;
+	}
+	getResponseBody() {
+		return this.#batchToSend.join("\n");
+	}
+};
+async function newHttpBatchRpcResponse(request, localMain, options) {
+	if (request.method !== "POST") return new Response("This endpoint only accepts POST requests.", { status: 405 });
+	let body = await request.text();
+	let transport = new BatchServerTransport(body === "" ? [] : body.split("\n"));
+	let rpc = new RpcSession(transport, localMain, options);
+	await transport.whenAllReceived();
+	await rpc.drain();
+	return new Response(transport.getResponseBody());
+}
+var currentMapBuilder;
+var MapBuilder = class {
+	context;
+	captureMap = /* @__PURE__ */ new Map();
+	instructions = [];
+	constructor(subject, path) {
+		if (currentMapBuilder) this.context = {
+			parent: currentMapBuilder,
+			captures: [],
+			subject: currentMapBuilder.capture(subject),
+			path
+		};
+		else this.context = {
+			parent: void 0,
+			captures: [],
+			subject,
+			path
+		};
+		currentMapBuilder = this;
+	}
+	unregister() {
+		currentMapBuilder = this.context.parent;
+	}
+	makeInput() {
+		return new MapVariableHook(this, 0);
+	}
+	makeOutput(result) {
+		let devalued;
+		try {
+			devalued = Devaluator.devaluate(result.value, void 0, this, result);
+		} finally {
+			result.dispose();
+		}
+		this.instructions.push(devalued);
+		if (this.context.parent) {
+			this.context.parent.instructions.push([
+				"remap",
+				this.context.subject,
+				this.context.path,
+				this.context.captures.map((cap) => ["import", cap]),
+				this.instructions
+			]);
+			return new MapVariableHook(this.context.parent, this.context.parent.instructions.length);
+		} else return this.context.subject.map(this.context.path, this.context.captures, this.instructions);
+	}
+	pushCall(hook, path, params) {
+		let devalued = Devaluator.devaluate(params.value, void 0, this, params);
+		devalued = devalued[0];
+		let subject = this.capture(hook.dup());
+		this.instructions.push([
+			"pipeline",
+			subject,
+			path,
+			devalued
+		]);
+		return new MapVariableHook(this, this.instructions.length);
+	}
+	pushGet(hook, path) {
+		let subject = this.capture(hook.dup());
+		this.instructions.push([
+			"pipeline",
+			subject,
+			path
+		]);
+		return new MapVariableHook(this, this.instructions.length);
+	}
+	capture(hook) {
+		if (hook instanceof MapVariableHook && hook.mapper === this) return hook.idx;
+		let result = this.captureMap.get(hook);
+		if (result === void 0) {
+			if (this.context.parent) {
+				let parentIdx = this.context.parent.capture(hook);
+				this.context.captures.push(parentIdx);
+			} else this.context.captures.push(hook);
+			result = -this.context.captures.length;
+			this.captureMap.set(hook, result);
+		}
+		return result;
+	}
+	exportStub(hook) {
+		throw new Error("Can't construct an RpcTarget or RPC callback inside a mapper function. Try creating a new RpcStub outside the callback first, then using it inside the callback.");
+	}
+	exportPromise(hook) {
+		return this.exportStub(hook);
+	}
+	getImport(hook) {
+		return this.capture(hook);
+	}
+	unexport(ids) {}
+	onSendError(error) {}
+};
+mapImpl.sendMap = (hook, path, func) => {
+	let builder = new MapBuilder(hook, path);
+	let result;
+	try {
+		result = RpcPayload.fromAppReturn(withCallInterceptor(builder.pushCall.bind(builder), () => {
+			return func(new RpcPromise(builder.makeInput(), []));
+		}));
+	} finally {
+		builder.unregister();
+	}
+	if (result instanceof Promise) {
+		result.catch((err) => {});
+		throw new Error("RPC map() callbacks cannot be async.");
+	}
+	return new RpcPromise(builder.makeOutput(result), []);
+};
+function throwMapperBuilderUseError() {
+	throw new Error("Attempted to use an abstract placeholder from a mapper function. Please make sure your map function has no side effects.");
+}
+var MapVariableHook = class extends StubHook {
+	constructor(mapper, idx) {
+		super();
+		this.mapper = mapper;
+		this.idx = idx;
+	}
+	dup() {
+		return this;
+	}
+	dispose() {}
+	get(path) {
+		if (path.length == 0) return this;
+		else if (currentMapBuilder) return currentMapBuilder.pushGet(this, path);
+		else throwMapperBuilderUseError();
+	}
+	call(path, args) {
+		throwMapperBuilderUseError();
+	}
+	map(path, captures, instructions) {
+		throwMapperBuilderUseError();
+	}
+	pull() {
+		throwMapperBuilderUseError();
+	}
+	ignoreUnhandledRejections() {}
+	onBroken(callback) {
+		throwMapperBuilderUseError();
+	}
+};
+var MapApplicator = class {
+	constructor(captures, input) {
+		this.captures = captures;
+		this.variables = [input];
+	}
+	variables;
+	dispose() {
+		for (let variable of this.variables) variable.dispose();
+	}
+	apply(instructions) {
+		try {
+			if (instructions.length < 1) throw new Error("Invalid empty mapper function.");
+			for (let instruction of instructions.slice(0, -1)) {
+				let payload = new Evaluator(this).evaluateCopy(instruction);
+				if (payload.value instanceof RpcStub) {
+					let hook = unwrapStubNoProperties(payload.value);
+					if (hook) {
+						this.variables.push(hook);
+						continue;
+					}
+				}
+				this.variables.push(new PayloadStubHook(payload));
+			}
+			return new Evaluator(this).evaluateCopy(instructions[instructions.length - 1]);
+		} finally {
+			for (let variable of this.variables) variable.dispose();
+		}
+	}
+	importStub(idx) {
+		throw new Error("A mapper function cannot refer to exports.");
+	}
+	importPromise(idx) {
+		return this.importStub(idx);
+	}
+	getExport(idx) {
+		if (idx < 0) return this.captures[-idx - 1];
+		else return this.variables[idx];
+	}
+};
+function applyMapToElement(input, parent, owner, captures, instructions) {
+	let mapper = new MapApplicator(captures, new PayloadStubHook(RpcPayload.deepCopyFrom(input, parent, owner)));
+	try {
+		return mapper.apply(instructions);
+	} finally {
+		mapper.dispose();
+	}
+}
+mapImpl.applyMap = (input, parent, owner, captures, instructions) => {
+	try {
+		let result;
+		if (input instanceof RpcPromise) throw new Error("applyMap() can't be called on RpcPromise");
+		else if (input instanceof Array) {
+			let payloads = [];
+			try {
+				for (let elem of input) payloads.push(applyMapToElement(elem, input, owner, captures, instructions));
+			} catch (err) {
+				for (let payload of payloads) payload.dispose();
+				throw err;
+			}
+			result = RpcPayload.fromArray(payloads);
+		} else if (input === null || input === void 0) result = RpcPayload.fromAppReturn(input);
+		else result = applyMapToElement(input, parent, owner, captures, instructions);
+		return new PayloadStubHook(result);
+	} finally {
+		for (let cap of captures) cap.dispose();
+	}
+};
+async function newWorkersRpcResponse(request, localMain) {
+	if (request.method === "POST") {
+		let response = await newHttpBatchRpcResponse(request, localMain);
+		response.headers.set("Access-Control-Allow-Origin", "*");
+		return response;
+	} else if (request.headers.get("Upgrade")?.toLowerCase() === "websocket") return newWorkersWebSocketRpcResponse(request, localMain);
+	else return new Response("This endpoint only accepts POST or WebSocket requests.", { status: 400 });
+}
+
+//#endregion
+//#region workers/remote-binding-proxy.ts
+var BindingNotFoundError = class extends Error {
+	constructor(name) {
+		super(`Binding ${name ? `"${name}"` : ""} not found`);
+	}
+};
+/**
+* For most bindings, we expose them as
+*  - RPC stubs directly to capnweb, or
+*  - HTTP based fetchers
+* However, there are some special cases:
+*  - SendEmail bindings need to take EmailMessage as their first parameter,
+*    which is not serialisable. As such, we reconstruct it before sending it
+*    on to the binding. See packages/miniflare/src/workers/email/email.worker.ts
+*  - Dispatch Namespace bindings have a synchronous .get() method. Since we
+*    can't emulate that over an async boundary, we mock it locally and _actually_
+*    perform the .get() remotely at the first appropriate async point. See
+*    packages/miniflare/src/workers/dispatch-namespace/dispatch-namespace.worker.ts
+*
+* getExposedJSRPCBinding() and getExposedFetcher() perform the logic for figuring out
+* which binding is being accessed, dependending on the request. Note: Both have logic
+* for dispatch namespaces, because dispatch namespaces can use both fetch or RPC depending
+* on context.
+*/
+function getExposedJSRPCBinding(request, env) {
+	const url = new URL(request.url);
+	const bindingName = url.searchParams.get("MF-Binding");
+	if (!bindingName) throw new BindingNotFoundError();
+	const targetBinding = env[bindingName];
+	if (!targetBinding) throw new BindingNotFoundError(bindingName);
+	if (targetBinding.constructor.name === "SendEmail") return { async send(e) {
+		const message = new EmailMessage(e.from, e.to, e["EmailMessage::raw"]);
+		return targetBinding.send(message);
+	} };
+	if (url.searchParams.has("MF-Dispatch-Namespace-Options")) {
+		const { name, args, options } = JSON.parse(url.searchParams.get("MF-Dispatch-Namespace-Options"));
+		return targetBinding.get(name, args, options);
+	}
+	return targetBinding;
+}
+function getExposedFetcher(request, env) {
+	const bindingName = request.headers.get("MF-Binding");
+	if (!bindingName) throw new BindingNotFoundError();
+	const targetBinding = env[bindingName];
+	if (!targetBinding) throw new BindingNotFoundError(bindingName);
+	const dispatchNamespaceOptions = request.headers.get("MF-Dispatch-Namespace-Options");
+	if (dispatchNamespaceOptions) {
+		const { name, args, options } = JSON.parse(dispatchNamespaceOptions);
+		return targetBinding.get(name, args, options);
+	}
+	return targetBinding;
+}
+/**
+* This Worker can proxy two types of remote binding:
+*  1. "raw" bindings, where this Worker has been configured to pass through the raw
+*     fetch from a local workerd instance to the relevant binding
+*  2. JSRPC bindings, where this Worker uses capnweb to proxy RPC
+*     communication in userland. This is always over a WebSocket connection
+*/
+function isJSRPCBinding(request) {
+	const url = new URL(request.url);
+	return request.headers.has("Upgrade") && url.searchParams.has("MF-Binding");
+}
+var remote_binding_proxy_default = { async fetch(request, env) {
+	try {
+		if (isJSRPCBinding(request)) return newWorkersRpcResponse(request, getExposedJSRPCBinding(request, env));
+		else {
+			const fetcher = getExposedFetcher(request, env);
+			const originalHeaders = new Headers();
+			for (const [name, value] of request.headers) if (name.startsWith("mf-header-")) originalHeaders.set(name.slice(10), value);
+			else if (name === "upgrade") originalHeaders.set(name, value);
+			return fetcher.fetch(request.headers.get("MF-URL") ?? "http://example.com", new Request(request, {
+				redirect: "manual",
+				headers: originalHeaders
+			}));
+		}
+	} catch (e) {
+		if (e instanceof BindingNotFoundError) return new Response(e.message, { status: 400 });
+		return new Response(e.message, { status: 500 });
+	}
+} };
+
+//#endregion
+export { remote_binding_proxy_default as default };