@rivetkit/engine-api-full 2.0.4-rc.1

package/dist/browser/cjs/index.js

@@ -0,0 +1,4241 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/fetcher/stream-wrappers/Node18UniversalStreamWrapper.ts
+var Node18UniversalStreamWrapper_exports = {};
+__export(Node18UniversalStreamWrapper_exports, {
+  Node18UniversalStreamWrapper: () => Node18UniversalStreamWrapper
+});
+var Node18UniversalStreamWrapper;
+var init_Node18UniversalStreamWrapper = __esm({
+  "src/core/fetcher/stream-wrappers/Node18UniversalStreamWrapper.ts"() {
+    "use strict";
+    Node18UniversalStreamWrapper = class _Node18UniversalStreamWrapper {
+      readableStream;
+      reader;
+      events;
+      paused;
+      resumeCallback;
+      encoding;
+      constructor(readableStream) {
+        this.readableStream = readableStream;
+        this.reader = this.readableStream.getReader();
+        this.events = {
+          data: [],
+          end: [],
+          error: [],
+          readable: [],
+          close: [],
+          pause: [],
+          resume: []
+        };
+        this.paused = false;
+        this.resumeCallback = null;
+        this.encoding = null;
+      }
+      on(event, callback) {
+        this.events[event]?.push(callback);
+      }
+      off(event, callback) {
+        this.events[event] = this.events[event]?.filter((cb) => cb !== callback);
+      }
+      pipe(dest) {
+        this.on("data", async (chunk) => {
+          if (dest instanceof _Node18UniversalStreamWrapper) {
+            dest._write(chunk);
+          } else if (dest instanceof WritableStream) {
+            const writer = dest.getWriter();
+            writer.write(chunk).then(() => writer.releaseLock());
+          } else {
+            dest.write(chunk);
+          }
+        });
+        this.on("end", async () => {
+          if (dest instanceof _Node18UniversalStreamWrapper) {
+            dest._end();
+          } else if (dest instanceof WritableStream) {
+            const writer = dest.getWriter();
+            writer.close();
+          } else {
+            dest.end();
+          }
+        });
+        this.on("error", async (error) => {
+          if (dest instanceof _Node18UniversalStreamWrapper) {
+            dest._error(error);
+          } else if (dest instanceof WritableStream) {
+            const writer = dest.getWriter();
+            writer.abort(error);
+          } else {
+            dest.destroy(error);
+          }
+        });
+        this._startReading();
+        return dest;
+      }
+      pipeTo(dest) {
+        return this.pipe(dest);
+      }
+      unpipe(dest) {
+        this.off("data", async (chunk) => {
+          if (dest instanceof _Node18UniversalStreamWrapper) {
+            dest._write(chunk);
+          } else if (dest instanceof WritableStream) {
+            const writer = dest.getWriter();
+            writer.write(chunk).then(() => writer.releaseLock());
+          } else {
+            dest.write(chunk);
+          }
+        });
+        this.off("end", async () => {
+          if (dest instanceof _Node18UniversalStreamWrapper) {
+            dest._end();
+          } else if (dest instanceof WritableStream) {
+            const writer = dest.getWriter();
+            writer.close();
+          } else {
+            dest.end();
+          }
+        });
+        this.off("error", async (error) => {
+          if (dest instanceof _Node18UniversalStreamWrapper) {
+            dest._error(error);
+          } else if (dest instanceof WritableStream) {
+            const writer = dest.getWriter();
+            writer.abort(error);
+          } else {
+            dest.destroy(error);
+          }
+        });
+      }
+      destroy(error) {
+        this.reader.cancel(error).then(() => {
+          this._emit("close");
+        }).catch((err) => {
+          this._emit("error", err);
+        });
+      }
+      pause() {
+        this.paused = true;
+        this._emit("pause");
+      }
+      resume() {
+        if (this.paused) {
+          this.paused = false;
+          this._emit("resume");
+          if (this.resumeCallback) {
+            this.resumeCallback();
+            this.resumeCallback = null;
+          }
+        }
+      }
+      get isPaused() {
+        return this.paused;
+      }
+      async read() {
+        if (this.paused) {
+          await new Promise((resolve) => {
+            this.resumeCallback = resolve;
+          });
+        }
+        const { done, value } = await this.reader.read();
+        if (done) {
+          return void 0;
+        }
+        return value;
+      }
+      setEncoding(encoding) {
+        this.encoding = encoding;
+      }
+      async text() {
+        const chunks = [];
+        while (true) {
+          const { done, value } = await this.reader.read();
+          if (done) {
+            break;
+          }
+          if (value) {
+            chunks.push(value);
+          }
+        }
+        const decoder = new TextDecoder(this.encoding || "utf-8");
+        return decoder.decode(await new Blob(chunks).arrayBuffer());
+      }
+      async json() {
+        const text = await this.text();
+        return JSON.parse(text);
+      }
+      _write(chunk) {
+        this._emit("data", chunk);
+      }
+      _end() {
+        this._emit("end");
+      }
+      _error(error) {
+        this._emit("error", error);
+      }
+      _emit(event, data) {
+        if (this.events[event]) {
+          for (const callback of this.events[event] || []) {
+            callback(data);
+          }
+        }
+      }
+      async _startReading() {
+        try {
+          this._emit("readable");
+          while (true) {
+            if (this.paused) {
+              await new Promise((resolve) => {
+                this.resumeCallback = resolve;
+              });
+            }
+            const { done, value } = await this.reader.read();
+            if (done) {
+              this._emit("end");
+              this._emit("close");
+              break;
+            }
+            if (value) {
+              this._emit("data", value);
+            }
+          }
+        } catch (error) {
+          this._emit("error", error);
+        }
+      }
+      [Symbol.asyncIterator]() {
+        return {
+          next: async () => {
+            if (this.paused) {
+              await new Promise((resolve) => {
+                this.resumeCallback = resolve;
+              });
+            }
+            const { done, value } = await this.reader.read();
+            if (done) {
+              return { done: true, value: void 0 };
+            }
+            return { done: false, value };
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/core/fetcher/stream-wrappers/UndiciStreamWrapper.ts
+var UndiciStreamWrapper_exports = {};
+__export(UndiciStreamWrapper_exports, {
+  UndiciStreamWrapper: () => UndiciStreamWrapper
+});
+var UndiciStreamWrapper;
+var init_UndiciStreamWrapper = __esm({
+  "src/core/fetcher/stream-wrappers/UndiciStreamWrapper.ts"() {
+    "use strict";
+    UndiciStreamWrapper = class _UndiciStreamWrapper {
+      readableStream;
+      reader;
+      events;
+      paused;
+      resumeCallback;
+      encoding;
+      constructor(readableStream) {
+        this.readableStream = readableStream;
+        this.reader = this.readableStream.getReader();
+        this.events = {
+          data: [],
+          end: [],
+          error: [],
+          readable: [],
+          close: [],
+          pause: [],
+          resume: []
+        };
+        this.paused = false;
+        this.resumeCallback = null;
+        this.encoding = null;
+      }
+      on(event, callback) {
+        this.events[event]?.push(callback);
+      }
+      off(event, callback) {
+        this.events[event] = this.events[event]?.filter((cb) => cb !== callback);
+      }
+      pipe(dest) {
+        this.on("data", (chunk) => {
+          if (dest instanceof _UndiciStreamWrapper) {
+            dest._write(chunk);
+          } else {
+            const writer = dest.getWriter();
+            writer.write(chunk).then(() => writer.releaseLock());
+          }
+        });
+        this.on("end", () => {
+          if (dest instanceof _UndiciStreamWrapper) {
+            dest._end();
+          } else {
+            const writer = dest.getWriter();
+            writer.close();
+          }
+        });
+        this.on("error", (error) => {
+          if (dest instanceof _UndiciStreamWrapper) {
+            dest._error(error);
+          } else {
+            const writer = dest.getWriter();
+            writer.abort(error);
+          }
+        });
+        this._startReading();
+        return dest;
+      }
+      pipeTo(dest) {
+        return this.pipe(dest);
+      }
+      unpipe(dest) {
+        this.off("data", (chunk) => {
+          if (dest instanceof _UndiciStreamWrapper) {
+            dest._write(chunk);
+          } else {
+            const writer = dest.getWriter();
+            writer.write(chunk).then(() => writer.releaseLock());
+          }
+        });
+        this.off("end", () => {
+          if (dest instanceof _UndiciStreamWrapper) {
+            dest._end();
+          } else {
+            const writer = dest.getWriter();
+            writer.close();
+          }
+        });
+        this.off("error", (error) => {
+          if (dest instanceof _UndiciStreamWrapper) {
+            dest._error(error);
+          } else {
+            const writer = dest.getWriter();
+            writer.abort(error);
+          }
+        });
+      }
+      destroy(error) {
+        this.reader.cancel(error).then(() => {
+          this._emit("close");
+        }).catch((err) => {
+          this._emit("error", err);
+        });
+      }
+      pause() {
+        this.paused = true;
+        this._emit("pause");
+      }
+      resume() {
+        if (this.paused) {
+          this.paused = false;
+          this._emit("resume");
+          if (this.resumeCallback) {
+            this.resumeCallback();
+            this.resumeCallback = null;
+          }
+        }
+      }
+      get isPaused() {
+        return this.paused;
+      }
+      async read() {
+        if (this.paused) {
+          await new Promise((resolve) => {
+            this.resumeCallback = resolve;
+          });
+        }
+        const { done, value } = await this.reader.read();
+        if (done) {
+          return void 0;
+        }
+        return value;
+      }
+      setEncoding(encoding) {
+        this.encoding = encoding;
+      }
+      async text() {
+        const chunks = [];
+        while (true) {
+          const { done, value } = await this.reader.read();
+          if (done) {
+            break;
+          }
+          if (value) {
+            chunks.push(value);
+          }
+        }
+        const decoder = new TextDecoder(this.encoding || "utf-8");
+        return decoder.decode(await new Blob(chunks).arrayBuffer());
+      }
+      async json() {
+        const text = await this.text();
+        return JSON.parse(text);
+      }
+      _write(chunk) {
+        this._emit("data", chunk);
+      }
+      _end() {
+        this._emit("end");
+      }
+      _error(error) {
+        this._emit("error", error);
+      }
+      _emit(event, data) {
+        if (this.events[event]) {
+          for (const callback of this.events[event] || []) {
+            callback(data);
+          }
+        }
+      }
+      async _startReading() {
+        try {
+          this._emit("readable");
+          while (true) {
+            if (this.paused) {
+              await new Promise((resolve) => {
+                this.resumeCallback = resolve;
+              });
+            }
+            const { done, value } = await this.reader.read();
+            if (done) {
+              this._emit("end");
+              this._emit("close");
+              break;
+            }
+            if (value) {
+              this._emit("data", value);
+            }
+          }
+        } catch (error) {
+          this._emit("error", error);
+        }
+      }
+      [Symbol.asyncIterator]() {
+        return {
+          next: async () => {
+            if (this.paused) {
+              await new Promise((resolve) => {
+                this.resumeCallback = resolve;
+              });
+            }
+            const { done, value } = await this.reader.read();
+            if (done) {
+              return { done: true, value: void 0 };
+            }
+            return { done: false, value };
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/core/fetcher/stream-wrappers/NodePre18StreamWrapper.ts
+var NodePre18StreamWrapper_exports = {};
+__export(NodePre18StreamWrapper_exports, {
+  NodePre18StreamWrapper: () => NodePre18StreamWrapper
+});
+var NodePre18StreamWrapper;
+var init_NodePre18StreamWrapper = __esm({
+  "src/core/fetcher/stream-wrappers/NodePre18StreamWrapper.ts"() {
+    "use strict";
+    NodePre18StreamWrapper = class {
+      readableStream;
+      encoding;
+      constructor(readableStream) {
+        this.readableStream = readableStream;
+      }
+      on(event, callback) {
+        this.readableStream.on(event, callback);
+      }
+      off(event, callback) {
+        this.readableStream.off(event, callback);
+      }
+      pipe(dest) {
+        this.readableStream.pipe(dest);
+        return dest;
+      }
+      pipeTo(dest) {
+        return this.pipe(dest);
+      }
+      unpipe(dest) {
+        if (dest) {
+          this.readableStream.unpipe(dest);
+        } else {
+          this.readableStream.unpipe();
+        }
+      }
+      destroy(error) {
+        this.readableStream.destroy(error);
+      }
+      pause() {
+        this.readableStream.pause();
+      }
+      resume() {
+        this.readableStream.resume();
+      }
+      get isPaused() {
+        return this.readableStream.isPaused();
+      }
+      async read() {
+        return new Promise((resolve, reject) => {
+          const chunk = this.readableStream.read();
+          if (chunk) {
+            resolve(chunk);
+          } else {
+            this.readableStream.once("readable", () => {
+              const chunk2 = this.readableStream.read();
+              resolve(chunk2);
+            });
+            this.readableStream.once("error", reject);
+          }
+        });
+      }
+      setEncoding(encoding) {
+        this.readableStream.setEncoding(encoding);
+        this.encoding = encoding;
+      }
+      async text() {
+        const chunks = [];
+        const encoder = new TextEncoder();
+        this.readableStream.setEncoding(this.encoding || "utf-8");
+        for await (const chunk of this.readableStream) {
+          chunks.push(encoder.encode(chunk));
+        }
+        const decoder = new TextDecoder(this.encoding || "utf-8");
+        return decoder.decode(Buffer.concat(chunks));
+      }
+      async json() {
+        const text = await this.text();
+        return JSON.parse(text);
+      }
+      [Symbol.asyncIterator]() {
+        const readableStream = this.readableStream;
+        const iterator = readableStream[Symbol.asyncIterator]();
+        return {
+          async next() {
+            const { value, done } = await iterator.next();
+            return { value, done };
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Rivet: () => api_exports,
+  RivetClient: () => RivetClient,
+  RivetError: () => RivetError,
+  RivetTimeoutError: () => RivetTimeoutError,
+  serialization: () => serialization_exports
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/api/index.ts
+var api_exports = {};
+__export(api_exports, {
+  CrashPolicy: () => CrashPolicy,
+  HealthStatus: () => HealthStatus,
+  RunnerConfigVariant: () => RunnerConfigVariant,
+  datacenters: () => datacenters_exports,
+  health: () => health_exports,
+  metadata: () => metadata_exports,
+  namespaces: () => namespaces_exports,
+  runners: () => runners_exports
+});
+
+// src/api/types/CrashPolicy.ts
+var CrashPolicy = {
+  Restart: "restart",
+  Sleep: "sleep",
+  Destroy: "destroy"
+};
+
+// src/api/types/HealthStatus.ts
+var HealthStatus = {
+  Ok: "ok",
+  Error: "error"
+};
+
+// src/api/types/RunnerConfigVariant.ts
+var RunnerConfigVariant = {
+  Serverless: "serverless",
+  Normal: "normal"
+};
+
+// src/api/resources/datacenters/index.ts
+var datacenters_exports = {};
+
+// src/api/resources/health/index.ts
+var health_exports = {};
+
+// src/api/resources/metadata/index.ts
+var metadata_exports = {};
+
+// src/api/resources/namespaces/index.ts
+var namespaces_exports = {};
+
+// src/api/resources/runners/index.ts
+var runners_exports = {};
+
+// src/core/json.ts
+var toJson = (value, replacer, space) => {
+  return JSON.stringify(value, replacer, space);
+};
+
+// src/core/fetcher/createRequestUrl.ts
+var import_qs = __toESM(require("qs"));
+function createRequestUrl(baseUrl, queryParameters) {
+  return Object.keys(queryParameters ?? {}).length > 0 ? `${baseUrl}?${import_qs.default.stringify(queryParameters, { arrayFormat: "repeat" })}` : baseUrl;
+}
+
+// src/core/runtime/runtime.ts
+var RUNTIME = evaluateRuntime();
+function evaluateRuntime() {
+  const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+  if (isBrowser) {
+    return {
+      type: "browser",
+      version: window.navigator.userAgent
+    };
+  }
+  const isCloudflare = typeof globalThis !== "undefined" && globalThis?.navigator?.userAgent === "Cloudflare-Workers";
+  if (isCloudflare) {
+    return {
+      type: "workerd"
+    };
+  }
+  const isEdgeRuntime = typeof EdgeRuntime === "string";
+  if (isEdgeRuntime) {
+    return {
+      type: "edge-runtime"
+    };
+  }
+  const isWebWorker = typeof self === "object" && // @ts-ignore
+  typeof self?.importScripts === "function" && (self.constructor?.name === "DedicatedWorkerGlobalScope" || self.constructor?.name === "ServiceWorkerGlobalScope" || self.constructor?.name === "SharedWorkerGlobalScope");
+  if (isWebWorker) {
+    return {
+      type: "web-worker"
+    };
+  }
+  const isDeno = typeof Deno !== "undefined" && typeof Deno.version !== "undefined" && typeof Deno.version.deno !== "undefined";
+  if (isDeno) {
+    return {
+      type: "deno",
+      version: Deno.version.deno
+    };
+  }
+  const isBun = typeof Bun !== "undefined" && typeof Bun.version !== "undefined";
+  if (isBun) {
+    return {
+      type: "bun",
+      version: Bun.version
+    };
+  }
+  const isNode = typeof process !== "undefined" && "version" in process && !!process.version && "versions" in process && !!process.versions?.node;
+  if (isNode) {
+    return {
+      type: "node",
+      version: process.versions.node,
+      parsedVersion: Number(process.versions.node.split(".")[0])
+    };
+  }
+  const isReactNative = typeof navigator !== "undefined" && navigator?.product === "ReactNative";
+  if (isReactNative) {
+    return {
+      type: "react-native"
+    };
+  }
+  return {
+    type: "unknown"
+  };
+}
+
+// src/core/fetcher/getFetchFn.ts
+async function getFetchFn() {
+  if (RUNTIME.type === "node" && RUNTIME.parsedVersion != null && RUNTIME.parsedVersion >= 18) {
+    return fetch;
+  }
+  if (RUNTIME.type === "node") {
+    return (await import("node-fetch")).default;
+  }
+  if (typeof fetch == "function") {
+    return fetch;
+  }
+  return (await import("node-fetch")).default;
+}
+
+// src/core/fetcher/getRequestBody.ts
+async function getRequestBody({ body, type }) {
+  if (type.includes("json")) {
+    return toJson(body);
+  } else {
+    return body;
+  }
+}
+
+// src/core/fetcher/stream-wrappers/chooseStreamWrapper.ts
+async function chooseStreamWrapper(responseBody) {
+  if (RUNTIME.type === "node" && RUNTIME.parsedVersion != null && RUNTIME.parsedVersion >= 18) {
+    return new (await Promise.resolve().then(() => (init_Node18UniversalStreamWrapper(), Node18UniversalStreamWrapper_exports))).Node18UniversalStreamWrapper(
+      responseBody
+    );
+  } else if (RUNTIME.type !== "node" && typeof fetch === "function") {
+    return new (await Promise.resolve().then(() => (init_UndiciStreamWrapper(), UndiciStreamWrapper_exports))).UndiciStreamWrapper(responseBody);
+  } else {
+    return new (await Promise.resolve().then(() => (init_NodePre18StreamWrapper(), NodePre18StreamWrapper_exports))).NodePre18StreamWrapper(responseBody);
+  }
+}
+
+// src/core/fetcher/getResponseBody.ts
+async function getResponseBody(response, responseType) {
+  if (response.body != null && responseType === "blob") {
+    return await response.blob();
+  } else if (response.body != null && responseType === "arrayBuffer") {
+    return await response.arrayBuffer();
+  } else if (response.body != null && responseType === "sse") {
+    return response.body;
+  } else if (response.body != null && responseType === "streaming") {
+    return chooseStreamWrapper(response.body);
+  } else if (response.body != null && responseType === "text") {
+    return await response.text();
+  } else {
+    const text = await response.text();
+    if (text.length > 0) {
+      try {
+        let responseBody = JSON.parse(text);
+        return responseBody;
+      } catch (err) {
+        return {
+          ok: false,
+          error: {
+            reason: "non-json",
+            statusCode: response.status,
+            rawBody: text
+          }
+        };
+      }
+    } else {
+      return void 0;
+    }
+  }
+}
+
+// src/core/fetcher/signals.ts
+var TIMEOUT = "timeout";
+function getTimeoutSignal(timeoutMs) {
+  const controller = new AbortController();
+  const abortId = setTimeout(() => controller.abort(TIMEOUT), timeoutMs);
+  return { signal: controller.signal, abortId };
+}
+function anySignal(...args) {
+  const signals = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+  const controller = new AbortController();
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort(signal?.reason);
+      break;
+    }
+    signal.addEventListener("abort", () => controller.abort(signal?.reason), {
+      signal: controller.signal
+    });
+  }
+  return controller.signal;
+}
+
+// src/core/fetcher/makeRequest.ts
+var makeRequest = async (fetchFn, url, method, headers, requestBody, timeoutMs, abortSignal, withCredentials, duplex) => {
+  const signals = [];
+  let timeoutAbortId = void 0;
+  if (timeoutMs != null) {
+    const { signal, abortId } = getTimeoutSignal(timeoutMs);
+    timeoutAbortId = abortId;
+    signals.push(signal);
+  }
+  if (abortSignal != null) {
+    signals.push(abortSignal);
+  }
+  let newSignals = anySignal(signals);
+  const response = await fetchFn(url, {
+    method,
+    headers,
+    body: requestBody,
+    signal: newSignals,
+    credentials: withCredentials ? "include" : void 0,
+    // @ts-ignore
+    duplex
+  });
+  if (timeoutAbortId != null) {
+    clearTimeout(timeoutAbortId);
+  }
+  return response;
+};
+
+// src/core/fetcher/requestWithRetries.ts
+var INITIAL_RETRY_DELAY = 1e3;
+var MAX_RETRY_DELAY = 6e4;
+var DEFAULT_MAX_RETRIES = 2;
+var JITTER_FACTOR = 0.2;
+function addJitter(delay) {
+  const jitterMultiplier = 1 + (Math.random() * 2 - 1) * JITTER_FACTOR;
+  return delay * jitterMultiplier;
+}
+async function requestWithRetries(requestFn, maxRetries = DEFAULT_MAX_RETRIES) {
+  let response = await requestFn();
+  for (let i = 0; i < maxRetries; ++i) {
+    if ([408, 429].includes(response.status) || response.status >= 500) {
+      const baseDelay = Math.min(INITIAL_RETRY_DELAY * Math.pow(2, i), MAX_RETRY_DELAY);
+      const delayWithJitter = addJitter(baseDelay);
+      await new Promise((resolve) => setTimeout(resolve, delayWithJitter));
+      response = await requestFn();
+    } else {
+      break;
+    }
+  }
+  return response;
+}
+
+// src/core/fetcher/Fetcher.ts
+async function fetcherImpl(args) {
+  const headers = {};
+  if (args.body !== void 0 && args.contentType != null) {
+    headers["Content-Type"] = args.contentType;
+  }
+  if (args.headers != null) {
+    for (const [key, value] of Object.entries(args.headers)) {
+      if (value != null) {
+        headers[key] = value;
+      }
+    }
+  }
+  const url = createRequestUrl(args.url, args.queryParameters);
+  const requestBody = await getRequestBody({
+    body: args.body,
+    type: args.requestType === "json" ? "json" : "other"
+  });
+  const fetchFn = await getFetchFn();
+  try {
+    const response = await requestWithRetries(
+      async () => makeRequest(
+        fetchFn,
+        url,
+        args.method,
+        headers,
+        requestBody,
+        args.timeoutMs,
+        args.abortSignal,
+        args.withCredentials,
+        args.duplex
+      ),
+      args.maxRetries
+    );
+    const responseBody = await getResponseBody(response, args.responseType);
+    if (response.status >= 200 && response.status < 400) {
+      return {
+        ok: true,
+        body: responseBody,
+        headers: response.headers
+      };
+    } else {
+      return {
+        ok: false,
+        error: {
+          reason: "status-code",
+          statusCode: response.status,
+          body: responseBody
+        }
+      };
+    }
+  } catch (error) {
+    if (args.abortSignal != null && args.abortSignal.aborted) {
+      return {
+        ok: false,
+        error: {
+          reason: "unknown",
+          errorMessage: "The user aborted a request"
+        }
+      };
+    } else if (error instanceof Error && error.name === "AbortError") {
+      return {
+        ok: false,
+        error: {
+          reason: "timeout"
+        }
+      };
+    } else if (error instanceof Error) {
+      return {
+        ok: false,
+        error: {
+          reason: "unknown",
+          errorMessage: error.message
+        }
+      };
+    }
+    return {
+      ok: false,
+      error: {
+        reason: "unknown",
+        errorMessage: toJson(error)
+      }
+    };
+  }
+}
+var fetcher = fetcherImpl;
+
+// src/core/fetcher/Supplier.ts
+var Supplier = {
+  get: async (supplier) => {
+    if (typeof supplier === "function") {
+      return supplier();
+    } else {
+      return supplier;
+    }
+  }
+};
+
+// src/core/auth/BasicAuth.ts
+var import_js_base64 = require("js-base64");
+
+// src/core/schemas/index.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  JsonError: () => JsonError,
+  ParseError: () => ParseError,
+  any: () => any,
+  bigint: () => bigint,
+  boolean: () => boolean,
+  booleanLiteral: () => booleanLiteral,
+  date: () => date,
+  discriminant: () => discriminant,
+  enum_: () => enum_,
+  getObjectLikeUtils: () => getObjectLikeUtils,
+  getObjectUtils: () => getObjectUtils,
+  getSchemaUtils: () => getSchemaUtils,
+  isProperty: () => isProperty,
+  lazy: () => lazy,
+  lazyObject: () => lazyObject,
+  list: () => list,
+  number: () => number,
+  object: () => object,
+  objectWithoutOptionalProperties: () => objectWithoutOptionalProperties,
+  optional: () => optional,
+  property: () => property,
+  record: () => record,
+  set: () => set,
+  string: () => string,
+  stringLiteral: () => stringLiteral,
+  transform: () => transform,
+  undiscriminatedUnion: () => undiscriminatedUnion,
+  union: () => union,
+  unknown: () => unknown,
+  withParsedProperties: () => withParsedProperties
+});
+
+// src/core/schemas/Schema.ts
+var SchemaType = {
+  BIGINT: "bigint",
+  DATE: "date",
+  ENUM: "enum",
+  LIST: "list",
+  STRING_LITERAL: "stringLiteral",
+  BOOLEAN_LITERAL: "booleanLiteral",
+  OBJECT: "object",
+  ANY: "any",
+  BOOLEAN: "boolean",
+  NUMBER: "number",
+  STRING: "string",
+  UNKNOWN: "unknown",
+  RECORD: "record",
+  SET: "set",
+  UNION: "union",
+  UNDISCRIMINATED_UNION: "undiscriminatedUnion",
+  NULLABLE: "nullable",
+  OPTIONAL: "optional",
+  OPTIONAL_NULLABLE: "optionalNullable"
+};
+
+// src/core/schemas/utils/getErrorMessageForIncorrectType.ts
+function getErrorMessageForIncorrectType(value, expectedType) {
+  return `Expected ${expectedType}. Received ${getTypeAsString(value)}.`;
+}
+function getTypeAsString(value) {
+  if (Array.isArray(value)) {
+    return "list";
+  }
+  if (value === null) {
+    return "null";
+  }
+  if (value instanceof BigInt) {
+    return "BigInt";
+  }
+  switch (typeof value) {
+    case "string":
+      return `"${value}"`;
+    case "bigint":
+    case "number":
+    case "boolean":
+    case "undefined":
+      return `${value}`;
+  }
+  return typeof value;
+}
+
+// src/core/schemas/utils/maybeSkipValidation.ts
+function maybeSkipValidation(schema) {
+  return {
+    ...schema,
+    json: transformAndMaybeSkipValidation(schema.json),
+    parse: transformAndMaybeSkipValidation(schema.parse)
+  };
+}
+function transformAndMaybeSkipValidation(transform2) {
+  return (value, opts) => {
+    const transformed = transform2(value, opts);
+    const { skipValidation = false } = opts ?? {};
+    if (!transformed.ok && skipValidation) {
+      console.warn(
+        [
+          "Failed to validate.",
+          ...transformed.errors.map(
+            (error) => "  - " + (error.path.length > 0 ? `${error.path.join(".")}: ${error.message}` : error.message)
+          )
+        ].join("\n")
+      );
+      return {
+        ok: true,
+        value
+      };
+    } else {
+      return transformed;
+    }
+  };
+}
+
+// src/core/schemas/builders/schema-utils/stringifyValidationErrors.ts
+function stringifyValidationError(error) {
+  if (error.path.length === 0) {
+    return error.message;
+  }
+  return `${error.path.join(" -> ")}: ${error.message}`;
+}
+
+// src/core/schemas/builders/schema-utils/JsonError.ts
+var JsonError = class _JsonError extends Error {
+  constructor(errors) {
+    super(errors.map(stringifyValidationError).join("; "));
+    this.errors = errors;
+    Object.setPrototypeOf(this, _JsonError.prototype);
+  }
+};
+
+// src/core/schemas/builders/schema-utils/ParseError.ts
+var ParseError = class _ParseError extends Error {
+  constructor(errors) {
+    super(errors.map(stringifyValidationError).join("; "));
+    this.errors = errors;
+    Object.setPrototypeOf(this, _ParseError.prototype);
+  }
+};
+
+// src/core/schemas/builders/schema-utils/getSchemaUtils.ts
+function getSchemaUtils(schema) {
+  return {
+    nullable: () => nullable(schema),
+    optional: () => optional(schema),
+    optionalNullable: () => optionalNullable(schema),
+    transform: (transformer) => transform(schema, transformer),
+    parseOrThrow: (raw, opts) => {
+      const parsed = schema.parse(raw, opts);
+      if (parsed.ok) {
+        return parsed.value;
+      }
+      throw new ParseError(parsed.errors);
+    },
+    jsonOrThrow: (parsed, opts) => {
+      const raw = schema.json(parsed, opts);
+      if (raw.ok) {
+        return raw.value;
+      }
+      throw new JsonError(raw.errors);
+    }
+  };
+}
+function nullable(schema) {
+  const baseSchema = {
+    parse: (raw, opts) => {
+      if (raw == null) {
+        return {
+          ok: true,
+          value: null
+        };
+      }
+      return schema.parse(raw, opts);
+    },
+    json: (parsed, opts) => {
+      if (parsed == null) {
+        return {
+          ok: true,
+          value: null
+        };
+      }
+      return schema.json(parsed, opts);
+    },
+    getType: () => SchemaType.NULLABLE
+  };
+  return {
+    ...baseSchema,
+    ...getSchemaUtils(baseSchema)
+  };
+}
+function optional(schema) {
+  const baseSchema = {
+    parse: (raw, opts) => {
+      if (raw == null) {
+        return {
+          ok: true,
+          value: void 0
+        };
+      }
+      return schema.parse(raw, opts);
+    },
+    json: (parsed, opts) => {
+      if (opts?.omitUndefined && parsed === void 0) {
+        return {
+          ok: true,
+          value: void 0
+        };
+      }
+      if (parsed == null) {
+        return {
+          ok: true,
+          value: null
+        };
+      }
+      return schema.json(parsed, opts);
+    },
+    getType: () => SchemaType.OPTIONAL
+  };
+  return {
+    ...baseSchema,
+    ...getSchemaUtils(baseSchema)
+  };
+}
+function optionalNullable(schema) {
+  const baseSchema = {
+    parse: (raw, opts) => {
+      if (raw === void 0) {
+        return {
+          ok: true,
+          value: void 0
+        };
+      }
+      if (raw === null) {
+        return {
+          ok: true,
+          value: null
+        };
+      }
+      return schema.parse(raw, opts);
+    },
+    json: (parsed, opts) => {
+      if (parsed === void 0) {
+        return {
+          ok: true,
+          value: void 0
+        };
+      }
+      if (parsed === null) {
+        return {
+          ok: true,
+          value: null
+        };
+      }
+      return schema.json(parsed, opts);
+    },
+    getType: () => SchemaType.OPTIONAL_NULLABLE
+  };
+  return {
+    ...baseSchema,
+    ...getSchemaUtils(baseSchema)
+  };
+}
+function transform(schema, transformer) {
+  const baseSchema = {
+    parse: (raw, opts) => {
+      const parsed = schema.parse(raw, opts);
+      if (!parsed.ok) {
+        return parsed;
+      }
+      return {
+        ok: true,
+        value: transformer.transform(parsed.value)
+      };
+    },
+    json: (transformed, opts) => {
+      const parsed = transformer.untransform(transformed);
+      return schema.json(parsed, opts);
+    },
+    getType: () => schema.getType()
+  };
+  return {
+    ...baseSchema,
+    ...getSchemaUtils(baseSchema)
+  };
+}
+
+// src/core/schemas/builders/bigint/bigint.ts
+function bigint() {
+  const baseSchema = {
+    parse: (raw, { breadcrumbsPrefix = [] } = {}) => {
+      if (typeof raw === "bigint") {
+        return {
+          ok: true,
+          value: raw
+        };
+      }
+      if (typeof raw === "number") {
+        return {
+          ok: true,
+          value: BigInt(raw)
+        };
+      }
+      return {
+        ok: false,
+        errors: [
+          {
+            path: breadcrumbsPrefix,
+            message: getErrorMessageForIncorrectType(raw, "bigint | number")
+          }
+        ]
+      };
+    },
+    json: (bigint2, { breadcrumbsPrefix = [] } = {}) => {
+      if (typeof bigint2 !== "bigint") {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: breadcrumbsPrefix,
+              message: getErrorMessageForIncorrectType(bigint2, "bigint")
+            }
+          ]
+        };
+      }
+      return {
+        ok: true,
+        value: bigint2
+      };
+    },
+    getType: () => SchemaType.BIGINT
+  };
+  return {
+    ...maybeSkipValidation(baseSchema),
+    ...getSchemaUtils(baseSchema)
+  };
+}
+
+// src/core/schemas/builders/date/date.ts
+var ISO_8601_REGEX = /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([.,]\d+(?!:))?)?(\17[0-5]\d([.,]\d+)?)?([zZ]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
+function date() {
+  const baseSchema = {
+    parse: (raw, { breadcrumbsPrefix = [] } = {}) => {
+      if (typeof raw !== "string") {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: breadcrumbsPrefix,
+              message: getErrorMessageForIncorrectType(raw, "string")
+            }
+          ]
+        };
+      }
+      if (!ISO_8601_REGEX.test(raw)) {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: breadcrumbsPrefix,
+              message: getErrorMessageForIncorrectType(raw, "ISO 8601 date string")
+            }
+          ]
+        };
+      }
+      return {
+        ok: true,
+        value: new Date(raw)
+      };
+    },
+    json: (date2, { breadcrumbsPrefix = [] } = {}) => {
+      if (date2 instanceof Date) {
+        return {
+          ok: true,
+          value: date2.toISOString()
+        };
+      } else {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: breadcrumbsPrefix,
+              message: getErrorMessageForIncorrectType(date2, "Date object")
+            }
+          ]
+        };
+      }
+    },
+    getType: () => SchemaType.DATE
+  };
+  return {
+    ...maybeSkipValidation(baseSchema),
+    ...getSchemaUtils(baseSchema)
+  };
+}
+
+// src/core/schemas/utils/createIdentitySchemaCreator.ts
+function createIdentitySchemaCreator(schemaType, validate) {
+  return () => {
+    const baseSchema = {
+      parse: validate,
+      json: validate,
+      getType: () => schemaType
+    };
+    return {
+      ...maybeSkipValidation(baseSchema),
+      ...getSchemaUtils(baseSchema)
+    };
+  };
+}
+
+// src/core/schemas/builders/enum/enum.ts
+function enum_(values) {
+  const validValues = new Set(values);
+  const schemaCreator = createIdentitySchemaCreator(
+    SchemaType.ENUM,
+    (value, { allowUnrecognizedEnumValues, breadcrumbsPrefix = [] } = {}) => {
+      if (typeof value !== "string") {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: breadcrumbsPrefix,
+              message: getErrorMessageForIncorrectType(value, "string")
+            }
+          ]
+        };
+      }
+      if (!validValues.has(value) && !allowUnrecognizedEnumValues) {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: breadcrumbsPrefix,
+              message: getErrorMessageForIncorrectType(value, "enum")
+            }
+          ]
+        };
+      }
+      return {
+        ok: true,
+        value
+      };
+    }
+  );
+  return schemaCreator();
+}
+
+// src/core/schemas/builders/lazy/lazy.ts
+function lazy(getter) {
+  const baseSchema = constructLazyBaseSchema(getter);
+  return {
+    ...baseSchema,
+    ...getSchemaUtils(baseSchema)
+  };
+}
+function constructLazyBaseSchema(getter) {
+  return {
+    parse: (raw, opts) => getMemoizedSchema(getter).parse(raw, opts),
+    json: (parsed, opts) => getMemoizedSchema(getter).json(parsed, opts),
+    getType: () => getMemoizedSchema(getter).getType()
+  };
+}
+function getMemoizedSchema(getter) {
+  const castedGetter = getter;
+  if (castedGetter.__zurg_memoized == null) {
+    castedGetter.__zurg_memoized = getter();
+  }
+  return castedGetter.__zurg_memoized;
+}
+
+// src/core/schemas/utils/entries.ts
+function entries(object2) {
+  return Object.entries(object2);
+}
+
+// src/core/schemas/utils/filterObject.ts
+function filterObject(obj, keysToInclude) {
+  const keysToIncludeSet = new Set(keysToInclude);
+  return Object.entries(obj).reduce(
+    (acc, [key, value]) => {
+      if (keysToIncludeSet.has(key)) {
+        acc[key] = value;
+      }
+      return acc;
+    },
+    {}
+  );
+}
+
+// src/core/schemas/utils/isPlainObject.ts
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (Object.getPrototypeOf(value) === null) {
+    return true;
+  }
+  let proto = value;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(value) === proto;
+}
+
+// src/core/schemas/utils/keys.ts
+function keys(object2) {
+  return Object.keys(object2);
+}
+
+// src/core/schemas/utils/partition.ts
+function partition(items, predicate) {
+  const trueItems = [], falseItems = [];
+  for (const item of items) {
+    if (predicate(item)) {
+      trueItems.push(item);
+    } else {
+      falseItems.push(item);
+    }
+  }
+  return [trueItems, falseItems];
+}
+
+// src/core/schemas/builders/object-like/getObjectLikeUtils.ts
+function getObjectLikeUtils(schema) {
+  return {
+    withParsedProperties: (properties) => withParsedProperties(schema, properties)
+  };
+}
+function withParsedProperties(objectLike, properties) {
+  const objectSchema = {
+    parse: (raw, opts) => {
+      const parsedObject = objectLike.parse(raw, opts);
+      if (!parsedObject.ok) {
+        return parsedObject;
+      }
+      const additionalProperties = Object.entries(properties).reduce(
+        (processed, [key, value]) => {
+          return {
+            ...processed,
+            [key]: typeof value === "function" ? value(parsedObject.value) : value
+          };
+        },
+        {}
+      );
+      return {
+        ok: true,
+        value: {
+          ...parsedObject.value,
+          ...additionalProperties
+        }
+      };
+    },
+    json: (parsed, opts) => {
+      if (!isPlainObject(parsed)) {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: opts?.breadcrumbsPrefix ?? [],
+              message: getErrorMessageForIncorrectType(parsed, "object")
+            }
+          ]
+        };
+      }
+      const addedPropertyKeys = new Set(Object.keys(properties));
+      const parsedWithoutAddedProperties = filterObject(
+        parsed,
+        Object.keys(parsed).filter((key) => !addedPropertyKeys.has(key))
+      );
+      return objectLike.json(parsedWithoutAddedProperties, opts);
+    },
+    getType: () => objectLike.getType()
+  };
+  return {
+    ...objectSchema,
+    ...getSchemaUtils(objectSchema),
+    ...getObjectLikeUtils(objectSchema)
+  };
+}
+
+// src/core/schemas/builders/object/property.ts
+function property(rawKey, valueSchema) {
+  return {
+    rawKey,
+    valueSchema,
+    isProperty: true
+  };
+}
+function isProperty(maybeProperty) {
+  return maybeProperty.isProperty;
+}
+
+// src/core/schemas/builders/object/object.ts
+function object(schemas) {
+  const baseSchema = {
+    _getRawProperties: () => Object.entries(schemas).map(
+      ([parsedKey, propertySchema]) => isProperty(propertySchema) ? propertySchema.rawKey : parsedKey
+    ),
+    _getParsedProperties: () => keys(schemas),
+    parse: (raw, opts) => {
+      const rawKeyToProperty = {};
+      const requiredKeys = [];
+      for (const [parsedKey, schemaOrObjectProperty] of entries(schemas)) {
+        const rawKey = isProperty(schemaOrObjectProperty) ? schemaOrObjectProperty.rawKey : parsedKey;
+        const valueSchema = isProperty(schemaOrObjectProperty) ? schemaOrObjectProperty.valueSchema : schemaOrObjectProperty;
+        const property2 = {
+          rawKey,
+          parsedKey,
+          valueSchema
+        };
+        rawKeyToProperty[rawKey] = property2;
+        if (isSchemaRequired(valueSchema)) {
+          requiredKeys.push(rawKey);
+        }
+      }
+      return validateAndTransformObject({
+        value: raw,
+        requiredKeys,
+        getProperty: (rawKey) => {
+          const property2 = rawKeyToProperty[rawKey];
+          if (property2 == null) {
+            return void 0;
+          }
+          return {
+            transformedKey: property2.parsedKey,
+            transform: (propertyValue) => property2.valueSchema.parse(propertyValue, {
+              ...opts,
+              breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], rawKey]
+            })
+          };
+        },
+        unrecognizedObjectKeys: opts?.unrecognizedObjectKeys,
+        skipValidation: opts?.skipValidation,
+        breadcrumbsPrefix: opts?.breadcrumbsPrefix,
+        omitUndefined: opts?.omitUndefined
+      });
+    },
+    json: (parsed, opts) => {
+      const requiredKeys = [];
+      for (const [parsedKey, schemaOrObjectProperty] of entries(schemas)) {
+        const valueSchema = isProperty(schemaOrObjectProperty) ? schemaOrObjectProperty.valueSchema : schemaOrObjectProperty;
+        if (isSchemaRequired(valueSchema)) {
+          requiredKeys.push(parsedKey);
+        }
+      }
+      return validateAndTransformObject({
+        value: parsed,
+        requiredKeys,
+        getProperty: (parsedKey) => {
+          const property2 = schemas[parsedKey];
+          if (property2 == null) {
+            return void 0;
+          }
+          if (isProperty(property2)) {
+            return {
+              transformedKey: property2.rawKey,
+              transform: (propertyValue) => property2.valueSchema.json(propertyValue, {
+                ...opts,
+                breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], parsedKey]
+              })
+            };
+          } else {
+            return {
+              transformedKey: parsedKey,
+              transform: (propertyValue) => property2.json(propertyValue, {
+                ...opts,
+                breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], parsedKey]
+              })
+            };
+          }
+        },
+        unrecognizedObjectKeys: opts?.unrecognizedObjectKeys,
+        skipValidation: opts?.skipValidation,
+        breadcrumbsPrefix: opts?.breadcrumbsPrefix,
+        omitUndefined: opts?.omitUndefined
+      });
+    },
+    getType: () => SchemaType.OBJECT
+  };
+  return {
+    ...maybeSkipValidation(baseSchema),
+    ...getSchemaUtils(baseSchema),
+    ...getObjectLikeUtils(baseSchema),
+    ...getObjectUtils(baseSchema)
+  };
+}
+function validateAndTransformObject({
+  value,
+  requiredKeys,
+  getProperty,
+  unrecognizedObjectKeys = "fail",
+  skipValidation = false,
+  breadcrumbsPrefix = []
+}) {
+  if (!isPlainObject(value)) {
+    return {
+      ok: false,
+      errors: [
+        {
+          path: breadcrumbsPrefix,
+          message: getErrorMessageForIncorrectType(value, "object")
+        }
+      ]
+    };
+  }
+  const missingRequiredKeys = new Set(requiredKeys);
+  const errors = [];
+  const transformed = {};
+  for (const [preTransformedKey, preTransformedItemValue] of Object.entries(value)) {
+    const property2 = getProperty(preTransformedKey);
+    if (property2 != null) {
+      missingRequiredKeys.delete(preTransformedKey);
+      const value2 = property2.transform(preTransformedItemValue);
+      if (value2.ok) {
+        transformed[property2.transformedKey] = value2.value;
+      } else {
+        transformed[preTransformedKey] = preTransformedItemValue;
+        errors.push(...value2.errors);
+      }
+    } else {
+      switch (unrecognizedObjectKeys) {
+        case "fail":
+          errors.push({
+            path: [...breadcrumbsPrefix, preTransformedKey],
+            message: `Unexpected key "${preTransformedKey}"`
+          });
+          break;
+        case "strip":
+          break;
+        case "passthrough":
+          transformed[preTransformedKey] = preTransformedItemValue;
+          break;
+      }
+    }
+  }
+  errors.push(
+    ...requiredKeys.filter((key) => missingRequiredKeys.has(key)).map((key) => ({
+      path: breadcrumbsPrefix,
+      message: `Missing required key "${key}"`
+    }))
+  );
+  if (errors.length === 0 || skipValidation) {
+    return {
+      ok: true,
+      value: transformed
+    };
+  } else {
+    return {
+      ok: false,
+      errors
+    };
+  }
+}
+function getObjectUtils(schema) {
+  return {
+    extend: (extension) => {
+      const baseSchema = {
+        _getParsedProperties: () => [...schema._getParsedProperties(), ...extension._getParsedProperties()],
+        _getRawProperties: () => [...schema._getRawProperties(), ...extension._getRawProperties()],
+        parse: (raw, opts) => {
+          return validateAndTransformExtendedObject({
+            extensionKeys: extension._getRawProperties(),
+            value: raw,
+            transformBase: (rawBase) => schema.parse(rawBase, opts),
+            transformExtension: (rawExtension) => extension.parse(rawExtension, opts)
+          });
+        },
+        json: (parsed, opts) => {
+          return validateAndTransformExtendedObject({
+            extensionKeys: extension._getParsedProperties(),
+            value: parsed,
+            transformBase: (parsedBase) => schema.json(parsedBase, opts),
+            transformExtension: (parsedExtension) => extension.json(parsedExtension, opts)
+          });
+        },
+        getType: () => SchemaType.OBJECT
+      };
+      return {
+        ...baseSchema,
+        ...getSchemaUtils(baseSchema),
+        ...getObjectLikeUtils(baseSchema),
+        ...getObjectUtils(baseSchema)
+      };
+    },
+    passthrough: () => {
+      const baseSchema = {
+        _getParsedProperties: () => schema._getParsedProperties(),
+        _getRawProperties: () => schema._getRawProperties(),
+        parse: (raw, opts) => {
+          const transformed = schema.parse(raw, { ...opts, unrecognizedObjectKeys: "passthrough" });
+          if (!transformed.ok) {
+            return transformed;
+          }
+          return {
+            ok: true,
+            value: {
+              ...raw,
+              ...transformed.value
+            }
+          };
+        },
+        json: (parsed, opts) => {
+          const transformed = schema.json(parsed, { ...opts, unrecognizedObjectKeys: "passthrough" });
+          if (!transformed.ok) {
+            return transformed;
+          }
+          return {
+            ok: true,
+            value: {
+              ...parsed,
+              ...transformed.value
+            }
+          };
+        },
+        getType: () => SchemaType.OBJECT
+      };
+      return {
+        ...baseSchema,
+        ...getSchemaUtils(baseSchema),
+        ...getObjectLikeUtils(baseSchema),
+        ...getObjectUtils(baseSchema)
+      };
+    }
+  };
+}
+function validateAndTransformExtendedObject({
+  extensionKeys,
+  value,
+  transformBase,
+  transformExtension
+}) {
+  const extensionPropertiesSet = new Set(extensionKeys);
+  const [extensionProperties, baseProperties] = partition(
+    keys(value),
+    (key) => extensionPropertiesSet.has(key)
+  );
+  const transformedBase = transformBase(filterObject(value, baseProperties));
+  const transformedExtension = transformExtension(filterObject(value, extensionProperties));
+  if (transformedBase.ok && transformedExtension.ok) {
+    return {
+      ok: true,
+      value: {
+        ...transformedBase.value,
+        ...transformedExtension.value
+      }
+    };
+  } else {
+    return {
+      ok: false,
+      errors: [
+        ...transformedBase.ok ? [] : transformedBase.errors,
+        ...transformedExtension.ok ? [] : transformedExtension.errors
+      ]
+    };
+  }
+}
+function isSchemaRequired(schema) {
+  return !isSchemaOptional(schema);
+}
+function isSchemaOptional(schema) {
+  switch (schema.getType()) {
+    case SchemaType.ANY:
+    case SchemaType.UNKNOWN:
+    case SchemaType.OPTIONAL:
+    case SchemaType.OPTIONAL_NULLABLE:
+      return true;
+    default:
+      return false;
+  }
+}
+
+// src/core/schemas/builders/object/objectWithoutOptionalProperties.ts
+function objectWithoutOptionalProperties(schemas) {
+  return object(schemas);
+}
+
+// src/core/schemas/builders/lazy/lazyObject.ts
+function lazyObject(getter) {
+  const baseSchema = {
+    ...constructLazyBaseSchema(getter),
+    _getRawProperties: () => getMemoizedSchema(getter)._getRawProperties(),
+    _getParsedProperties: () => getMemoizedSchema(getter)._getParsedProperties()
+  };
+  return {
+    ...baseSchema,
+    ...getSchemaUtils(baseSchema),
+    ...getObjectLikeUtils(baseSchema),
+    ...getObjectUtils(baseSchema)
+  };
+}
+
+// src/core/schemas/builders/list/list.ts
+function list(schema) {
+  const baseSchema = {
+    parse: (raw, opts) => validateAndTransformArray(
+      raw,
+      (item, index) => schema.parse(item, {
+        ...opts,
+        breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], `[${index}]`]
+      })
+    ),
+    json: (parsed, opts) => validateAndTransformArray(
+      parsed,
+      (item, index) => schema.json(item, {
+        ...opts,
+        breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], `[${index}]`]
+      })
+    ),
+    getType: () => SchemaType.LIST
+  };
+  return {
+    ...maybeSkipValidation(baseSchema),
+    ...getSchemaUtils(baseSchema)
+  };
+}
+function validateAndTransformArray(value, transformItem) {
+  if (!Array.isArray(value)) {
+    return {
+      ok: false,
+      errors: [
+        {
+          message: getErrorMessageForIncorrectType(value, "list"),
+          path: []
+        }
+      ]
+    };
+  }
+  const maybeValidItems = value.map((item, index) => transformItem(item, index));
+  return maybeValidItems.reduce(
+    (acc, item) => {
+      if (acc.ok && item.ok) {
+        return {
+          ok: true,
+          value: [...acc.value, item.value]
+        };
+      }
+      const errors = [];
+      if (!acc.ok) {
+        errors.push(...acc.errors);
+      }
+      if (!item.ok) {
+        errors.push(...item.errors);
+      }
+      return {
+        ok: false,
+        errors
+      };
+    },
+    { ok: true, value: [] }
+  );
+}
+
+// src/core/schemas/builders/literals/stringLiteral.ts
+function stringLiteral(literal) {
+  const schemaCreator = createIdentitySchemaCreator(
+    SchemaType.STRING_LITERAL,
+    (value, { breadcrumbsPrefix = [] } = {}) => {
+      if (value === literal) {
+        return {
+          ok: true,
+          value: literal
+        };
+      } else {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: breadcrumbsPrefix,
+              message: getErrorMessageForIncorrectType(value, `"${literal}"`)
+            }
+          ]
+        };
+      }
+    }
+  );
+  return schemaCreator();
+}
+
+// src/core/schemas/builders/literals/booleanLiteral.ts
+function booleanLiteral(literal) {
+  const schemaCreator = createIdentitySchemaCreator(
+    SchemaType.BOOLEAN_LITERAL,
+    (value, { breadcrumbsPrefix = [] } = {}) => {
+      if (value === literal) {
+        return {
+          ok: true,
+          value: literal
+        };
+      } else {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: breadcrumbsPrefix,
+              message: getErrorMessageForIncorrectType(value, `${literal.toString()}`)
+            }
+          ]
+        };
+      }
+    }
+  );
+  return schemaCreator();
+}
+
+// src/core/schemas/builders/primitives/any.ts
+var any = createIdentitySchemaCreator(SchemaType.ANY, (value) => ({ ok: true, value }));
+
+// src/core/schemas/builders/primitives/boolean.ts
+var boolean = createIdentitySchemaCreator(
+  SchemaType.BOOLEAN,
+  (value, { breadcrumbsPrefix = [] } = {}) => {
+    if (typeof value === "boolean") {
+      return {
+        ok: true,
+        value
+      };
+    } else {
+      return {
+        ok: false,
+        errors: [
+          {
+            path: breadcrumbsPrefix,
+            message: getErrorMessageForIncorrectType(value, "boolean")
+          }
+        ]
+      };
+    }
+  }
+);
+
+// src/core/schemas/builders/primitives/number.ts
+var number = createIdentitySchemaCreator(
+  SchemaType.NUMBER,
+  (value, { breadcrumbsPrefix = [] } = {}) => {
+    if (typeof value === "number") {
+      return {
+        ok: true,
+        value
+      };
+    } else {
+      return {
+        ok: false,
+        errors: [
+          {
+            path: breadcrumbsPrefix,
+            message: getErrorMessageForIncorrectType(value, "number")
+          }
+        ]
+      };
+    }
+  }
+);
+
+// src/core/schemas/builders/primitives/string.ts
+var string = createIdentitySchemaCreator(
+  SchemaType.STRING,
+  (value, { breadcrumbsPrefix = [] } = {}) => {
+    if (typeof value === "string") {
+      return {
+        ok: true,
+        value
+      };
+    } else {
+      return {
+        ok: false,
+        errors: [
+          {
+            path: breadcrumbsPrefix,
+            message: getErrorMessageForIncorrectType(value, "string")
+          }
+        ]
+      };
+    }
+  }
+);
+
+// src/core/schemas/builders/primitives/unknown.ts
+var unknown = createIdentitySchemaCreator(SchemaType.UNKNOWN, (value) => ({ ok: true, value }));
+
+// src/core/schemas/builders/record/record.ts
+function record(keySchema, valueSchema) {
+  const baseSchema = {
+    parse: (raw, opts) => {
+      return validateAndTransformRecord({
+        value: raw,
+        isKeyNumeric: keySchema.getType() === SchemaType.NUMBER,
+        transformKey: (key) => keySchema.parse(key, {
+          ...opts,
+          breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], `${key} (key)`]
+        }),
+        transformValue: (value, key) => valueSchema.parse(value, {
+          ...opts,
+          breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], `${key}`]
+        }),
+        breadcrumbsPrefix: opts?.breadcrumbsPrefix
+      });
+    },
+    json: (parsed, opts) => {
+      return validateAndTransformRecord({
+        value: parsed,
+        isKeyNumeric: keySchema.getType() === SchemaType.NUMBER,
+        transformKey: (key) => keySchema.json(key, {
+          ...opts,
+          breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], `${key} (key)`]
+        }),
+        transformValue: (value, key) => valueSchema.json(value, {
+          ...opts,
+          breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], `${key}`]
+        }),
+        breadcrumbsPrefix: opts?.breadcrumbsPrefix
+      });
+    },
+    getType: () => SchemaType.RECORD
+  };
+  return {
+    ...maybeSkipValidation(baseSchema),
+    ...getSchemaUtils(baseSchema)
+  };
+}
+function validateAndTransformRecord({
+  value,
+  isKeyNumeric,
+  transformKey,
+  transformValue,
+  breadcrumbsPrefix = []
+}) {
+  if (!isPlainObject(value)) {
+    return {
+      ok: false,
+      errors: [
+        {
+          path: breadcrumbsPrefix,
+          message: getErrorMessageForIncorrectType(value, "object")
+        }
+      ]
+    };
+  }
+  return entries(value).reduce(
+    (accPromise, [stringKey, value2]) => {
+      if (value2 === void 0) {
+        return accPromise;
+      }
+      const acc = accPromise;
+      let key = stringKey;
+      if (isKeyNumeric) {
+        const numberKey = stringKey.length > 0 ? Number(stringKey) : NaN;
+        if (!isNaN(numberKey)) {
+          key = numberKey;
+        }
+      }
+      const transformedKey = transformKey(key);
+      const transformedValue = transformValue(value2, key);
+      if (acc.ok && transformedKey.ok && transformedValue.ok) {
+        return {
+          ok: true,
+          value: {
+            ...acc.value,
+            [transformedKey.value]: transformedValue.value
+          }
+        };
+      }
+      const errors = [];
+      if (!acc.ok) {
+        errors.push(...acc.errors);
+      }
+      if (!transformedKey.ok) {
+        errors.push(...transformedKey.errors);
+      }
+      if (!transformedValue.ok) {
+        errors.push(...transformedValue.errors);
+      }
+      return {
+        ok: false,
+        errors
+      };
+    },
+    { ok: true, value: {} }
+  );
+}
+
+// src/core/schemas/builders/set/set.ts
+function set(schema) {
+  const listSchema = list(schema);
+  const baseSchema = {
+    parse: (raw, opts) => {
+      const parsedList = listSchema.parse(raw, opts);
+      if (parsedList.ok) {
+        return {
+          ok: true,
+          value: new Set(parsedList.value)
+        };
+      } else {
+        return parsedList;
+      }
+    },
+    json: (parsed, opts) => {
+      if (!(parsed instanceof Set)) {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: opts?.breadcrumbsPrefix ?? [],
+              message: getErrorMessageForIncorrectType(parsed, "Set")
+            }
+          ]
+        };
+      }
+      const jsonList = listSchema.json([...parsed], opts);
+      return jsonList;
+    },
+    getType: () => SchemaType.SET
+  };
+  return {
+    ...maybeSkipValidation(baseSchema),
+    ...getSchemaUtils(baseSchema)
+  };
+}
+
+// src/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.ts
+function undiscriminatedUnion(schemas) {
+  const baseSchema = {
+    parse: (raw, opts) => {
+      return validateAndTransformUndiscriminatedUnion(
+        (schema, opts2) => schema.parse(raw, opts2),
+        schemas,
+        opts
+      );
+    },
+    json: (parsed, opts) => {
+      return validateAndTransformUndiscriminatedUnion(
+        (schema, opts2) => schema.json(parsed, opts2),
+        schemas,
+        opts
+      );
+    },
+    getType: () => SchemaType.UNDISCRIMINATED_UNION
+  };
+  return {
+    ...maybeSkipValidation(baseSchema),
+    ...getSchemaUtils(baseSchema)
+  };
+}
+function validateAndTransformUndiscriminatedUnion(transform2, schemas, opts) {
+  const errors = [];
+  for (const [index, schema] of schemas.entries()) {
+    const transformed = transform2(schema, { ...opts, skipValidation: false });
+    if (transformed.ok) {
+      return transformed;
+    } else {
+      for (const error of transformed.errors) {
+        errors.push({
+          path: error.path,
+          message: `[Variant ${index}] ${error.message}`
+        });
+      }
+    }
+  }
+  return {
+    ok: false,
+    errors
+  };
+}
+
+// src/core/schemas/builders/union/discriminant.ts
+function discriminant(parsedDiscriminant, rawDiscriminant) {
+  return {
+    parsedDiscriminant,
+    rawDiscriminant
+  };
+}
+
+// src/core/schemas/builders/union/union.ts
+function union(discriminant2, union2) {
+  const rawDiscriminant = typeof discriminant2 === "string" ? discriminant2 : discriminant2.rawDiscriminant;
+  const parsedDiscriminant = typeof discriminant2 === "string" ? discriminant2 : discriminant2.parsedDiscriminant;
+  const discriminantValueSchema = enum_(keys(union2));
+  const baseSchema = {
+    parse: (raw, opts) => {
+      return transformAndValidateUnion({
+        value: raw,
+        discriminant: rawDiscriminant,
+        transformedDiscriminant: parsedDiscriminant,
+        transformDiscriminantValue: (discriminantValue) => discriminantValueSchema.parse(discriminantValue, {
+          allowUnrecognizedEnumValues: opts?.allowUnrecognizedUnionMembers,
+          breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], rawDiscriminant]
+        }),
+        getAdditionalPropertiesSchema: (discriminantValue) => union2[discriminantValue],
+        allowUnrecognizedUnionMembers: opts?.allowUnrecognizedUnionMembers,
+        transformAdditionalProperties: (additionalProperties, additionalPropertiesSchema) => additionalPropertiesSchema.parse(additionalProperties, opts),
+        breadcrumbsPrefix: opts?.breadcrumbsPrefix
+      });
+    },
+    json: (parsed, opts) => {
+      return transformAndValidateUnion({
+        value: parsed,
+        discriminant: parsedDiscriminant,
+        transformedDiscriminant: rawDiscriminant,
+        transformDiscriminantValue: (discriminantValue) => discriminantValueSchema.json(discriminantValue, {
+          allowUnrecognizedEnumValues: opts?.allowUnrecognizedUnionMembers,
+          breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], parsedDiscriminant]
+        }),
+        getAdditionalPropertiesSchema: (discriminantValue) => union2[discriminantValue],
+        allowUnrecognizedUnionMembers: opts?.allowUnrecognizedUnionMembers,
+        transformAdditionalProperties: (additionalProperties, additionalPropertiesSchema) => additionalPropertiesSchema.json(additionalProperties, opts),
+        breadcrumbsPrefix: opts?.breadcrumbsPrefix
+      });
+    },
+    getType: () => SchemaType.UNION
+  };
+  return {
+    ...maybeSkipValidation(baseSchema),
+    ...getSchemaUtils(baseSchema),
+    ...getObjectLikeUtils(baseSchema)
+  };
+}
+function transformAndValidateUnion({
+  value,
+  discriminant: discriminant2,
+  transformedDiscriminant,
+  transformDiscriminantValue,
+  getAdditionalPropertiesSchema,
+  allowUnrecognizedUnionMembers = false,
+  transformAdditionalProperties,
+  breadcrumbsPrefix = []
+}) {
+  if (!isPlainObject(value)) {
+    return {
+      ok: false,
+      errors: [
+        {
+          path: breadcrumbsPrefix,
+          message: getErrorMessageForIncorrectType(value, "object")
+        }
+      ]
+    };
+  }
+  const { [discriminant2]: discriminantValue, ...additionalProperties } = value;
+  if (discriminantValue == null) {
+    return {
+      ok: false,
+      errors: [
+        {
+          path: breadcrumbsPrefix,
+          message: `Missing discriminant ("${discriminant2}")`
+        }
+      ]
+    };
+  }
+  const transformedDiscriminantValue = transformDiscriminantValue(discriminantValue);
+  if (!transformedDiscriminantValue.ok) {
+    return {
+      ok: false,
+      errors: transformedDiscriminantValue.errors
+    };
+  }
+  const additionalPropertiesSchema = getAdditionalPropertiesSchema(transformedDiscriminantValue.value);
+  if (additionalPropertiesSchema == null) {
+    if (allowUnrecognizedUnionMembers) {
+      return {
+        ok: true,
+        value: {
+          [transformedDiscriminant]: transformedDiscriminantValue.value,
+          ...additionalProperties
+        }
+      };
+    } else {
+      return {
+        ok: false,
+        errors: [
+          {
+            path: [...breadcrumbsPrefix, discriminant2],
+            message: "Unexpected discriminant value"
+          }
+        ]
+      };
+    }
+  }
+  const transformedAdditionalProperties = transformAdditionalProperties(
+    additionalProperties,
+    additionalPropertiesSchema
+  );
+  if (!transformedAdditionalProperties.ok) {
+    return transformedAdditionalProperties;
+  }
+  return {
+    ok: true,
+    value: {
+      [transformedDiscriminant]: discriminantValue,
+      ...transformedAdditionalProperties.value
+    }
+  };
+}
+
+// src/serialization/index.ts
+var serialization_exports = {};
+__export(serialization_exports, {
+  Actor: () => Actor,
+  ActorName: () => ActorName,
+  ActorsCreateRequest: () => ActorsCreateRequest,
+  ActorsCreateResponse: () => ActorsCreateResponse,
+  ActorsDeleteResponse: () => ActorsDeleteResponse,
+  ActorsGetOrCreateRequest: () => ActorsGetOrCreateRequest,
+  ActorsGetOrCreateResponse: () => ActorsGetOrCreateResponse,
+  ActorsKvGetResponse: () => ActorsKvGetResponse,
+  ActorsListNamesResponse: () => ActorsListNamesResponse,
+  ActorsListResponse: () => ActorsListResponse,
+  CrashPolicy: () => CrashPolicy2,
+  Datacenter: () => Datacenter,
+  DatacenterHealth: () => DatacenterHealth,
+  DatacentersListResponse: () => DatacentersListResponse,
+  HealthFanoutResponse: () => HealthFanoutResponse,
+  HealthResponse: () => HealthResponse,
+  HealthStatus: () => HealthStatus2,
+  MetadataGetResponse: () => MetadataGetResponse,
+  Namespace: () => Namespace,
+  NamespaceListResponse: () => NamespaceListResponse,
+  NamespacesCreateRequest: () => NamespacesCreateRequest,
+  NamespacesCreateResponse: () => NamespacesCreateResponse,
+  Pagination: () => Pagination,
+  RivetId: () => RivetId,
+  Runner: () => Runner,
+  RunnerConfig: () => RunnerConfig,
+  RunnerConfigKind: () => RunnerConfigKind,
+  RunnerConfigKindNormal: () => RunnerConfigKindNormal,
+  RunnerConfigKindServerless: () => RunnerConfigKindServerless,
+  RunnerConfigKindServerlessServerless: () => RunnerConfigKindServerlessServerless,
+  RunnerConfigResponse: () => RunnerConfigResponse,
+  RunnerConfigServerless: () => RunnerConfigServerless,
+  RunnerConfigVariant: () => RunnerConfigVariant2,
+  RunnerConfigsDeleteResponse: () => RunnerConfigsDeleteResponse,
+  RunnerConfigsListResponse: () => RunnerConfigsListResponse,
+  RunnerConfigsListResponseRunnerConfigsValue: () => RunnerConfigsListResponseRunnerConfigsValue,
+  RunnerConfigsRefreshMetadataRequestBody: () => RunnerConfigsRefreshMetadataRequestBody,
+  RunnerConfigsRefreshMetadataResponse: () => RunnerConfigsRefreshMetadataResponse,
+  RunnerConfigsServerlessHealthCheckRequest: () => RunnerConfigsServerlessHealthCheckRequest,
+  RunnerConfigsServerlessHealthCheckResponse: () => RunnerConfigsServerlessHealthCheckResponse,
+  RunnerConfigsServerlessHealthCheckResponseFailure: () => RunnerConfigsServerlessHealthCheckResponseFailure,
+  RunnerConfigsServerlessHealthCheckResponseFailureFailure: () => RunnerConfigsServerlessHealthCheckResponseFailureFailure,
+  RunnerConfigsServerlessHealthCheckResponseSuccess: () => RunnerConfigsServerlessHealthCheckResponseSuccess,
+  RunnerConfigsServerlessHealthCheckResponseSuccessSuccess: () => RunnerConfigsServerlessHealthCheckResponseSuccessSuccess,
+  RunnerConfigsServerlessMetadataError: () => RunnerConfigsServerlessMetadataError,
+  RunnerConfigsServerlessMetadataErrorInvalidRequest: () => RunnerConfigsServerlessMetadataErrorInvalidRequest,
+  RunnerConfigsServerlessMetadataErrorInvalidResponseJson: () => RunnerConfigsServerlessMetadataErrorInvalidResponseJson,
+  RunnerConfigsServerlessMetadataErrorInvalidResponseJsonInvalidResponseJson: () => RunnerConfigsServerlessMetadataErrorInvalidResponseJsonInvalidResponseJson,
+  RunnerConfigsServerlessMetadataErrorInvalidResponseSchema: () => RunnerConfigsServerlessMetadataErrorInvalidResponseSchema,
+  RunnerConfigsServerlessMetadataErrorInvalidResponseSchemaInvalidResponseSchema: () => RunnerConfigsServerlessMetadataErrorInvalidResponseSchemaInvalidResponseSchema,
+  RunnerConfigsServerlessMetadataErrorNonSuccessStatus: () => RunnerConfigsServerlessMetadataErrorNonSuccessStatus,
+  RunnerConfigsServerlessMetadataErrorNonSuccessStatusNonSuccessStatus: () => RunnerConfigsServerlessMetadataErrorNonSuccessStatusNonSuccessStatus,
+  RunnerConfigsServerlessMetadataErrorRequestFailed: () => RunnerConfigsServerlessMetadataErrorRequestFailed,
+  RunnerConfigsServerlessMetadataErrorRequestTimedOut: () => RunnerConfigsServerlessMetadataErrorRequestTimedOut,
+  RunnerConfigsUpsertRequestBody: () => RunnerConfigsUpsertRequestBody,
+  RunnerConfigsUpsertResponse: () => RunnerConfigsUpsertResponse,
+  RunnersListNamesResponse: () => RunnersListNamesResponse,
+  RunnersListResponse: () => RunnersListResponse,
+  namespaces: () => namespaces_exports2
+});
+
+// src/serialization/types/RivetId.ts
+var RivetId = schemas_exports.string();
+
+// src/serialization/types/CrashPolicy.ts
+var CrashPolicy2 = schemas_exports.enum_(["restart", "sleep", "destroy"]);
+
+// src/serialization/types/Actor.ts
+var Actor = schemas_exports.object({
+  actorId: schemas_exports.property("actor_id", RivetId),
+  connectableTs: schemas_exports.property("connectable_ts", schemas_exports.number().optional()),
+  crashPolicy: schemas_exports.property("crash_policy", CrashPolicy2),
+  createTs: schemas_exports.property("create_ts", schemas_exports.number()),
+  datacenter: schemas_exports.string(),
+  destroyTs: schemas_exports.property("destroy_ts", schemas_exports.number().optional()),
+  error: schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional(),
+  key: schemas_exports.string().optional(),
+  name: schemas_exports.string(),
+  namespaceId: schemas_exports.property("namespace_id", RivetId),
+  pendingAllocationTs: schemas_exports.property("pending_allocation_ts", schemas_exports.number().optional()),
+  rescheduleTs: schemas_exports.property("reschedule_ts", schemas_exports.number().optional()),
+  runnerNameSelector: schemas_exports.property("runner_name_selector", schemas_exports.string()),
+  sleepTs: schemas_exports.property("sleep_ts", schemas_exports.number().optional()),
+  startTs: schemas_exports.property("start_ts", schemas_exports.number().optional())
+});
+
+// src/serialization/types/ActorName.ts
+var ActorName = schemas_exports.object({
+  metadata: schemas_exports.record(schemas_exports.string(), schemas_exports.unknown())
+});
+
+// src/serialization/types/ActorsCreateResponse.ts
+var ActorsCreateResponse = schemas_exports.object({
+  actor: Actor
+});
+
+// src/serialization/types/ActorsDeleteResponse.ts
+var ActorsDeleteResponse = schemas_exports.record(schemas_exports.string(), schemas_exports.unknown());
+
+// src/serialization/types/ActorsGetOrCreateResponse.ts
+var ActorsGetOrCreateResponse = schemas_exports.object({
+  actor: Actor,
+  created: schemas_exports.boolean()
+});
+
+// src/serialization/types/ActorsKvGetResponse.ts
+var ActorsKvGetResponse = schemas_exports.object({
+  updateTs: schemas_exports.property("update_ts", schemas_exports.number()),
+  value: schemas_exports.string()
+});
+
+// src/serialization/types/Pagination.ts
+var Pagination = schemas_exports.object({
+  cursor: schemas_exports.string().optional()
+});
+
+// src/serialization/types/ActorsListNamesResponse.ts
+var ActorsListNamesResponse = schemas_exports.object({
+  names: schemas_exports.record(schemas_exports.string(), ActorName),
+  pagination: Pagination
+});
+
+// src/serialization/types/ActorsListResponse.ts
+var ActorsListResponse = schemas_exports.object({
+  actors: schemas_exports.list(Actor),
+  pagination: Pagination
+});
+
+// src/serialization/types/Datacenter.ts
+var Datacenter = schemas_exports.object({
+  label: schemas_exports.number(),
+  name: schemas_exports.string(),
+  url: schemas_exports.string()
+});
+
+// src/serialization/types/HealthResponse.ts
+var HealthResponse = schemas_exports.object({
+  runtime: schemas_exports.string(),
+  status: schemas_exports.string(),
+  version: schemas_exports.string()
+});
+
+// src/serialization/types/HealthStatus.ts
+var HealthStatus2 = schemas_exports.enum_(["ok", "error"]);
+
+// src/serialization/types/DatacenterHealth.ts
+var DatacenterHealth = schemas_exports.object({
+  datacenterLabel: schemas_exports.property("datacenter_label", schemas_exports.number()),
+  datacenterName: schemas_exports.property("datacenter_name", schemas_exports.string()),
+  error: schemas_exports.string().optional(),
+  response: HealthResponse.optional(),
+  rttMs: schemas_exports.property("rtt_ms", schemas_exports.number().optional()),
+  status: HealthStatus2
+});
+
+// src/serialization/types/DatacentersListResponse.ts
+var DatacentersListResponse = schemas_exports.object({
+  datacenters: schemas_exports.list(Datacenter),
+  pagination: Pagination
+});
+
+// src/serialization/types/HealthFanoutResponse.ts
+var HealthFanoutResponse = schemas_exports.object({
+  datacenters: schemas_exports.list(DatacenterHealth)
+});
+
+// src/serialization/types/MetadataGetResponse.ts
+var MetadataGetResponse = schemas_exports.object({
+  buildTimestamp: schemas_exports.property("build_timestamp", schemas_exports.string()),
+  cargoProfile: schemas_exports.property("cargo_profile", schemas_exports.string()),
+  cargoTarget: schemas_exports.property("cargo_target", schemas_exports.string()),
+  gitSha: schemas_exports.property("git_sha", schemas_exports.string()),
+  runtime: schemas_exports.string(),
+  rustcHost: schemas_exports.property("rustc_host", schemas_exports.string()),
+  rustcVersion: schemas_exports.property("rustc_version", schemas_exports.string()),
+  version: schemas_exports.string()
+});
+
+// src/serialization/types/Namespace.ts
+var Namespace = schemas_exports.object({
+  createTs: schemas_exports.property("create_ts", schemas_exports.number()),
+  displayName: schemas_exports.property("display_name", schemas_exports.string()),
+  name: schemas_exports.string(),
+  namespaceId: schemas_exports.property("namespace_id", RivetId)
+});
+
+// src/serialization/types/NamespaceListResponse.ts
+var NamespaceListResponse = schemas_exports.object({
+  namespaces: schemas_exports.list(Namespace),
+  pagination: Pagination
+});
+
+// src/serialization/types/NamespacesCreateResponse.ts
+var NamespacesCreateResponse = schemas_exports.object({
+  namespace: Namespace
+});
+
+// src/serialization/types/Runner.ts
+var Runner = schemas_exports.object({
+  createTs: schemas_exports.property("create_ts", schemas_exports.number()),
+  datacenter: schemas_exports.string(),
+  drainTs: schemas_exports.property("drain_ts", schemas_exports.number().optional()),
+  key: schemas_exports.string(),
+  lastConnectedTs: schemas_exports.property("last_connected_ts", schemas_exports.number().optional()),
+  lastPingTs: schemas_exports.property("last_ping_ts", schemas_exports.number()),
+  lastRtt: schemas_exports.property("last_rtt", schemas_exports.number()),
+  metadata: schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional(),
+  name: schemas_exports.string(),
+  namespaceId: schemas_exports.property("namespace_id", RivetId),
+  remainingSlots: schemas_exports.property("remaining_slots", schemas_exports.number()),
+  runnerId: schemas_exports.property("runner_id", RivetId),
+  stopTs: schemas_exports.property("stop_ts", schemas_exports.number().optional()),
+  totalSlots: schemas_exports.property("total_slots", schemas_exports.number()),
+  version: schemas_exports.number()
+});
+
+// src/serialization/types/RunnerConfigServerless.ts
+var RunnerConfigServerless = schemas_exports.object({
+  headers: schemas_exports.record(schemas_exports.string(), schemas_exports.string()).optional(),
+  maxRunners: schemas_exports.property("max_runners", schemas_exports.number()),
+  metadataPollInterval: schemas_exports.property("metadata_poll_interval", schemas_exports.number().optional()),
+  minRunners: schemas_exports.property("min_runners", schemas_exports.number().optional()),
+  requestLifespan: schemas_exports.property("request_lifespan", schemas_exports.number()),
+  runnersMargin: schemas_exports.property("runners_margin", schemas_exports.number().optional()),
+  slotsPerRunner: schemas_exports.property("slots_per_runner", schemas_exports.number()),
+  url: schemas_exports.string()
+});
+
+// src/serialization/types/RunnerConfig.ts
+var RunnerConfig = schemas_exports.object({
+  normal: schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional(),
+  serverless: RunnerConfigServerless.optional(),
+  drainOnVersionUpgrade: schemas_exports.property(
+    "drain_on_version_upgrade",
+    schemas_exports.boolean().optional()
+  ),
+  metadata: schemas_exports.unknown().optional()
+});
+
+// src/serialization/types/RunnerConfigKindNormal.ts
+var RunnerConfigKindNormal = schemas_exports.object({
+  normal: schemas_exports.record(schemas_exports.string(), schemas_exports.unknown())
+});
+
+// src/serialization/types/RunnerConfigKindServerlessServerless.ts
+var RunnerConfigKindServerlessServerless = schemas_exports.object({
+  headers: schemas_exports.record(schemas_exports.string(), schemas_exports.string()).optional(),
+  maxRunners: schemas_exports.property("max_runners", schemas_exports.number()),
+  metadataPollInterval: schemas_exports.property("metadata_poll_interval", schemas_exports.number().optional()),
+  minRunners: schemas_exports.property("min_runners", schemas_exports.number().optional()),
+  requestLifespan: schemas_exports.property("request_lifespan", schemas_exports.number()),
+  runnersMargin: schemas_exports.property("runners_margin", schemas_exports.number().optional()),
+  slotsPerRunner: schemas_exports.property("slots_per_runner", schemas_exports.number()),
+  url: schemas_exports.string()
+});
+
+// src/serialization/types/RunnerConfigKindServerless.ts
+var RunnerConfigKindServerless = schemas_exports.object({
+  serverless: RunnerConfigKindServerlessServerless
+});
+
+// src/serialization/types/RunnerConfigKind.ts
+var RunnerConfigKind = schemas_exports.undiscriminatedUnion([RunnerConfigKindNormal, RunnerConfigKindServerless]);
+
+// src/serialization/types/RunnerConfigResponse.ts
+var RunnerConfigResponse = schemas_exports.object({
+  runnerPoolError: schemas_exports.property(
+    "runner_pool_error",
+    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
+  )
+}).extend(RunnerConfig);
+
+// src/serialization/types/RunnerConfigVariant.ts
+var RunnerConfigVariant2 = schemas_exports.enum_(["serverless", "normal"]);
+
+// src/serialization/types/RunnerConfigsDeleteResponse.ts
+var RunnerConfigsDeleteResponse = schemas_exports.record(schemas_exports.string(), schemas_exports.unknown());
+
+// src/serialization/types/RunnerConfigsListResponseRunnerConfigsValue.ts
+var RunnerConfigsListResponseRunnerConfigsValue = schemas_exports.object({
+  datacenters: schemas_exports.record(schemas_exports.string(), RunnerConfigResponse)
+});
+
+// src/serialization/types/RunnerConfigsListResponse.ts
+var RunnerConfigsListResponse = schemas_exports.object({
+  pagination: Pagination,
+  runnerConfigs: schemas_exports.property(
+    "runner_configs",
+    schemas_exports.record(schemas_exports.string(), RunnerConfigsListResponseRunnerConfigsValue)
+  )
+});
+
+// src/serialization/types/RunnerConfigsRefreshMetadataRequestBody.ts
+var RunnerConfigsRefreshMetadataRequestBody = schemas_exports.record(schemas_exports.string(), schemas_exports.unknown());
+
+// src/serialization/types/RunnerConfigsRefreshMetadataResponse.ts
+var RunnerConfigsRefreshMetadataResponse = schemas_exports.record(schemas_exports.string(), schemas_exports.unknown());
+
+// src/serialization/types/RunnerConfigsServerlessHealthCheckResponseSuccessSuccess.ts
+var RunnerConfigsServerlessHealthCheckResponseSuccessSuccess = schemas_exports.object({
+  version: schemas_exports.string()
+});
+
+// src/serialization/types/RunnerConfigsServerlessHealthCheckResponseSuccess.ts
+var RunnerConfigsServerlessHealthCheckResponseSuccess = schemas_exports.object({
+  success: RunnerConfigsServerlessHealthCheckResponseSuccessSuccess
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataErrorInvalidRequest.ts
+var RunnerConfigsServerlessMetadataErrorInvalidRequest = schemas_exports.object({
+  invalidRequest: schemas_exports.property(
+    "invalid_request",
+    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown())
+  )
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataErrorRequestFailed.ts
+var RunnerConfigsServerlessMetadataErrorRequestFailed = schemas_exports.object({
+  requestFailed: schemas_exports.property(
+    "request_failed",
+    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown())
+  )
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataErrorRequestTimedOut.ts
+var RunnerConfigsServerlessMetadataErrorRequestTimedOut = schemas_exports.object({
+  requestTimedOut: schemas_exports.property(
+    "request_timed_out",
+    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown())
+  )
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataErrorNonSuccessStatusNonSuccessStatus.ts
+var RunnerConfigsServerlessMetadataErrorNonSuccessStatusNonSuccessStatus = schemas_exports.object({
+  body: schemas_exports.string(),
+  statusCode: schemas_exports.property("status_code", schemas_exports.number())
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataErrorNonSuccessStatus.ts
+var RunnerConfigsServerlessMetadataErrorNonSuccessStatus = schemas_exports.object({
+  nonSuccessStatus: schemas_exports.property(
+    "non_success_status",
+    RunnerConfigsServerlessMetadataErrorNonSuccessStatusNonSuccessStatus
+  )
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataErrorInvalidResponseJsonInvalidResponseJson.ts
+var RunnerConfigsServerlessMetadataErrorInvalidResponseJsonInvalidResponseJson = schemas_exports.object({
+  body: schemas_exports.string()
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataErrorInvalidResponseJson.ts
+var RunnerConfigsServerlessMetadataErrorInvalidResponseJson = schemas_exports.object({
+  invalidResponseJson: schemas_exports.property(
+    "invalid_response_json",
+    RunnerConfigsServerlessMetadataErrorInvalidResponseJsonInvalidResponseJson
+  )
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataErrorInvalidResponseSchemaInvalidResponseSchema.ts
+var RunnerConfigsServerlessMetadataErrorInvalidResponseSchemaInvalidResponseSchema = schemas_exports.object({
+  runtime: schemas_exports.string(),
+  version: schemas_exports.string()
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataErrorInvalidResponseSchema.ts
+var RunnerConfigsServerlessMetadataErrorInvalidResponseSchema = schemas_exports.object({
+  invalidResponseSchema: schemas_exports.property(
+    "invalid_response_schema",
+    RunnerConfigsServerlessMetadataErrorInvalidResponseSchemaInvalidResponseSchema
+  )
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataError.ts
+var RunnerConfigsServerlessMetadataError = schemas_exports.undiscriminatedUnion([
+  RunnerConfigsServerlessMetadataErrorInvalidRequest,
+  RunnerConfigsServerlessMetadataErrorRequestFailed,
+  RunnerConfigsServerlessMetadataErrorRequestTimedOut,
+  RunnerConfigsServerlessMetadataErrorNonSuccessStatus,
+  RunnerConfigsServerlessMetadataErrorInvalidResponseJson,
+  RunnerConfigsServerlessMetadataErrorInvalidResponseSchema
+]);
+
+// src/serialization/types/RunnerConfigsServerlessHealthCheckResponseFailureFailure.ts
+var RunnerConfigsServerlessHealthCheckResponseFailureFailure = schemas_exports.object({
+  error: RunnerConfigsServerlessMetadataError
+});
+
+// src/serialization/types/RunnerConfigsServerlessHealthCheckResponseFailure.ts
+var RunnerConfigsServerlessHealthCheckResponseFailure = schemas_exports.object({
+  failure: RunnerConfigsServerlessHealthCheckResponseFailureFailure
+});
+
+// src/serialization/types/RunnerConfigsServerlessHealthCheckResponse.ts
+var RunnerConfigsServerlessHealthCheckResponse = schemas_exports.undiscriminatedUnion([
+  RunnerConfigsServerlessHealthCheckResponseSuccess,
+  RunnerConfigsServerlessHealthCheckResponseFailure
+]);
+
+// src/serialization/types/RunnerConfigsUpsertResponse.ts
+var RunnerConfigsUpsertResponse = schemas_exports.object({
+  endpointConfigChanged: schemas_exports.property("endpoint_config_changed", schemas_exports.boolean())
+});
+
+// src/serialization/types/RunnersListNamesResponse.ts
+var RunnersListNamesResponse = schemas_exports.object({
+  names: schemas_exports.list(schemas_exports.string()),
+  pagination: Pagination
+});
+
+// src/serialization/types/RunnersListResponse.ts
+var RunnersListResponse = schemas_exports.object({
+  pagination: Pagination,
+  runners: schemas_exports.list(Runner)
+});
+
+// src/serialization/client/requests/ActorsCreateRequest.ts
+var ActorsCreateRequest = schemas_exports.object({
+  crashPolicy: schemas_exports.property("crash_policy", CrashPolicy2),
+  datacenter: schemas_exports.string().optional(),
+  input: schemas_exports.string().optional(),
+  key: schemas_exports.string().optional(),
+  name: schemas_exports.string(),
+  runnerNameSelector: schemas_exports.property("runner_name_selector", schemas_exports.string())
+});
+
+// src/serialization/client/requests/ActorsGetOrCreateRequest.ts
+var ActorsGetOrCreateRequest = schemas_exports.object({
+  crashPolicy: schemas_exports.property("crash_policy", CrashPolicy2),
+  datacenter: schemas_exports.string().optional(),
+  input: schemas_exports.string().optional(),
+  key: schemas_exports.string(),
+  name: schemas_exports.string(),
+  runnerNameSelector: schemas_exports.property("runner_name_selector", schemas_exports.string())
+});
+
+// src/serialization/client/requests/RunnerConfigsServerlessHealthCheckRequest.ts
+var RunnerConfigsServerlessHealthCheckRequest = schemas_exports.object({
+  headers: schemas_exports.record(schemas_exports.string(), schemas_exports.string()).optional(),
+  url: schemas_exports.string()
+});
+
+// src/serialization/client/requests/RunnerConfigsUpsertRequestBody.ts
+var RunnerConfigsUpsertRequestBody = schemas_exports.object({
+  datacenters: schemas_exports.record(schemas_exports.string(), RunnerConfig)
+});
+
+// src/serialization/resources/namespaces/index.ts
+var namespaces_exports2 = {};
+__export(namespaces_exports2, {
+  NamespacesCreateRequest: () => NamespacesCreateRequest
+});
+
+// src/serialization/resources/namespaces/client/requests/NamespacesCreateRequest.ts
+var NamespacesCreateRequest = schemas_exports.object({
+  displayName: schemas_exports.property("display_name", schemas_exports.string()),
+  name: schemas_exports.string()
+});
+
+// src/Client.ts
+var import_url_join6 = __toESM(require("url-join"));
+
+// src/errors/RivetError.ts
+var RivetError = class _RivetError extends Error {
+  statusCode;
+  body;
+  constructor({ message, statusCode, body }) {
+    super(buildMessage({ message, statusCode, body }));
+    Object.setPrototypeOf(this, _RivetError.prototype);
+    if (statusCode != null) {
+      this.statusCode = statusCode;
+    }
+    if (body !== void 0) {
+      this.body = body;
+    }
+  }
+};
+function buildMessage({
+  message,
+  statusCode,
+  body
+}) {
+  let lines = [];
+  if (message != null) {
+    lines.push(message);
+  }
+  if (statusCode != null) {
+    lines.push(`Status code: ${statusCode.toString()}`);
+  }
+  if (body != null) {
+    lines.push(`Body: ${toJson(body, void 0, 2)}`);
+  }
+  return lines.join("\n");
+}
+
+// src/errors/RivetTimeoutError.ts
+var RivetTimeoutError = class _RivetTimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, _RivetTimeoutError.prototype);
+  }
+};
+
+// src/api/resources/datacenters/client/Client.ts
+var import_url_join = __toESM(require("url-join"));
+var Datacenters = class {
+  constructor(_options) {
+    this._options = _options;
+  }
+  /**
+   * @param {Datacenters.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.datacenters.list()
+   */
+  async list(requestOptions) {
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "datacenters"
+      ),
+      method: "GET",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      requestType: "json",
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return DatacentersListResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError("Timeout exceeded when calling GET /datacenters.");
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  async _getAuthorizationHeader() {
+    return `Bearer ${await Supplier.get(this._options.token)}`;
+  }
+};
+
+// src/api/resources/health/client/Client.ts
+var import_url_join2 = __toESM(require("url-join"));
+var Health = class {
+  constructor(_options) {
+    this._options = _options;
+  }
+  /**
+   * @param {Health.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.health.fanout()
+   */
+  async fanout(requestOptions) {
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join2.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "health/fanout"
+      ),
+      method: "GET",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      requestType: "json",
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return HealthFanoutResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError("Timeout exceeded when calling GET /health/fanout.");
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  async _getAuthorizationHeader() {
+    return `Bearer ${await Supplier.get(this._options.token)}`;
+  }
+};
+
+// src/api/resources/metadata/client/Client.ts
+var import_url_join3 = __toESM(require("url-join"));
+var Metadata = class {
+  constructor(_options) {
+    this._options = _options;
+  }
+  /**
+   * @param {Metadata.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.metadata.get()
+   */
+  async get(requestOptions) {
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join3.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "metadata"
+      ),
+      method: "GET",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      requestType: "json",
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return MetadataGetResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError("Timeout exceeded when calling GET /metadata.");
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  async _getAuthorizationHeader() {
+    return `Bearer ${await Supplier.get(this._options.token)}`;
+  }
+};
+
+// src/api/resources/namespaces/client/Client.ts
+var import_url_join4 = __toESM(require("url-join"));
+var Namespaces = class {
+  constructor(_options) {
+    this._options = _options;
+  }
+  /**
+   * @param {Rivet.NamespacesListRequest} request
+   * @param {Namespaces.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.namespaces.list()
+   */
+  async list(request = {}, requestOptions) {
+    const { limit, cursor, name, namespaceIds, namespaceId } = request;
+    const _queryParams = {};
+    if (limit != null) {
+      _queryParams["limit"] = limit.toString();
+    }
+    if (cursor != null) {
+      _queryParams["cursor"] = cursor;
+    }
+    if (name != null) {
+      _queryParams["name"] = name;
+    }
+    if (namespaceIds != null) {
+      _queryParams["namespace_ids"] = namespaceIds;
+    }
+    if (namespaceId != null) {
+      if (Array.isArray(namespaceId)) {
+        _queryParams["namespace_id"] = namespaceId.map(
+          (item) => RivetId.jsonOrThrow(item, { unrecognizedObjectKeys: "strip" })
+        );
+      } else {
+        _queryParams["namespace_id"] = namespaceId;
+      }
+    }
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join4.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "namespaces"
+      ),
+      method: "GET",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return NamespaceListResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError("Timeout exceeded when calling GET /namespaces.");
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  /**
+   * @param {Rivet.NamespacesCreateRequest} request
+   * @param {Namespaces.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.namespaces.create({
+   *         displayName: "display_name",
+   *         name: "name"
+   *     })
+   */
+  async create(request, requestOptions) {
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join4.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "namespaces"
+      ),
+      method: "POST",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      requestType: "json",
+      body: NamespacesCreateRequest.jsonOrThrow(request, { unrecognizedObjectKeys: "strip" }),
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return NamespacesCreateResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError("Timeout exceeded when calling POST /namespaces.");
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  async _getAuthorizationHeader() {
+    return `Bearer ${await Supplier.get(this._options.token)}`;
+  }
+};
+
+// src/api/resources/runners/client/Client.ts
+var import_url_join5 = __toESM(require("url-join"));
+var Runners = class {
+  constructor(_options) {
+    this._options = _options;
+  }
+  /**
+   * @param {Rivet.RunnersListRequest} request
+   * @param {Runners.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.runners.list({
+   *         namespace: "namespace"
+   *     })
+   */
+  async list(request, requestOptions) {
+    const { namespace, name, runnerIds, runnerId, includeStopped, limit, cursor } = request;
+    const _queryParams = {};
+    _queryParams["namespace"] = namespace;
+    if (name != null) {
+      _queryParams["name"] = name;
+    }
+    if (runnerIds != null) {
+      _queryParams["runner_ids"] = runnerIds;
+    }
+    if (runnerId != null) {
+      if (Array.isArray(runnerId)) {
+        _queryParams["runner_id"] = runnerId.map(
+          (item) => RivetId.jsonOrThrow(item, { unrecognizedObjectKeys: "strip" })
+        );
+      } else {
+        _queryParams["runner_id"] = runnerId;
+      }
+    }
+    if (includeStopped != null) {
+      _queryParams["include_stopped"] = includeStopped.toString();
+    }
+    if (limit != null) {
+      _queryParams["limit"] = limit.toString();
+    }
+    if (cursor != null) {
+      _queryParams["cursor"] = cursor;
+    }
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join5.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "runners"
+      ),
+      method: "GET",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return RunnersListResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError("Timeout exceeded when calling GET /runners.");
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  /**
+   * 2 round trips:
+   *
+   * - GET /runners/names (fanout)
+   * - [api-peer] namespace::ops::resolve_for_name_global
+   *
+   * @param {Rivet.RunnersListNamesRequest} request
+   * @param {Runners.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.runners.listNames({
+   *         namespace: "namespace"
+   *     })
+   */
+  async listNames(request, requestOptions) {
+    const { namespace, limit, cursor } = request;
+    const _queryParams = {};
+    _queryParams["namespace"] = namespace;
+    if (limit != null) {
+      _queryParams["limit"] = limit.toString();
+    }
+    if (cursor != null) {
+      _queryParams["cursor"] = cursor;
+    }
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join5.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "runners/names"
+      ),
+      method: "GET",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return RunnersListNamesResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError("Timeout exceeded when calling GET /runners/names.");
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  async _getAuthorizationHeader() {
+    return `Bearer ${await Supplier.get(this._options.token)}`;
+  }
+};
+
+// src/Client.ts
+var RivetClient = class {
+  constructor(_options) {
+    this._options = _options;
+  }
+  _datacenters;
+  _health;
+  _metadata;
+  _namespaces;
+  _runners;
+  get datacenters() {
+    return this._datacenters ??= new Datacenters(this._options);
+  }
+  get health() {
+    return this._health ??= new Health(this._options);
+  }
+  get metadata() {
+    return this._metadata ??= new Metadata(this._options);
+  }
+  get namespaces() {
+    return this._namespaces ??= new Namespaces(this._options);
+  }
+  get runners() {
+    return this._runners ??= new Runners(this._options);
+  }
+  /**
+   * **If key is some & `include_destroyed` is false**
+   *
+   * 2 round trips:
+   *
+   * - namespace::ops::resolve_for_name_global
+   * - GET /actors (multiple DCs based on actor IDs)
+   *
+   *   This path is optimized because we can read the actor IDs fro the key directly from Epoxy with
+   *   stale consistency to determine which datacenter the actor lives in. Under most circumstances,
+   *   this means we don't need to fan out to all datacenters (like normal list does).
+   *
+   *   The reason `include_destroyed` has to be false is Epoxy only stores currently active actors. If
+   *   `include_destroyed` is true, we show all previous iterations of actors with the same key.
+   *
+   * **Otherwise**
+   *
+   * 2 round trips:
+   *
+   * - namespace::ops::resolve_for_name_global
+   * - GET /actors (fanout)
+   *
+   * ## Optimized Alternative Routes
+   *
+   * @param {Rivet.ActorsListRequest} request
+   * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.actorsList({
+   *         namespace: "namespace"
+   *     })
+   */
+  async actorsList(request, requestOptions) {
+    const { namespace, name, key, actorIds, actorId, includeDestroyed, limit, cursor } = request;
+    const _queryParams = {};
+    _queryParams["namespace"] = namespace;
+    if (name != null) {
+      _queryParams["name"] = name;
+    }
+    if (key != null) {
+      _queryParams["key"] = key;
+    }
+    if (actorIds != null) {
+      _queryParams["actor_ids"] = actorIds;
+    }
+    if (actorId != null) {
+      if (Array.isArray(actorId)) {
+        _queryParams["actor_id"] = actorId.map(
+          (item) => RivetId.jsonOrThrow(item, { unrecognizedObjectKeys: "strip" })
+        );
+      } else {
+        _queryParams["actor_id"] = actorId;
+      }
+    }
+    if (includeDestroyed != null) {
+      _queryParams["include_destroyed"] = includeDestroyed.toString();
+    }
+    if (limit != null) {
+      _queryParams["limit"] = limit.toString();
+    }
+    if (cursor != null) {
+      _queryParams["cursor"] = cursor;
+    }
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join6.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "actors"
+      ),
+      method: "GET",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return ActorsListResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError("Timeout exceeded when calling GET /actors.");
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  /**
+   * **If actor is created in the current datacenter:**
+   *
+   * 2 round trips:
+   *
+   * - namespace::ops::resolve_for_name_global
+   * - [pegboard::workflows::actor] Create actor workflow (includes Epoxy key allocation)
+   *
+   * **If actor is created in a different datacenter:**
+   *
+   * 3 round trips:
+   *
+   * - namespace::ops::resolve_for_name_global
+   * - POST /actors to remote datacenter
+   * - [pegboard::workflows::actor] Create actor workflow (includes Epoxy key allocation)
+   *
+   * actor::get will always be in the same datacenter.
+   *
+   * @param {Rivet.ActorsCreateRequest} request
+   * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.actorsCreate({
+   *         namespace: "namespace",
+   *         crashPolicy: "restart",
+   *         name: "name",
+   *         runnerNameSelector: "runner_name_selector"
+   *     })
+   */
+  async actorsCreate(request, requestOptions) {
+    const { namespace, ..._body } = request;
+    const _queryParams = {};
+    _queryParams["namespace"] = namespace;
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join6.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "actors"
+      ),
+      method: "POST",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      body: ActorsCreateRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return ActorsCreateResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError("Timeout exceeded when calling POST /actors.");
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  /**
+   * **If actor exists**
+   *
+   * 2 round trips:
+   *
+   * - namespace::ops::resolve_for_name_global
+   * - GET /actors/{}
+   *
+   * **If actor does not exist and is created in the current datacenter:**
+   *
+   * 2 round trips:
+   *
+   * - namespace::ops::resolve_for_name_global
+   * - [pegboard::workflows::actor] Create actor workflow (includes Epoxy key allocation)
+   *
+   * **If actor does not exist and is created in a different datacenter:**
+   *
+   * 3 round trips:
+   *
+   * - namespace::ops::resolve_for_name_global
+   * - POST /actors to remote datacenter
+   * - [pegboard::workflows::actor] Create actor workflow (includes Epoxy key allocation)
+   *
+   * actor::get will always be in the same datacenter.
+   *
+   * ## Optimized Alternative Routes
+   *
+   * @param {Rivet.ActorsGetOrCreateRequest} request
+   * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.actorsGetOrCreate({
+   *         namespace: "namespace",
+   *         crashPolicy: "restart",
+   *         key: "key",
+   *         name: "name",
+   *         runnerNameSelector: "runner_name_selector"
+   *     })
+   */
+  async actorsGetOrCreate(request, requestOptions) {
+    const { namespace, ..._body } = request;
+    const _queryParams = {};
+    _queryParams["namespace"] = namespace;
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join6.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "actors"
+      ),
+      method: "PUT",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      body: ActorsGetOrCreateRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return ActorsGetOrCreateResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError("Timeout exceeded when calling PUT /actors.");
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  /**
+   * 2 round trips:
+   *
+   * - GET /actors/names (fanout)
+   * - [api-peer] namespace::ops::resolve_for_name_global
+   *
+   * @param {Rivet.ActorsListNamesRequest} request
+   * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.actorsListNames({
+   *         namespace: "namespace"
+   *     })
+   */
+  async actorsListNames(request, requestOptions) {
+    const { namespace, limit, cursor } = request;
+    const _queryParams = {};
+    _queryParams["namespace"] = namespace;
+    if (limit != null) {
+      _queryParams["limit"] = limit.toString();
+    }
+    if (cursor != null) {
+      _queryParams["cursor"] = cursor;
+    }
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join6.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "actors/names"
+      ),
+      method: "GET",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return ActorsListNamesResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError("Timeout exceeded when calling GET /actors/names.");
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  /**
+   * 2 round trip:
+   *
+   * - DELETE /actors/{}
+   * - [api-peer] namespace::ops::resolve_for_name_global
+   *
+   * @param {Rivet.RivetId} actorId
+   * @param {Rivet.ActorsDeleteRequest} request
+   * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.actorsDelete("actor_id", {
+   *         namespace: "namespace"
+   *     })
+   */
+  async actorsDelete(actorId, request, requestOptions) {
+    const { namespace } = request;
+    const _queryParams = {};
+    _queryParams["namespace"] = namespace;
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join6.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        `actors/${encodeURIComponent(RivetId.jsonOrThrow(actorId))}`
+      ),
+      method: "DELETE",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return ActorsDeleteResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError("Timeout exceeded when calling DELETE /actors/{actor_id}.");
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  /**
+   * @param {Rivet.RivetId} actorId
+   * @param {string} key
+   * @param {Rivet.ActorsKvGetRequest} request
+   * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.actorsKvGet("actor_id", "key", {
+   *         namespace: "namespace"
+   *     })
+   */
+  async actorsKvGet(actorId, key, request, requestOptions) {
+    const { namespace } = request;
+    const _queryParams = {};
+    _queryParams["namespace"] = namespace;
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join6.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        `actors/${encodeURIComponent(RivetId.jsonOrThrow(actorId))}/kv/keys/${encodeURIComponent(key)}`
+      ),
+      method: "GET",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return ActorsKvGetResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError(
+          "Timeout exceeded when calling GET /actors/{actor_id}/kv/keys/{key}."
+        );
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  /**
+   * @param {Rivet.RunnerConfigsListRequest} request
+   * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.runnerConfigsList({
+   *         namespace: "namespace"
+   *     })
+   */
+  async runnerConfigsList(request, requestOptions) {
+    const { namespace, limit, cursor, variant, runnerNames, runnerName } = request;
+    const _queryParams = {};
+    _queryParams["namespace"] = namespace;
+    if (limit != null) {
+      _queryParams["limit"] = limit.toString();
+    }
+    if (cursor != null) {
+      _queryParams["cursor"] = cursor;
+    }
+    if (variant != null) {
+      _queryParams["variant"] = RunnerConfigVariant2.jsonOrThrow(variant, {
+        unrecognizedObjectKeys: "strip"
+      });
+    }
+    if (runnerNames != null) {
+      _queryParams["runner_names"] = runnerNames;
+    }
+    if (runnerName != null) {
+      if (Array.isArray(runnerName)) {
+        _queryParams["runner_name"] = runnerName.map((item) => item);
+      } else {
+        _queryParams["runner_name"] = runnerName;
+      }
+    }
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join6.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "runner-configs"
+      ),
+      method: "GET",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return RunnerConfigsListResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError("Timeout exceeded when calling GET /runner-configs.");
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  /**
+   * @param {Rivet.RunnerConfigsServerlessHealthCheckRequest} request
+   * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.runnerConfigsServerlessHealthCheck({
+   *         namespace: "namespace",
+   *         url: "url"
+   *     })
+   */
+  async runnerConfigsServerlessHealthCheck(request, requestOptions) {
+    const { namespace, ..._body } = request;
+    const _queryParams = {};
+    _queryParams["namespace"] = namespace;
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join6.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "runner-configs/serverless-health-check"
+      ),
+      method: "POST",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      body: RunnerConfigsServerlessHealthCheckRequest.jsonOrThrow(_body, {
+        unrecognizedObjectKeys: "strip"
+      }),
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return RunnerConfigsServerlessHealthCheckResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError(
+          "Timeout exceeded when calling POST /runner-configs/serverless-health-check."
+        );
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  /**
+   * @param {string} runnerName
+   * @param {Rivet.RunnerConfigsUpsertRequestBody} request
+   * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.runnerConfigsUpsert("runner_name", {
+   *         namespace: "namespace",
+   *         datacenters: {
+   *             "key": {}
+   *         }
+   *     })
+   */
+  async runnerConfigsUpsert(runnerName, request, requestOptions) {
+    const { namespace, ..._body } = request;
+    const _queryParams = {};
+    _queryParams["namespace"] = namespace;
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join6.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        `runner-configs/${encodeURIComponent(runnerName)}`
+      ),
+      method: "PUT",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      body: RunnerConfigsUpsertRequestBody.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return RunnerConfigsUpsertResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError("Timeout exceeded when calling PUT /runner-configs/{runner_name}.");
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  /**
+   * @param {string} runnerName
+   * @param {Rivet.RunnerConfigsDeleteRequest} request
+   * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.runnerConfigsDelete("runner_name", {
+   *         namespace: "namespace"
+   *     })
+   */
+  async runnerConfigsDelete(runnerName, request, requestOptions) {
+    const { namespace } = request;
+    const _queryParams = {};
+    _queryParams["namespace"] = namespace;
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join6.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        `runner-configs/${encodeURIComponent(runnerName)}`
+      ),
+      method: "DELETE",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return RunnerConfigsDeleteResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError(
+          "Timeout exceeded when calling DELETE /runner-configs/{runner_name}."
+        );
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  /**
+   * @param {string} runnerName
+   * @param {Rivet.RunnerConfigsRefreshMetadataRequest} request
+   * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.runnerConfigsRefreshMetadata("runner_name", {
+   *         namespace: "namespace",
+   *         body: {
+   *             "key": "value"
+   *         }
+   *     })
+   */
+  async runnerConfigsRefreshMetadata(runnerName, request, requestOptions) {
+    const { namespace, body: _body } = request;
+    const _queryParams = {};
+    _queryParams["namespace"] = namespace;
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join6.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        `runner-configs/${encodeURIComponent(runnerName)}/refresh-metadata`
+      ),
+      method: "POST",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      body: RunnerConfigsRefreshMetadataRequestBody.jsonOrThrow(_body, {
+        unrecognizedObjectKeys: "strip"
+      }),
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return RunnerConfigsRefreshMetadataResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError(
+          "Timeout exceeded when calling POST /runner-configs/{runner_name}/refresh-metadata."
+        );
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  async _getAuthorizationHeader() {
+    return `Bearer ${await Supplier.get(this._options.token)}`;
+  }
+};