exoagent 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -1,2687 +1,62 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
-var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
-var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
-var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
-var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
-var __runInitializers = (array, flags, self, value) => {
-  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
-  return value;
-};
-var __decorateElement = (array, flags, name, decorators, target, extra) => {
-  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
-  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
-  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
-  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
-    return __privateGet(this, extra);
-  }, set [name](x) {
-    return __privateSet(this, extra, x);
-  } }, name));
-  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
-  for (var i = decorators.length - 1; i >= 0; i--) {
-    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
-    if (k) {
-      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
-      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
-      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
-    }
-    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
-    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
-    else if (typeof it !== "object" || it === null) __typeError("Object expected");
-    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
-  }
-  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
-};
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-
-// src/code-mode-deno.ts
-import { spawn } from "node:child_process";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { Readable, Writable } from "node:stream";
-function createDenoSandbox(options = {}) {
-  const { args = [], denoPath = "deno" } = options;
-  return {
-    safeEval: async (code) => {
-      const tempDir = await mkdtemp(join(tmpdir(), "exoagent-deno-"));
-      const tempFile = join(tempDir, "code.ts");
-      await writeFile(tempFile, code, "utf-8");
-      const child = spawn(denoPath, ["run", ...args, tempFile], {
-        stdio: ["pipe", "pipe", "inherit"]
-      });
-      return {
-        input: Readable.toWeb(child.stdout),
-        output: Writable.toWeb(child.stdin),
-        wait: () => new Promise((resolve, reject) => {
-          child.on("exit", async (code2) => {
-            await rm(tempDir, { recursive: true, force: true }).catch(() => {
-            });
-            code2 === 0 ? resolve() : reject(new Error(`Deno process exited with code ${code2}`));
-          });
-          child.on("error", async (err) => {
-            await rm(tempDir, { recursive: true, force: true }).catch(() => {
-            });
-            reject(err);
-          });
-        })
-      };
-    },
-    sandboxContext: `Promise.resolve({
-      input: Deno.stdin.readable,
-      output: Deno.stdout.writable,
-      onSuccess: () => Deno.exit(0),
-      onFailure: () => Deno.exit(1)
-    })`
-  };
-}
-
-// src/code-mode.ts
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-
-// packages/capnweb/dist/index.js
-var WORKERS_MODULE_SYMBOL = /* @__PURE__ */ Symbol("workers-module");
-if (!Symbol.dispose) {
-  Symbol.dispose = /* @__PURE__ */ Symbol.for("dispose");
-}
-if (!Symbol.asyncDispose) {
-  Symbol.asyncDispose = /* @__PURE__ */ Symbol.for("asyncDispose");
-}
-if (!Promise.withResolvers) {
-  Promise.withResolvers = function() {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej) => {
-      resolve = res;
-      reject = rej;
-    });
-    return { promise, resolve, reject };
-  };
-}
-var workersModule = globalThis[WORKERS_MODULE_SYMBOL];
-var RpcTarget = workersModule ? workersModule.RpcTarget : class {
-};
-var AsyncFunction = (async function() {
-}).constructor;
-var getGlobalRpcSessionOptions = () => ({});
-var CALLBACK_CLEANUP = /* @__PURE__ */ Symbol("callback-cleanup");
-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:
-    case AsyncFunction.prototype:
-      return "function";
-    case Array.prototype:
-      return "array";
-    case Date.prototype:
-      return "date";
-    case Uint8Array.prototype:
-      return "bytes";
-    // TODO: All other structured clone types.
-    case RpcStub.prototype:
-      return "stub";
-    case RpcPromise.prototype:
-      return "rpc-promise";
-    // TODO: Promise<T> or thenable
-    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, recordCallback: 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(
-  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 = /* @__PURE__ */ 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 void 0;
-    }
-  },
-  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) {
-    return void 0;
-  },
-  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 {
-  // Although `hook` and `path` are declared `public` here, they are effectively hidden by the
-  // proxy.
-  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);
-  }
-  toString() {
-    return "[object RpcStub]";
-  }
-};
-var RpcPromise = class extends RpcStub {
-  // TODO: Support passing target value or promise to constructor.
-  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);
-  }
-  toString() {
-    return "[object RpcPromise]";
-  }
-};
-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 void 0;
-  }
-  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);
-  }
-  let payload = await hook.pull();
-  return payload.deliverResolve();
-}
-var RpcPayload = class _RpcPayload {
-  // Private constructor; use factory functions above to construct.
-  constructor(value, source, stubs, promises) {
-    this.value = value;
-    this.source = source;
-    this.stubs = stubs;
-    this.promises = promises;
-  }
-  // Create a payload from a value passed as params to an RPC from the app.
-  //
-  // The payload does NOT take ownership of any stubs in `value`, and but promises not to modify
-  // `value`. If the payload is delivered locally, `value` will be deep-copied first, so as not
-  // to have the sender and recipient end up sharing the same mutable object. `value` will not be
-  // touched again after the call returns synchronously (returns a promise) -- by that point,
-  // the value has either been copied or serialized to the wire.
-  static fromAppParams(value) {
-    return new _RpcPayload(value, "params");
-  }
-  // Create a payload from a value return from an RPC implementation by the app.
-  //
-  // Unlike fromAppParams(), in this case the payload takes ownership of all stubs in `value`, and
-  // may hold onto `value` for an arbitrarily long time (e.g. to serve pipelined requests). It
-  // will still avoid modifying `value` and will make a deep copy if it is delivered locally.
-  static fromAppReturn(value) {
-    return new _RpcPayload(value, "return");
-  }
-  // Combine an array of payloads into a single payload whose value is an array. Ownership of all
-  // stubs is transferred from the inputs to the outputs, hence if the output is disposed, the
-  // inputs should not be. (In case of exception, nothing is disposed, though.)
-  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);
-  }
-  // Create a payload from a value parsed off the wire using Evaluator.evaluate().
-  //
-  // A payload is constructed with a null value and the given stubs and promises arrays. The value
-  // is expected to be filled in by the evaluator, and the stubs and promises arrays are expected
-  // to be extended with stubs found during parsing. (This weird usage model is necessary so that
-  // if the root value turns out to be a promise, its `parent` in `promises` can be the payload
-  // object itself.)
-  //
-  // When done, the payload takes ownership of the final value and all the stubs within. It may
-  // modify the value in preparation for delivery, and may deliver the value directly to the app
-  // without copying.
-  static forEvaluate(stubs, promises) {
-    return new _RpcPayload(null, "owned", stubs, promises);
-  }
-  // Deep-copy the given value, including dup()ing all stubs.
-  //
-  // If `value` is a function, it should be bound to `oldParent` as its `this`.
-  //
-  // If deep-copying from a branch of some other RpcPayload, it must be provided, to make sure
-  // RpcTargets found within don't get duplicate stubs.
-  static deepCopyFrom(value, oldParent, owner) {
-    let result = new _RpcPayload(null, "owned", [], []);
-    result.value = result.deepCopy(
-      value,
-      oldParent,
-      "value",
-      result,
-      /*dupStubs=*/
-      true,
-      owner
-    );
-    return result;
-  }
-  // For `source === "return"` payloads only, this tracks any StubHooks created around RpcTargets
-  // found in the payload at the time that it is serialized (or deep-copied) for return, so that we
-  // can make sure they are not disposed before the pipeline ends.
-  //
-  // This is initialized on first use.
-  rpcTargets;
-  // Get the StubHook representing the given RpcTarget found inside this payload.
-  getHookForRpcTarget(target, parent, dupStubs = true) {
-    if (this.source === "params") {
-      if (dupStubs) {
-        let dupable = target;
-        if (typeof dupable.dup === "function") {
-          target = dupable.dup();
-        }
-      }
-      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) {
-    let kind = typeForRpc(value);
-    switch (kind) {
-      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":
-        if (this.source === "owned" && typeof value === "function" && !(value instanceof RpcTarget)) {
-          return value;
-        }
-      // Fall through to rpc-target handling
-      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");
-    }
-  }
-  // Ensures that if the value originally came from an unowned source, we have replaced it with a
-  // deep copy.
-  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;
-    }
-  }
-  // Resolve all promises in this payload and then assign the final value into `parent[property]`.
-  deliverTo(parent, property, promises) {
-    const unwrapRpcTargets = (value) => {
-      if (value instanceof RpcStub) {
-        const { hook, pathIfPromise } = unwrapStubAndPath(value);
-        if (pathIfPromise == null && hook instanceof TargetStubHook) {
-          const target = hook.getTarget();
-          return target;
-        }
-      }
-      return value;
-    };
-    this.ensureDeepCopied();
-    if (this.value instanceof RpcPromise) {
-      _RpcPayload.deliverRpcPromiseTo(this.value, parent, property, promises);
-    } else {
-      const unwrapped = unwrapRpcTargets(this.value);
-      parent[property] = unwrapped;
-      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);
-        }
-      }));
-    }
-  }
-  // Call the given function with the payload as an argument. The call is made synchronously if
-  // possible, in order to maintain e-order. However, if any RpcPromises exist in the payload,
-  // they are awaited and substituted before calling the function. The result of the call is
-  // wrapped into another payload.
-  //
-  // The payload is automatically disposed after the call completes. The caller should not call
-  // dispose().
-  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();
-    }
-  }
-  // Produce a promise for this payload for return to the application. Any RpcPromises in the
-  // payload are awaited and substituted with their results first.
-  //
-  // The returned object will have a disposer which disposes the payload. The caller should not
-  // separately dispose it.
-  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, {
-            // NOTE: Using `this.dispose.bind(this)` here causes Playwright's build of
-            //   Chromium 140.0.7339.16 to fail when the object is assigned to a `using` variable,
-            //   with the error:
-            //       TypeError: Symbol(Symbol.dispose) is not a function
-            //   I cannot reproduce this problem in Chrome 140.0.7339.127 nor in Node or workerd,
-            //   so maybe it was a short-lived V8 bug or something. To be safe, though, we use
-            //   `() => this.dispose()`, which seems to always work.
-            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()?");
-      }
-    } else ;
-    this.source = "owned";
-    this.stubs = [];
-    this.promises = [];
-  }
-  // Recursive dispose, called only when `source` is "return".
-  disposeImpl(value, parent) {
-    let kind = typeForRpc(value);
-    switch (kind) {
-      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 stub = value;
-        let hook = unwrapStubNoProperties(stub);
-        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;
-    }
-  }
-  // Ignore unhandled rejections in all promises in this payload -- that is, all promises that
-  // *would* be awaited if this payload were to be delivered. See the similarly-named method of
-  // StubHook for explanation.
-  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) {
-    let kind = typeForRpc(value);
-    switch (kind) {
-      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;
-    }
-    let kind = typeForRpc(value);
-    switch (kind) {
-      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)) {
-          throw new TypeError(
-            `Attempted to access property '${part}', which is an instance property of the RpcTarget. To avoid leaking private internals, instance properties cannot be accessed over RPC. If you want to make this property available over RPC, define it as a method or getter on the class, instead of an instance property.`
-          );
-        } 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.`);
-      }
-      let promise = args.deliverCall(followResult.value, followResult.parent);
-      return new PromiseStubHook(promise.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;
-  // cleared when disposed
-  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 {
-  // Constructs a TargetStubHook that is not duplicated from an existing hook.
-  //
-  // If `value` is a function, `parent` is bound as its "this".
-  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;
-  // cleared when disposed
-  parent;
-  // `this` parameter when calling `target`
-  refcount;
-  // undefined if not needed (because target has no disposer)
-  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(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 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;
-  }
-  // ---------------------------------------------------------------------------
-  // implements Exporter
-  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), []);
-};
-mapImpl.recordCallback = (func) => {
-  const builder = new MapBuilder(new PayloadStubHook(RpcPayload.fromAppParams([])), []);
-  let result;
-  try {
-    result = RpcPayload.fromAppReturn(withCallInterceptor(builder.pushCall.bind(builder), () => {
-      return func(new RpcPromise(builder.makeInput(), []));
-    }));
-  } finally {
-    builder.unregister();
-  }
-  const devaluatedResult = Devaluator.devaluate(result.value, void 0, builder, result);
-  const instructions = [...builder.instructions, devaluatedResult];
-  const context = builder.context;
-  if (context.parent) {
-    return ["callback", context.captures.map((cap) => ["import", cap]), instructions];
-  } else {
-    return ["callback", context.captures, instructions];
-  }
-};
-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;
-  }
-  // We don't have anything we actually need to dispose, so dup() can just return the same hook.
-  dup() {
-    return this;
-  }
-  dispose() {
-  }
-  get(path) {
-    if (path.length == 0) {
-      return this;
-    } else if (currentMapBuilder) {
-      return currentMapBuilder.pushGet(this, path);
-    } else {
-      throwMapperBuilderUseError();
-    }
-  }
-  // Other methods should never be called.
-  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 inputHook = new PayloadStubHook(RpcPayload.deepCopyFrom(input, parent, owner));
-  let mapper = new MapApplicator(captures, inputHook);
-  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();
-    }
-  }
-};
-var isExplicitCallback = (arg) => {
-  return typeof arg === "function" && "serializationMode" in arg;
-};
-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) {
-    return void 0;
-  }
-  unexport(ids) {
-  }
-  onSendError(error) {
-  }
-};
-var NULL_EXPORTER = new NullExporter();
-var ERROR_TYPES = {
-  Error,
-  EvalError,
-  RangeError,
-  ReferenceError,
-  SyntaxError,
-  TypeError,
-  URIError,
-  AggregateError
-  // TODO: DOMError? Others?
-};
-var Devaluator = class _Devaluator {
-  constructor(exporter, source) {
-    this.exporter = exporter;
-    this.source = source;
-  }
-  // Devaluate the given value.
-  // * value: The value to devaluate.
-  // * parent: The value's parent object, which would be used as `this` if the value were called
-  //     as a function.
-  // * exporter: Callbacks to the RPC session for exporting capabilities found in this message.
-  // * source: The RpcPayload which contains the value, and therefore owns stubs within.
-  //
-  // Returns: The devaluated value, ready to be JSON-serialized.
-  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?)"
-      );
-    }
-    let kind = typeForRpc(value);
-    switch (kind) {
-      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":
-        if (typeof value === "number" && !isFinite(value)) {
-          if (value === Infinity) {
-            return ["inf"];
-          } else if (value === -Infinity) {
-            return ["-inf"];
-          } else {
-            return ["nan"];
-          }
-        } else {
-          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": {
-        let shouldRecordReplay = false;
-        if (kind === "function") {
-          if (isExplicitCallback(value)) {
-            const explicitMode = value.serializationMode;
-            shouldRecordReplay = explicitMode === "recordReplay";
-          } else {
-            shouldRecordReplay = getGlobalRpcSessionOptions().recordReplayMode === "all";
-          }
-        }
-        if (shouldRecordReplay) {
-          const res = mapImpl.recordCallback(value);
-          const captures = res[1];
-          if (captures.length === 0 || captures[0] instanceof StubHook) {
-            const captureHooks = captures;
-            const serializedCaptures = captureHooks.map((stub) => {
-              const importId = this.exporter.getImport(stub);
-              if (importId !== void 0) {
-                return ["import", importId];
-              } else {
-                return ["export", this.exporter.exportStub(stub)];
-              }
-            });
-            for (const hook2 of captureHooks) {
-              hook2.dispose();
-            }
-            return ["callback", serializedCaptures, res[2]];
-          } else {
-            return res;
-          }
-        }
-        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) {
-    return void 0;
-  }
-};
-var NULL_IMPORTER = new NullImporter();
-var Evaluator = class _Evaluator {
-  constructor(importer) {
-    this.importer = importer;
-  }
-  stubs = [];
-  promises = [];
-  // Resolve serialized captures to StubHooks. Used by both "callback" and "remap" evaluation.
-  resolveCaptures(capsData) {
-    return capsData.map((cap) => {
-      if (!(cap instanceof Array) || cap.length !== 2 || cap[0] !== "import" && cap[0] !== "export" || typeof cap[1] !== "number") {
-        throw new TypeError(`unknown 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();
-      }
-    });
-  }
-  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;
-    }
-  }
-  // Evaluate the value without destroying it.
-  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 "callback": {
-          if (value.length < 3 || !(value[1] instanceof Array) || !(value[2] instanceof Array)) {
-            break;
-          }
-          const captures = this.resolveCaptures(value[1]);
-          const instructions = value[2];
-          const replayFn = (arg) => {
-            const capturesForThisCall = captures.map((c) => c.dup());
-            const inputHook = new PayloadStubHook(RpcPayload.fromAppParams(arg));
-            const applicator = new MapApplicator(capturesForThisCall, inputHook);
-            const disposeInvocation = () => {
-              applicator.dispose();
-              for (const cap of capturesForThisCall) {
-                cap.dispose();
-              }
-              const cleanup = replayFn[CALLBACK_CLEANUP];
-              if (typeof cleanup === "function") {
-                cleanup();
-              }
-            };
-            let resultPayload;
-            try {
-              resultPayload = applicator.apply(instructions);
-            } catch (err) {
-              disposeInvocation();
-              throw err;
-            }
-            return resultPayload.deliverResolve().finally(disposeInvocation);
-          };
-          replayFn[CALLBACK_CLEANUP] = () => {
-            for (const cap of captures) {
-              cap.dispose();
-            }
-          };
-          return replayFn;
-        }
-        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 cls = ERROR_TYPES[value[1]] || Error;
-            let result = new cls(value[2]);
-            if (typeof value[3] === "string") {
-              result.stack = value[3];
-            }
-            return result;
-          }
-          break;
-        case "undefined":
-          if (value.length === 1) {
-            return void 0;
-          }
-          break;
-        case "inf":
-          return Infinity;
-        case "-inf":
-          return -Infinity;
-        case "nan":
-          return NaN;
-        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) => {
-            const unwrapped = maybeUnwrapStubHook(hook2);
-            if (unwrapped) {
-              hook2.dispose();
-              return unwrapped;
-            }
-            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;
-          }
-          let subEval = new _Evaluator(this.importer);
-          args = subEval.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 = this.resolveCaptures(value[3]);
-          let instructions = value[4];
-          let resultHook = hook.map(path, captures, instructions);
-          let promise = new RpcPromise(resultHook, []);
-          this.promises.push({ promise, parent, property });
-          return promise;
-        }
-        case "export":
-        case "promise":
-          if (typeof value[1] == "number") {
-            if (value[0] == "promise") {
-              let hook = this.importer.importPromise(value[1]);
-              let promise = new RpcPromise(hook, []);
-              this.promises.push({ parent, property, promise });
-              return promise;
-            } else {
-              let hook = this.importer.importStub(value[1]);
-              let stub = new RpcStub(hook);
-              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 maybeUnwrapStubHook = (hook) => {
-  if (!(hook instanceof PayloadStubHook)) {
-    return void 0;
-  }
-  const payload = hook.getPayload();
-  if (payload.value instanceof RpcStub) {
-    const { hook: innerHook, pathIfPromise } = unwrapStubAndPath(payload.value);
-    if (pathIfPromise == null && innerHook instanceof TargetStubHook) {
-      return innerHook.getTarget();
-    } else {
-      return innerHook;
-    }
-  }
-  return void 0;
-};
-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;
-  // List of integer indexes into session.onBrokenCallbacks which are callbacks registered on
-  // this import. Initialized on first use (so `undefined` is the same as an empty list).
-  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(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 {
-  // undefined when we're disposed
-  // `pulling` is true if we already expect that this import is going to be resolved later, and
-  // null if this import is not allowed to be pulled (i.e. it's a stub not a promise).
-  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.");
-    }
-  }
-  // -------------------------------------------------------------------------------------
-  // implements StubHook
-  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;
-  // We assign positive numbers to imports we initiate, and negative numbers to exports we
-  // initiate. So the next import ID is just `imports.length`, but the next export ID needs
-  // to be tracked explicitly.
-  nextExportId = -1;
-  // If set, call this when all incoming calls are complete.
-  onBatchDone;
-  // How many promises is our peer expecting us to resolve?
-  pullCount = 0;
-  // Sparse array of onBrokenCallback registrations. Items are strictly appended to the end but
-  // may be deleted from the middle (hence leaving the array sparse).
-  onBrokenCallbacks = [];
-  // Should only be called once immediately after construction.
-  getMainImport() {
-    return new RpcMainHook(this.imports[0]);
-  }
-  shutdown() {
-    this.abort(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 void 0;
-    }
-  }
-  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(
-      /*isPromise=*/
-      false,
-      entry
-    );
-  }
-  importPromise(idx) {
-    if (this.abortReason) throw this.abortReason;
-    if (this.imports[idx]) {
-      return new ErrorStubHook(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(
-      /*isPromise=*/
-      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(
-      /*isPromise=*/
-      true,
-      entry
-    );
-  }
-  sendMap(id, path, captures, instructions) {
-    if (this.abortReason) {
-      for (let cap of captures) {
-        cap.dispose();
-      }
-      throw this.abortReason;
-    }
-    let devaluedCaptures = captures.map((hook) => {
-      let importId = this.getImport(hook);
-      if (importId !== void 0) {
-        return ["import", importId];
-      } else {
-        return ["export", this.exportStub(hook)];
-      }
-    });
-    let value = ["remap", id, path, devaluedCaptures, instructions];
-    this.send(["push", value]);
-    let entry = new ImportTableEntry(this, this.imports.length, false);
-    this.imports.push(entry);
-    return new RpcImportHook(
-      /*isPromise=*/
-      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 payload = new Evaluator(this).evaluate(msg[1]);
-              let hook = new PayloadStubHook(payload);
-              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":
-          // ["resolve", ExportId, Expression]
-          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(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);
-  }
-  let transport = new WebSocketTransport(webSocket);
-  let rpc = new RpcSession(transport, localMain, options);
-  return rpc.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(new TypeError("Received non-string message from WebSocket."));
-      }
-    });
-    webSocket.addEventListener("close", (event) => {
-      this.#receivedError(new Error(`Peer closed WebSocket: ${event.code} ${event.reason}`));
-    });
-    webSocket.addEventListener("error", (event) => {
-      this.#receivedError(new Error(`WebSocket connection failed.`));
-    });
-  }
-  #webSocket;
-  #sendQueue;
-  // only if not opened yet
-  #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) => {
+import { spawn } from "node:child_process";
+import { mkdtemp, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Writable, Readable } from "node:stream";
+import { RpcTarget, RpcSession } from "capnweb";
+import { z } from "zod";
+import { asSchema } from "ai";
+import camelCase from "camelcase";
+import { validate } from "json-schema";
+import { compile } from "json-schema-to-typescript";
+import invariant from "tiny-invariant";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { R as RpcToolset } from "./rpc-toolset-BnC2BXPq.js";
+import { t } from "./rpc-toolset-BnC2BXPq.js";
+function createDenoSandbox(options = {}) {
+  const { args = [], denoPath = "deno" } = options;
+  return {
+    kind: "direct",
+    safeEval: async (code) => {
+      const tempDir = await mkdtemp(join(tmpdir(), "exoagent-deno-"));
+      const tempFile = join(tempDir, "code.ts");
+      await writeFile(tempFile, code, "utf-8");
+      const child = spawn(denoPath, ["run", ...args, tempFile], {
+        stdio: ["pipe", "pipe", "inherit"]
       });
-    }
-  }
-  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 batch = body === "" ? [] : body.split("\n");
-  let transport = new BatchServerTransport(batch);
-  let rpc = new RpcSession(transport, localMain, options);
-  await transport.whenAllReceived();
-  await rpc.drain();
-  return new Response(transport.getResponseBody());
-}
-var RpcSession2 = RpcSession;
-var RpcTarget4 = RpcTarget;
-var newWebSocketRpcSession2 = newWebSocketRpcSession;
-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 });
-  }
+      return {
+        input: Readable.toWeb(child.stdout),
+        output: Writable.toWeb(child.stdin),
+        wait: () => new Promise((resolve, reject) => {
+          child.on("exit", async (code2) => {
+            await rm(tempDir, { recursive: true, force: true }).catch(() => {
+            });
+            code2 === 0 ? resolve() : reject(new Error(`Deno process exited with code ${code2}`));
+          });
+          child.on("error", async (err) => {
+            await rm(tempDir, { recursive: true, force: true }).catch(() => {
+            });
+            reject(err);
+          });
+        })
+      };
+    },
+    sandboxContext: `Promise.resolve({
+      input: Deno.stdin.readable,
+      output: Deno.stdout.writable,
+      onSuccess: () => Deno.exit(0),
+      onFailure: () => Deno.exit(1)
+    })`
+  };
 }
