@rivetkit/engine-api-full 25.5.3

package/dist/browser/esm/core.js

@@ -0,0 +1,2271 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 });
+};
+
+// 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/core/json.ts
+var toJson = (value, replacer, space) => {
+  return JSON.stringify(value, replacer, space);
+};
+
+// src/core/fetcher/createRequestUrl.ts
+import qs from "qs";
+function createRequestUrl(baseUrl, queryParameters) {
+  return Object.keys(queryParameters ?? {}).length > 0 ? `${baseUrl}?${qs.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/getHeader.ts
+function getHeader(headers, header) {
+  for (const [headerKey, headerValue] of Object.entries(headers)) {
+    if (headerKey.toLowerCase() === header.toLowerCase()) {
+      return headerValue;
+    }
+  }
+  return void 0;
+}
+
+// src/core/fetcher/Supplier.ts
+var Supplier = {
+  get: async (supplier) => {
+    if (typeof supplier === "function") {
+      return supplier();
+    } else {
+      return supplier;
+    }
+  }
+};
+
+// 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
+    }
+  };
+}
+export {
+  RUNTIME,
+  Supplier,
+  fetcher,
+  getHeader,
+  schemas_exports as serialization
+};