@kaito-http/core 4.0.0-beta.3 → 4.0.0-beta.31

package/dist/index.cjs

@@ -20,18 +20,38 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  BaseSchema: () => BaseSchema,
+  KArray: () => KArray,
+  KBoolean: () => KBoolean,
+  KLazy: () => KLazy,
+  KLiteral: () => KLiteral,
+  KNativeEnum: () => KNativeEnum,
+  KNull: () => KNull,
+  KNumber: () => KNumber,
+  KObject: () => KObject,
+  KObjectFromURLSearchParams: () => KObjectFromURLSearchParams,
+  KRecord: () => KRecord,
+  KRef: () => KRef,
+  KScalar: () => KScalar,
+  KString: () => KString,
+  KUnion: () => KUnion,
   KaitoError: () => KaitoError,
+  KaitoHead: () => KaitoHead,
   KaitoRequest: () => KaitoRequest,
+  ParseContext: () => ParseContext,
   Router: () => Router,
+  STRING_FORMAT_REGEXES: () => STRING_FORMAT_REGEXES,
+  SchemaError: () => SchemaError,
   WrappedError: () => WrappedError,
   create: () => create,
-  isNodeLikeDev: () => isNodeLikeDev
+  isNodeLikeDev: () => isNodeLikeDev,
+  isPrimitiveJSONValue: () => isPrimitiveJSONValue,
+  k: () => k
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/router/router.ts
-var import_zod = require("zod");
-var import_zod_openapi = require("zod-openapi");
+var OpenAPI = require("openapi3-ts/oas31");
 
 // src/error.ts
 var WrappedError = class _WrappedError extends Error {
@@ -84,14 +104,14 @@ var KaitoHead = class {
    * @param body The Kaito JSON format to be sent as the response body
    * @returns A Response instance, ready to be sent
    */
-  toResponse(body) {
+  toResponse(data) {
     const init = {
       status: this.#status
     };
     if (this.#headers) {
       init.headers = this.#headers;
     }
-    return Response.json(body, init);
+    return Response.json(data, init);
   }
   /**
    * Whether this KaitoHead instance has been touched/modified
@@ -139,43 +159,1048 @@ var KaitoRequest = class {
   }
 };
 
+// src/schema/schema.ts
+function isPrimitiveJSONValue(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null;
+}
+var SchemaError = class extends Error {
+  constructor(issues) {
+    const first = issues.values().next().value;
+    if (first === void 0) {
+      throw new Error("SchemaError expects at least one issue to be provided");
+    }
+    super(first.message);
+    this.issues = issues;
+  }
+};
+var ParseContext = class _ParseContext {
+  static ISSUE = Symbol("ISSUE");
+  ISSUE = _ParseContext.ISSUE;
+  #issues = /* @__PURE__ */ new Set();
+  addIssue(message, path) {
+    this.#issues.add({ message, path });
+    return _ParseContext.ISSUE;
+  }
+  addIssues(issues, path) {
+    for (const issue of issues) {
+      this.#issues.add({ ...issue, path: [...path, ...issue.path] });
+    }
+    return _ParseContext.ISSUE;
+  }
+  get issues() {
+    return this.#issues;
+  }
+  static result(fn) {
+    const result = _ParseContext.with(fn);
+    if (result.type === "FATAL" || result.issues.size > 0) {
+      return {
+        success: false,
+        issues: result.issues
+      };
+    }
+    return {
+      success: true,
+      result: result.data
+    };
+  }
+  static with(fn) {
+    const ctx = new _ParseContext();
+    const data = fn(ctx);
+    if (data === _ParseContext.ISSUE) {
+      return {
+        type: "FATAL",
+        issues: ctx.issues
+      };
+    }
+    return {
+      type: "PARSED",
+      issues: ctx.issues,
+      data
+    };
+  }
+};
+var BaseSchema = class {
+  /** @internal */
+  _input;
+  /** @internal */
+  _output;
+  def;
+  getSchemaObject() {
+    const schema = {};
+    if (this.def.description !== void 0) {
+      schema.description = this.def.description;
+    }
+    if (this.def.example !== void 0) {
+      schema.example = this.def.example;
+    }
+    return schema;
+  }
+  clone(def) {
+    return new this.constructor({
+      ...this.def,
+      ...def
+    });
+  }
+  constructor(def) {
+    this.def = def;
+  }
+  or(other) {
+    return k.union([this, other]);
+  }
+  example(example) {
+    if (example === void 0) {
+      return this.def.example;
+    }
+    return this.clone({ example });
+  }
+  description(description) {
+    if (description === void 0) {
+      return this.def.description;
+    }
+    return this.clone({ description });
+  }
+};
+var STRING_FORMAT_REGEXES = {
+  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i,
+  email: /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i,
+  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+  ipv6: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/,
+  date: /^([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/,
+  uri: /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\/.+|^[a-zA-Z][a-zA-Z0-9+.-]*:[^\/].+/,
+  hostname: /^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$/
+};
+var KString = class _KString extends BaseSchema {
+  static create = () => new _KString({});
+  serialize(value) {
+    return value;
+  }
+  setCheck(check) {
+    return this.clone({ [check.type]: check });
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    const schema = {
+      ...baseSchema,
+      type: "string"
+    };
+    if (this.def.regex) {
+      schema.pattern = this.def.regex.regex.source;
+    }
+    if (this.def.format) {
+      schema.format = this.def.format.format;
+    }
+    if (this.def.min !== void 0) {
+      schema.minLength = this.def.min.val;
+    }
+    if (this.def.max !== void 0) {
+      schema.maxLength = this.def.max.val;
+    }
+    return schema;
+  }
+  /**
+   * Sets the minimum length of the string
+   *
+   * @param min The minimum length of the string
+   * @returns A clone of the schema with the minimum length set
+   */
+  min(min, message) {
+    return this.setCheck({ type: "min", val: min, message });
+  }
+  /**
+   * Sets the maximum length of the string
+   *
+   * @param max The maximum length of the string
+   * @returns A clone of the schema with the maximum length set
+   */
+  max(max, message) {
+    return this.setCheck({ type: "max", val: max, message });
+  }
+  regex(regex, message) {
+    return this.setCheck({ type: "regex", regex, message });
+  }
+  startsWith(prefix, message) {
+    return this.setCheck({ type: "startsWith", prefix, message });
+  }
+  endsWith(suffix, message) {
+    return this.setCheck({ type: "endsWith", suffix, message });
+  }
+  format(format, message) {
+    return this.setCheck({ type: "format", format, message });
+  }
+  uri(message) {
+    return this.format("uri", message);
+  }
+  /**
+   * Deprecated because OpenAPI uses the term "uri"
+   * but this method exists for making migration from
+   * Zod easier.
+   *
+   * @deprecated Use {@link uri} instead
+   */
+  url(message) {
+    return this.uri(message);
+  }
+  email(message) {
+    return this.format("email", message);
+  }
+  uuid(message) {
+    return this.format("uuid", message);
+  }
+  ipv4(message) {
+    return this.format("ipv4", message);
+  }
+  ipv6(message) {
+    return this.format("ipv6", message);
+  }
+  date(message) {
+    return this.format("date", message);
+  }
+  dateTime(message) {
+    return this.format("date-time", message);
+  }
+  password(message) {
+    return this.format("password", message);
+  }
+  byte(message) {
+    return this.format("byte", message);
+  }
+  binary(message) {
+    return this.format("binary", message);
+  }
+  hostname(message) {
+    return this.format("hostname", message);
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (typeof json !== "string") {
+        return ctx.addIssue("Expected string", []);
+      }
+      if (this.def.min !== void 0 && json.length < this.def.min.val) {
+        ctx.addIssue(this.def.min.message ?? `String must be at least ${this.def.min.val} characters`, []);
+      }
+      if (this.def.max !== void 0 && json.length > this.def.max.val) {
+        ctx.addIssue(this.def.max.message ?? `String must be at most ${this.def.max.val} characters`, []);
+      }
+      if (this.def.regex !== void 0 && !this.def.regex.regex.test(json)) {
+        ctx.addIssue(this.def.regex.message ?? `String must match ${this.def.regex.regex.source}`, []);
+      }
+      if (this.def.startsWith !== void 0 && !json.startsWith(this.def.startsWith.prefix)) {
+        ctx.addIssue(this.def.startsWith.message ?? `String must start with "${this.def.startsWith.prefix}"`, []);
+      }
+      if (this.def.endsWith !== void 0 && !json.endsWith(this.def.endsWith.suffix)) {
+        ctx.addIssue(this.def.endsWith.message ?? `String must end with "${this.def.endsWith.suffix}"`, []);
+      }
+      if (this.def.format !== void 0) {
+        switch (this.def.format.format) {
+          case "uuid":
+            if (!STRING_FORMAT_REGEXES.uuid.test(json)) {
+              ctx.addIssue(this.def.format.message ?? "Invalid UUID format", []);
+            }
+            break;
+          case "email":
+            if (!STRING_FORMAT_REGEXES.email.test(json)) {
+              ctx.addIssue(this.def.format.message ?? "Invalid email format", []);
+            }
+            break;
+          case "ipv4":
+            if (!STRING_FORMAT_REGEXES.ipv4.test(json)) {
+              ctx.addIssue(this.def.format.message ?? "Invalid IPv4 address", []);
+            }
+            break;
+          case "ipv6":
+            if (!STRING_FORMAT_REGEXES.ipv6.test(json)) {
+              ctx.addIssue(this.def.format.message ?? "Invalid IPv6 address", []);
+            }
+            break;
+          case "date":
+            if (!STRING_FORMAT_REGEXES.date.test(json)) {
+              ctx.addIssue(this.def.format.message ?? "Invalid date format", []);
+            }
+            break;
+          case "date-time":
+            if (Number.isNaN(new Date(json).getTime())) {
+              ctx.addIssue(this.def.format.message ?? "Invalid date-time format", []);
+            }
+            break;
+          case "byte":
+            if (!/^[A-Za-z0-9+/]*={0,2}$/.test(json) || json.length % 4 !== 0) {
+              ctx.addIssue(this.def.format.message ?? "Invalid base64 format", []);
+            }
+            break;
+          case "uri":
+            if (!STRING_FORMAT_REGEXES.uri.test(json)) {
+              ctx.addIssue(this.def.format.message ?? "Invalid URI format", []);
+            }
+            break;
+          case "hostname":
+            if (!STRING_FORMAT_REGEXES.hostname.test(json)) {
+              ctx.addIssue(this.def.format.message ?? "Invalid hostname format", []);
+            }
+            break;
+          case "binary":
+            break;
+          case "password":
+            break;
+          default:
+            this.def.format.format;
+            break;
+        }
+      }
+      return json;
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  visit() {
+  }
+};
+var KNumber = class _KNumber extends BaseSchema {
+  static create = () => new _KNumber({});
+  serialize(value) {
+    return value;
+  }
+  setCheck(check) {
+    return this.clone({ [check.type]: check });
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    const schema = {
+      ...baseSchema,
+      type: "number"
+    };
+    if (this.def.min !== void 0) {
+      schema.minimum = this.def.min.val;
+    }
+    if (this.def.max !== void 0) {
+      schema.maximum = this.def.max.val;
+    }
+    if (this.def.multipleOf !== void 0) {
+      schema.multipleOf = this.def.multipleOf.val;
+    }
+    if (this.def.integer) {
+      schema.type = "integer";
+    }
+    if (this.def.format) {
+      switch (this.def.format.format) {
+        case "float":
+          schema.format = "float";
+          schema.type = "number";
+          break;
+        case "double":
+          schema.format = "double";
+          schema.type = "number";
+          break;
+        case "int32":
+          schema.format = "int32";
+          schema.type = "integer";
+          break;
+        case "int64":
+          schema.format = "int64";
+          schema.type = "integer";
+          break;
+      }
+    }
+    if (this.def.format) {
+      schema.format = this.def.format.format;
+    }
+    return schema;
+  }
+  min(min) {
+    return this.setCheck({ type: "min", val: min });
+  }
+  max(max) {
+    return this.setCheck({ type: "max", val: max });
+  }
+  integer() {
+    return this.setCheck({ type: "integer" });
+  }
+  multipleOf(multipleOf) {
+    if (multipleOf <= 0) {
+      throw new Error("multipleOf must be a positive number");
+    }
+    return this.setCheck({ type: "multipleOf", val: multipleOf });
+  }
+  float() {
+    return this.setCheck({ type: "format", format: "float" });
+  }
+  double() {
+    return this.setCheck({ type: "format", format: "double" });
+  }
+  int32() {
+    return this.setCheck({ type: "format", format: "int32" }).integer();
+  }
+  int64() {
+    return this.setCheck({ type: "format", format: "int64" }).integer();
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (typeof json !== "number") {
+        return ctx.addIssue("Expected number", []);
+      }
+      if (this.def.integer && !Number.isInteger(json)) {
+        ctx.addIssue(this.def.integer.message ?? "Expected integer", []);
+      }
+      if (this.def.min !== void 0 && json < this.def.min.val) {
+        ctx.addIssue(this.def.min.message ?? `Number must be greater than or equal to ${this.def.min.val}`, []);
+      }
+      if (this.def.max !== void 0 && json > this.def.max.val) {
+        ctx.addIssue(this.def.max.message ?? `Number must be less than or equal to ${this.def.max.val}`, []);
+      }
+      if (this.def.multipleOf !== void 0 && json % this.def.multipleOf.val !== 0) {
+        ctx.addIssue(this.def.multipleOf.message ?? `Number must be multiple of ${this.def.multipleOf.val}`, []);
+      }
+      return json;
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  visit() {
+  }
+};
+var KBoolean = class _KBoolean extends BaseSchema {
+  static create = () => new _KBoolean({});
+  serialize(value) {
+    return value;
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    return {
+      ...baseSchema,
+      type: "boolean"
+    };
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (typeof json !== "boolean") {
+        return ctx.addIssue("Expected boolean", []);
+      }
+      return json;
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  visit() {
+  }
+};
+var KArray = class _KArray extends BaseSchema {
+  static create = (items) => new _KArray({ items });
+  serialize(value) {
+    return value.map((item) => this.def.items.serialize(item));
+  }
+  setCheck(check) {
+    return this.clone({ [check.type]: check });
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    return {
+      ...baseSchema,
+      type: "array",
+      items: this.def.items.toOpenAPI(),
+      ...this.def.minItems !== void 0 ? { minItems: this.def.minItems.val } : {},
+      ...this.def.maxItems !== void 0 ? { maxItems: this.def.maxItems.val } : {},
+      ...this.def.uniqueItems !== void 0 ? { uniqueItems: this.def.uniqueItems.val } : {}
+    };
+  }
+  min(minItems) {
+    return this.setCheck({ type: "minItems", val: minItems });
+  }
+  max(maxItems) {
+    return this.setCheck({ type: "maxItems", val: maxItems });
+  }
+  unique() {
+    return this.setCheck({ type: "uniqueItems", val: true });
+  }
+  notUnique() {
+    return this.setCheck({ type: "uniqueItems", val: false });
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (!Array.isArray(json)) {
+        return ctx.addIssue("Expected array", []);
+      }
+      if (this.def.minItems !== void 0 && json.length < this.def.minItems.val) {
+        ctx.addIssue(this.def.minItems.message ?? `Array must have at least ${this.def.minItems.val} items`, []);
+      }
+      if (this.def.maxItems !== void 0 && json.length > this.def.maxItems.val) {
+        ctx.addIssue(this.def.maxItems.message ?? `Array must have at most ${this.def.maxItems.val} items`, []);
+      }
+      if (this.def.uniqueItems?.val === true && new Set(json).size !== json.length) {
+        ctx.addIssue(this.def.uniqueItems.message ?? "Array items must be unique", []);
+      }
+      const items = [];
+      for (let i = 0; i < json.length; i++) {
+        const item = json[i];
+        const result = this.def.items.parseSafe(item);
+        if (!result.success) {
+          ctx.addIssues(result.issues, [i.toString()]);
+        } else {
+          items.push(result.result);
+        }
+      }
+      return items;
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  visit(visitor) {
+    const child = this.def.items;
+    visitor(child);
+    child.visit(visitor);
+  }
+};
+var KNull = class _KNull extends BaseSchema {
+  static create = () => new _KNull({});
+  serialize(value) {
+    return value;
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    return {
+      ...baseSchema,
+      type: "null"
+    };
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (json !== null) {
+        return ctx.addIssue("Expected null", []);
+      }
+      return null;
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  visit() {
+  }
+};
+var KObject = class _KObject extends BaseSchema {
+  static create = (shape) => new _KObject({ shape });
+  serialize(value) {
+    const result = {};
+    for (const key in this.def.shape) {
+      if (Object.prototype.hasOwnProperty.call(this.def.shape, key)) {
+        const fieldValue = value[key];
+        if (fieldValue === void 0) {
+          throw new Error(`Missing required property: ${key}`);
+        }
+        result[key] = this.def.shape[key].serialize(fieldValue);
+      }
+    }
+    return result;
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    return {
+      ...baseSchema,
+      type: "object",
+      properties: Object.fromEntries(
+        Object.entries(this.def.shape).map((entry) => {
+          const [key, value] = entry;
+          return [key, value.toOpenAPI()];
+        })
+      ),
+      required: Object.keys(this.def.shape)
+    };
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (typeof json !== "object" || json === null || Array.isArray(json)) {
+        return ctx.addIssue(`Expected object, got ${typeof json}`, []);
+      }
+      const result = {};
+      for (const key in this.def.shape) {
+        if (Object.prototype.hasOwnProperty.call(this.def.shape, key)) {
+          const value = json[key];
+          if (value === void 0) {
+            return ctx.addIssue(`Missing required property: ${key}`, [key]);
+          }
+          const parseResult = this.def.shape[key].parseSafe(value);
+          if (!parseResult.success) {
+            return ctx.addIssues(parseResult.issues, [key]);
+          }
+          result[key] = parseResult.result;
+        }
+      }
+      return result;
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  get shape() {
+    return this.def.shape;
+  }
+  visit(visitor) {
+    for (const child of Object.values(this.def.shape)) {
+      visitor(child);
+      child.visit(visitor);
+    }
+  }
+};
+var KObjectFromURLSearchParams = class _KObjectFromURLSearchParams extends KObject {
+  static create = (shape) => new _KObjectFromURLSearchParams({ shape });
+  serialize(value) {
+    return super.serialize(value);
+  }
+  toOpenAPI() {
+    return super.toOpenAPI();
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (!(json instanceof URLSearchParams)) {
+        return ctx.addIssue(`Expected URLSearchParams, got ${typeof json}`, []);
+      }
+      const result = {};
+      for (const key in this.def.shape) {
+        if (Object.prototype.hasOwnProperty.call(this.def.shape, key)) {
+          const value = json.get(key);
+          if (value === null) {
+            return ctx.addIssue(`Missing required property: ${key}`, [key]);
+          }
+          const parseResult = this.def.shape[key].parseSafe(value);
+          if (!parseResult.success) {
+            return ctx.addIssues(parseResult.issues, [key]);
+          }
+          result[key] = parseResult.result;
+        }
+      }
+      return result;
+    });
+  }
+};
+var KRef = class _KRef extends BaseSchema {
+  static create = (name, shape) => new _KRef({ name, shape });
+  serialize(value) {
+    const result = {};
+    for (const key in this.def.shape) {
+      if (Object.prototype.hasOwnProperty.call(this.def.shape, key)) {
+        const fieldValue = value[key];
+        if (fieldValue === void 0) {
+          throw new Error(`Missing required property: ${key}`);
+        }
+        result[key] = this.def.shape[key].serialize(fieldValue);
+      }
+    }
+    return result;
+  }
+  visit(visitor) {
+    for (const child of Object.values(this.def.shape)) {
+      visitor(child);
+      child.visit(visitor);
+    }
+  }
+  example() {
+    throw new Error("Cannot set an example on a KRef");
+  }
+  toOpenAPI() {
+    return {
+      $ref: `#/components/schemas/${this.def.name}`,
+      ...this.def.description ? { description: this.def.description } : {},
+      ...this.def.summary ? { summary: this.def.summary } : {}
+    };
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (typeof json !== "object" || json === null || Array.isArray(json)) {
+        return ctx.addIssue(`Expected object, got ${typeof json}`, []);
+      }
+      const result = {};
+      for (const key in this.def.shape) {
+        if (Object.prototype.hasOwnProperty.call(this.def.shape, key)) {
+          const value = json[key];
+          if (value === void 0) {
+            return ctx.addIssue(`Missing required property: ${key}`, [key]);
+          }
+          const parseResult = this.def.shape[key].parseSafe(value);
+          if (!parseResult.success) {
+            return ctx.addIssues(parseResult.issues, [key]);
+          }
+          result[key] = parseResult.result;
+        }
+      }
+      return result;
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  summary(summary) {
+    if (summary === void 0) {
+      return this.def.summary;
+    }
+    return this.clone({ summary });
+  }
+  get shape() {
+    return this.def.shape;
+  }
+  get name() {
+    return this.def.name;
+  }
+};
+var KScalar = class _KScalar extends BaseSchema {
+  static create = (options) => new _KScalar(options);
+  constructor(def) {
+    super({
+      ...def,
+      example: def.schema.example(),
+      description: def.schema.description()
+    });
+  }
+  serialize(value) {
+    return this.def.toClient(value);
+  }
+  toOpenAPI() {
+    return {
+      ...this.def.schema.toOpenAPI(),
+      ...this.def.description ? { description: this.def.description } : {},
+      ...this.def.example ? { example: this.def.example } : {}
+    };
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      const jsonValue = this.def.schema.parseSafe(json);
+      if (!jsonValue.success) {
+        return ctx.addIssues(jsonValue.issues, []);
+      }
+      try {
+        return this.def.toServer(jsonValue.result);
+      } catch (error) {
+        return ctx.addIssue(error instanceof Error ? error.message : "Conversion failed", []);
+      }
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  visit(visitor) {
+    const child = this.def.schema;
+    visitor(child);
+    child.visit(visitor);
+  }
+};
+var KUnion = class _KUnion extends BaseSchema {
+  static create = (items) => new _KUnion({ items });
+  static enum = (values) => k.union(values.map((v) => k.literal(v)));
+  serialize(value) {
+    for (const option of this.def.items) {
+      try {
+        return option.serialize(value);
+      } catch {
+      }
+    }
+    throw new Error("Value does not match any union option for serialization");
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    return {
+      ...baseSchema,
+      oneOf: this.def.items.map((option) => option.toOpenAPI())
+    };
+  }
+  parseSafe(json) {
+    let lastIssues;
+    for (const option of this.def.items) {
+      const result = option.parseSafe(json);
+      if (result.success) {
+        return { success: true, result: result.result };
+      } else {
+        lastIssues = result.issues;
+      }
+    }
+    return { success: false, issues: lastIssues ?? /* @__PURE__ */ new Set([{ message: "No union option matched", path: [] }]) };
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  visit(visitor) {
+    for (const child of this.def.items) {
+      visitor(child);
+      child.visit(visitor);
+    }
+  }
+};
+var KLiteral = class _KLiteral extends BaseSchema {
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  static create = (value) => new _KLiteral({ value });
+  serialize(value) {
+    return value;
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    const type = typeof this.def.value;
+    return {
+      ...baseSchema,
+      type,
+      enum: [this.def.value]
+    };
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (json !== this.def.value) {
+        return ctx.addIssue(`Expected ${this.def.value}`, []);
+      }
+      return this.def.value;
+    });
+  }
+  visit() {
+  }
+};
+var KNativeEnum = class _KNativeEnum extends BaseSchema {
+  static create = (enumObject) => new _KNativeEnum({ enum: enumObject });
+  serialize(value) {
+    return value;
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    const actualValues = Object.keys(this.def.enum).filter((key) => Number.isNaN(Number(key))).map((key) => this.def.enum[key]);
+    const uniqueValues = [...new Set(actualValues)];
+    const type = typeof uniqueValues[0] === "number" ? "number" : "string";
+    return {
+      ...baseSchema,
+      type,
+      enum: uniqueValues
+    };
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      const actualValues = Object.keys(this.def.enum).filter((key) => Number.isNaN(Number(key))).map((key) => this.def.enum[key]);
+      if (!actualValues.includes(json)) {
+        return ctx.addIssue(`Expected one of: ${actualValues.join(", ")}`, []);
+      }
+      return json;
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  visit() {
+  }
+};
+var KRecord = class _KRecord extends BaseSchema {
+  static create = (keys, values) => new _KRecord({ keys, values });
+  serialize(value) {
+    const result = {};
+    for (const key in value) {
+      if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+      const keySerialize = this.def.keys.serialize(key);
+      const valueSerialize = this.def.values.serialize(value[key]);
+      result[keySerialize] = valueSerialize;
+    }
+    return result;
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    return {
+      ...baseSchema,
+      type: "object",
+      propertyNames: this.def.keys.toOpenAPI(),
+      additionalProperties: this.def.values.toOpenAPI()
+    };
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (typeof json !== "object" || json === null || Array.isArray(json)) {
+        return ctx.addIssue("Expected object", []);
+      }
+      const result = {};
+      for (const key in json) {
+        if (!Object.prototype.hasOwnProperty.call(json, key)) continue;
+        const keyParse = this.def.keys.parseSafe(key);
+        if (!keyParse.success) {
+          return ctx.addIssues(keyParse.issues, [key]);
+        }
+        const value = json[keyParse.result];
+        const valueParse = this.def.values.parseSafe(value);
+        if (!valueParse.success) {
+          return ctx.addIssues(valueParse.issues, [key]);
+        }
+        result[keyParse.result] = valueParse.result;
+      }
+      return result;
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  visit(visitor) {
+    visitor(this.def.keys);
+    visitor(this.def.values);
+  }
+};
+var KLazy = class _KLazy extends BaseSchema {
+  schema;
+  static create = (getter) => new _KLazy({ getter });
+  getSchema() {
+    if (!this.schema) {
+      this.schema = this.def.getter();
+    }
+    return this.schema;
+  }
+  serialize(value) {
+    return this.getSchema().serialize(value);
+  }
+  toOpenAPI() {
+    return this.getSchema().toOpenAPI();
+  }
+  parseSafe(json) {
+    return this.getSchema().parseSafe(json);
+  }
+  parse(json) {
+    return this.getSchema().parse(json);
+  }
+  visit(visitor) {
+    const schema = this.getSchema();
+    visitor(schema);
+    schema.visit(visitor);
+  }
+};
+var k = {
+  string: KString.create,
+  number: KNumber.create,
+  boolean: KBoolean.create,
+  array: KArray.create,
+  null: KNull.create,
+  ref: KRef.create,
+  record: KRecord.create,
+  object: KObject.create,
+  scalar: KScalar.create,
+  literal: KLiteral.create,
+  enum: KUnion.enum,
+  nativeEnum: KNativeEnum.create,
+  union: KUnion.create,
+  lazy: KLazy.create,
+  /**
+   * Schema for any valid JSON value
+   */
+  json: () => {
+    const jsonSchema = k.lazy(
+      () => k.union([k.string(), k.number(), k.boolean(), k.null(), k.array(jsonSchema), k.record(k.string(), jsonSchema)])
+    );
+    return jsonSchema;
+  },
+  /**
+   * @internal
+   * @experimental
+   */
+  objectFromURLSearchParams: KObjectFromURLSearchParams.create
+};
+
+// src/stream/stream.ts
+var KaitoSSEResponse = class {
+  events;
+  constructor(events) {
+    this.events = events;
+  }
+};
+function sseEventToString(event) {
+  const lines = [];
+  if (event.event) {
+    lines.push(`event:${event.event}`);
+  }
+  if (event.id) {
+    lines.push(`id:${event.id}`);
+  }
+  if (event.retry) {
+    lines.push(`retry:${event.retry}`);
+  }
+  if (event.data !== void 0) {
+    lines.push(`data:${JSON.stringify(event.data)}`);
+  }
+  return lines.join("\n");
+}
+
 // src/util.ts
 var isNodeLikeDev = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.NODE_ENV === "development";
 
 // src/router/router.ts
 var Router = class _Router {
-  state;
-  static create = (config) => new _Router({
-    through: async (context) => context,
-    routes: /* @__PURE__ */ new Set(),
-    config
-  });
+  #state;
+  static create = (config = {}) => new _Router({ through: (context) => context, routes: /* @__PURE__ */ new Set(), config });
   constructor(state) {
-    this.state = state;
+    this.#state = state;
   }
   get routes() {
-    return this.state.routes;
+    return this.#state.routes;
   }
   add = (method, path, route) => {
     const merged = {
       ...typeof route === "object" ? route : { run: route },
       method,
       path,
-      through: this.state.through
+      router: this
     };
     return new _Router({
-      ...this.state,
-      routes: /* @__PURE__ */ new Set([...this.state.routes, merged])
+      ...this.#state,
+      routes: /* @__PURE__ */ new Set([...this.#state.routes, merged])
     });
   };
+  params = () => this;
   merge = (pathPrefix, other) => {
-    const newRoutes = [...other.state.routes].map((route) => ({
+    const newRoutes = [...other.#state.routes].map((route) => ({
       ...route,
-      path: `${pathPrefix}${route.path}`
+      // handle pathPrefix = / & route.path = / case causing //
+      // we intentionally are replacing on the joining path and not the pathPrefix, in case of
+      // /named -> merged to -> / causing /named/ not /named
+      path: `${pathPrefix}${route.path === "/" ? "" : route.path}`
     }));
     return new _Router({
-      ...this.state,
-      routes: /* @__PURE__ */ new Set([...this.state.routes, ...newRoutes])
+      ...this.#state,
+      routes: /* @__PURE__ */ new Set([...this.#state.routes, ...newRoutes])
     });
   };
   static getFindRoute = (routes) => (method, path) => {
@@ -203,52 +1228,60 @@ var Router = class _Router {
     }
     return {};
   };
-  static buildQuerySchema = (schema) => {
-    const keys = Object.keys(schema);
-    return import_zod.z.instanceof(URLSearchParams).transform((params) => {
-      const result = {};
-      for (const key of keys) {
-        result[key] = params.get(key);
-      }
-      return result;
-    }).pipe(import_zod.z.object(schema));
-  };
   serve = () => {
     const methodToRoutesMap = /* @__PURE__ */ new Map();
-    for (const route of this.state.routes) {
+    for (const route of this.#state.routes) {
       if (!methodToRoutesMap.has(route.method)) {
         methodToRoutesMap.set(route.method, /* @__PURE__ */ new Map());
       }
       methodToRoutesMap.get(route.method).set(route.path, {
         ...route,
-        fastQuerySchema: route.query ? _Router.buildQuerySchema(route.query) : void 0
+        fastQuerySchema: route.query ? k.objectFromURLSearchParams(route.query) : void 0
       });
     }
     const findRoute = _Router.getFindRoute(methodToRoutesMap);
-    const handle = async (req) => {
+    const handle = async (req, ...args) => {
       const url = new URL(req.url);
       const method = req.method;
-      const { route, params } = findRoute(method, url.pathname);
+      const { route, params: rawParams } = findRoute(method, url.pathname);
       if (!route) {
-        const body = {
-          success: false,
-          data: null,
-          message: `Cannot ${method} ${url.pathname}`
-        };
-        return Response.json(body, { status: 404 });
+        return Response.json({ message: `Cannot ${method} ${url.pathname}` }, { status: 404 });
       }
       const request = new KaitoRequest(url, req);
       const head = new KaitoHead();
       try {
-        const body = route.body ? await route.body.parseAsync(await req.json()) : void 0;
-        const query = route.fastQuerySchema ? await route.fastQuerySchema.parseAsync(url.searchParams) : {};
-        const ctx = await route.through(await this.state.config.getContext?.(request, head) ?? null);
+        const body = route.body ? await route.body.parse(await req.json()) : void 0;
+        const query = route.fastQuerySchema ? route.fastQuerySchema.parse(url.searchParams) : {};
+        const ctx = await route.router.#state.through(
+          await this.#state.config.getContext?.(request, head, ...args) ?? null,
+          rawParams
+        );
         const result = await route.run({
           ctx,
           body,
           query,
-          params
+          params: rawParams
         });
+        if (result instanceof KaitoSSEResponse) {
+          const body2 = route.openapi?.body;
+          const schema = body2 && "schema" in body2 ? body2.schema : void 0;
+          const stringStream = result.events.pipeThrough(
+            new TransformStream({
+              transform(event, controller) {
+                const serialized = schema ? { ...event, data: event.data !== void 0 ? schema.serialize(event.data) : void 0 } : event;
+                controller.enqueue(sseEventToString(serialized) + "\n\n");
+              }
+            })
+          );
+          const sseHeaders = new Headers(head.touched ? head.headers : void 0);
+          sseHeaders.set("Content-Type", "text/event-stream");
+          sseHeaders.set("Cache-Control", "no-cache");
+          sseHeaders.set("Connection", "keep-alive");
+          return new Response(stringStream, {
+            status: head.status(),
+            headers: sseHeaders
+          });
+        }
         if (result instanceof Response) {
           if (isNodeLikeDev) {
             if (head.touched) {
@@ -263,50 +1296,46 @@ var Router = class _Router {
           }
           return result;
         }
-        return head.toResponse({
-          success: true,
-          data: result
-        });
+        if (route.openapi && "schema" in route.openapi.body && route.openapi.body.schema) {
+          const parsed = route.openapi.body.schema.serialize(result);
+          return head.toResponse(parsed);
+        }
+        if (result === void 0) {
+          return head.toResponse(null);
+        }
+        return head.toResponse(result);
       } catch (e) {
         const error = WrappedError.maybe(e);
         if (error instanceof KaitoError) {
           return head.status(error.status).toResponse({
-            success: false,
-            data: null,
             message: error.message
           });
         }
-        if (!this.state.config.onError) {
+        if (!this.#state.config.onError) {
           return head.status(500).toResponse({
-            success: false,
-            data: null,
             message: "Internal Server Error"
           });
         }
         try {
-          const { status, message } = await this.state.config.onError(error, request);
+          const { status, message } = await this.#state.config.onError(error, request);
           return head.status(status).toResponse({
-            success: false,
-            data: null,
             message
           });
         } catch (e2) {
-          console.error("KAITO - Failed to handle error inside `.onError()`, returning 500 and Internal Server Error");
+          console.error("[Kaito] Failed to handle error inside `.onError()`, returning 500 and Internal Server Error");
           console.error(e2);
           return head.status(500).toResponse({
-            success: false,
-            data: null,
             message: "Internal Server Error"
           });
         }
       }
     };
-    return async (request) => {
-      if (this.state.config.before) {
-        const result = await this.state.config.before(request);
+    return async (request, ...args) => {
+      if (this.#state.config.before) {
+        const result = await this.#state.config.before(request);
         if (result instanceof Response) {
-          if (this.state.config.transform) {
-            const transformed = await this.state.config.transform(request, result);
+          if (this.#state.config.transform) {
+            const transformed = await this.#state.config.transform(request, result);
             if (transformed instanceof Response) {
               return result;
             }
@@ -314,9 +1343,9 @@ var Router = class _Router {
           return result;
         }
       }
-      const response = await handle(request);
-      if (this.state.config.transform) {
-        const transformed = await this.state.config.transform(request, response);
+      const response = await handle(request, ...args);
+      if (this.#state.config.transform) {
+        const transformed = await this.#state.config.transform(request, response);
         if (transformed instanceof Response) {
           return transformed;
         }
@@ -324,66 +1353,124 @@ var Router = class _Router {
       return response;
     };
   };
-  openapi = (highLevelSpec) => {
-    const OPENAPI_VERSION = "3.0.0";
+  /**
+   * Create a `/openapi.json` route on this router.
+   *
+   * Any routes defined AFTER this method call will NOT be included in the
+   * file. This is because all methods in Kaito are immutable, so there's no
+   * way for the router to know about routes that were created in the future
+   * on another router.
+   *
+   * @example
+   * ```ts
+   * router.get("/", () => "hey").openapi({
+   * 	info: {
+   * 		title: "My API",
+   * 		version: "1.0.0",
+   * 	},
+   * });
+   * ```
+   *
+   * @param options Options object
+   * @returns
+   */
+  openapi = ({
+    info,
+    servers
+  }) => {
+    const OPENAPI_VERSION = "3.1.0";
+    const componentsSchemas = {};
+    const addSchemaForRef = (ref) => {
+      const name = ref.name;
+      const properties = Object.fromEntries(Object.entries(ref.shape).map(([key, value]) => [key, value.toOpenAPI()]));
+      const desc = ref.description();
+      const schemaObject = {
+        type: "object",
+        properties,
+        required: Object.keys(ref.shape),
+        ...desc ? { description: desc } : {}
+      };
+      const existing = componentsSchemas[name];
+      if (existing) {
+        if (JSON.stringify(existing) !== JSON.stringify(schemaObject)) {
+          throw new Error(
+            `Conflicting KRef definitions detected for "${name}". OpenAPI components require a single schema per name.`
+          );
+        }
+        return;
+      }
+      componentsSchemas[name] = schemaObject;
+    };
+    function visit(schema, seen = /* @__PURE__ */ new Set()) {
+      if (seen.has(schema)) return;
+      seen.add(schema);
+      if (schema instanceof KRef) addSchemaForRef(schema);
+      schema.visit((child) => visit(child, seen));
+    }
     const paths = {};
-    for (const route of this.state.routes) {
-      const path = route.path;
-      const pathWithColonParamsReplaceWithCurlyBraces = path.replace(/:(\w+)/g, "{$1}");
+    for (const route of this.#state.routes) {
+      if (!route.openapi) {
+        continue;
+      }
+      const pathWithColonParamsReplaceWithCurlyBraces = route.path.replace(/:(\w+)/g, "{$1}");
       if (!paths[pathWithColonParamsReplaceWithCurlyBraces]) {
         paths[pathWithColonParamsReplaceWithCurlyBraces] = {};
       }
+      let contentType;
+      const type = route.openapi.body.type;
+      switch (type) {
+        case "json":
+          contentType = "application/json";
+          break;
+        case "sse":
+          contentType = "text/event-stream";
+          break;
+        case "response":
+          contentType = "application/octet-stream";
+          break;
+        default:
+          throw new Error(`Unknown output type in route ${route.method} ${route.path}: ${type}`);
+      }
+      if ("schema" in route.openapi.body && route.openapi.body.schema) visit(route.openapi.body.schema);
+      if (route.body) visit(route.body);
+      const responseSchema = "schema" in route.openapi.body && route.openapi.body.schema ? route.openapi.body.schema.toOpenAPI() : { type: "string" };
       const item = {
+        ...route.openapi.summary ? { summary: route.openapi.summary } : {},
         description: route.openapi?.description ?? "Successful response",
         responses: {
           200: {
-            description: route.openapi?.description ?? "Successful response",
-            ...route.openapi ? {
-              content: {
-                [{
-                  json: "application/json",
-                  sse: "text/event-stream"
-                }[route.openapi.body.type]]: { schema: route.openapi?.body.schema }
+            description: route.openapi.body.description ?? "Successful response",
+            content: {
+              [contentType]: {
+                schema: responseSchema
               }
-            } : {}
+            }
           }
         }
       };
       if (route.body) {
         item.requestBody = {
           content: {
-            "application/json": { schema: route.body }
+            "application/json": { schema: route.body.toOpenAPI() }
           }
         };
       }
-      const params = {};
-      if (route.query) {
-        params.query = import_zod.z.object(route.query);
-      }
-      const urlParams = path.match(/:(\w+)/g);
-      if (urlParams) {
-        const pathParams = {};
-        for (const param of urlParams) {
-          pathParams[param.slice(1)] = import_zod.z.string();
-        }
-        params.path = import_zod.z.object(pathParams);
-      }
-      item.requestParams = params;
       paths[pathWithColonParamsReplaceWithCurlyBraces][route.method.toLowerCase()] = item;
     }
-    const doc = (0, import_zod_openapi.createDocument)({
+    const doc = {
       openapi: OPENAPI_VERSION,
+      info,
       paths,
-      ...highLevelSpec,
-      servers: Object.entries(highLevelSpec.servers ?? {}).map((entry) => {
+      ...Object.keys(componentsSchemas).length > 0 ? { components: { schemas: componentsSchemas } } : {},
+      servers: Object.entries(servers ?? {}).map((entry) => {
         const [url, description] = entry;
         return {
           url,
           description
         };
       })
-    });
-    return this.add("GET", "/openapi.json", async () => Response.json(doc));
+    };
+    return this.get("/openapi.json", () => Response.json(doc));
   };
   method = (method) => {
     return (path, route) => this.add(method, path, route);
@@ -397,22 +1484,47 @@ var Router = class _Router {
   options = this.method("OPTIONS");
   through = (through) => {
     return new _Router({
-      ...this.state,
-      through: async (context) => await through(await this.state.through(context))
+      ...this.#state,
+      through: (context, params) => {
+        const next = this.#state.through(context, params);
+        if (next instanceof Promise) {
+          return next.then((next2) => through(next2, params));
+        }
+        return through(next, params);
+      }
     });
   };
 };
 
-// src/create.ts
-function create(config = {}) {
-  return () => Router.create(config);
-}
+// src/index.ts
+var create = Router.create;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BaseSchema,
+  KArray,
+  KBoolean,
+  KLazy,
+  KLiteral,
+  KNativeEnum,
+  KNull,
+  KNumber,
+  KObject,
+  KObjectFromURLSearchParams,
+  KRecord,
+  KRef,
+  KScalar,
+  KString,
+  KUnion,
   KaitoError,
+  KaitoHead,
   KaitoRequest,
+  ParseContext,
   Router,
+  STRING_FORMAT_REGEXES,
+  SchemaError,
   WrappedError,
   create,
-  isNodeLikeDev
+  isNodeLikeDev,
+  isPrimitiveJSONValue,
+  k
 });