-
-// src/code-mode.ts
-import { z } from "zod";
-
-// src/stream-transport.ts
+const runtimeCode = '// packages/capnweb/dist/index.js\nvar WORKERS_MODULE_SYMBOL = /* @__PURE__ */ Symbol("workers-module");\nif (!Symbol.dispose) {\n  Symbol.dispose = /* @__PURE__ */ Symbol.for("dispose");\n}\nif (!Symbol.asyncDispose) {\n  Symbol.asyncDispose = /* @__PURE__ */ Symbol.for("asyncDispose");\n}\nif (!Promise.withResolvers) {\n  Promise.withResolvers = function() {\n    let resolve;\n    let reject;\n    const promise = new Promise((res, rej) => {\n      resolve = res;\n      reject = rej;\n    });\n    return { promise, resolve, reject };\n  };\n}\nvar workersModule = globalThis[WORKERS_MODULE_SYMBOL];\nvar RpcTarget = workersModule ? workersModule.RpcTarget : class {\n};\nvar AsyncFunction = (async function() {\n}).constructor;\nvar getGlobalRpcSessionOptions = () => ({});\nvar setGlobalRpcSessionOptions = (options) => {\n  getGlobalRpcSessionOptions = options;\n};\nvar CALLBACK_CLEANUP = /* @__PURE__ */ Symbol("callback-cleanup");\nfunction typeForRpc(value) {\n  switch (typeof value) {\n    case "boolean":\n    case "number":\n    case "string":\n      return "primitive";\n    case "undefined":\n      return "undefined";\n    case "object":\n    case "function":\n      break;\n    case "bigint":\n      return "bigint";\n    default:\n      return "unsupported";\n  }\n  if (value === null) {\n    return "primitive";\n  }\n  let prototype = Object.getPrototypeOf(value);\n  switch (prototype) {\n    case Object.prototype:\n      return "object";\n    case Function.prototype:\n    case AsyncFunction.prototype:\n      return "function";\n    case Array.prototype:\n      return "array";\n    case Date.prototype:\n      return "date";\n    case Uint8Array.prototype:\n      return "bytes";\n    // TODO: All other structured clone types.\n    case RpcStub.prototype:\n      return "stub";\n    case RpcPromise.prototype:\n      return "rpc-promise";\n    // TODO: Promise<T> or thenable\n    default:\n      if (workersModule) {\n        if (prototype == workersModule.RpcStub.prototype || value instanceof workersModule.ServiceStub) {\n          return "rpc-target";\n        } else if (prototype == workersModule.RpcPromise.prototype || prototype == workersModule.RpcProperty.prototype) {\n          return "rpc-thenable";\n        }\n      }\n      if (value instanceof RpcTarget) {\n        return "rpc-target";\n      }\n      if (value instanceof Error) {\n        return "error";\n      }\n      return "unsupported";\n  }\n}\nfunction mapNotLoaded() {\n  throw new Error("RPC map() implementation was not loaded.");\n}\nvar mapImpl = { applyMap: mapNotLoaded, sendMap: mapNotLoaded, recordCallback: mapNotLoaded };\nvar StubHook = class {\n};\nvar ErrorStubHook = class extends StubHook {\n  constructor(error) {\n    super();\n    this.error = error;\n  }\n  call(path, args) {\n    return this;\n  }\n  map(path, captures, instructions) {\n    return this;\n  }\n  get(path) {\n    return this;\n  }\n  dup() {\n    return this;\n  }\n  pull() {\n    return Promise.reject(this.error);\n  }\n  ignoreUnhandledRejections() {\n  }\n  dispose() {\n  }\n  onBroken(callback) {\n    try {\n      callback(this.error);\n    } catch (err) {\n      Promise.resolve(err);\n    }\n  }\n};\nvar DISPOSED_HOOK = new ErrorStubHook(\n  new Error("Attempted to use RPC stub after it has been disposed.")\n);\nvar doCall = (hook, path, params) => {\n  return hook.call(path, params);\n};\nfunction withCallInterceptor(interceptor, callback) {\n  let oldValue = doCall;\n  doCall = interceptor;\n  try {\n    return callback();\n  } finally {\n    doCall = oldValue;\n  }\n}\nvar RAW_STUB = /* @__PURE__ */ Symbol("realStub");\nvar PROXY_HANDLERS = {\n  apply(target, thisArg, argumentsList) {\n    let stub = target.raw;\n    return new RpcPromise(doCall(\n      stub.hook,\n      stub.pathIfPromise || [],\n      RpcPayload.fromAppParams(argumentsList)\n    ), []);\n  },\n  get(target, prop, receiver) {\n    let stub = target.raw;\n    if (prop === RAW_STUB) {\n      return stub;\n    } else if (prop in RpcPromise.prototype) {\n      return stub[prop];\n    } else if (typeof prop === "string") {\n      return new RpcPromise(\n        stub.hook,\n        stub.pathIfPromise ? [...stub.pathIfPromise, prop] : [prop]\n      );\n    } else if (prop === Symbol.dispose && (!stub.pathIfPromise || stub.pathIfPromise.length == 0)) {\n      return () => {\n        stub.hook.dispose();\n        stub.hook = DISPOSED_HOOK;\n      };\n    } else {\n      return void 0;\n    }\n  },\n  has(target, prop) {\n    let stub = target.raw;\n    if (prop === RAW_STUB) {\n      return true;\n    } else if (prop in RpcPromise.prototype) {\n      return prop in stub;\n    } else if (typeof prop === "string") {\n      return true;\n    } else if (prop === Symbol.dispose && (!stub.pathIfPromise || stub.pathIfPromise.length == 0)) {\n      return true;\n    } else {\n      return false;\n    }\n  },\n  construct(target, args) {\n    throw new Error("An RPC stub cannot be used as a constructor.");\n  },\n  defineProperty(target, property, attributes) {\n    throw new Error("Can\'t define properties on RPC stubs.");\n  },\n  deleteProperty(target, p) {\n    throw new Error("Can\'t delete properties on RPC stubs.");\n  },\n  getOwnPropertyDescriptor(target, p) {\n    return void 0;\n  },\n  getPrototypeOf(target) {\n    return Object.getPrototypeOf(target.raw);\n  },\n  isExtensible(target) {\n    return false;\n  },\n  ownKeys(target) {\n    return [];\n  },\n  preventExtensions(target) {\n    return true;\n  },\n  set(target, p, newValue, receiver) {\n    throw new Error("Can\'t assign properties on RPC stubs.");\n  },\n  setPrototypeOf(target, v) {\n    throw new Error("Can\'t override prototype of RPC stubs.");\n  }\n};\nvar RpcStub = class _RpcStub extends RpcTarget {\n  // Although `hook` and `path` are declared `public` here, they are effectively hidden by the\n  // proxy.\n  constructor(hook, pathIfPromise) {\n    super();\n    if (!(hook instanceof StubHook)) {\n      let value = hook;\n      if (value instanceof RpcTarget || value instanceof Function) {\n        hook = TargetStubHook.create(value, void 0);\n      } else {\n        hook = new PayloadStubHook(RpcPayload.fromAppReturn(value));\n      }\n      if (pathIfPromise) {\n        throw new TypeError("RpcStub constructor expected one argument, received two.");\n      }\n    }\n    this.hook = hook;\n    this.pathIfPromise = pathIfPromise;\n    let func = () => {\n    };\n    func.raw = this;\n    return new Proxy(func, PROXY_HANDLERS);\n  }\n  hook;\n  pathIfPromise;\n  dup() {\n    let target = this[RAW_STUB];\n    if (target.pathIfPromise) {\n      return new _RpcStub(target.hook.get(target.pathIfPromise));\n    } else {\n      return new _RpcStub(target.hook.dup());\n    }\n  }\n  onRpcBroken(callback) {\n    this[RAW_STUB].hook.onBroken(callback);\n  }\n  map(func) {\n    let { hook, pathIfPromise } = this[RAW_STUB];\n    return mapImpl.sendMap(hook, pathIfPromise || [], func);\n  }\n  toString() {\n    return "[object RpcStub]";\n  }\n};\nvar RpcPromise = class extends RpcStub {\n  // TODO: Support passing target value or promise to constructor.\n  constructor(hook, pathIfPromise) {\n    super(hook, pathIfPromise);\n  }\n  then(onfulfilled, onrejected) {\n    return pullPromise(this).then(...arguments);\n  }\n  catch(onrejected) {\n    return pullPromise(this).catch(...arguments);\n  }\n  finally(onfinally) {\n    return pullPromise(this).finally(...arguments);\n  }\n  toString() {\n    return "[object RpcPromise]";\n  }\n};\nfunction unwrapStubTakingOwnership(stub) {\n  let { hook, pathIfPromise } = stub[RAW_STUB];\n  if (pathIfPromise && pathIfPromise.length > 0) {\n    return hook.get(pathIfPromise);\n  } else {\n    return hook;\n  }\n}\nfunction unwrapStubAndDup(stub) {\n  let { hook, pathIfPromise } = stub[RAW_STUB];\n  if (pathIfPromise) {\n    return hook.get(pathIfPromise);\n  } else {\n    return hook.dup();\n  }\n}\nfunction unwrapStubNoProperties(stub) {\n  let { hook, pathIfPromise } = stub[RAW_STUB];\n  if (pathIfPromise && pathIfPromise.length > 0) {\n    return void 0;\n  }\n  return hook;\n}\nfunction unwrapStubOrParent(stub) {\n  return stub[RAW_STUB].hook;\n}\nfunction unwrapStubAndPath(stub) {\n  return stub[RAW_STUB];\n}\nasync function pullPromise(promise) {\n  let { hook, pathIfPromise } = promise[RAW_STUB];\n  if (pathIfPromise.length > 0) {\n    hook = hook.get(pathIfPromise);\n  }\n  let payload = await hook.pull();\n  return payload.deliverResolve();\n}\nvar RpcPayload = class _RpcPayload {\n  // Private constructor; use factory functions above to construct.\n  constructor(value, source, stubs, promises) {\n    this.value = value;\n    this.source = source;\n    this.stubs = stubs;\n    this.promises = promises;\n  }\n  // Create a payload from a value passed as params to an RPC from the app.\n  //\n  // The payload does NOT take ownership of any stubs in `value`, and but promises not to modify\n  // `value`. If the payload is delivered locally, `value` will be deep-copied first, so as not\n  // to have the sender and recipient end up sharing the same mutable object. `value` will not be\n  // touched again after the call returns synchronously (returns a promise) -- by that point,\n  // the value has either been copied or serialized to the wire.\n  static fromAppParams(value) {\n    return new _RpcPayload(value, "params");\n  }\n  // Create a payload from a value return from an RPC implementation by the app.\n  //\n  // Unlike fromAppParams(), in this case the payload takes ownership of all stubs in `value`, and\n  // may hold onto `value` for an arbitrarily long time (e.g. to serve pipelined requests). It\n  // will still avoid modifying `value` and will make a deep copy if it is delivered locally.\n  static fromAppReturn(value) {\n    return new _RpcPayload(value, "return");\n  }\n  // Combine an array of payloads into a single payload whose value is an array. Ownership of all\n  // stubs is transferred from the inputs to the outputs, hence if the output is disposed, the\n  // inputs should not be. (In case of exception, nothing is disposed, though.)\n  static fromArray(array) {\n    let stubs = [];\n    let promises = [];\n    let resultArray = [];\n    for (let payload of array) {\n      payload.ensureDeepCopied();\n      for (let stub of payload.stubs) {\n        stubs.push(stub);\n      }\n      for (let promise of payload.promises) {\n        if (promise.parent === payload) {\n          promise = {\n            parent: resultArray,\n            property: resultArray.length,\n            promise: promise.promise\n          };\n        }\n        promises.push(promise);\n      }\n      resultArray.push(payload.value);\n    }\n    return new _RpcPayload(resultArray, "owned", stubs, promises);\n  }\n  // Create a payload from a value parsed off the wire using Evaluator.evaluate().\n  //\n  // A payload is constructed with a null value and the given stubs and promises arrays. The value\n  // is expected to be filled in by the evaluator, and the stubs and promises arrays are expected\n  // to be extended with stubs found during parsing. (This weird usage model is necessary so that\n  // if the root value turns out to be a promise, its `parent` in `promises` can be the payload\n  // object itself.)\n  //\n  // When done, the payload takes ownership of the final value and all the stubs within. It may\n  // modify the value in preparation for delivery, and may deliver the value directly to the app\n  // without copying.\n  static forEvaluate(stubs, promises) {\n    return new _RpcPayload(null, "owned", stubs, promises);\n  }\n  // Deep-copy the given value, including dup()ing all stubs.\n  //\n  // If `value` is a function, it should be bound to `oldParent` as its `this`.\n  //\n  // If deep-copying from a branch of some other RpcPayload, it must be provided, to make sure\n  // RpcTargets found within don\'t get duplicate stubs.\n  static deepCopyFrom(value, oldParent, owner) {\n    let result = new _RpcPayload(null, "owned", [], []);\n    result.value = result.deepCopy(\n      value,\n      oldParent,\n      "value",\n      result,\n      /*dupStubs=*/\n      true,\n      owner\n    );\n    return result;\n  }\n  // For `source === "return"` payloads only, this tracks any StubHooks created around RpcTargets\n  // found in the payload at the time that it is serialized (or deep-copied) for return, so that we\n  // can make sure they are not disposed before the pipeline ends.\n  //\n  // This is initialized on first use.\n  rpcTargets;\n  // Get the StubHook representing the given RpcTarget found inside this payload.\n  getHookForRpcTarget(target, parent, dupStubs = true) {\n    if (this.source === "params") {\n      if (dupStubs) {\n        let dupable = target;\n        if (typeof dupable.dup === "function") {\n          target = dupable.dup();\n        }\n      }\n      return TargetStubHook.create(target, parent);\n    } else if (this.source === "return") {\n      let hook = this.rpcTargets?.get(target);\n      if (hook) {\n        if (dupStubs) {\n          return hook.dup();\n        } else {\n          this.rpcTargets?.delete(target);\n          return hook;\n        }\n      } else {\n        hook = TargetStubHook.create(target, parent);\n        if (dupStubs) {\n          if (!this.rpcTargets) {\n            this.rpcTargets = /* @__PURE__ */ new Map();\n          }\n          this.rpcTargets.set(target, hook);\n          return hook.dup();\n        } else {\n          return hook;\n        }\n      }\n    } else {\n      throw new Error("owned payload shouldn\'t contain raw RpcTargets");\n    }\n  }\n  deepCopy(value, oldParent, property, parent, dupStubs, owner) {\n    let kind = typeForRpc(value);\n    switch (kind) {\n      case "unsupported":\n        return value;\n      case "primitive":\n      case "bigint":\n      case "date":\n      case "bytes":\n      case "error":\n      case "undefined":\n        return value;\n      case "array": {\n        let array = value;\n        let len = array.length;\n        let result = new Array(len);\n        for (let i = 0; i < len; i++) {\n          result[i] = this.deepCopy(array[i], array, i, result, dupStubs, owner);\n        }\n        return result;\n      }\n      case "object": {\n        let result = {};\n        let object = value;\n        for (let i in object) {\n          result[i] = this.deepCopy(object[i], object, i, result, dupStubs, owner);\n        }\n        return result;\n      }\n      case "stub":\n      case "rpc-promise": {\n        let stub = value;\n        let hook;\n        if (dupStubs) {\n          hook = unwrapStubAndDup(stub);\n        } else {\n          hook = unwrapStubTakingOwnership(stub);\n        }\n        if (stub instanceof RpcPromise) {\n          let promise = new RpcPromise(hook, []);\n          this.promises.push({ parent, property, promise });\n          return promise;\n        } else {\n          let newStub = new RpcStub(hook);\n          this.stubs.push(newStub);\n          return newStub;\n        }\n      }\n      case "function":\n        if (this.source === "owned" && typeof value === "function" && !(value instanceof RpcTarget)) {\n          return value;\n        }\n      // Fall through to rpc-target handling\n      case "rpc-target": {\n        let target = value;\n        let stub;\n        if (owner) {\n          stub = new RpcStub(owner.getHookForRpcTarget(target, oldParent, dupStubs));\n        } else {\n          stub = new RpcStub(TargetStubHook.create(target, oldParent));\n        }\n        this.stubs.push(stub);\n        return stub;\n      }\n      case "rpc-thenable": {\n        let target = value;\n        let promise;\n        if (owner) {\n          promise = new RpcPromise(owner.getHookForRpcTarget(target, oldParent, dupStubs), []);\n        } else {\n          promise = new RpcPromise(TargetStubHook.create(target, oldParent), []);\n        }\n        this.promises.push({ parent, property, promise });\n        return promise;\n      }\n      default:\n        throw new Error("unreachable");\n    }\n  }\n  // Ensures that if the value originally came from an unowned source, we have replaced it with a\n  // deep copy.\n  ensureDeepCopied() {\n    if (this.source !== "owned") {\n      let dupStubs = this.source === "params";\n      this.stubs = [];\n      this.promises = [];\n      try {\n        this.value = this.deepCopy(this.value, void 0, "value", this, dupStubs, this);\n      } catch (err) {\n        this.stubs = void 0;\n        this.promises = void 0;\n        throw err;\n      }\n      this.source = "owned";\n      if (this.rpcTargets && this.rpcTargets.size > 0) {\n        throw new Error("Not all rpcTargets were accounted for in deep-copy?");\n      }\n      this.rpcTargets = void 0;\n    }\n  }\n  // Resolve all promises in this payload and then assign the final value into `parent[property]`.\n  deliverTo(parent, property, promises) {\n    const unwrapRpcTargets = (value) => {\n      if (value instanceof RpcStub) {\n        const { hook, pathIfPromise } = unwrapStubAndPath(value);\n        if (pathIfPromise == null && hook instanceof TargetStubHook) {\n          const target = hook.getTarget();\n          return target;\n        }\n      }\n      return value;\n    };\n    this.ensureDeepCopied();\n    if (this.value instanceof RpcPromise) {\n      _RpcPayload.deliverRpcPromiseTo(this.value, parent, property, promises);\n    } else {\n      const unwrapped = unwrapRpcTargets(this.value);\n      parent[property] = unwrapped;\n      for (let record of this.promises) {\n        _RpcPayload.deliverRpcPromiseTo(record.promise, record.parent, record.property, promises);\n      }\n    }\n  }\n  static deliverRpcPromiseTo(promise, parent, property, promises) {\n    let hook = unwrapStubNoProperties(promise);\n    if (!hook) {\n      throw new Error("property promises should have been resolved earlier");\n    }\n    let inner = hook.pull();\n    if (inner instanceof _RpcPayload) {\n      inner.deliverTo(parent, property, promises);\n    } else {\n      promises.push(inner.then((payload) => {\n        let subPromises = [];\n        payload.deliverTo(parent, property, subPromises);\n        if (subPromises.length > 0) {\n          return Promise.all(subPromises);\n        }\n      }));\n    }\n  }\n  // Call the given function with the payload as an argument. The call is made synchronously if\n  // possible, in order to maintain e-order. However, if any RpcPromises exist in the payload,\n  // they are awaited and substituted before calling the function. The result of the call is\n  // wrapped into another payload.\n  //\n  // The payload is automatically disposed after the call completes. The caller should not call\n  // dispose().\n  async deliverCall(func, thisArg) {\n    try {\n      let promises = [];\n      this.deliverTo(this, "value", promises);\n      if (promises.length > 0) {\n        await Promise.all(promises);\n      }\n      let result = Function.prototype.apply.call(func, thisArg, this.value);\n      if (result instanceof RpcPromise) {\n        return _RpcPayload.fromAppReturn(result);\n      } else {\n        return _RpcPayload.fromAppReturn(await result);\n      }\n    } finally {\n      this.dispose();\n    }\n  }\n  // Produce a promise for this payload for return to the application. Any RpcPromises in the\n  // payload are awaited and substituted with their results first.\n  //\n  // The returned object will have a disposer which disposes the payload. The caller should not\n  // separately dispose it.\n  async deliverResolve() {\n    try {\n      let promises = [];\n      this.deliverTo(this, "value", promises);\n      if (promises.length > 0) {\n        await Promise.all(promises);\n      }\n      let result = this.value;\n      if (result instanceof Object) {\n        if (!(Symbol.dispose in result)) {\n          Object.defineProperty(result, Symbol.dispose, {\n            // NOTE: Using `this.dispose.bind(this)` here causes Playwright\'s build of\n            //   Chromium 140.0.7339.16 to fail when the object is assigned to a `using` variable,\n            //   with the error:\n            //       TypeError: Symbol(Symbol.dispose) is not a function\n            //   I cannot reproduce this problem in Chrome 140.0.7339.127 nor in Node or workerd,\n            //   so maybe it was a short-lived V8 bug or something. To be safe, though, we use\n            //   `() => this.dispose()`, which seems to always work.\n            value: () => this.dispose(),\n            writable: true,\n            enumerable: false,\n            configurable: true\n          });\n        }\n      }\n      return result;\n    } catch (err) {\n      this.dispose();\n      throw err;\n    }\n  }\n  dispose() {\n    if (this.source === "owned") {\n      this.stubs.forEach((stub) => stub[Symbol.dispose]());\n      this.promises.forEach((promise) => promise.promise[Symbol.dispose]());\n    } else if (this.source === "return") {\n      this.disposeImpl(this.value, void 0);\n      if (this.rpcTargets && this.rpcTargets.size > 0) {\n        throw new Error("Not all rpcTargets were accounted for in disposeImpl()?");\n      }\n    } else ;\n    this.source = "owned";\n    this.stubs = [];\n    this.promises = [];\n  }\n  // Recursive dispose, called only when `source` is "return".\n  disposeImpl(value, parent) {\n    let kind = typeForRpc(value);\n    switch (kind) {\n      case "unsupported":\n      case "primitive":\n      case "bigint":\n      case "bytes":\n      case "date":\n      case "error":\n      case "undefined":\n        return;\n      case "array": {\n        let array = value;\n        let len = array.length;\n        for (let i = 0; i < len; i++) {\n          this.disposeImpl(array[i], array);\n        }\n        return;\n      }\n      case "object": {\n        let object = value;\n        for (let i in object) {\n          this.disposeImpl(object[i], object);\n        }\n        return;\n      }\n      case "stub":\n      case "rpc-promise": {\n        let stub = value;\n        let hook = unwrapStubNoProperties(stub);\n        if (hook) {\n          hook.dispose();\n        }\n        return;\n      }\n      case "function":\n      case "rpc-target": {\n        let target = value;\n        let hook = this.rpcTargets?.get(target);\n        if (hook) {\n          hook.dispose();\n          this.rpcTargets.delete(target);\n        } else {\n          disposeRpcTarget(target);\n        }\n        return;\n      }\n      case "rpc-thenable":\n        return;\n      default:\n        return;\n    }\n  }\n  // Ignore unhandled rejections in all promises in this payload -- that is, all promises that\n  // *would* be awaited if this payload were to be delivered. See the similarly-named method of\n  // StubHook for explanation.\n  ignoreUnhandledRejections() {\n    if (this.stubs) {\n      this.stubs.forEach((stub) => {\n        unwrapStubOrParent(stub).ignoreUnhandledRejections();\n      });\n      this.promises.forEach(\n        (promise) => unwrapStubOrParent(promise.promise).ignoreUnhandledRejections()\n      );\n    } else {\n      this.ignoreUnhandledRejectionsImpl(this.value);\n    }\n  }\n  ignoreUnhandledRejectionsImpl(value) {\n    let kind = typeForRpc(value);\n    switch (kind) {\n      case "unsupported":\n      case "primitive":\n      case "bigint":\n      case "bytes":\n      case "date":\n      case "error":\n      case "undefined":\n      case "function":\n      case "rpc-target":\n        return;\n      case "array": {\n        let array = value;\n        let len = array.length;\n        for (let i = 0; i < len; i++) {\n          this.ignoreUnhandledRejectionsImpl(array[i]);\n        }\n        return;\n      }\n      case "object": {\n        let object = value;\n        for (let i in object) {\n          this.ignoreUnhandledRejectionsImpl(object[i]);\n        }\n        return;\n      }\n      case "stub":\n      case "rpc-promise":\n        unwrapStubOrParent(value).ignoreUnhandledRejections();\n        return;\n      case "rpc-thenable":\n        value.then((_) => {\n        }, (_) => {\n        });\n        return;\n      default:\n        return;\n    }\n  }\n};\nfunction followPath(value, parent, path, owner) {\n  for (let i = 0; i < path.length; i++) {\n    parent = value;\n    let part = path[i];\n    if (part in Object.prototype) {\n      value = void 0;\n      continue;\n    }\n    let kind = typeForRpc(value);\n    switch (kind) {\n      case "object":\n      case "function":\n        if (Object.hasOwn(value, part)) {\n          value = value[part];\n        } else {\n          value = void 0;\n        }\n        break;\n      case "array":\n        if (Number.isInteger(part) && part >= 0) {\n          value = value[part];\n        } else {\n          value = void 0;\n        }\n        break;\n      case "rpc-target":\n      case "rpc-thenable": {\n        if (Object.hasOwn(value, part)) {\n          throw new TypeError(\n            `Attempted to access property \'${part}\', which is an instance property of the RpcTarget. To avoid leaking private internals, instance properties cannot be accessed over RPC. If you want to make this property available over RPC, define it as a method or getter on the class, instead of an instance property.`\n          );\n        } else {\n          value = value[part];\n        }\n        owner = null;\n        break;\n      }\n      case "stub":\n      case "rpc-promise": {\n        let { hook, pathIfPromise } = unwrapStubAndPath(value);\n        return { hook, remainingPath: pathIfPromise ? pathIfPromise.concat(path.slice(i)) : path.slice(i) };\n      }\n      case "primitive":\n      case "bigint":\n      case "bytes":\n      case "date":\n      case "error":\n        value = void 0;\n        break;\n      case "undefined":\n        value = value[part];\n        break;\n      case "unsupported": {\n        if (i === 0) {\n          throw new TypeError(`RPC stub points at a non-serializable type.`);\n        } else {\n          let prefix = path.slice(0, i).join(".");\n          let remainder = path.slice(0, i).join(".");\n          throw new TypeError(\n            `\'${prefix}\' is not a serializable type, so property ${remainder} cannot be accessed.`\n          );\n        }\n      }\n      default:\n        throw new TypeError("unreachable");\n    }\n  }\n  if (value instanceof RpcPromise) {\n    let { hook, pathIfPromise } = unwrapStubAndPath(value);\n    return { hook, remainingPath: pathIfPromise || [] };\n  }\n  return {\n    value,\n    parent,\n    owner\n  };\n}\nvar ValueStubHook = class extends StubHook {\n  call(path, args) {\n    try {\n      let { value, owner } = this.getValue();\n      let followResult = followPath(value, void 0, path, owner);\n      if (followResult.hook) {\n        return followResult.hook.call(followResult.remainingPath, args);\n      }\n      if (typeof followResult.value != "function") {\n        throw new TypeError(`\'${path.join(".")}\' is not a function.`);\n      }\n      let promise = args.deliverCall(followResult.value, followResult.parent);\n      return new PromiseStubHook(promise.then((payload) => {\n        return new PayloadStubHook(payload);\n      }));\n    } catch (err) {\n      return new ErrorStubHook(err);\n    }\n  }\n  map(path, captures, instructions) {\n    try {\n      let followResult;\n      try {\n        let { value, owner } = this.getValue();\n        followResult = followPath(value, void 0, path, owner);\n        ;\n      } catch (err) {\n        for (let cap of captures) {\n          cap.dispose();\n        }\n        throw err;\n      }\n      if (followResult.hook) {\n        return followResult.hook.map(followResult.remainingPath, captures, instructions);\n      }\n      return mapImpl.applyMap(\n        followResult.value,\n        followResult.parent,\n        followResult.owner,\n        captures,\n        instructions\n      );\n    } catch (err) {\n      return new ErrorStubHook(err);\n    }\n  }\n  get(path) {\n    try {\n      let { value, owner } = this.getValue();\n      if (path.length === 0 && owner === null) {\n        throw new Error("Can\'t dup an RpcTarget stub as a promise.");\n      }\n      let followResult = followPath(value, void 0, path, owner);\n      if (followResult.hook) {\n        return followResult.hook.get(followResult.remainingPath);\n      }\n      return new PayloadStubHook(RpcPayload.deepCopyFrom(\n        followResult.value,\n        followResult.parent,\n        followResult.owner\n      ));\n    } catch (err) {\n      return new ErrorStubHook(err);\n    }\n  }\n};\nvar PayloadStubHook = class _PayloadStubHook extends ValueStubHook {\n  constructor(payload) {\n    super();\n    this.payload = payload;\n  }\n  payload;\n  // cleared when disposed\n  getPayload() {\n    if (this.payload) {\n      return this.payload;\n    } else {\n      throw new Error("Attempted to use an RPC StubHook after it was disposed.");\n    }\n  }\n  getValue() {\n    let payload = this.getPayload();\n    return { value: payload.value, owner: payload };\n  }\n  dup() {\n    let thisPayload = this.getPayload();\n    return new _PayloadStubHook(RpcPayload.deepCopyFrom(\n      thisPayload.value,\n      void 0,\n      thisPayload\n    ));\n  }\n  pull() {\n    return this.getPayload();\n  }\n  ignoreUnhandledRejections() {\n    if (this.payload) {\n      this.payload.ignoreUnhandledRejections();\n    }\n  }\n  dispose() {\n    if (this.payload) {\n      this.payload.dispose();\n      this.payload = void 0;\n    }\n  }\n  onBroken(callback) {\n    if (this.payload) {\n      if (this.payload.value instanceof RpcStub) {\n        this.payload.value.onRpcBroken(callback);\n      }\n    }\n  }\n};\nfunction disposeRpcTarget(target) {\n  if (Symbol.dispose in target) {\n    try {\n      target[Symbol.dispose]();\n    } catch (err) {\n      Promise.reject(err);\n    }\n  }\n}\nvar TargetStubHook = class _TargetStubHook extends ValueStubHook {\n  // Constructs a TargetStubHook that is not duplicated from an existing hook.\n  //\n  // If `value` is a function, `parent` is bound as its "this".\n  static create(value, parent) {\n    if (typeof value !== "function") {\n      parent = void 0;\n    }\n    return new _TargetStubHook(value, parent);\n  }\n  constructor(target, parent, dupFrom) {\n    super();\n    this.target = target;\n    this.parent = parent;\n    if (dupFrom) {\n      if (dupFrom.refcount) {\n        this.refcount = dupFrom.refcount;\n        ++this.refcount.count;\n      }\n    } else if (Symbol.dispose in target) {\n      this.refcount = { count: 1 };\n    }\n  }\n  target;\n  // cleared when disposed\n  parent;\n  // `this` parameter when calling `target`\n  refcount;\n  // undefined if not needed (because target has no disposer)\n  getTarget() {\n    if (this.target) {\n      return this.target;\n    } else {\n      throw new Error("Attempted to use an RPC StubHook after it was disposed.");\n    }\n  }\n  getValue() {\n    return { value: this.getTarget(), owner: null };\n  }\n  dup() {\n    return new _TargetStubHook(this.getTarget(), this.parent, this);\n  }\n  pull() {\n    let target = this.getTarget();\n    if ("then" in target) {\n      return Promise.resolve(target).then((resolution) => {\n        return RpcPayload.fromAppReturn(resolution);\n      });\n    } else {\n      return Promise.reject(new Error("Tried to resolve a non-promise stub."));\n    }\n  }\n  ignoreUnhandledRejections() {\n  }\n  dispose() {\n    if (this.target) {\n      if (this.refcount) {\n        if (--this.refcount.count == 0) {\n          disposeRpcTarget(this.target);\n        }\n      }\n      this.target = void 0;\n    }\n  }\n  onBroken(callback) {\n  }\n};\nvar PromiseStubHook = class _PromiseStubHook extends StubHook {\n  promise;\n  resolution;\n  constructor(promise) {\n    super();\n    this.promise = promise.then((res) => {\n      this.resolution = res;\n      return res;\n    });\n  }\n  call(path, args) {\n    args.ensureDeepCopied();\n    return new _PromiseStubHook(this.promise.then((hook) => hook.call(path, args)));\n  }\n  map(path, captures, instructions) {\n    return new _PromiseStubHook(this.promise.then(\n      (hook) => hook.map(path, captures, instructions),\n      (err) => {\n        for (let cap of captures) {\n          cap.dispose();\n        }\n        throw err;\n      }\n    ));\n  }\n  get(path) {\n    return new _PromiseStubHook(this.promise.then((hook) => hook.get(path)));\n  }\n  dup() {\n    if (this.resolution) {\n      return this.resolution.dup();\n    } else {\n      return new _PromiseStubHook(this.promise.then((hook) => hook.dup()));\n    }\n  }\n  pull() {\n    if (this.resolution) {\n      return this.resolution.pull();\n    } else {\n      return this.promise.then((hook) => hook.pull());\n    }\n  }\n  ignoreUnhandledRejections() {\n    if (this.resolution) {\n      this.resolution.ignoreUnhandledRejections();\n    } else {\n      this.promise.then((res) => {\n        res.ignoreUnhandledRejections();\n      }, (err) => {\n      });\n    }\n  }\n  dispose() {\n    if (this.resolution) {\n      this.resolution.dispose();\n    } else {\n      this.promise.then((hook) => {\n        hook.dispose();\n      }, (err) => {\n      });\n    }\n  }\n  onBroken(callback) {\n    if (this.resolution) {\n      this.resolution.onBroken(callback);\n    } else {\n      this.promise.then((hook) => {\n        hook.onBroken(callback);\n      }, callback);\n    }\n  }\n};\nvar currentMapBuilder;\nvar MapBuilder = class {\n  context;\n  captureMap = /* @__PURE__ */ new Map();\n  instructions = [];\n  constructor(subject, path) {\n    if (currentMapBuilder) {\n      this.context = {\n        parent: currentMapBuilder,\n        captures: [],\n        subject: currentMapBuilder.capture(subject),\n        path\n      };\n    } else {\n      this.context = {\n        parent: void 0,\n        captures: [],\n        subject,\n        path\n      };\n    }\n    currentMapBuilder = this;\n  }\n  unregister() {\n    currentMapBuilder = this.context.parent;\n  }\n  makeInput() {\n    return new MapVariableHook(this, 0);\n  }\n  makeOutput(result) {\n    let devalued;\n    try {\n      devalued = Devaluator.devaluate(result.value, void 0, this, result);\n    } finally {\n      result.dispose();\n    }\n    this.instructions.push(devalued);\n    if (this.context.parent) {\n      this.context.parent.instructions.push(\n        [\n          "remap",\n          this.context.subject,\n          this.context.path,\n          this.context.captures.map((cap) => ["import", cap]),\n          this.instructions\n        ]\n      );\n      return new MapVariableHook(this.context.parent, this.context.parent.instructions.length);\n    } else {\n      return this.context.subject.map(this.context.path, this.context.captures, this.instructions);\n    }\n  }\n  pushCall(hook, path, params) {\n    let devalued = Devaluator.devaluate(params.value, void 0, this, params);\n    devalued = devalued[0];\n    let subject = this.capture(hook.dup());\n    this.instructions.push(["pipeline", subject, path, devalued]);\n    return new MapVariableHook(this, this.instructions.length);\n  }\n  pushGet(hook, path) {\n    let subject = this.capture(hook.dup());\n    this.instructions.push(["pipeline", subject, path]);\n    return new MapVariableHook(this, this.instructions.length);\n  }\n  capture(hook) {\n    if (hook instanceof MapVariableHook && hook.mapper === this) {\n      return hook.idx;\n    }\n    let result = this.captureMap.get(hook);\n    if (result === void 0) {\n      if (this.context.parent) {\n        let parentIdx = this.context.parent.capture(hook);\n        this.context.captures.push(parentIdx);\n      } else {\n        this.context.captures.push(hook);\n      }\n      result = -this.context.captures.length;\n      this.captureMap.set(hook, result);\n    }\n    return result;\n  }\n  // ---------------------------------------------------------------------------\n  // implements Exporter\n  exportStub(hook) {\n    throw new Error(\n      "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."\n    );\n  }\n  exportPromise(hook) {\n    return this.exportStub(hook);\n  }\n  getImport(hook) {\n    return this.capture(hook);\n  }\n  unexport(ids) {\n  }\n  onSendError(error) {\n  }\n};\nmapImpl.sendMap = (hook, path, func) => {\n  let builder = new MapBuilder(hook, path);\n  let result;\n  try {\n    result = RpcPayload.fromAppReturn(withCallInterceptor(builder.pushCall.bind(builder), () => {\n      return func(new RpcPromise(builder.makeInput(), []));\n    }));\n  } finally {\n    builder.unregister();\n  }\n  if (result instanceof Promise) {\n    result.catch((err) => {\n    });\n    throw new Error("RPC map() callbacks cannot be async.");\n  }\n  return new RpcPromise(builder.makeOutput(result), []);\n};\nmapImpl.recordCallback = (func) => {\n  const builder = new MapBuilder(new PayloadStubHook(RpcPayload.fromAppParams([])), []);\n  let result;\n  try {\n    result = RpcPayload.fromAppReturn(withCallInterceptor(builder.pushCall.bind(builder), () => {\n      return func(new RpcPromise(builder.makeInput(), []));\n    }));\n  } finally {\n    builder.unregister();\n  }\n  const devaluatedResult = Devaluator.devaluate(result.value, void 0, builder, result);\n  const instructions = [...builder.instructions, devaluatedResult];\n  const context = builder.context;\n  if (context.parent) {\n    return ["callback", context.captures.map((cap) => ["import", cap]), instructions];\n  } else {\n    return ["callback", context.captures, instructions];\n  }\n};\nfunction throwMapperBuilderUseError() {\n  throw new Error(\n    "Attempted to use an abstract placeholder from a mapper function. Please make sure your map function has no side effects."\n  );\n}\nvar MapVariableHook = class extends StubHook {\n  constructor(mapper, idx) {\n    super();\n    this.mapper = mapper;\n    this.idx = idx;\n  }\n  // We don\'t have anything we actually need to dispose, so dup() can just return the same hook.\n  dup() {\n    return this;\n  }\n  dispose() {\n  }\n  get(path) {\n    if (path.length == 0) {\n      return this;\n    } else if (currentMapBuilder) {\n      return currentMapBuilder.pushGet(this, path);\n    } else {\n      throwMapperBuilderUseError();\n    }\n  }\n  // Other methods should never be called.\n  call(path, args) {\n    throwMapperBuilderUseError();\n  }\n  map(path, captures, instructions) {\n    throwMapperBuilderUseError();\n  }\n  pull() {\n    throwMapperBuilderUseError();\n  }\n  ignoreUnhandledRejections() {\n  }\n  onBroken(callback) {\n    throwMapperBuilderUseError();\n  }\n};\nvar MapApplicator = class {\n  constructor(captures, input) {\n    this.captures = captures;\n    this.variables = [input];\n  }\n  variables;\n  dispose() {\n    for (let variable of this.variables) {\n      variable.dispose();\n    }\n  }\n  apply(instructions) {\n    try {\n      if (instructions.length < 1) {\n        throw new Error("Invalid empty mapper function.");\n      }\n      for (let instruction of instructions.slice(0, -1)) {\n        let payload = new Evaluator(this).evaluateCopy(instruction);\n        if (payload.value instanceof RpcStub) {\n          let hook = unwrapStubNoProperties(payload.value);\n          if (hook) {\n            this.variables.push(hook);\n            continue;\n          }\n        }\n        this.variables.push(new PayloadStubHook(payload));\n      }\n      return new Evaluator(this).evaluateCopy(instructions[instructions.length - 1]);\n    } finally {\n      for (let variable of this.variables) {\n        variable.dispose();\n      }\n    }\n  }\n  importStub(idx) {\n    throw new Error("A mapper function cannot refer to exports.");\n  }\n  importPromise(idx) {\n    return this.importStub(idx);\n  }\n  getExport(idx) {\n    if (idx < 0) {\n      return this.captures[-idx - 1];\n    } else {\n      return this.variables[idx];\n    }\n  }\n};\nfunction applyMapToElement(input, parent, owner, captures, instructions) {\n  let inputHook = new PayloadStubHook(RpcPayload.deepCopyFrom(input, parent, owner));\n  let mapper = new MapApplicator(captures, inputHook);\n  try {\n    return mapper.apply(instructions);\n  } finally {\n    mapper.dispose();\n  }\n}\nmapImpl.applyMap = (input, parent, owner, captures, instructions) => {\n  try {\n    let result;\n    if (input instanceof RpcPromise) {\n      throw new Error("applyMap() can\'t be called on RpcPromise");\n    } else if (input instanceof Array) {\n      let payloads = [];\n      try {\n        for (let elem of input) {\n          payloads.push(applyMapToElement(elem, input, owner, captures, instructions));\n        }\n      } catch (err) {\n        for (let payload of payloads) {\n          payload.dispose();\n        }\n        throw err;\n      }\n      result = RpcPayload.fromArray(payloads);\n    } else if (input === null || input === void 0) {\n      result = RpcPayload.fromAppReturn(input);\n    } else {\n      result = applyMapToElement(input, parent, owner, captures, instructions);\n    }\n    return new PayloadStubHook(result);\n  } finally {\n    for (let cap of captures) {\n      cap.dispose();\n    }\n  }\n};\nvar isExplicitCallback = (arg) => {\n  return typeof arg === "function" && "serializationMode" in arg;\n};\nvar NullExporter = class {\n  exportStub(stub) {\n    throw new Error("Cannot serialize RPC stubs without an RPC session.");\n  }\n  exportPromise(stub) {\n    throw new Error("Cannot serialize RPC stubs without an RPC session.");\n  }\n  getImport(hook) {\n    return void 0;\n  }\n  unexport(ids) {\n  }\n  onSendError(error) {\n  }\n};\nvar NULL_EXPORTER = new NullExporter();\nvar ERROR_TYPES = {\n  Error,\n  EvalError,\n  RangeError,\n  ReferenceError,\n  SyntaxError,\n  TypeError,\n  URIError,\n  AggregateError\n  // TODO: DOMError? Others?\n};\nvar Devaluator = class _Devaluator {\n  constructor(exporter, source) {\n    this.exporter = exporter;\n    this.source = source;\n  }\n  // Devaluate the given value.\n  // * value: The value to devaluate.\n  // * parent: The value\'s parent object, which would be used as `this` if the value were called\n  //     as a function.\n  // * exporter: Callbacks to the RPC session for exporting capabilities found in this message.\n  // * source: The RpcPayload which contains the value, and therefore owns stubs within.\n  //\n  // Returns: The devaluated value, ready to be JSON-serialized.\n  static devaluate(value, parent, exporter = NULL_EXPORTER, source) {\n    let devaluator = new _Devaluator(exporter, source);\n    try {\n      return devaluator.devaluateImpl(value, parent, 0);\n    } catch (err) {\n      if (devaluator.exports) {\n        try {\n          exporter.unexport(devaluator.exports);\n        } catch (err2) {\n        }\n      }\n      throw err;\n    }\n  }\n  exports;\n  devaluateImpl(value, parent, depth) {\n    if (depth >= 64) {\n      throw new Error(\n        "Serialization exceeded maximum allowed depth. (Does the message contain cycles?)"\n      );\n    }\n    let kind = typeForRpc(value);\n    switch (kind) {\n      case "unsupported": {\n        let msg;\n        try {\n          msg = `Cannot serialize value: ${value}`;\n        } catch (err) {\n          msg = "Cannot serialize value: (couldn\'t stringify value)";\n        }\n        throw new TypeError(msg);\n      }\n      case "primitive":\n        if (typeof value === "number" && !isFinite(value)) {\n          if (value === Infinity) {\n            return ["inf"];\n          } else if (value === -Infinity) {\n            return ["-inf"];\n          } else {\n            return ["nan"];\n          }\n        } else {\n          return value;\n        }\n      case "object": {\n        let object = value;\n        let result = {};\n        for (let key in object) {\n          result[key] = this.devaluateImpl(object[key], object, depth + 1);\n        }\n        return result;\n      }\n      case "array": {\n        let array = value;\n        let len = array.length;\n        let result = new Array(len);\n        for (let i = 0; i < len; i++) {\n          result[i] = this.devaluateImpl(array[i], array, depth + 1);\n        }\n        return [result];\n      }\n      case "bigint":\n        return ["bigint", value.toString()];\n      case "date":\n        return ["date", value.getTime()];\n      case "bytes": {\n        let bytes = value;\n        if (bytes.toBase64) {\n          return ["bytes", bytes.toBase64({ omitPadding: true })];\n        } else {\n          return [\n            "bytes",\n            btoa(String.fromCharCode.apply(null, bytes).replace(/=*$/, ""))\n          ];\n        }\n      }\n      case "error": {\n        let e = value;\n        let rewritten = this.exporter.onSendError(e);\n        if (rewritten) {\n          e = rewritten;\n        }\n        let result = ["error", e.name, e.message];\n        if (rewritten && rewritten.stack) {\n          result.push(rewritten.stack);\n        }\n        return result;\n      }\n      case "undefined":\n        return ["undefined"];\n      case "stub":\n      case "rpc-promise": {\n        if (!this.source) {\n          throw new Error("Can\'t serialize RPC stubs in this context.");\n        }\n        let { hook, pathIfPromise } = unwrapStubAndPath(value);\n        let importId = this.exporter.getImport(hook);\n        if (importId !== void 0) {\n          if (pathIfPromise) {\n            if (pathIfPromise.length > 0) {\n              return ["pipeline", importId, pathIfPromise];\n            } else {\n              return ["pipeline", importId];\n            }\n          } else {\n            return ["import", importId];\n          }\n        }\n        if (pathIfPromise) {\n          hook = hook.get(pathIfPromise);\n        } else {\n          hook = hook.dup();\n        }\n        return this.devaluateHook(pathIfPromise ? "promise" : "export", hook);\n      }\n      case "function":\n      case "rpc-target": {\n        let shouldRecordReplay = false;\n        if (kind === "function") {\n          if (isExplicitCallback(value)) {\n            const explicitMode = value.serializationMode;\n            shouldRecordReplay = explicitMode === "recordReplay";\n          } else {\n            shouldRecordReplay = getGlobalRpcSessionOptions().recordReplayMode === "all";\n          }\n        }\n        if (shouldRecordReplay) {\n          const res = mapImpl.recordCallback(value);\n          const captures = res[1];\n          if (captures.length === 0 || captures[0] instanceof StubHook) {\n            const captureHooks = captures;\n            const serializedCaptures = captureHooks.map((stub) => {\n              const importId = this.exporter.getImport(stub);\n              if (importId !== void 0) {\n                return ["import", importId];\n              } else {\n                return ["export", this.exporter.exportStub(stub)];\n              }\n            });\n            for (const hook2 of captureHooks) {\n              hook2.dispose();\n            }\n            return ["callback", serializedCaptures, res[2]];\n          } else {\n            return res;\n          }\n        }\n        if (!this.source) {\n          throw new Error("Can\'t serialize RPC stubs in this context.");\n        }\n        let hook = this.source.getHookForRpcTarget(value, parent);\n        return this.devaluateHook("export", hook);\n      }\n      case "rpc-thenable": {\n        if (!this.source) {\n          throw new Error("Can\'t serialize RPC stubs in this context.");\n        }\n        let hook = this.source.getHookForRpcTarget(value, parent);\n        return this.devaluateHook("promise", hook);\n      }\n      default:\n        throw new Error("unreachable");\n    }\n  }\n  devaluateHook(type, hook) {\n    if (!this.exports) this.exports = [];\n    let exportId = type === "promise" ? this.exporter.exportPromise(hook) : this.exporter.exportStub(hook);\n    this.exports.push(exportId);\n    return [type, exportId];\n  }\n};\nvar NullImporter = class {\n  importStub(idx) {\n    throw new Error("Cannot deserialize RPC stubs without an RPC session.");\n  }\n  importPromise(idx) {\n    throw new Error("Cannot deserialize RPC stubs without an RPC session.");\n  }\n  getExport(idx) {\n    return void 0;\n  }\n};\nvar NULL_IMPORTER = new NullImporter();\nvar Evaluator = class _Evaluator {\n  constructor(importer) {\n    this.importer = importer;\n  }\n  stubs = [];\n  promises = [];\n  // Resolve serialized captures to StubHooks. Used by both "callback" and "remap" evaluation.\n  resolveCaptures(capsData) {\n    return capsData.map((cap) => {\n      if (!(cap instanceof Array) || cap.length !== 2 || cap[0] !== "import" && cap[0] !== "export" || typeof cap[1] !== "number") {\n        throw new TypeError(`unknown capture: ${JSON.stringify(cap)}`);\n      }\n      if (cap[0] === "export") {\n        return this.importer.importStub(cap[1]);\n      } else {\n        let exp = this.importer.getExport(cap[1]);\n        if (!exp) {\n          throw new Error(`no such entry on exports table: ${cap[1]}`);\n        }\n        return exp.dup();\n      }\n    });\n  }\n  evaluate(value) {\n    let payload = RpcPayload.forEvaluate(this.stubs, this.promises);\n    try {\n      payload.value = this.evaluateImpl(value, payload, "value");\n      return payload;\n    } catch (err) {\n      payload.dispose();\n      throw err;\n    }\n  }\n  // Evaluate the value without destroying it.\n  evaluateCopy(value) {\n    return this.evaluate(structuredClone(value));\n  }\n  evaluateImpl(value, parent, property) {\n    if (value instanceof Array) {\n      if (value.length == 1 && value[0] instanceof Array) {\n        let result = value[0];\n        for (let i = 0; i < result.length; i++) {\n          result[i] = this.evaluateImpl(result[i], result, i);\n        }\n        return result;\n      } else switch (value[0]) {\n        case "callback": {\n          if (value.length < 3 || !(value[1] instanceof Array) || !(value[2] instanceof Array)) {\n            break;\n          }\n          const captures = this.resolveCaptures(value[1]);\n          const instructions = value[2];\n          const replayFn = (arg) => {\n            const capturesForThisCall = captures.map((c) => c.dup());\n            const inputHook = new PayloadStubHook(RpcPayload.fromAppParams(arg));\n            const applicator = new MapApplicator(capturesForThisCall, inputHook);\n            const disposeInvocation = () => {\n              applicator.dispose();\n              for (const cap of capturesForThisCall) {\n                cap.dispose();\n              }\n              const cleanup = replayFn[CALLBACK_CLEANUP];\n              if (typeof cleanup === "function") {\n                cleanup();\n              }\n            };\n            let resultPayload;\n            try {\n              resultPayload = applicator.apply(instructions);\n            } catch (err) {\n              disposeInvocation();\n              throw err;\n            }\n            return resultPayload.deliverResolve().finally(disposeInvocation);\n          };\n          replayFn[CALLBACK_CLEANUP] = () => {\n            for (const cap of captures) {\n              cap.dispose();\n            }\n          };\n          return replayFn;\n        }\n        case "bigint":\n          if (typeof value[1] == "string") {\n            return BigInt(value[1]);\n          }\n          break;\n        case "date":\n          if (typeof value[1] == "number") {\n            return new Date(value[1]);\n          }\n          break;\n        case "bytes": {\n          let b64 = Uint8Array;\n          if (typeof value[1] == "string") {\n            if (b64.fromBase64) {\n              return b64.fromBase64(value[1]);\n            } else {\n              let bs = atob(value[1]);\n              let len = bs.length;\n              let bytes = new Uint8Array(len);\n              for (let i = 0; i < len; i++) {\n                bytes[i] = bs.charCodeAt(i);\n              }\n              return bytes;\n            }\n          }\n          break;\n        }\n        case "error":\n          if (value.length >= 3 && typeof value[1] === "string" && typeof value[2] === "string") {\n            let cls = ERROR_TYPES[value[1]] || Error;\n            let result = new cls(value[2]);\n            if (typeof value[3] === "string") {\n              result.stack = value[3];\n            }\n            return result;\n          }\n          break;\n        case "undefined":\n          if (value.length === 1) {\n            return void 0;\n          }\n          break;\n        case "inf":\n          return Infinity;\n        case "-inf":\n          return -Infinity;\n        case "nan":\n          return NaN;\n        case "import":\n        case "pipeline": {\n          if (value.length < 2 || value.length > 4) {\n            break;\n          }\n          if (typeof value[1] != "number") {\n            break;\n          }\n          let hook = this.importer.getExport(value[1]);\n          if (!hook) {\n            throw new Error(`no such entry on exports table: ${value[1]}`);\n          }\n          let isPromise = value[0] == "pipeline";\n          let addStub = (hook2) => {\n            const unwrapped = maybeUnwrapStubHook(hook2);\n            if (unwrapped) {\n              hook2.dispose();\n              return unwrapped;\n            }\n            if (isPromise) {\n              let promise = new RpcPromise(hook2, []);\n              this.promises.push({ promise, parent, property });\n              return promise;\n            } else {\n              let stub = new RpcPromise(hook2, []);\n              this.stubs.push(stub);\n              return stub;\n            }\n          };\n          if (value.length == 2) {\n            if (isPromise) {\n              return addStub(hook.get([]));\n            } else {\n              return addStub(hook.dup());\n            }\n          }\n          let path = value[2];\n          if (!(path instanceof Array)) {\n            break;\n          }\n          if (!path.every(\n            (part) => {\n              return typeof part == "string" || typeof part == "number";\n            }\n          )) {\n            break;\n          }\n          if (value.length == 3) {\n            return addStub(hook.get(path));\n          }\n          let args = value[3];\n          if (!(args instanceof Array)) {\n            break;\n          }\n          let subEval = new _Evaluator(this.importer);\n          args = subEval.evaluate([args]);\n          return addStub(hook.call(path, args));\n        }\n        case "remap": {\n          if (value.length !== 5 || typeof value[1] !== "number" || !(value[2] instanceof Array) || !(value[3] instanceof Array) || !(value[4] instanceof Array)) {\n            break;\n          }\n          let hook = this.importer.getExport(value[1]);\n          if (!hook) {\n            throw new Error(`no such entry on exports table: ${value[1]}`);\n          }\n          let path = value[2];\n          if (!path.every(\n            (part) => {\n              return typeof part == "string" || typeof part == "number";\n            }\n          )) {\n            break;\n          }\n          let captures = this.resolveCaptures(value[3]);\n          let instructions = value[4];\n          let resultHook = hook.map(path, captures, instructions);\n          let promise = new RpcPromise(resultHook, []);\n          this.promises.push({ promise, parent, property });\n          return promise;\n        }\n        case "export":\n        case "promise":\n          if (typeof value[1] == "number") {\n            if (value[0] == "promise") {\n              let hook = this.importer.importPromise(value[1]);\n              let promise = new RpcPromise(hook, []);\n              this.promises.push({ parent, property, promise });\n              return promise;\n            } else {\n              let hook = this.importer.importStub(value[1]);\n              let stub = new RpcStub(hook);\n              this.stubs.push(stub);\n              return stub;\n            }\n          }\n          break;\n      }\n      throw new TypeError(`unknown special value: ${JSON.stringify(value)}`);\n    } else if (value instanceof Object) {\n      let result = value;\n      for (let key in result) {\n        if (key in Object.prototype || key === "toJSON") {\n          this.evaluateImpl(result[key], result, key);\n          delete result[key];\n        } else {\n          result[key] = this.evaluateImpl(result[key], result, key);\n        }\n      }\n      return result;\n    } else {\n      return value;\n    }\n  }\n};\nvar maybeUnwrapStubHook = (hook) => {\n  if (!(hook instanceof PayloadStubHook)) {\n    return void 0;\n  }\n  const payload = hook.getPayload();\n  if (payload.value instanceof RpcStub) {\n    const { hook: innerHook, pathIfPromise } = unwrapStubAndPath(payload.value);\n    if (pathIfPromise == null && innerHook instanceof TargetStubHook) {\n      return innerHook.getTarget();\n    } else {\n      return innerHook;\n    }\n  }\n  return void 0;\n};\nvar ImportTableEntry = class {\n  constructor(session, importId, pulling) {\n    this.session = session;\n    this.importId = importId;\n    if (pulling) {\n      this.activePull = Promise.withResolvers();\n    }\n  }\n  localRefcount = 0;\n  remoteRefcount = 1;\n  activePull;\n  resolution;\n  // List of integer indexes into session.onBrokenCallbacks which are callbacks registered on\n  // this import. Initialized on first use (so `undefined` is the same as an empty list).\n  onBrokenRegistrations;\n  resolve(resolution) {\n    if (this.localRefcount == 0) {\n      resolution.dispose();\n      return;\n    }\n    this.resolution = resolution;\n    this.sendRelease();\n    if (this.onBrokenRegistrations) {\n      for (let i of this.onBrokenRegistrations) {\n        let callback = this.session.onBrokenCallbacks[i];\n        let endIndex = this.session.onBrokenCallbacks.length;\n        resolution.onBroken(callback);\n        if (this.session.onBrokenCallbacks[endIndex] === callback) {\n          delete this.session.onBrokenCallbacks[endIndex];\n        } else {\n          delete this.session.onBrokenCallbacks[i];\n        }\n      }\n      this.onBrokenRegistrations = void 0;\n    }\n    if (this.activePull) {\n      this.activePull.resolve();\n      this.activePull = void 0;\n    }\n  }\n  async awaitResolution() {\n    if (!this.activePull) {\n      this.session.sendPull(this.importId);\n      this.activePull = Promise.withResolvers();\n    }\n    await this.activePull.promise;\n    return this.resolution.pull();\n  }\n  dispose() {\n    if (this.resolution) {\n      this.resolution.dispose();\n    } else {\n      this.abort(new Error("RPC was canceled because the RpcPromise was disposed."));\n      this.sendRelease();\n    }\n  }\n  abort(error) {\n    if (!this.resolution) {\n      this.resolution = new ErrorStubHook(error);\n      if (this.activePull) {\n        this.activePull.reject(error);\n        this.activePull = void 0;\n      }\n      this.onBrokenRegistrations = void 0;\n    }\n  }\n  onBroken(callback) {\n    if (this.resolution) {\n      this.resolution.onBroken(callback);\n    } else {\n      let index = this.session.onBrokenCallbacks.length;\n      this.session.onBrokenCallbacks.push(callback);\n      if (!this.onBrokenRegistrations) this.onBrokenRegistrations = [];\n      this.onBrokenRegistrations.push(index);\n    }\n  }\n  sendRelease() {\n    if (this.remoteRefcount > 0) {\n      this.session.sendRelease(this.importId, this.remoteRefcount);\n      this.remoteRefcount = 0;\n    }\n  }\n};\nvar RpcImportHook = class _RpcImportHook extends StubHook {\n  // undefined when we\'re disposed\n  // `pulling` is true if we already expect that this import is going to be resolved later, and\n  // null if this import is not allowed to be pulled (i.e. it\'s a stub not a promise).\n  constructor(isPromise, entry) {\n    super();\n    this.isPromise = isPromise;\n    ++entry.localRefcount;\n    this.entry = entry;\n  }\n  entry;\n  collectPath(path) {\n    return this;\n  }\n  getEntry() {\n    if (this.entry) {\n      return this.entry;\n    } else {\n      throw new Error("This RpcImportHook was already disposed.");\n    }\n  }\n  // -------------------------------------------------------------------------------------\n  // implements StubHook\n  call(path, args) {\n    let entry = this.getEntry();\n    if (entry.resolution) {\n      return entry.resolution.call(path, args);\n    } else {\n      return entry.session.sendCall(entry.importId, path, args);\n    }\n  }\n  map(path, captures, instructions) {\n    let entry;\n    try {\n      entry = this.getEntry();\n    } catch (err) {\n      for (let cap of captures) {\n        cap.dispose();\n      }\n      throw err;\n    }\n    if (entry.resolution) {\n      return entry.resolution.map(path, captures, instructions);\n    } else {\n      return entry.session.sendMap(entry.importId, path, captures, instructions);\n    }\n  }\n  get(path) {\n    let entry = this.getEntry();\n    if (entry.resolution) {\n      return entry.resolution.get(path);\n    } else {\n      return entry.session.sendCall(entry.importId, path);\n    }\n  }\n  dup() {\n    return new _RpcImportHook(false, this.getEntry());\n  }\n  pull() {\n    let entry = this.getEntry();\n    if (!this.isPromise) {\n      throw new Error("Can\'t pull this hook because it\'s not a promise hook.");\n    }\n    if (entry.resolution) {\n      return entry.resolution.pull();\n    }\n    return entry.awaitResolution();\n  }\n  ignoreUnhandledRejections() {\n  }\n  dispose() {\n    let entry = this.entry;\n    this.entry = void 0;\n    if (entry) {\n      if (--entry.localRefcount === 0) {\n        entry.dispose();\n      }\n    }\n  }\n  onBroken(callback) {\n    if (this.entry) {\n      this.entry.onBroken(callback);\n    }\n  }\n};\nvar RpcMainHook = class extends RpcImportHook {\n  session;\n  constructor(entry) {\n    super(false, entry);\n    this.session = entry.session;\n  }\n  dispose() {\n    if (this.session) {\n      let session = this.session;\n      this.session = void 0;\n      session.shutdown();\n    }\n  }\n};\nvar RpcSessionImpl = class {\n  constructor(transport, mainHook, options) {\n    this.transport = transport;\n    this.options = options;\n    this.exports.push({ hook: mainHook, refcount: 1 });\n    this.imports.push(new ImportTableEntry(this, 0, false));\n    let rejectFunc;\n    let abortPromise = new Promise((resolve, reject) => {\n      rejectFunc = reject;\n    });\n    this.cancelReadLoop = rejectFunc;\n    this.readLoop(abortPromise).catch((err) => this.abort(err));\n  }\n  exports = [];\n  reverseExports = /* @__PURE__ */ new Map();\n  imports = [];\n  abortReason;\n  cancelReadLoop;\n  // We assign positive numbers to imports we initiate, and negative numbers to exports we\n  // initiate. So the next import ID is just `imports.length`, but the next export ID needs\n  // to be tracked explicitly.\n  nextExportId = -1;\n  // If set, call this when all incoming calls are complete.\n  onBatchDone;\n  // How many promises is our peer expecting us to resolve?\n  pullCount = 0;\n  // Sparse array of onBrokenCallback registrations. Items are strictly appended to the end but\n  // may be deleted from the middle (hence leaving the array sparse).\n  onBrokenCallbacks = [];\n  // Should only be called once immediately after construction.\n  getMainImport() {\n    return new RpcMainHook(this.imports[0]);\n  }\n  shutdown() {\n    this.abort(new Error("RPC session was shut down by disposing the main stub"), false);\n  }\n  exportStub(hook) {\n    if (this.abortReason) throw this.abortReason;\n    let existingExportId = this.reverseExports.get(hook);\n    if (existingExportId !== void 0) {\n      ++this.exports[existingExportId].refcount;\n      return existingExportId;\n    } else {\n      let exportId = this.nextExportId--;\n      this.exports[exportId] = { hook, refcount: 1 };\n      this.reverseExports.set(hook, exportId);\n      return exportId;\n    }\n  }\n  exportPromise(hook) {\n    if (this.abortReason) throw this.abortReason;\n    let exportId = this.nextExportId--;\n    this.exports[exportId] = { hook, refcount: 1 };\n    this.reverseExports.set(hook, exportId);\n    this.ensureResolvingExport(exportId);\n    return exportId;\n  }\n  unexport(ids) {\n    for (let id of ids) {\n      this.releaseExport(id, 1);\n    }\n  }\n  releaseExport(exportId, refcount) {\n    let entry = this.exports[exportId];\n    if (!entry) {\n      throw new Error(`no such export ID: ${exportId}`);\n    }\n    if (entry.refcount < refcount) {\n      throw new Error(`refcount would go negative: ${entry.refcount} < ${refcount}`);\n    }\n    entry.refcount -= refcount;\n    if (entry.refcount === 0) {\n      delete this.exports[exportId];\n      this.reverseExports.delete(entry.hook);\n      entry.hook.dispose();\n    }\n  }\n  onSendError(error) {\n    if (this.options.onSendError) {\n      return this.options.onSendError(error);\n    }\n  }\n  ensureResolvingExport(exportId) {\n    let exp = this.exports[exportId];\n    if (!exp) {\n      throw new Error(`no such export ID: ${exportId}`);\n    }\n    if (!exp.pull) {\n      let resolve = async () => {\n        let hook = exp.hook;\n        for (; ; ) {\n          let payload = await hook.pull();\n          if (payload.value instanceof RpcStub) {\n            let { hook: inner, pathIfPromise } = unwrapStubAndPath(payload.value);\n            if (pathIfPromise && pathIfPromise.length == 0) {\n              if (this.getImport(hook) === void 0) {\n                hook = inner;\n                continue;\n              }\n            }\n          }\n          return payload;\n        }\n      };\n      ++this.pullCount;\n      exp.pull = resolve().then(\n        (payload) => {\n          let value = Devaluator.devaluate(payload.value, void 0, this, payload);\n          this.send(["resolve", exportId, value]);\n        },\n        (error) => {\n          this.send(["reject", exportId, Devaluator.devaluate(error, void 0, this)]);\n        }\n      ).catch(\n        (error) => {\n          try {\n            this.send(["reject", exportId, Devaluator.devaluate(error, void 0, this)]);\n          } catch (error2) {\n            this.abort(error2);\n          }\n        }\n      ).finally(() => {\n        if (--this.pullCount === 0) {\n          if (this.onBatchDone) {\n            this.onBatchDone.resolve();\n          }\n        }\n      });\n    }\n  }\n  getImport(hook) {\n    if (hook instanceof RpcImportHook && hook.entry && hook.entry.session === this) {\n      return hook.entry.importId;\n    } else {\n      return void 0;\n    }\n  }\n  importStub(idx) {\n    if (this.abortReason) throw this.abortReason;\n    let entry = this.imports[idx];\n    if (!entry) {\n      entry = new ImportTableEntry(this, idx, false);\n      this.imports[idx] = entry;\n    }\n    return new RpcImportHook(\n      /*isPromise=*/\n      false,\n      entry\n    );\n  }\n  importPromise(idx) {\n    if (this.abortReason) throw this.abortReason;\n    if (this.imports[idx]) {\n      return new ErrorStubHook(new Error(\n        "Bug in RPC system: The peer sent a promise reusing an existing export ID."\n      ));\n    }\n    let entry = new ImportTableEntry(this, idx, true);\n    this.imports[idx] = entry;\n    return new RpcImportHook(\n      /*isPromise=*/\n      true,\n      entry\n    );\n  }\n  getExport(idx) {\n    return this.exports[idx]?.hook;\n  }\n  send(msg) {\n    if (this.abortReason !== void 0) {\n      return;\n    }\n    let msgText;\n    try {\n      msgText = JSON.stringify(msg);\n    } catch (err) {\n      try {\n        this.abort(err);\n      } catch (err2) {\n      }\n      throw err;\n    }\n    this.transport.send(msgText).catch((err) => this.abort(err, false));\n  }\n  sendCall(id, path, args) {\n    if (this.abortReason) throw this.abortReason;\n    let value = ["pipeline", id, path];\n    if (args) {\n      let devalue = Devaluator.devaluate(args.value, void 0, this, args);\n      value.push(devalue[0]);\n    }\n    this.send(["push", value]);\n    let entry = new ImportTableEntry(this, this.imports.length, false);\n    this.imports.push(entry);\n    return new RpcImportHook(\n      /*isPromise=*/\n      true,\n      entry\n    );\n  }\n  sendMap(id, path, captures, instructions) {\n    if (this.abortReason) {\n      for (let cap of captures) {\n        cap.dispose();\n      }\n      throw this.abortReason;\n    }\n    let devaluedCaptures = captures.map((hook) => {\n      let importId = this.getImport(hook);\n      if (importId !== void 0) {\n        return ["import", importId];\n      } else {\n        return ["export", this.exportStub(hook)];\n      }\n    });\n    let value = ["remap", id, path, devaluedCaptures, instructions];\n    this.send(["push", value]);\n    let entry = new ImportTableEntry(this, this.imports.length, false);\n    this.imports.push(entry);\n    return new RpcImportHook(\n      /*isPromise=*/\n      true,\n      entry\n    );\n  }\n  sendPull(id) {\n    if (this.abortReason) throw this.abortReason;\n    this.send(["pull", id]);\n  }\n  sendRelease(id, remoteRefcount) {\n    if (this.abortReason) return;\n    this.send(["release", id, remoteRefcount]);\n    delete this.imports[id];\n  }\n  abort(error, trySendAbortMessage = true) {\n    if (this.abortReason !== void 0) return;\n    this.cancelReadLoop(error);\n    if (trySendAbortMessage) {\n      try {\n        this.transport.send(JSON.stringify(["abort", Devaluator.devaluate(error, void 0, this)])).catch((err) => {\n        });\n      } catch (err) {\n      }\n    }\n    if (error === void 0) {\n      error = "undefined";\n    }\n    this.abortReason = error;\n    if (this.onBatchDone) {\n      this.onBatchDone.reject(error);\n    }\n    if (this.transport.abort) {\n      try {\n        this.transport.abort(error);\n      } catch (err) {\n        Promise.resolve(err);\n      }\n    }\n    for (let i in this.onBrokenCallbacks) {\n      try {\n        this.onBrokenCallbacks[i](error);\n      } catch (err) {\n        Promise.resolve(err);\n      }\n    }\n    for (let i in this.imports) {\n      this.imports[i].abort(error);\n    }\n    for (let i in this.exports) {\n      this.exports[i].hook.dispose();\n    }\n  }\n  async readLoop(abortPromise) {\n    while (!this.abortReason) {\n      let msg = JSON.parse(await Promise.race([this.transport.receive(), abortPromise]));\n      if (this.abortReason) break;\n      if (msg instanceof Array) {\n        switch (msg[0]) {\n          case "push":\n            if (msg.length > 1) {\n              let payload = new Evaluator(this).evaluate(msg[1]);\n              let hook = new PayloadStubHook(payload);\n              hook.ignoreUnhandledRejections();\n              this.exports.push({ hook, refcount: 1 });\n              continue;\n            }\n            break;\n          case "pull": {\n            let exportId = msg[1];\n            if (typeof exportId == "number") {\n              this.ensureResolvingExport(exportId);\n              continue;\n            }\n            break;\n          }\n          case "resolve":\n          // ["resolve", ExportId, Expression]\n          case "reject": {\n            let importId = msg[1];\n            if (typeof importId == "number" && msg.length > 2) {\n              let imp = this.imports[importId];\n              if (imp) {\n                if (msg[0] == "resolve") {\n                  imp.resolve(new PayloadStubHook(new Evaluator(this).evaluate(msg[2])));\n                } else {\n                  let payload = new Evaluator(this).evaluate(msg[2]);\n                  payload.dispose();\n                  imp.resolve(new ErrorStubHook(payload.value));\n                }\n              } else {\n                if (msg[0] == "resolve") {\n                  new Evaluator(this).evaluate(msg[2]).dispose();\n                }\n              }\n              continue;\n            }\n            break;\n          }\n          case "release": {\n            let exportId = msg[1];\n            let refcount = msg[2];\n            if (typeof exportId == "number" && typeof refcount == "number") {\n              this.releaseExport(exportId, refcount);\n              continue;\n            }\n            break;\n          }\n          case "abort": {\n            let payload = new Evaluator(this).evaluate(msg[1]);\n            payload.dispose();\n            this.abort(payload, false);\n            break;\n          }\n        }\n      }\n      throw new Error(`bad RPC message: ${JSON.stringify(msg)}`);\n    }\n  }\n  async drain() {\n    if (this.abortReason) {\n      throw this.abortReason;\n    }\n    if (this.pullCount > 0) {\n      let { promise, resolve, reject } = Promise.withResolvers();\n      this.onBatchDone = { resolve, reject };\n      await promise;\n    }\n  }\n  getStats() {\n    let result = { imports: 0, exports: 0 };\n    for (let i in this.imports) {\n      ++result.imports;\n    }\n    for (let i in this.exports) {\n      ++result.exports;\n    }\n    return result;\n  }\n};\nvar RpcSession = class {\n  #session;\n  #mainStub;\n  constructor(transport, localMain, options = {}) {\n    let mainHook;\n    if (localMain) {\n      mainHook = new PayloadStubHook(RpcPayload.fromAppReturn(localMain));\n    } else {\n      mainHook = new ErrorStubHook(new Error("This connection has no main object."));\n    }\n    this.#session = new RpcSessionImpl(transport, mainHook, options);\n    this.#mainStub = new RpcStub(this.#session.getMainImport());\n  }\n  getRemoteMain() {\n    return this.#mainStub;\n  }\n  getStats() {\n    return this.#session.getStats();\n  }\n  drain() {\n    return this.#session.drain();\n  }\n};\nvar RpcSession2 = RpcSession;\n\n// src/stream-transport.ts\nfunction concatBuffers(a, b) {\n  const result = new Uint8Array(a.length + b.length);\n  result.set(a, 0);\n  result.set(b, a.length);\n  return result;\n}\nvar BufferedReader = class {\n  buffer;\n  reader;\n  constructor(input) {\n    this.buffer = new Uint8Array(0);\n    this.reader = input.getReader();\n  }\n  async read(numberOfBytes) {\n    if (numberOfBytes <= 0) {\n      throw new Error("numberOfBytes must be positive");\n    }\n    while (this.buffer.length < numberOfBytes) {\n      const result2 = await this.reader.read();\n      if (result2.done || result2.value == null) {\n        throw new Error("Stream closed");\n      }\n      this.buffer = concatBuffers(this.buffer, result2.value);\n    }\n    const result = this.buffer.slice(0, numberOfBytes);\n    this.buffer = this.buffer.slice(numberOfBytes);\n    return result;\n  }\n};\nvar StreamTransport = class {\n  constructor(input, output) {\n    this.input = input;\n    this.output = output;\n    this.bufferReader = new BufferedReader(input);\n    this.writer = output.getWriter();\n  }\n  bufferReader;\n  writer;\n  async send(message) {\n    const encoder = new TextEncoder();\n    const messageBytes = encoder.encode(message);\n    const length = messageBytes.length;\n    if (length > 4294967295) {\n      throw new Error("Message length exceeds maximum allowed size (4GB)");\n    }\n    const lengthBytes = new Uint8Array(4);\n    const view = new DataView(lengthBytes.buffer);\n    view.setUint32(0, length, true);\n    const combined = new Uint8Array(4 + length);\n    combined.set(lengthBytes, 0);\n    combined.set(messageBytes, 4);\n    await this.writer.write(combined);\n  }\n  async receive() {\n    const lengthBytes = await this.bufferReader.read(4);\n    const lengthBuffer = new Uint8Array(lengthBytes).buffer;\n    const length = new DataView(lengthBuffer).getUint32(0, true);\n    if (length > 100 * 1024 * 1024) {\n      throw new Error("Message length exceeds maximum allowed size");\n    }\n    if (length === 0) {\n      return "";\n    }\n    const messageBytes = await this.bufferReader.read(length);\n    const decoder = new TextDecoder();\n    return decoder.decode(messageBytes);\n  }\n  abort(reason) {\n    this.input.cancel(reason).catch(() => {\n    });\n    this.writer.close().catch(() => {\n    });\n  }\n};\n\n// src/code-mode-runtime.ts\nsetGlobalRpcSessionOptions(() => ({ recordReplayMode: "all" }));\nasync function run(context) {\n  const transport = new StreamTransport(context.input, context.output);\n  try {\n    const session = new RpcSession2(transport);\n    const api = session.getRemoteMain();\n    const code = await api.__code__();\n    const fn = new Function("api", `return (${code})(api)`);\n    const result = await fn(api);\n    await api.__return__(result);\n  } finally {\n    transport.abort("done");\n  }\n}\nasync function main() {\n  if (!__SANDBOX_CONTEXT_PROMISE__) {\n    throw new TypeError("__SANDBOX_CONTEXT_PROMISE__ was not replaced prior to execution.");\n  }\n  const ctx = await __SANDBOX_CONTEXT_PROMISE__;\n  const { input, output, onSuccess, onFailure } = ctx;\n  return run({ input, output }).then(() => {\n    onSuccess();\n  }).catch((err) => {\n    console.error("runtime error", err);\n    onFailure();\n  });\n}\nmain();\n';
 function concatBuffers(a, b) {
   const result = new Uint8Array(a.length + b.length);
   result.set(a, 0);
   result.set(b, a.length);
   return result;
 }
-var BufferedReader = class {
+class BufferedReader {
   buffer;
   reader;
   constructor(input) {
@@ -2703,8 +78,8 @@ var BufferedReader = class {
     this.buffer = this.buffer.slice(numberOfBytes);
     return result;
   }
-};
-var StreamTransport = class {
+}
+class StreamTransport {
   constructor(input, output) {
     this.input = input;
     this.output = output;
@@ -2748,160 +123,8 @@ var StreamTransport = class {
     this.writer.close().catch(() => {
     });
   }
-};
-
-// src/tool-wrapper.ts
-import { asSchema } from "ai";
-import camelCase from "camelcase";
-import { validate as validate2 } from "json-schema";
-import { compile as compileJsonSchemaToTs } from "json-schema-to-typescript";
-import invariant from "tiny-invariant";
-import { zodToJsonSchema } from "zod-to-json-schema";
-
-// src/rpc-toolset.ts
-import { inspect } from "node:util";
-var validate = (schema, value) => {
-  if ("~standard" in schema) {
-    const validation = schema["~standard"].validate(value);
-    if (validation instanceof Promise) {
-      throw new TypeError(`Validation must be synchronous`);
-    }
-    if (validation.issues) {
-      throw new Error(`Invalid value: ${validation.issues.map((e) => e.message).join(", ")}`);
-    }
-  } else {
-    if (!schema(value)) {
-      throw new Error(`Invalid value: ${inspect(value)} (expected ${schema.name || schema.toString()})`);
-    }
-  }
-};
-var toolMetadataKey = /* @__PURE__ */ Symbol("toolMetadata");
-var setToolMetadata = (target, metadata) => {
-  const meta = target;
-  meta[toolMetadataKey] = {
-    ...meta[toolMetadataKey],
-    ...metadata
-  };
-};
-function toolDef(inputSchema) {
-  return (target, context) => {
-    if (context.kind !== "method") {
-      throw new Error(`Tool decorator can only be used on methods`);
-    }
-    const methodName = String(context.name);
-    const replacementMethod = function(...args) {
-      const expectedArgs = inputSchema ? 1 : 0;
-      if (args.length > expectedArgs) {
-        throw new Error(`Tool ${methodName} got too many arguments: ${args.length} provided (expected ${expectedArgs})`);
-      }
-      if (inputSchema) {
-        const arg = args[0];
-        validate(inputSchema, arg);
-        return target.call(this, arg);
-      } else {
-        return target.call(this);
-      }
-    };
-    setToolMetadata(replacementMethod, { runtimeValidationEnabled: true });
-    return replacementMethod;
-  };
-}
-function toolUnsafeNoValidation() {
-  return (target, context) => {
-    if (context.kind !== "method") {
-      throw new Error(`Tool decorator can only be used on methods`);
-    }
-    setToolMetadata(target, { runtimeValidationEnabled: true });
-    return target;
-  };
-}
-var callbackMetadataKey = /* @__PURE__ */ Symbol("callbackMetadata");
-function callbackTool() {
-  return (target, context) => {
-    if (context.kind !== "method") {
-      throw new Error(`Tool decorator can only be used on methods`);
-    }
-    const methodName = String(context.name);
-    const replacementMethod = function(...args) {
-      if (args.length !== 1) {
-        throw new Error(`Tool ${methodName} got too many arguments: ${args.length} provided (expected 1)`);
-      }
-      const callback = args[0];
-      if (typeof callback !== "function") {
-        throw new TypeError(`Callback for tool ${methodName} must be a function`);
-      }
-      const callbackWrapped = (() => {
-        throw new Error(`Callback for tool ${methodName} must be wrapped with \`tool.unwrapCallback\``);
-      });
-      callbackWrapped[callbackMetadataKey] = {
-        callback
-      };
-      return target.call(this, callbackWrapped);
-    };
-    setToolMetadata(replacementMethod, { runtimeValidationEnabled: true });
-    return replacementMethod;
-  };
 }
-var unwrapCallback = (toolCallback, returnSchema) => (arg, then, opts) => {
-  const callback = callbackMetadataKey in toolCallback ? toolCallback[callbackMetadataKey].callback : toolCallback;
-  let isPromise = false;
-  try {
-    const result = callback(arg);
-    if (result instanceof Promise) {
-      isPromise = true;
-      let ret;
-      ret = result.then(async (r) => {
-        validate(returnSchema, r);
-        return then(r);
-      }, opts?.catch);
-      if (opts?.finally) {
-        ret = ret.finally(opts.finally);
-      }
-      return ret;
-    }
-    validate(returnSchema, result);
-    return then(result);
-  } catch (error) {
-    if (opts?.catch) {
-      return opts.catch(error);
-    }
-    throw error;
-  } finally {
-    if (!isPromise) {
-      opts?.finally?.();
-    }
-  }
-};
-var tool = toolDef;
-tool.callback = callbackTool;
-tool.unwrap = unwrapCallback;
-tool.unsafeNoValidation = toolUnsafeNoValidation;
-var RpcToolset = class _RpcToolset extends RpcTarget4 {
-  constructor() {
-    super();
-    let prototype = Object.getPrototypeOf(this);
-    while (prototype !== null && prototype !== _RpcToolset.prototype) {
-      for (const key of Object.getOwnPropertyNames(prototype)) {
-        if (key === "constructor") {
-          continue;
-        }
-        const descriptor = Object.getOwnPropertyDescriptor(prototype, key);
-        const fn = descriptor?.value ?? descriptor?.get;
-        if (!fn || typeof fn !== "function") {
-          throw new Error(`RpcToolset prototype must be methods or getters: ${key} is not`);
-        }
-        const meta = fn;
-        if (!meta[toolMetadataKey]?.runtimeValidationEnabled) {
-          throw new Error(`Prototype method \`${key}\` is not a tool. Did you forget to use the @tool decorator?`);
-        }
-      }
-      prototype = Object.getPrototypeOf(prototype);
-    }
-  }
-};
-
-// src/tool-wrapper.ts
-var extractTypeBody = (interfaceCode) => {
+const extractTypeBody = (interfaceCode) => {
   const match = interfaceCode.match(/interface \w+ \{([\s\S]*)\}/);
   if (!match) {
     return "object";
@@ -2916,7 +139,7 @@ var extractTypeBody = (interfaceCode) => {
   const formatted = lines.join("; ").replace(/;+/g, ";");
   return `{ ${formatted} }`;
 };
-var getJsonSchema = (schema) => {
+const getJsonSchema = (schema) => {
   if (schema != null && typeof schema === "object" && ("_def" in schema || "parse" in schema && "safeParse" in schema && "shape" in schema)) {
     try {
       return zodToJsonSchema(schema);
@@ -2929,21 +152,21 @@ var getJsonSchema = (schema) => {
 async function* generateToolTypes(tools, name) {
   yield `class ${name} {`;
   const toolEntries = Array.isArray(tools) ? tools.map(
-    (tool2, index) => [
-      tool2.title ?? `tool_${index}`,
-      tool2
+    (tool, index) => [
+      tool.title ?? `tool_${index}`,
+      tool
     ]
   ) : Object.entries(tools);
-  for (const [toolName, tool2] of toolEntries) {
-    if (typeof tool2 === "function") {
-      const toolset = tool2();
+  for (const [toolName, tool] of toolEntries) {
+    if (typeof tool === "function") {
+      const toolset = tool();
       yield `// \`RpcToolset\`: ${toolName} (see .d.ts below for methods)`;
       yield `  ${toolName}: () => RpcPromise<${toolset.constructor.name}>`;
       continue;
     }
-    const inputSchema = getJsonSchema(tool2.inputSchema);
-    const outputSchema = tool2.outputSchema ? getJsonSchema(tool2.outputSchema) : null;
-    const inputJsonType = await compileJsonSchemaToTs(
+    const inputSchema = getJsonSchema(tool.inputSchema);
+    const outputSchema = tool.outputSchema ? getJsonSchema(tool.outputSchema) : null;
+    const inputJsonType = await compile(
       inputSchema,
       `${camelCase(toolName, { pascalCase: true })}Input`,
       {
@@ -2951,7 +174,7 @@ async function* generateToolTypes(tools, name) {
         bannerComment: " "
       }
     );
-    const outputJsonType = outputSchema ? await compileJsonSchemaToTs(
+    const outputJsonType = outputSchema ? await compile(
       outputSchema,
       `${camelCase(toolName, { pascalCase: true })}Output`,
       {
@@ -2961,7 +184,7 @@ async function* generateToolTypes(tools, name) {
     ) : null;
     const inputTypeBody = extractTypeBody(inputJsonType);
     const outputTypeBody = outputJsonType ? extractTypeBody(outputJsonType) : "object";
-    const description = tool2.description?.trim() ?? "";
+    const description = tool.description?.trim() ?? "";
     const toolDoc = description ? `
   /**
    * ${description}
@@ -2973,8 +196,8 @@ async function* generateToolTypes(tools, name) {
 
 export default ${name};`;
 }
-var generateToolApi = (tools, opts) => {
-  class ToolApi extends RpcTarget4 {
+const generateToolApi = (tools, opts) => {
+  class ToolApi extends RpcTarget {
     __return_value__ = null;
     __raw_code__;
     constructor(code) {
@@ -2989,48 +212,36 @@ var generateToolApi = (tools, opts) => {
     }
   }
   const toolEntries = Array.isArray(tools) ? tools.map(
-    (tool2, index) => [
-      tool2.title ?? `tool_${index}`,
-      tool2
+    (tool, index) => [
+      tool.title ?? `tool_${index}`,
+      tool
     ]
   ) : Object.entries(tools);
-  for (const [toolName, tool2] of toolEntries) {
+  for (const [toolName, tool] of toolEntries) {
     ToolApi.prototype[toolName] = async function(...args) {
-      if (typeof tool2 === "function") {
-        const toolset = tool2();
+      if (typeof tool === "function") {
+        const toolset = tool();
         invariant(toolset instanceof RpcToolset, "Tool must return an instance of RpcToolset");
         return toolset;
       }
       if (args.length !== 1) {
         throw new Error(`Tool ${toolName} only accepts exactly one argument, but ${args.length} were provided`);
       }
-      const schema = asSchema(tool2.inputSchema);
+      const schema = asSchema(tool.inputSchema);
       const jsonSchema = await schema.jsonSchema;
-      const validation = validate2(args[0], jsonSchema);
+      const validation = validate(args[0], jsonSchema);
       if (!validation.valid) {
         throw new Error(`Invalid arguments for tool ${toolName}: ${validation.errors.map((e) => e.message || e.property).join(", ")}`);
       }
-      if (!tool2.execute) {
+      if (!tool.execute) {
         throw new Error(`Tool ${toolName} does not have an execute function`);
       }
-      return tool2.execute(args[0], opts);
+      return tool.execute(args[0], opts);
     };
   }
   return ToolApi;
 };
-
-// src/code-mode.ts
-var _BUNDLED_RUNTIME_CODE;
-function getBundledRuntimeCode() {
-  if (_BUNDLED_RUNTIME_CODE === void 0) {
-    _BUNDLED_RUNTIME_CODE = readFileSync(
-      fileURLToPath(new URL("../dist/code-mode-runtime.mjs", import.meta.url)),
-      "utf-8"
-    );
-  }
-  return _BUNDLED_RUNTIME_CODE;
-}
-var CodeMode = class {
+class CodeMode {
   constructor(context) {
     this.context = context;
   }
@@ -3041,8 +252,8 @@ var CodeMode = class {
     }
     const definitions = typeDefinitions.join("");
     return {
-      description: `Write code to use the following tools:.
-        
+      description: `Execute code using the following API. You MUST call this tool to run any code - never output code directly in your response.
+
         \`\`\`typescript
         ${definitions}
 
@@ -3053,12 +264,13 @@ var CodeMode = class {
         ${dts ? `// .d.ts for the \`RpcToolset\`s:
 ${dts}` : ""}
 
-        You must write the code in the following format:
-        \`\`\`typescript
-            
-        
-            (api: Tools) => Promise<Returnable> {
-                // Call the tools here
+        Provide a valid **javascript** (NOT TypeScript) function taking a single argument of type \`Tools\` and returning
+        a value of type \`Promise<Returnable>\`.
+
+        Example:
+        \`\`\`javascript
+            (api) => {
+                // Call the API here (only vanilla JS is allowed)
                 // The returned result will be passed back into context
             }
         \`\`\`
@@ -3067,531 +279,25 @@ ${dts}` : ""}
         code: z.string()
       }),
       execute: async ({ code }, opts) => {
-        const injectedCode = `globalThis.__SANDBOX_CONTEXT_PROMISE__ = ${this.context.sandboxContext};
-${getBundledRuntimeCode()}`;
-        const { input, output, wait } = await this.context.safeEval(injectedCode);
         const ToolApi = generateToolApi(tools, opts);
         const api = new ToolApi(code);
+        if (this.context.kind === "rpc") {
+          return await this.context.safeEval(code, api);
+        }
+        const injectedCode = `globalThis.__SANDBOX_CONTEXT_PROMISE__ = ${this.context.sandboxContext};
+${runtimeCode}`;
+        const { input, output, wait } = await this.context.safeEval(injectedCode);
         const transport = new StreamTransport(input, output);
-        const _session = new RpcSession2(transport, api);
+        new RpcSession(transport, api);
         await wait();
         return api.__return_value__;
       }
     };
   }
-};
-
-// src/sql/builder.ts
-import { Kysely } from "kysely";
-import invariant2 from "tiny-invariant";
-import z3 from "zod";
-
-// src/sql/expression.ts
-import z2 from "zod";
-
-// src/sql/sql.ts
-import { sql as kyselySql } from "kysely";
-var sql = kyselySql;
-var buildSql = (parts, separator = kyselySql` `) => {
-  return kyselySql.join(parts.filter((x) => x != null), separator);
-};
-
-// src/sql/expression.ts
-var asSqlExpression = (value) => {
-  return value instanceof SqlExpression ? value : new LiteralExpression(value);
-};
-var isSqlExpressionIn = (value) => {
-  return typeof value === "number" || typeof value === "string" || typeof value === "boolean" || value === null || value === void 0 || value instanceof SqlExpression;
-};
-var zSqlExpression = z2.custom((val) => val instanceof SqlExpression);
-var zNumericSqlExpression = z2.union([zSqlExpression, z2.number(), z2.string()]);
-var zSqlExpressionIn = z2.union([zSqlExpression, z2.number(), z2.string(), z2.boolean(), z2.null()]);
-var _desc_dec, _asc_dec, ___dec, ___dec2, ___dec3, ___dec4, ___dec5, _NOT_LIKE_dec, _LIKE_dec, ____dec, ____dec2, ___dec6, ____dec3, ___dec7, ____dec4, ___dec8, _isNotNull_dec, _isNull_dec, _not_dec, _and_dec, _or_dec, _a, _init;
-var SqlExpression = class extends (_a = RpcToolset, _or_dec = [tool(zSqlExpression)], _and_dec = [tool(zSqlExpression)], _not_dec = [tool()], _isNull_dec = [tool()], _isNotNull_dec = [tool()], ___dec8 = [tool(zNumericSqlExpression)], ____dec4 = [tool(zNumericSqlExpression)], ___dec7 = [tool(zNumericSqlExpression)], ____dec3 = [tool(zNumericSqlExpression)], ___dec6 = [tool(zSqlExpressionIn)], ____dec2 = [tool(zSqlExpressionIn)], ____dec = [tool(zSqlExpressionIn)], _LIKE_dec = [tool(z2.union([zSqlExpression, z2.string()]))], _NOT_LIKE_dec = [tool(z2.union([zSqlExpression, z2.string()]))], ___dec5 = [tool(zNumericSqlExpression)], ___dec4 = [tool(zNumericSqlExpression)], ___dec3 = [tool(zNumericSqlExpression)], ___dec2 = [tool(zNumericSqlExpression)], ___dec = [tool(zNumericSqlExpression)], _asc_dec = [tool()], _desc_dec = [tool()], _a) {
-  constructor(precedence = 100) {
-    super();
-    this.precedence = precedence;
-    __runInitializers(_init, 5, this);
-    // `= () => ` to ensure the method is a direct property of the class instance,
-    // not a method of the class prototype
-    __publicField(this, "compile", () => {
-      throw new Error("Not implemented");
-    });
-  }
-  or(expr) {
-    return new BinaryExpression(this, expr, sql`OR`, 1);
-  }
-  and(expr) {
-    return new BinaryExpression(this, expr, sql`AND`, 2);
-  }
-  not() {
-    return new UnaryExpression(this, sql`NOT`, "prefix", 3);
-  }
-  isNull() {
-    return new UnaryExpression(this, sql`IS NULL`, "postfix", 4);
-  }
-  isNotNull() {
-    return new UnaryExpression(this, sql`IS NOT NULL`, "postfix", 4);
-  }
-  "<"(expr) {
-    return new BinaryExpression(this, asSqlExpression(expr), sql`<`, 5);
-  }
-  "<="(expr) {
-    return new BinaryExpression(this, asSqlExpression(expr), sql`<=`, 5);
-  }
-  ">"(expr) {
-    return new BinaryExpression(this, asSqlExpression(expr), sql`>`, 5);
-  }
-  ">="(expr) {
-    return new BinaryExpression(this, asSqlExpression(expr), sql`>=`, 5);
-  }
-  "="(expr) {
-    return new BinaryExpression(this, asSqlExpression(expr), sql`=`, 5);
-  }
-  "<>"(expr) {
-    return new BinaryExpression(this, asSqlExpression(expr), sql`<>`, 5);
-  }
-  "!="(expr) {
-    return new BinaryExpression(this, asSqlExpression(expr), sql`!=`, 5);
-  }
-  "LIKE"(expr) {
-    return new BinaryExpression(this, asSqlExpression(expr), sql`LIKE`, 6);
-  }
-  "NOT LIKE"(expr) {
-    return new BinaryExpression(this, asSqlExpression(expr), sql`NOT LIKE`, 6);
-  }
-  "+"(expr) {
-    return new BinaryExpression(this, asSqlExpression(expr), sql`+`, 8);
-  }
-  "-"(expr) {
-    return new BinaryExpression(this, asSqlExpression(expr), sql`-`, 8);
-  }
-  "*"(expr) {
-    return new BinaryExpression(this, asSqlExpression(expr), sql`*`, 9);
-  }
-  "/"(expr) {
-    return new BinaryExpression(this, asSqlExpression(expr), sql`/`, 9);
-  }
-  "%"(expr) {
-    return new BinaryExpression(this, asSqlExpression(expr), sql`%`, 9);
-  }
-  asc() {
-    return new OrderByValue(this, sql`ASC`);
-  }
-  desc() {
-    return new OrderByValue(this, sql`DESC`);
-  }
-};
-_init = __decoratorStart(_a);
-__decorateElement(_init, 1, "or", _or_dec, SqlExpression);
-__decorateElement(_init, 1, "and", _and_dec, SqlExpression);
-__decorateElement(_init, 1, "not", _not_dec, SqlExpression);
-__decorateElement(_init, 1, "isNull", _isNull_dec, SqlExpression);
-__decorateElement(_init, 1, "isNotNull", _isNotNull_dec, SqlExpression);
-__decorateElement(_init, 1, "<", ___dec8, SqlExpression);
-__decorateElement(_init, 1, "<=", ____dec4, SqlExpression);
-__decorateElement(_init, 1, ">", ___dec7, SqlExpression);
-__decorateElement(_init, 1, ">=", ____dec3, SqlExpression);
-__decorateElement(_init, 1, "=", ___dec6, SqlExpression);
-__decorateElement(_init, 1, "<>", ____dec2, SqlExpression);
-__decorateElement(_init, 1, "!=", ____dec, SqlExpression);
-__decorateElement(_init, 1, "LIKE", _LIKE_dec, SqlExpression);
-__decorateElement(_init, 1, "NOT LIKE", _NOT_LIKE_dec, SqlExpression);
-__decorateElement(_init, 1, "+", ___dec5, SqlExpression);
-__decorateElement(_init, 1, "-", ___dec4, SqlExpression);
-__decorateElement(_init, 1, "*", ___dec3, SqlExpression);
-__decorateElement(_init, 1, "/", ___dec2, SqlExpression);
-__decorateElement(_init, 1, "%", ___dec, SqlExpression);
-__decorateElement(_init, 1, "asc", _asc_dec, SqlExpression);
-__decorateElement(_init, 1, "desc", _desc_dec, SqlExpression);
-__decoratorMetadata(_init, SqlExpression);
-var BinaryExpression = class extends SqlExpression {
-  constructor(left, right, operator, precedence) {
-    super(precedence ?? 100);
-    this.left = left;
-    this.right = right;
-    this.operator = operator;
-  }
-  // `= () => ` to ensure the method is a direct property of the class instance,
-  // not a method of the class prototype
-  compile = () => {
-    const leftCompiled = this.left.compile();
-    const rightCompiled = this.right.compile();
-    return buildSql([
-      this.precedence > this.left.precedence ? sql`(${leftCompiled})` : leftCompiled,
-      this.operator,
-      this.precedence > this.right.precedence ? sql`(${rightCompiled})` : rightCompiled
-    ]);
-  };
-};
-var UnaryExpression = class extends SqlExpression {
-  constructor(operand, operator, placement, precedence) {
-    super(precedence ?? 100);
-    this.operand = operand;
-    this.operator = operator;
-    this.placement = placement;
-  }
-  // `= () => ` to ensure the method is a direct property of the class instance,
-  // not a method of the class prototype
-  compile = () => {
-    const operandCompiled = this.operand.compile();
-    const wrappedOperand = this.precedence > this.operand.precedence ? sql`(${operandCompiled})` : operandCompiled;
-    return this.placement === "postfix" ? buildSql([wrappedOperand, this.operator]) : buildSql([this.operator, wrappedOperand]);
-  };
-};
-var ColumnReferenceExpression = class extends SqlExpression {
-  constructor(alias, column) {
-    super();
-    this.alias = alias;
-    this.column = column;
-  }
-  // `= () => ` to ensure the method is a direct property of the class instance,
-  // not a method of the class prototype
-  compile = () => {
-    return sql.ref(`${this.alias}.${this.column}`);
-  };
-};
-var UnboundColumnReferenceExpression = class extends ColumnReferenceExpression {
-  constructor(alias, column) {
-    super(alias, column);
-    this.alias = alias;
-    this.column = column;
-  }
-  // `= () => ` to ensure the method is a direct property of the class instance,
-  // not a method of the class prototype
-  compile = () => {
-    throw new Error("Unbound column reference cannot be compiled");
-  };
-};
-var LiteralExpression = class extends SqlExpression {
-  constructor(value) {
-    super();
-    this.value = value;
-  }
-  // `= () => ` to ensure the method is a direct property of the class instance,
-  // not a method of the class prototype
-  compile = () => {
-    return sql`${this.value}`;
-  };
-};
-var OrderByValue = class {
-  constructor(value, direction) {
-    this.value = value;
-    this.direction = direction;
-  }
-};
-
-// src/sql/builder.ts
-var safeAliasRegex = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-var isSafeAlias = (value) => {
-  return safeAliasRegex.test(value) && !(value === "constructor" || value === "prototype" || value === "__proto__") && !(value in Object.prototype) && value !== "toJSON";
-};
-var assertSafeAlias = (value) => {
-  if (!isSafeAlias(value)) {
-    throw new Error(`Alias must be a safe alias: "${value}" does not match the regex ${safeAliasRegex.source}`);
-  }
-};
-var asRowLike = (value) => {
-  if (value instanceof TableBase) {
-    return value;
-  }
-  return Object.fromEntries(Object.entries(value).map(([key, value2]) => [key, asSqlExpression(value2)]));
-};
-var isRowLikeRawIn = (value) => {
-  return typeof value === "object" && value !== null && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null) && Object.entries(value).every(([key, value2]) => {
-    assertSafeAlias(key);
-    return typeof key === "string" && isSqlExpressionIn(value2);
-  });
-};
-var isRowLikeIn = (value) => {
-  return isRowLikeRawIn(value) || value instanceof TableBase;
-};
-var rowLikeRawEntries = (value) => {
-  const entries = [];
-  const myKeys = Object.keys(value);
-  const protoKeys = [];
-  if (value instanceof TableBase) {
-    let proto = Object.getPrototypeOf(value);
-    while (proto != null && proto !== TableBase.prototype) {
-      protoKeys.push(...Object.keys(proto));
-      proto = Object.getPrototypeOf(proto);
-    }
-  }
-  for (const key of /* @__PURE__ */ new Set([...myKeys, ...protoKeys])) {
-    const v = value[key];
-    if (v instanceof SqlExpression) {
-      entries.push([key, v]);
-    }
-  }
-  return entries;
-};
-var isTableClass = (value) => {
-  return typeof value === "function" && value.prototype instanceof TableBase;
-};
-var isFromItem = (value) => {
-  return value instanceof QueryBuilder || isTableClass(value);
-};
-var combinePredicates = (...predicates) => {
-  const filtered = predicates.filter((p) => p != null);
-  if (filtered.length === 0) {
-    return void 0;
-  }
-  return filtered.reduce((acc, predicate) => acc.and(predicate));
-};
-var namespacedArg = (tables) => {
-  return Object.fromEntries(Object.entries(tables).map(([k, v]) => [k, v.fromItem.toRowLike()]));
-};
-var _execute_dec, _join_dec, _offset_dec, _limit_dec, _orderBy_dec, _where_dec, _select_dec, _a2, _db, _limit, _offset, _init2;
-var _QueryBuilder = class _QueryBuilder extends (_a2 = RpcToolset, _select_dec = [tool.callback()], _where_dec = [tool.callback()], _orderBy_dec = [tool.callback()], _limit_dec = [tool(z3.number().int().nonnegative())], _offset_dec = [tool(z3.number().int().nonnegative())], _join_dec = [tool.unsafeNoValidation()], _execute_dec = [tool()], _a2) {
-  // set only when created directly from a TableClass
-  constructor(params) {
-    super();
-    __runInitializers(_init2, 5, this);
-    __privateAdd(this, _db);
-    __publicField(this, "alias");
-    __publicField(this, "selectRowLike");
-    __publicField(this, "tables");
-    __publicField(this, "whereExpression");
-    __publicField(this, "orderByExpressions");
-    __privateAdd(this, _limit);
-    __privateAdd(this, _offset);
-    __publicField(this, "arg");
-    __publicField(this, "rawTable");
-    // Note, we use `= () => ` to ensure the method is a direct property of the class instance,
-    // not a method of the class prototype
-    __publicField(this, "paramsForCopy", () => {
-      return {
-        alias: this.alias,
-        tables: this.tables,
-        selectRowLike: this.selectRowLike,
-        whereExpression: this.whereExpression,
-        orderByExpressions: this.orderByExpressions,
-        limit: __privateGet(this, _limit),
-        offset: __privateGet(this, _offset),
-        db: __privateGet(this, _db),
-        // `rawTable` is set only when created directly from a TableClass
-        rawTable: void 0
-      };
-    });
-    __publicField(this, "toRowLike", () => {
-      if (this.selectRowLike instanceof TableBase) {
-        const tableClass = this.selectRowLike.constructor;
-        return tableClass.as(this.alias).toRowLike({ remapColumns: true });
-      }
-      return Object.fromEntries(Object.keys(this.selectRowLike).map((key) => [key, new ColumnReferenceExpression(this.alias, key)]));
-    });
-    __publicField(this, "compile", (opts) => {
-      const { tables, selectRowLike, whereExpression, orderByExpressions } = this;
-      const tablesList = Object.entries(tables);
-      const [[_, baseTable], ...rest] = tablesList.filter(([alias, table2]) => {
-        invariant2(table2.fromItem.alias === alias, `Alias mismatch: ${table2.fromItem.alias} !== ${alias}`);
-        return table2.joinType === null;
-      });
-      const joins = tablesList.filter(([, table2]) => table2.joinType !== null);
-      invariant2(baseTable, "Base table not found");
-      invariant2(rest.length === 0, "Implicit joins not supported");
-      invariant2(Object.keys(selectRowLike).length > 0, "select must return a non-empty row");
-      const combinedWhere = combinePredicates(whereExpression, baseTable.fromItem.onExpression);
-      const result = buildSql([
-        sql`SELECT ${buildSql(rowLikeRawEntries(selectRowLike).map(([key, value]) => sql`${value.compile()} as ${sql.ref(key)}`), sql`, `)}`,
-        sql`FROM ${baseTable.fromItem.compile({ isSubquery: true })}`,
-        ...joins.map(([, table2]) => buildSql([table2.joinType === "inner" ? sql`JOIN` : table2.joinType === "left" ? sql`LEFT JOIN` : null, table2.isLateral ? sql`LATERAL` : null, table2.fromItem.compile({ isSubquery: true }), table2.on ? sql`ON ${table2.on.compile()}` : null]), sql` `),
-        combinedWhere ? sql`WHERE ${combinedWhere.compile()}` : null,
-        orderByExpressions && orderByExpressions.length > 0 ? sql`ORDER BY ${buildSql(orderByExpressions.map((expr) => buildSql([expr.value.compile(), expr.direction])), sql`, `)}` : null,
-        __privateGet(this, _limit) != null ? sql`LIMIT ${__privateGet(this, _limit)}` : null,
-        __privateGet(this, _offset) != null ? sql`OFFSET ${__privateGet(this, _offset)}` : null
-      ]);
-      return opts?.isSubquery ? sql`(${result}) AS ${sql.ref(this.alias)}` : result;
-    });
-    __privateSet(this, _db, params.db);
-    this.alias = params.alias;
-    this.selectRowLike = params.selectRowLike;
-    this.tables = params.tables;
-    this.whereExpression = params.whereExpression;
-    this.orderByExpressions = params.orderByExpressions;
-    this.arg = namespacedArg(params.tables);
-    __privateSet(this, _limit, params.limit);
-    __privateSet(this, _offset, params.offset);
-    this.rawTable = params.rawTable;
-  }
-  select(select) {
-    const selectUnwrapped = tool.unwrap(select, isRowLikeIn);
-    return selectUnwrapped(this.arg, (result) => {
-      return new _QueryBuilder({ ...this.paramsForCopy(), selectRowLike: asRowLike(result) });
-    });
-  }
-  where(where) {
-    const whereUnwrapped = tool.unwrap(where, isSqlExpressionIn);
-    return whereUnwrapped(this.arg, (result) => {
-      return new _QueryBuilder({ ...this.paramsForCopy(), whereExpression: combinePredicates(this.whereExpression, asSqlExpression(result)) });
-    });
-  }
-  orderBy(orderBy) {
-    const orderByUnwrapped = tool.unwrap(orderBy, (arg) => {
-      if (Array.isArray(arg)) {
-        return arg.every((e) => e instanceof SqlExpression || e instanceof OrderByValue);
-      }
-      return arg instanceof SqlExpression || arg instanceof OrderByValue;
-    });
-    return orderByUnwrapped(this.arg, (raw) => {
-      const rawArray = Array.isArray(raw) ? raw : [raw];
-      const exprs = rawArray.map((e) => {
-        invariant2(e instanceof SqlExpression || e instanceof OrderByValue, "orderBy must return a SqlExpression/OrderByValue or an array of SqlExpressions/OrderByValues");
-        return e instanceof SqlExpression ? new OrderByValue(e) : e;
-      });
-      return new _QueryBuilder({ ...this.paramsForCopy(), orderByExpressions: (this.orderByExpressions ?? []).concat(exprs) });
-    });
-  }
-  limit(limit) {
-    invariant2(typeof limit === "number" && limit >= 0, "limit must be greater than or equal to 0");
-    return new _QueryBuilder({ ...this.paramsForCopy(), limit: Math.min(limit, __privateGet(this, _limit) ?? Infinity) });
-  }
-  offset(offset) {
-    invariant2(typeof offset === "number" && offset >= 0, "offset must be greater than or equal to 0");
-    return new _QueryBuilder({ ...this.paramsForCopy(), offset: (__privateGet(this, _offset) ?? 0) + offset });
-  }
-  join(fromItem, on) {
-    const fromItemCallbackRaw = isFromItem(fromItem) ? () => fromItem : fromItem;
-    const fromItemCallback = tool.unwrap(fromItemCallbackRaw, isFromItem);
-    const res = fromItemCallback(this.arg, (fromItemResolved) => {
-      if (fromItemResolved instanceof _QueryBuilder && fromItemResolved.rawTable) {
-        fromItemResolved = fromItemResolved.rawTable;
-      }
-      const alias = fromItemResolved.alias;
-      if (this.tables[alias]) {
-        throw new Error(`Join already exists: ${alias} in ${Object.keys(this.tables)}`);
-      }
-      const arg = {
-        ...this.arg,
-        [alias]: fromItemResolved.toRowLike()
-      };
-      const onCallback = tool.unwrap(on ?? (() => void 0), (raw) => raw === void 0 || isSqlExpressionIn(raw));
-      return onCallback(arg, (onRaw) => {
-        const onResolved = combinePredicates(onRaw !== void 0 ? asSqlExpression(onRaw) : void 0, fromItemResolved.onExpression);
-        invariant2(onResolved != null, "Must specify an `on` expression or use `Table.on` to set the on expression");
-        invariant2(onResolved instanceof SqlExpression, "on must return a SqlExpression");
-        const tablesWithAlias = {
-          ...this.tables,
-          [alias]: {
-            fromItem: fromItemResolved,
-            on: onResolved,
-            joinType: "inner",
-            // If `fromItem` is a function that returns a QueryBuilder, it is implicitly a lateral join (depends on the other tables)
-            isLateral: !isFromItem(fromItem) && fromItemResolved instanceof _QueryBuilder
-          }
-        };
-        return new _QueryBuilder({ ...this.paramsForCopy(), tables: tablesWithAlias });
-      });
-    });
-    return res;
-  }
-  async execute() {
-    return await __privateGet(this, _db).execute(this.compile());
-  }
-};
-_init2 = __decoratorStart(_a2);
-_db = new WeakMap();
-_limit = new WeakMap();
-_offset = new WeakMap();
-__decorateElement(_init2, 1, "select", _select_dec, _QueryBuilder);
-__decorateElement(_init2, 1, "where", _where_dec, _QueryBuilder);
-__decorateElement(_init2, 1, "orderBy", _orderBy_dec, _QueryBuilder);
-__decorateElement(_init2, 1, "limit", _limit_dec, _QueryBuilder);
-__decorateElement(_init2, 1, "offset", _offset_dec, _QueryBuilder);
-__decorateElement(_init2, 1, "join", _join_dec, _QueryBuilder);
-__decorateElement(_init2, 1, "execute", _execute_dec, _QueryBuilder);
-__decoratorMetadata(_init2, _QueryBuilder);
-var QueryBuilder = _QueryBuilder;
-var TableBase = class extends RpcToolset {
-  opts;
-  // `= () => ` to ensure the method is a direct property of the class instance,
-  // not a method of the class prototype
-  column = function(columnName) {
-    const cls = this.constructor;
-    return new UnboundColumnReferenceExpression(cls.alias ?? cls.tableName, columnName);
-  };
-};
-var table = (db, name) => {
-  const { [name]: tableClass } = { [name]: class extends TableBase {
-    static tableName = name;
-    static alias = name;
-    static onExpression;
-    constructor(opts) {
-      super();
-      this.opts = opts;
-    }
-    static from() {
-      const tables = { [this.alias]: { fromItem: this, joinType: null, isLateral: false } };
-      return new QueryBuilder({ db, alias: this.alias, tables, selectRowLike: this.toRowLike(), rawTable: this });
-    }
-    static as(alias) {
-      assertSafeAlias(alias);
-      class Ret extends this {
-        static alias = alias;
-      }
-      return Ret;
-    }
-    static on(on) {
-      const Base = this;
-      return class extends Base {
-        static onExpression = combinePredicates(Base.onExpression, on(Base.toRowLike()));
-      };
-    }
-    // use `function` to bind `this` to the current class instance
-    static toRowLike = function(opts) {
-      const rowLike = new this(opts);
-      for (const key of Object.keys(rowLike)) {
-        const value = rowLike[key];
-        if (value instanceof UnboundColumnReferenceExpression) {
-          const proto = Object.getPrototypeOf(rowLike);
-          const getter = function() {
-            const cls = this.constructor;
-            return new ColumnReferenceExpression(cls.alias ?? cls.tableName, this.opts?.remapColumns ? key : value.column);
-          };
-          setToolMetadata(getter, { runtimeValidationEnabled: true });
-          Object.defineProperty(proto, key, {
-            get: getter,
-            enumerable: true,
-            configurable: true
-          });
-          delete rowLike[key];
-        }
-      }
-      return rowLike;
-    };
-    static compile = function() {
-      return sql`${sql.ref(this.tableName)} AS ${sql.ref(this.alias ?? this.tableName)}`;
-    };
-  } };
-  tableClass;
-  return tableClass;
-};
-var Database = class {
-  constructor(dialect, opts) {
-    this.dialect = dialect;
-    this.opts = opts;
-  }
-  kysely;
-  async execute(query) {
-    if (this.kysely == null) {
-      this.kysely = new Kysely({ dialect: this.dialect });
-    }
-    if (this.opts?.logQuery) {
-      this.opts.logQuery(query.compile(this.kysely));
-    }
-    const result = await query.execute(this.kysely);
-    return result.rows;
-  }
-  Table(name) {
-    return table(this, name);
-  }
-};
+}
 export {
   CodeMode,
-  Database,
   RpcToolset,
   createDenoSandbox,
-  newWebSocketRpcSession2 as newWebSocketRpcSession,
-  newWorkersRpcResponse,
-  tool
+  t as tool
 };