@aklinker1/zeta 2.1.2 → 2.1.3

package/dist/index.mjs

@@ -0,0 +1,1236 @@
+import { createBunTransport } from "./transports/bun-transport.mjs";
+import { createDenoTransport } from "./transports/deno-transport.mjs";
+import { ErrorResponse, ErrorResponseJsonSchema, NoResponse, isZetaSchema } from "./schema.mjs";
+import { n as smartSerialize, t as smartDeserialize } from "./serialization-C8e7ECQ2.mjs";
+import { addRoute, createRouter } from "rou3";
+import { compileRouter } from "rou3/compiler";
+import { titleCase } from "scule";
+//#region src/status.ts
+/**
+* Enum containing all HTTP status codes.
+*/
+let HttpStatus = /* @__PURE__ */ function(HttpStatus) {
+	HttpStatus[HttpStatus["Continue"] = 100] = "Continue";
+	HttpStatus[HttpStatus["SwitchingProtocols"] = 101] = "SwitchingProtocols";
+	HttpStatus[HttpStatus["ProcessingDeprecated"] = 102] = "ProcessingDeprecated";
+	HttpStatus[HttpStatus["EarlyHints"] = 103] = "EarlyHints";
+	HttpStatus[HttpStatus["Ok"] = 200] = "Ok";
+	HttpStatus[HttpStatus["Created"] = 201] = "Created";
+	HttpStatus[HttpStatus["Accepted"] = 202] = "Accepted";
+	HttpStatus[HttpStatus["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
+	HttpStatus[HttpStatus["NoContent"] = 204] = "NoContent";
+	HttpStatus[HttpStatus["ResetContent"] = 205] = "ResetContent";
+	HttpStatus[HttpStatus["PartialContent"] = 206] = "PartialContent";
+	HttpStatus[HttpStatus["MultiStatus"] = 207] = "MultiStatus";
+	HttpStatus[HttpStatus["AlreadyReported"] = 208] = "AlreadyReported";
+	HttpStatus[HttpStatus["ImUsed"] = 226] = "ImUsed";
+	HttpStatus[HttpStatus["MultipleChoices"] = 300] = "MultipleChoices";
+	HttpStatus[HttpStatus["MovedPermanently"] = 301] = "MovedPermanently";
+	HttpStatus[HttpStatus["Found"] = 302] = "Found";
+	HttpStatus[HttpStatus["SeeOther"] = 303] = "SeeOther";
+	HttpStatus[HttpStatus["NotModified"] = 304] = "NotModified";
+	HttpStatus[HttpStatus["UseProxyDeprecated"] = 305] = "UseProxyDeprecated";
+	HttpStatus[HttpStatus["Unused"] = 306] = "Unused";
+	HttpStatus[HttpStatus["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+	HttpStatus[HttpStatus["PermanentRedirect"] = 308] = "PermanentRedirect";
+	HttpStatus[HttpStatus["BadRequest"] = 400] = "BadRequest";
+	HttpStatus[HttpStatus["Unauthorized"] = 401] = "Unauthorized";
+	HttpStatus[HttpStatus["PaymentRequired"] = 402] = "PaymentRequired";
+	HttpStatus[HttpStatus["Forbidden"] = 403] = "Forbidden";
+	HttpStatus[HttpStatus["NotFound"] = 404] = "NotFound";
+	HttpStatus[HttpStatus["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+	HttpStatus[HttpStatus["NotAcceptable"] = 406] = "NotAcceptable";
+	HttpStatus[HttpStatus["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
+	HttpStatus[HttpStatus["RequestTimeout"] = 408] = "RequestTimeout";
+	HttpStatus[HttpStatus["Conflict"] = 409] = "Conflict";
+	HttpStatus[HttpStatus["Gone"] = 410] = "Gone";
+	HttpStatus[HttpStatus["LengthRequired"] = 411] = "LengthRequired";
+	HttpStatus[HttpStatus["PreconditionFailed"] = 412] = "PreconditionFailed";
+	HttpStatus[HttpStatus["ContentTooLarge"] = 413] = "ContentTooLarge";
+	HttpStatus[HttpStatus["UriTooLong"] = 414] = "UriTooLong";
+	HttpStatus[HttpStatus["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+	HttpStatus[HttpStatus["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
+	HttpStatus[HttpStatus["ExpectationFailed"] = 417] = "ExpectationFailed";
+	HttpStatus[HttpStatus["ImATeapot"] = 418] = "ImATeapot";
+	HttpStatus[HttpStatus["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+	HttpStatus[HttpStatus["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+	HttpStatus[HttpStatus["Locked"] = 423] = "Locked";
+	HttpStatus[HttpStatus["FailedDependency"] = 424] = "FailedDependency";
+	HttpStatus[HttpStatus["TooEarly"] = 425] = "TooEarly";
+	HttpStatus[HttpStatus["UpgradeRequired"] = 426] = "UpgradeRequired";
+	HttpStatus[HttpStatus["PreconditionRequired"] = 428] = "PreconditionRequired";
+	HttpStatus[HttpStatus["TooManyRequests"] = 429] = "TooManyRequests";
+	HttpStatus[HttpStatus["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
+	HttpStatus[HttpStatus["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
+	HttpStatus[HttpStatus["InternalServerError"] = 500] = "InternalServerError";
+	HttpStatus[HttpStatus["NotImplemented"] = 501] = "NotImplemented";
+	HttpStatus[HttpStatus["BadGateway"] = 502] = "BadGateway";
+	HttpStatus[HttpStatus["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+	HttpStatus[HttpStatus["GatewayTimeout"] = 504] = "GatewayTimeout";
+	HttpStatus[HttpStatus["HttpVersionNotSupported"] = 505] = "HttpVersionNotSupported";
+	HttpStatus[HttpStatus["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+	HttpStatus[HttpStatus["InsufficientStorage"] = 507] = "InsufficientStorage";
+	HttpStatus[HttpStatus["LoopDetected"] = 508] = "LoopDetected";
+	HttpStatus[HttpStatus["NotExtended"] = 510] = "NotExtended";
+	HttpStatus[HttpStatus["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+	return HttpStatus;
+}({});
+const STATUS_NAME_MAP = {
+	[HttpStatus.Continue]: "Continue",
+	[HttpStatus.SwitchingProtocols]: "Switching Protocols",
+	[HttpStatus.ProcessingDeprecated]: "Processing",
+	[HttpStatus.EarlyHints]: "Early Hints",
+	[HttpStatus.Ok]: "OK",
+	[HttpStatus.Created]: "Created",
+	[HttpStatus.Accepted]: "Accepted",
+	[HttpStatus.NonAuthoritativeInformation]: "Non-Authoritative Information",
+	[HttpStatus.NoContent]: "No Content",
+	[HttpStatus.ResetContent]: "Reset Content",
+	[HttpStatus.PartialContent]: "Partial Content",
+	[HttpStatus.MultiStatus]: "Multi-Status",
+	[HttpStatus.AlreadyReported]: "Already Reported",
+	[HttpStatus.ImUsed]: "IM Used",
+	[HttpStatus.MultipleChoices]: "Multiple Choices",
+	[HttpStatus.MovedPermanently]: "Moved Permanently",
+	[HttpStatus.Found]: "Found",
+	[HttpStatus.SeeOther]: "See Other",
+	[HttpStatus.NotModified]: "Not Modified",
+	[HttpStatus.UseProxyDeprecated]: "Use Proxy",
+	[HttpStatus.Unused]: "Unused",
+	[HttpStatus.TemporaryRedirect]: "Temporary Redirect",
+	[HttpStatus.PermanentRedirect]: "Permanent Redirect",
+	[HttpStatus.BadRequest]: "Bad Request",
+	[HttpStatus.Unauthorized]: "Unauthorized",
+	[HttpStatus.PaymentRequired]: "Payment Required",
+	[HttpStatus.Forbidden]: "Forbidden",
+	[HttpStatus.NotFound]: "Not Found",
+	[HttpStatus.MethodNotAllowed]: "Method Not Allowed",
+	[HttpStatus.NotAcceptable]: "Not Acceptable",
+	[HttpStatus.ProxyAuthenticationRequired]: "Proxy Authentication Required",
+	[HttpStatus.RequestTimeout]: "Request Timeout",
+	[HttpStatus.Conflict]: "Conflict",
+	[HttpStatus.Gone]: "Gone",
+	[HttpStatus.LengthRequired]: "Length Required",
+	[HttpStatus.PreconditionFailed]: "Precondition Failed",
+	[HttpStatus.ContentTooLarge]: "Content Too Large",
+	[HttpStatus.UriTooLong]: "URI Too Long",
+	[HttpStatus.UnsupportedMediaType]: "Unsupported Media Type",
+	[HttpStatus.RangeNotSatisfiable]: "Range Not Satisfiable",
+	[HttpStatus.ExpectationFailed]: "Expectation Failed",
+	[HttpStatus.ImATeapot]: "I'm a Teapot",
+	[HttpStatus.MisdirectedRequest]: "Misdirected Request",
+	[HttpStatus.UnprocessableEntity]: "Unprocessable Entity",
+	[HttpStatus.Locked]: "Locked",
+	[HttpStatus.FailedDependency]: "Failed Dependency",
+	[HttpStatus.TooEarly]: "Too Early",
+	[HttpStatus.UpgradeRequired]: "Upgrade Required",
+	[HttpStatus.PreconditionRequired]: "Precondition Required",
+	[HttpStatus.TooManyRequests]: "Too Many Requests",
+	[HttpStatus.RequestHeaderFieldsTooLarge]: "Request Header Fields Too Large",
+	[HttpStatus.UnavailableForLegalReasons]: "Unavailable For Legal Reasons",
+	[HttpStatus.InternalServerError]: "Internal Server Error",
+	[HttpStatus.NotImplemented]: "Not Implemented",
+	[HttpStatus.BadGateway]: "Bad Gateway",
+	[HttpStatus.ServiceUnavailable]: "Service Unavailable",
+	[HttpStatus.GatewayTimeout]: "Gateway Timeout",
+	[HttpStatus.HttpVersionNotSupported]: "HTTP Version Not Supported",
+	[HttpStatus.VariantAlsoNegotiates]: "Variant Also Negotiates",
+	[HttpStatus.InsufficientStorage]: "Insufficient Storage",
+	[HttpStatus.LoopDetected]: "Loop Detected",
+	[HttpStatus.NotExtended]: "Not Extended",
+	[HttpStatus.NetworkAuthenticationRequired]: "Network Authentication Required"
+};
+/**
+* Returns the name of the HTTP status code (200 -> "OK").
+* @param status The HTTP status code.
+* @returns The name of the HTTP status code or `undefined` if the status code is not recognized.
+*/
+function getHttpStatusName(status) {
+	return STATUS_NAME_MAP[status];
+}
+//#endregion
+//#region src/errors.ts
+/**
+* Base class of all HTTP errors. You can throw this error or throw any of the
+* subclasses. Zeta will automatically detect and handle these errors, setting
+* the appropriate status code and message.
+*
+* Error responses will include the stacktrace during development. To hide the
+* stacktrace in production, set the `NODE_ENV` environment variable to
+* `production`.
+*
+* @example
+* ```ts
+* throw new HttpError(HttpStatus.BadRequest, "Bad request")
+* // OR
+* throw new BadRequestError()
+* ```
+*/
+var HttpError = class extends Error {
+	constructor(status, message, additionalInfo, options) {
+		super(message, options);
+		this.status = status;
+		this.additionalInfo = additionalInfo;
+		this.name = "HttpError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.BadRequest, "Bad Request", ...)` */
+var BadRequestHttpError = class extends HttpError {
+	constructor(message = "Bad Request", additionalInfo, options) {
+		super(HttpStatus.BadRequest, message, additionalInfo, options);
+		this.name = "BadRequestError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.Unauthorized, "Unauthorized", ...)` */
+var UnauthorizedHttpError = class extends HttpError {
+	constructor(message = "Unauthorized", additionalInfo, options) {
+		super(HttpStatus.Unauthorized, message, additionalInfo, options);
+		this.name = "UnauthorizedError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.PaymentRequired, "Payment Required", ...)` */
+var PaymentRequiredHttpError = class extends HttpError {
+	constructor(message = "Payment Required", additionalInfo, options) {
+		super(HttpStatus.PaymentRequired, message, additionalInfo, options);
+		this.name = "PaymentRequiredError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.Forbidden, "Forbidden", ...)` */
+var ForbiddenHttpError = class extends HttpError {
+	constructor(message = "Forbidden", additionalInfo, options) {
+		super(HttpStatus.Forbidden, message, additionalInfo, options);
+		this.name = "ForbiddenError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.NotFound, "Not Found", ...)` */
+var NotFoundHttpError = class extends HttpError {
+	constructor(message = "Not Found", additionalInfo, options) {
+		super(HttpStatus.NotFound, message, additionalInfo, options);
+		this.name = "NotFoundHttpError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.MethodNotAllowed, "Method Not Allowed", ...)` */
+var MethodNotAllowedHttpError = class extends HttpError {
+	constructor(message = "Method Not Allowed", additionalInfo, options) {
+		super(HttpStatus.MethodNotAllowed, message, additionalInfo, options);
+		this.name = "MethodNotAllowedError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.NotAcceptable, "Not Acceptable", ...)` */
+var NotAcceptableHttpError = class extends HttpError {
+	constructor(message = "Not Acceptable", additionalInfo, options) {
+		super(HttpStatus.NotAcceptable, message, additionalInfo, options);
+		this.name = "NotAcceptableError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.ProxyAuthenticationRequired, "Proxy Authentication Required", ...)` */
+var ProxyAuthenticationRequiredHttpError = class extends HttpError {
+	constructor(message = "Proxy Authentication Required", additionalInfo, options) {
+		super(HttpStatus.ProxyAuthenticationRequired, message, additionalInfo, options);
+		this.name = "ProxyAuthenticationRequiredError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.RequestTimeout, "Request Timeout", ...)` */
+var RequestTimeoutHttpError = class extends HttpError {
+	constructor(message = "Request Timeout", additionalInfo, options) {
+		super(HttpStatus.RequestTimeout, message, additionalInfo, options);
+		this.name = "RequestTimeoutError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.Conflict, "Conflict", ...)` */
+var ConflictHttpError = class extends HttpError {
+	constructor(message = "Conflict", additionalInfo, options) {
+		super(HttpStatus.Conflict, message, additionalInfo, options);
+		this.name = "ConflictError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.Gone, "Gone", ...)` */
+var GoneHttpError = class extends HttpError {
+	constructor(message = "Gone", additionalInfo, options) {
+		super(HttpStatus.Gone, message, additionalInfo, options);
+		this.name = "GoneError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.LengthRequired, "Length Required", ...)` */
+var LengthRequiredHttpError = class extends HttpError {
+	constructor(message = "Length Required", additionalInfo, options) {
+		super(HttpStatus.LengthRequired, message, additionalInfo, options);
+		this.name = "LengthRequiredError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.PreconditionFailed, "Precondition Failed", ...)` */
+var PreconditionFailedHttpError = class extends HttpError {
+	constructor(message = "Precondition Failed", additionalInfo, options) {
+		super(HttpStatus.PreconditionFailed, message, additionalInfo, options);
+		this.name = "PreconditionFailedError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.ContentTooLarge, "Content Too Large", ...)` */
+var ContentTooLargeHttpError = class extends HttpError {
+	constructor(message = "Content Too Large", additionalInfo, options) {
+		super(HttpStatus.ContentTooLarge, message, additionalInfo, options);
+		this.name = "ContentTooLargeError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.UriTooLong, "URI Too Long", ...)` */
+var UriTooLongHttpError = class extends HttpError {
+	constructor(message = "URI Too Long", additionalInfo, options) {
+		super(HttpStatus.UriTooLong, message, additionalInfo, options);
+		this.name = "UriTooLongError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.UnsupportedMediaType, "Unsupported Media Type", ...)` */
+var UnsupportedMediaTypeHttpError = class extends HttpError {
+	constructor(message = "Unsupported Media Type", additionalInfo, options) {
+		super(HttpStatus.UnsupportedMediaType, message, additionalInfo, options);
+		this.name = "UnsupportedMediaTypeError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.RangeNotSatisfiable, "Range Not Satisfiable", ...)` */
+var RangeNotSatisfiableHttpError = class extends HttpError {
+	constructor(message = "Range Not Satisfiable", additionalInfo, options) {
+		super(HttpStatus.RangeNotSatisfiable, message, additionalInfo, options);
+		this.name = "RangeNotSatisfiableError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.ExpectationFailed, "Expectation Failed", ...)` */
+var ExpectationFailedHttpError = class extends HttpError {
+	constructor(message = "Expectation Failed", additionalInfo, options) {
+		super(HttpStatus.ExpectationFailed, message, additionalInfo, options);
+		this.name = "ExpectationFailedError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.ImATeapot, "I'm a Teapot", ...)` */
+var ImATeapotHttpError = class extends HttpError {
+	constructor(message = "I'm a Teapot", additionalInfo, options) {
+		super(HttpStatus.ImATeapot, message, additionalInfo, options);
+		this.name = "ImATeapotError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.MisdirectedRequest, "Misdirected Request", ...)` */
+var MisdirectedRequestHttpError = class extends HttpError {
+	constructor(message = "Misdirected Request", additionalInfo, options) {
+		super(HttpStatus.MisdirectedRequest, message, additionalInfo, options);
+		this.name = "MisdirectedRequestError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.UnprocessableEntity, "Unprocessable Entity", ...)` */
+var UnprocessableEntityHttpError = class extends HttpError {
+	constructor(message = "Unprocessable Entity", additionalInfo, options) {
+		super(HttpStatus.UnprocessableEntity, message, additionalInfo, options);
+		this.name = "UnprocessableEntityError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.Locked, "Locked", ...)` */
+var LockedHttpError = class extends HttpError {
+	constructor(message = "Locked", additionalInfo, options) {
+		super(HttpStatus.Locked, message, additionalInfo, options);
+		this.name = "LockedError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.FailedDependency, "Failed Dependency", ...)` */
+var FailedDependencyHttpError = class extends HttpError {
+	constructor(message = "Failed Dependency", additionalInfo, options) {
+		super(HttpStatus.FailedDependency, message, additionalInfo, options);
+		this.name = "FailedDependencyError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.TooEarly, "Too Early", ...)` */
+var TooEarlyHttpError = class extends HttpError {
+	constructor(message = "Too Early", additionalInfo, options) {
+		super(HttpStatus.TooEarly, message, additionalInfo, options);
+		this.name = "TooEarlyError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.UpgradeRequired, "Upgrade Required", ...)` */
+var UpgradeRequiredHttpError = class extends HttpError {
+	constructor(message = "Upgrade Required", additionalInfo, options) {
+		super(HttpStatus.UpgradeRequired, message, additionalInfo, options);
+		this.name = "UpgradeRequiredError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.PreconditionRequired, "Precondition Required", ...)` */
+var PreconditionRequiredHttpError = class extends HttpError {
+	constructor(message = "Precondition Required", additionalInfo, options) {
+		super(HttpStatus.PreconditionRequired, message, additionalInfo, options);
+		this.name = "PreconditionRequiredError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.TooManyRequests, "Too Many Requests", ...)` */
+var TooManyRequestsHttpError = class extends HttpError {
+	constructor(message = "Too Many Requests", additionalInfo, options) {
+		super(HttpStatus.TooManyRequests, message, additionalInfo, options);
+		this.name = "TooManyRequestsError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.RequestHeaderFieldsTooLarge, "Request Header Fields Too Large", ...)` */
+var RequestHeaderFieldsTooLargeHttpError = class extends HttpError {
+	constructor(message = "Request Header Fields Too Large", additionalInfo, options) {
+		super(HttpStatus.RequestHeaderFieldsTooLarge, message, additionalInfo, options);
+		this.name = "RequestHeaderFieldsTooLargeError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.UnavailableForLegalReasons, "Unavailable For Legal Reasons", ...)` */
+var UnavailableForLegalReasonsHttpError = class extends HttpError {
+	constructor(message = "Unavailable For Legal Reasons", additionalInfo, options) {
+		super(HttpStatus.UnavailableForLegalReasons, message, additionalInfo, options);
+		this.name = "UnavailableForLegalReasonsError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.InternalServerError, "Internal Server Error", ...)` */
+var InternalServerErrorHttpError = class extends HttpError {
+	constructor(message = "Internal Server Error", additionalInfo, options) {
+		super(HttpStatus.InternalServerError, message, additionalInfo, options);
+		this.name = "InternalServerErrorError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.NotImplemented, "Not Implemented", ...)` */
+var NotImplementedHttpError = class extends HttpError {
+	constructor(message = "Not Implemented", additionalInfo, options) {
+		super(HttpStatus.NotImplemented, message, additionalInfo, options);
+		this.name = "NotImplementedHttpError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.BadGateway, "Bad Gateway", ...)` */
+var BadGatewayHttpError = class extends HttpError {
+	constructor(message = "Bad Gateway", additionalInfo, options) {
+		super(HttpStatus.BadGateway, message, additionalInfo, options);
+		this.name = "BadGatewayError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.ServiceUnavailable, "Service Unavailable", ...)` */
+var ServiceUnavailableHttpError = class extends HttpError {
+	constructor(message = "Service Unavailable", additionalInfo, options) {
+		super(HttpStatus.ServiceUnavailable, message, additionalInfo, options);
+		this.name = "ServiceUnavailableError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.GatewayTimeout, "Gateway Timeout", ...)` */
+var GatewayTimeoutHttpError = class extends HttpError {
+	constructor(message = "Gateway Timeout", additionalInfo, options) {
+		super(HttpStatus.GatewayTimeout, message, additionalInfo, options);
+		this.name = "GatewayTimeoutError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.HttpVersionNotSupported, "HTTP Version Not Supported", ...)` */
+var HttpVersionNotSupportedHttpError = class extends HttpError {
+	constructor(message = "HTTP Version Not Supported", additionalInfo, options) {
+		super(HttpStatus.HttpVersionNotSupported, message, additionalInfo, options);
+		this.name = "HttpVersionNotSupportedError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.VariantAlsoNegotiates, "Variant Also Negotiates", ...)` */
+var VariantAlsoNegotiatesHttpError = class extends HttpError {
+	constructor(message = "Variant Also Negotiates", additionalInfo, options) {
+		super(HttpStatus.VariantAlsoNegotiates, message, additionalInfo, options);
+		this.name = "VariantAlsoNegotiatesError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.InsufficientStorage, "Insufficient Storage", ...)` */
+var InsufficientStorageHttpError = class extends HttpError {
+	constructor(message = "Insufficient Storage", additionalInfo, options) {
+		super(HttpStatus.InsufficientStorage, message, additionalInfo, options);
+		this.name = "InsufficientStorageError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.LoopDetected, "Loop Detected", ...)` */
+var LoopDetectedHttpError = class extends HttpError {
+	constructor(message = "Loop Detected", additionalInfo, options) {
+		super(HttpStatus.LoopDetected, message, additionalInfo, options);
+		this.name = "LoopDetectedError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.NotExtended, "Not Extended", ...)` */
+var NotExtendedHttpError = class extends HttpError {
+	constructor(message = "Not Extended", additionalInfo, options) {
+		super(HttpStatus.NotExtended, message, additionalInfo, options);
+		this.name = "NotExtendedError";
+	}
+};
+/** Shorthand for `new HttpError(HttpStatus.NetworkAuthenticationRequired, "Network Authentication Required", ...)` */
+var NetworkAuthenticationRequiredHttpError = class extends HttpError {
+	constructor(message = "Network Authentication Required", additionalInfo, options) {
+		super(HttpStatus.NetworkAuthenticationRequired, message, additionalInfo, options);
+		this.name = "NetworkAuthenticationRequiredError";
+	}
+};
+//#endregion
+//#region src/internal/utils.ts
+function validateSchema(schema, input, status, message) {
+	const res = schema["~standard"].validate(input);
+	if (res instanceof Promise) throw Error("Async validation not supported");
+	if (res.issues) throw new HttpError(status, message, {
+		issues: res.issues,
+		input
+	});
+	return res.value;
+}
+function createHttpSchemaValidator(status, message) {
+	return (schema, input) => validateSchema(schema, input, status, message);
+}
+const validateInputSchema = createHttpSchemaValidator(HttpStatus.BadRequest, "Input validation failed");
+const validateOutputSchema = createHttpSchemaValidator(HttpStatus.UnprocessableEntity, "Output validation failed");
+function getRawPathname(request) {
+	const start = request.url.indexOf("/", 8);
+	if (start === -1) return "/";
+	for (let i = start + 1; i < request.url.length; i++) if (request.url[i] === "?" || request.url[i] === "#") return request.url.slice(start, i);
+	return request.url.slice(start);
+}
+function getRawQuery(request) {
+	let index = request.url.indexOf("?");
+	if (index === -1) return {};
+	const res = {};
+	const str = request.url;
+	const len = str.length;
+	let start = index + 1;
+	for (let i = start; i < len; i++) if (str[i] === "&" || i === len - 1) {
+		const end = i === len - 1 ? len : i;
+		const eqIndex = str.indexOf("=", start);
+		if (eqIndex !== -1 && eqIndex < end) res[str.slice(start, eqIndex)] = str.slice(eqIndex + 1, end);
+		start = i + 1;
+	}
+	return res;
+}
+function getRawParams(route) {
+	const params = route.params;
+	if (!params) return {};
+	const res = {};
+	for (const key in params) {
+		const outKey = key === "_" ? "**" : key;
+		res[outKey] = decodeURIComponent(params[key]);
+	}
+	return res;
+}
+function getErrorStack(err) {
+	if (process.env.NODE_ENV === "production") return;
+	return err.stack?.split("\n").map((line) => line.trim()).slice(1);
+}
+function serializeErrorResponse(err) {
+	if (err instanceof HttpError) return {
+		status: err.status,
+		name: err.name,
+		message: err.message,
+		...err.additionalInfo,
+		stack: getErrorStack(err),
+		cause: err.cause != null ? serializeErrorResponse(err.cause) : void 0
+	};
+	if (err instanceof Error) return {
+		status: HttpStatus.InternalServerError,
+		name: err.name,
+		message: err.message,
+		stack: getErrorStack(err),
+		cause: err.cause != null ? serializeErrorResponse(err.cause) : void 0
+	};
+	return {
+		name: "Unknown Error",
+		message: "An unknown error occurred",
+		status: HttpStatus.InternalServerError,
+		stack: getErrorStack(err)
+	};
+}
+const IsStatusResult = Symbol("IsStatusResult");
+function detectTransport() {
+	if (typeof Bun !== "undefined") return createBunTransport();
+	if (typeof Deno !== "undefined") return createDenoTransport();
+	throw Error(`Cannot automatically detect which transport to use. You must specify a transport in your top-level app:
+
+    ---
+    import { createBunTransport } from '@aklinker1/zeta/transports/bun-transport';
+
+    const app = createApp({
+      transport: createBunTransport(),
+    })
+
+    app.listen();
+    ---`);
+}
+function cleanupCompiledWhitespace(code) {
+	return code.replace(/^ +$/gm, "").replace(/\n\n+/gm, "\n\n").replaceAll("{\n\n", "{\n");
+}
+//#endregion
+//#region src/internal/context.ts
+var Context = class {
+	set = {
+		status: HttpStatus.Ok,
+		headers: {}
+	};
+	matchedRoute;
+	#params;
+	#query;
+	constructor(request, path, origin) {
+		this.request = request;
+		this.path = path;
+		this.origin = origin;
+	}
+	get url() {
+		return new URL(this.request.url, this.origin);
+	}
+	get params() {
+		if (this.#params !== void 0) return this.#params;
+		return this.matchedRoute?.params ? getRawParams(this.matchedRoute) : {};
+	}
+	set params(value) {
+		this.#params = value;
+	}
+	get query() {
+		if (this.#query !== void 0) return this.#query;
+		return this.request.url.includes("?") ? getRawQuery(this.request) : {};
+	}
+	set query(value) {
+		this.#query = value;
+	}
+	get route() {
+		return this.matchedRoute?.data.route;
+	}
+	get method() {
+		return this.request.method;
+	}
+	status(status, body) {
+		return {
+			[IsStatusResult]: true,
+			status,
+			body
+		};
+	}
+};
+//#endregion
+//#region src/internal/compile-fetch-function.ts
+function compileFetchFunction(options) {
+	const onGlobalRequestCount = options.hooks.onGlobalRequest?.length;
+	const onGlobalAfterResponseCount = options.hooks.onGlobalAfterResponse?.length;
+	const onGlobalErrorCount = options.hooks.onGlobalError?.length;
+	const js = `
+return (request) => {
+  const path = utils.getRawPathname(request);
+  const ctx = new utils.Context(request, path, utils.origin);
+  ${onGlobalAfterResponseCount ? "let handlerReturnedPromise = false;" : ""}
+
+  try {
+${onGlobalRequestCount ? compileOnGlobalRequestHook(onGlobalRequestCount) : ""}
+
+    const matchedRoute = utils.getRoute(request.method, path);
+    if (matchedRoute == null) {
+      throw new utils.NotFoundHttpError(undefined, {
+        method: request.method,
+        path,
+      });
+    } else {
+      ctx.matchedRoute = matchedRoute;
+    }
+
+    ctx.response = matchedRoute.data.compiledHandler(request, ctx);
+    if (typeof ctx.response.then !== utils.FUNCTION) return ctx.response;
+
+    ${onGlobalAfterResponseCount ? "handlerReturnedPromise = true;" : ""}
+    return ctx.response.catch(error => {
+${onGlobalErrorCount ? compileOnGlobalErrorHook(onGlobalErrorCount, 3) : ""}
+
+${compileErrorResponse(3)}
+    })${onGlobalAfterResponseCount ? compileOnGlobalAfterResponsePromiseFinally(onGlobalAfterResponseCount, 2) : ""};
+  } catch (error) {
+${onGlobalErrorCount ? compileOnGlobalErrorHook(onGlobalErrorCount, 2) : ""}
+
+${compileErrorResponse(2)}
+  } ${onGlobalAfterResponseCount ? compileOnGlobalAfterResponseFinally(onGlobalAfterResponseCount, 1) : ""}
+}
+//#sourceURL=zeta-jit-generated://zeta-fetch-fn.js
+  `;
+	return new Function("utils", cleanupCompiledWhitespace(js))({
+		FUNCTION: "function",
+		getRawPathname,
+		hooks: options.hooks,
+		Context,
+		getRoute: options.getRoute,
+		NotFoundHttpError,
+		origin: options.origin,
+		HttpError,
+		HttpStatus,
+		serializeErrorResponse
+	});
+}
+function compileOnGlobalRequestHook(hookCount) {
+	const lines = [];
+	for (let i = 0; i < hookCount; i++) {
+		const resultVar = `onGlobalRequestRes${i}`;
+		lines.push(`    const ${resultVar} = utils.hooks.onGlobalRequest[${i}].callback(ctx);`, ...process.env.NODE_ENV !== "production" ? [`    if (${resultVar} instanceof Promise)`, `      console.warn("Warning: Promise returned from onGlobalRequest hook. Promises returned from onGlobalRequest are not awaited, ignoring the return value.");`] : [], `    if (${resultVar})`, `      if (typeof ${resultVar}.body?.bytes === utils.FUNCTION)`, `        return ${resultVar};`, `      else`, `        for (const key of Object.keys(${resultVar}))`, `          ctx[key] = ${resultVar}[key];`);
+	}
+	return lines.join("\n");
+}
+function compileOnGlobalErrorHook(hookCount, tabs) {
+	const indent = "  ".repeat(tabs);
+	const lines = [`${indent}ctx.error = error;`];
+	for (let i = 0; i < hookCount; i++) lines.push(`${indent}utils.hooks.onGlobalError[${i}].callback(ctx);`);
+	return lines.join("\n");
+}
+function compileOnGlobalAfterResponseFinally(hookCount, tabs) {
+	const indent = "  ".repeat(tabs);
+	return `finally {
+${indent}  if (!handlerReturnedPromise) {
+${compileOnGlobalAfterResponseHook(hookCount, tabs + 2)}
+${indent}  }
+${indent}}
+`;
+}
+function compileOnGlobalAfterResponsePromiseFinally(hookCount, tabs) {
+	const indent = "  ".repeat(tabs);
+	return `.finally(() => {
+${compileOnGlobalAfterResponseHook(hookCount, tabs + 1)}
+${indent}})`;
+}
+function compileOnGlobalAfterResponseHook(hookCount, tabs) {
+	const indent = "  ".repeat(tabs);
+	const lines = [`${indent}setTimeout(() => {`];
+	for (let i = 0; i < hookCount; i++) lines.push(`${indent}  utils.hooks.onGlobalAfterResponse[${i}].callback(ctx);`);
+	lines.push(`${indent}})`);
+	return lines.join("\n");
+}
+function compileErrorResponse(tabs) {
+	const indent = "  ".repeat(tabs);
+	return `${indent}const status =
+${indent}  error instanceof utils.HttpError
+${indent}    ? error.status
+${indent}    : utils.HttpStatus.InternalServerError;
+${indent}return (
+${indent}  ctx.response = Response.json(
+${indent}    utils.serializeErrorResponse(error),
+${indent}    { status, headers: ctx.set.headers },
+${indent}  )
+${indent});`;
+}
+//#endregion
+//#region src/meta.ts
+/** Get metadata for either a ZetaSchema or a StandardSchemaV1. */
+function getMeta(adapter, schema) {
+	if (isZetaSchema(schema)) return schema["~zeta"].meta;
+	if (!adapter) return {};
+	return adapter.getMeta(schema) ?? {};
+}
+//#endregion
+//#region src/internal/compile-route-handler.ts
+function compileRouteHandler(options) {
+	if (options.fetch) return new Function(`
+      return (request, ctx) => ctx.matchedRoute.data.fetch(request)
+      //#sourceURL=${getSourceUrl(options)}
+    `)();
+	const responseContentTypeMap = getResponseContentTypeMap(options);
+	const js = `
+return async (request, ctx) => {
+  ${options.method === "GET" ? "" : ADD_CTX_BODY}
+
+${options.hooks.onTransform?.length ? compileCtxModifierHookCall("onTransform", options.hooks.onTransform.length) : ""}
+
+  ${options.def?.body ? "ctx.body = utils.validateInputSchema(ctx.matchedRoute.data.def.body, ctx.body);" : ""}
+  ${options.def?.params ? "ctx.params = utils.validateInputSchema(ctx.matchedRoute.data.def.params, ctx.params);" : ""}
+  ${options.def?.query ? "ctx.query = utils.validateInputSchema(ctx.matchedRoute.data.def.query, ctx.query);" : ""}
+
+${options.hooks.onBeforeHandle?.length ? compileCtxModifierHookCall("onBeforeHandle", options.hooks.onBeforeHandle.length) : ""}
+
+  ctx.response = await ctx.matchedRoute.data.handler(ctx);
+  if (ctx.response) {
+    if (ctx.response[utils.IsStatusResult]) {
+      ctx.set.status = ctx.response.status;
+      ctx.response = ctx.response.body;
+    }
+    if (typeof ctx.response?.body?.bytes === utils.FUNCTION) return ctx.response;
+  }
+
+  ${compileValidateResponse(options)}
+
+${options.hooks.onAfterHandle?.length ? compileResponseModifierHookCall("onAfterHandle", options.hooks.onAfterHandle.length) : ""}
+
+${options.hooks.onMapResponse?.length ? compileResponseModifierHookCall("onMapResponse", options.hooks.onMapResponse.length) : ""}
+
+  if (ctx.response == null) {
+    return (
+      ctx.response = new Response(undefined, {
+        status: ctx.set.status,
+        headers: ctx.set.headers,
+      })
+    )
+  }
+
+  const serialized = utils.smartSerialize(ctx.response);
+  if (!ctx.set.headers["Content-Type"]) ctx.set.headers["Content-Type"] = ${responseContentTypeMap ? "responseContentTypeMap[ctx.set.status] ??" : ""} serialized.contentType
+  return (
+    ctx.response = new Response(serialized.value, {
+      status: ctx.set.status,
+      headers: ctx.set.headers,
+    })
+  )
+}
+//#sourceURL=${getSourceUrl(options)}
+  `;
+	return new Function("utils", "responseContentTypeMap", cleanupCompiledWhitespace(js))(UTILS, responseContentTypeMap);
+}
+const UTILS = {
+	smartDeserialize,
+	smartSerialize,
+	FUNCTION: "function",
+	IsStatusResult,
+	validateInputSchema,
+	validateOutputSchema
+};
+function getSourceUrl(options) {
+	return `zeta-jit-generated://${options.method.toLowerCase()}-${options.route.replace(/\s/gm, "").replaceAll("/", "-")}.js`;
+}
+const ADD_CTX_BODY = `
+  ctx.body = utils.smartDeserialize(request);
+  if (ctx.body) ctx.body = await ctx.body;
+`;
+function compileCtxModifierHookCall(hook, hookCount) {
+	const lines = [];
+	for (let i = 0; i < hookCount; i++) {
+		const resultVar = `${hook}Res${i}`;
+		lines.push(`  const ${resultVar} = await ctx.matchedRoute.data.hooks.${hook}[${i}].callback(ctx);`, `  if (${resultVar})`, `    if (typeof ${resultVar}.body?.bytes === utils.FUNCTION)`, `      return ${resultVar};`, `    else`, `      for (const key of Object.keys(${resultVar}))`, `        ctx[key] = ${resultVar}[key];`);
+	}
+	return lines.join("\n");
+}
+function compileResponseModifierHookCall(hook, hookCount) {
+	const lines = [];
+	for (let i = 0; i < hookCount; i++) {
+		const resultVar = `${hook}Res${i}`;
+		lines.push(`  const ${resultVar} = await ctx.matchedRoute.data.hooks.${hook}[${i}].callback(ctx);`, `  if (${resultVar}) ctx.response = ${resultVar};`, `  if (typeof ${resultVar}.body?.bytes === utils.FUNCTION)`, `    return ${resultVar};`);
+	}
+	return lines.join("\n");
+}
+function compileValidateResponse(options) {
+	if (!options.def?.responses) return "";
+	if ("~standard" in options.def.responses) return "ctx.response = utils.validateOutputSchema(ctx.matchedRoute.data.def.responses, ctx.response);";
+	return "ctx.response = utils.validateOutputSchema(ctx.matchedRoute.data.def.responses[ctx.set.status], ctx.response);";
+}
+function getResponseContentTypeMap(options) {
+	if (!options.def?.responses) return;
+	if ("~standard" in options.def.responses) {
+		const { contentType } = getMeta(options.schemaAdapter, options.def.responses);
+		if (!contentType) return;
+		return { [200]: contentType };
+	}
+	const map = {};
+	for (const [status, schema] of Object.entries(options.def.responses)) {
+		const { contentType } = getMeta(options.schemaAdapter, schema);
+		map[Number(status)] = contentType;
+	}
+	if (Object.keys(map).length === 0) return;
+	return map;
+}
+//#endregion
+//#region src/open-api.ts
+function buildOpenApiDocs(options, app) {
+	try {
+		if (!options?.schemaAdapter) return {
+			type: "error",
+			error: "OpenAPI docs require a schema adapter"
+		};
+		const adapter = options.schemaAdapter;
+		const userDoc = options.openApi ?? {};
+		const docs = {
+			openapi: "3.1.0",
+			...userDoc,
+			info: {
+				title: "Zeta Application",
+				version: "1.0.0",
+				...userDoc.info
+			},
+			paths: {},
+			components: {
+				...userDoc.components,
+				schemas: {
+					...userDoc.components?.schemas,
+					ErrorResponse: ErrorResponseJsonSchema
+				}
+			}
+		};
+		for (const [method, methodEntry] of Object.entries(app["~zeta"].routes)) for (const [path, routerData] of Object.entries(methodEntry)) {
+			const openApiPath = path.replace(/\/:([^/]+)/g, "/{$1}").replace(/\/$/, "") || "/";
+			const { headers, params, query, body, responses, ...openApiOperation } = routerData.def ?? {};
+			docs.paths ??= {};
+			docs.paths[openApiPath] ??= {};
+			docs.paths[openApiPath][method.toLowerCase()] = {
+				...openApiOperation,
+				summary: openApiOperation.summary ?? (openApiOperation.operationId ? titleCase(openApiOperation.operationId) : void 0),
+				requestBody: body ? { content: { [getMeta(adapter, body)?.contentType ?? "application/json"]: { schema: isZetaSchema(body) ? body.toJsonSchema?.() : adapter.toJsonSchema(body) } } } : void 0,
+				parameters: [
+					...mapParameters(adapter, params, "path"),
+					...mapParameters(adapter, query, "query"),
+					...mapParameters(adapter, headers, "header")
+				],
+				responses: {
+					...!responses ? {} : "~standard" in responses ? { 200: buildResponse(200, responses, adapter) } : Object.fromEntries(Object.entries(responses).map(([status, response]) => [status, buildResponse(Number(status), response, adapter)])),
+					...(params || query || headers || body) && { 400: {
+						description: "Bad Request",
+						content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } }
+					} }
+				}
+			};
+		}
+		return {
+			type: "success",
+			spec: optimizeSpec(docs)
+		};
+	} catch (error) {
+		return {
+			type: "error",
+			error
+		};
+	}
+}
+function buildScalarHtml(jsonRoute, options) {
+	const scalarConfig = {
+		defaultOpenAllTags: true,
+		...options?.scalar,
+		url: jsonRoute
+	};
+	return `<!doctype html>
+<html>
+  <head>
+    <title>API Reference</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+  </head>
+  <body>
+    <div id="app"></div>
+    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"><\/script>
+    <script>
+      const config = ${JSON.stringify(scalarConfig)};
+      if (${process.env.NODE_ENV !== "production"}) {
+        config.servers ??= [];
+        config.servers.unshift({ url: location.origin })
+      }
+      Scalar.createApiReference('#app', config)
+    <\/script>
+  </body>
+</html>
+`;
+}
+function mapParameters(adapter, schema, in_) {
+	if (!schema) return [];
+	const openApiSchema = adapter.toJsonSchema(schema);
+	if (openApiSchema.type !== "object") throw Error(`Param in ${in_} must have { "type": "object", ... }, but got ${JSON.stringify(openApiSchema, null, 2)}`);
+	return Object.entries(openApiSchema.properties).map(([name, def]) => ({
+		name,
+		in: in_,
+		description: def.description,
+		schema: def,
+		required: !!openApiSchema.required?.includes(name)
+	}));
+}
+function buildResponse(status, schema, adapter) {
+	const meta = getMeta(adapter, schema);
+	if (isZetaSchema(schema)) {
+		const description = meta?.responseDescription ?? getHttpStatusName(status) ?? "";
+		if (schema["~zeta"].type === "NoResponse") return { description };
+		if (schema["~zeta"].type === "ErrorResponse") return {
+			description,
+			content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } }
+		};
+	}
+	return {
+		description: meta?.responseDescription ?? getHttpStatusName(status),
+		content: { [meta?.contentType ?? "application/json"]: { schema: adapter.toJsonSchema(schema) } }
+	};
+}
+function optimizeSpec(spec) {
+	const optimized = structuredClone(spec);
+	addModelRefs(optimized);
+	sortComponentSchemas(optimized);
+	return optimized;
+}
+/**
+* Look for `ref` properties from schema metadata and move those models to
+* `components.schemas`.
+*/
+function addModelRefs(spec) {
+	const recurse = (obj) => {
+		if (obj == null) return;
+		if (typeof obj !== "object") return;
+		if (Array.isArray(obj)) {
+			for (let i = 0, il = obj.length; i < il; i++) recurse(obj[i]);
+			return;
+		}
+		const values = Object.values(obj);
+		for (let i = 0, il = values.length; i < il; i++) recurse(values[i]);
+		if (typeof obj.ref === "string") {
+			const ref = obj.ref;
+			spec.components ??= {};
+			spec.components.schemas ??= {};
+			spec.components.schemas[ref] = {
+				...structuredClone(obj),
+				ref: void 0
+			};
+			for (const key of Object.keys(obj)) delete obj[key];
+			obj.$ref = `#/components/schemas/${ref}`;
+		}
+	};
+	recurse(spec.paths);
+}
+function sortComponentSchemas(spec) {
+	if (!spec?.components?.schemas) return;
+	spec.components.schemas = Object.fromEntries(Object.entries(spec.components.schemas).sort((a, b) => a[0].toLowerCase().localeCompare(b[0].toLowerCase())));
+}
+//#endregion
+//#region src/app.ts
+let appIdInc = 0;
+const nextAppId = () => `app-${appIdInc++}`;
+let _hookIdInc = 0;
+const nextHookId = (appId) => `${appId}/hook-${_hookIdInc++}`;
+/**
+* Create a server-side, Zeta application.
+*
+* Zeta provides simple support for serving applications using `Bun.serve` and
+* `Deno.serve` by calling `app.listen(3000)`.
+*
+* If you need more customization, you can use the `build` method to create a
+* `fetch` function and serve it however you like.
+*
+* @example
+* ```ts
+* import { createApp } from "@aklinker1/zeta";
+*
+* const app = createApp({ prefix: "/api" })
+*   .get("/health", () => "OK")
+*   .get("/users", () => ["user1", "user2"]);
+*
+* app.listen(3000);
+*
+* // Or serve the app yourself
+* const fetch = app.build();
+* Bun.serve({ fetch, ... });
+* Deno.serve({ fetch, ... });
+* ```
+*
+* @param options Configure application behavior.
+*/
+function createApp(options) {
+	const appId = nextAppId();
+	const { origin = "http://localhost", prefix = "" } = options ?? {};
+	const hooks = {};
+	const routes = {};
+	const addRoutesEntry = (method, route, data) => {
+		routes[method] ??= {};
+		if (routes[method][route]) console.warn(`Route ${route} already exists`);
+		routes[method][route] = data;
+	};
+	const cloneHooks = () => {
+		const cloned = {};
+		for (const key of Object.keys(hooks)) if (hooks[key]) cloned[key] = [...hooks[key]];
+		return cloned;
+	};
+	const app = {
+		[Symbol.toStringTag]: "ZetaApp",
+		"~zeta": {
+			id: appId,
+			prefix,
+			routes,
+			hooks
+		},
+		build: () => {
+			const jsonRoute = options?.openApiRoute ?? "/openapi.json";
+			const scalarRoute = options?.scalarRoute ?? "/scalar";
+			const docs = buildOpenApiDocs(options, app);
+			if (docs.type === "error") console.error("Failed to build OpenAPI docs:", docs.error);
+			app.get(jsonRoute, () => {
+				if (docs.type === "error") {
+					console.error("Failed to build OpenAPI docs:", docs.error);
+					throw docs.error;
+				}
+				return docs.spec;
+			});
+			if (docs.type === "success") {
+				const scalarHtml = buildScalarHtml(jsonRoute, options);
+				app.get(scalarRoute, () => new Response(scalarHtml, { headers: { "content-type": "text/html;charset=utf-8" } }));
+			}
+			const router = createRouter();
+			for (const [method, methodValue] of Object.entries(routes)) for (const [path, data] of Object.entries(methodValue)) addRoute(router, method === Method.Any ? void 0 : method, path, data);
+			return compileFetchFunction({
+				getRoute: compileRouter(router),
+				hooks,
+				origin
+			});
+		},
+		getOpenApiSpec: () => {
+			const res = buildOpenApiDocs(options, app);
+			if (res.type === "error") throw res.error;
+			return res.spec;
+		},
+		export: () => {
+			app["~zeta"].exported = true;
+			return app;
+		},
+		listen: (port, cb) => {
+			(options?.transport ?? detectTransport()).listen(port, app.build(), cb);
+			return app;
+		},
+		decorate: (...args) => {
+			const obj = args.length === 2 ? { [args[0]]: args[1] } : args[0];
+			hooks.onTransform ??= [];
+			hooks.onTransform.push({
+				id: nextHookId(appId),
+				applyTo: "local",
+				callback: () => obj
+			});
+			return app;
+		},
+		onGlobalRequest(callback) {
+			hooks.onGlobalRequest ??= [];
+			hooks.onGlobalRequest.push({
+				id: nextHookId(appId),
+				applyTo: "global",
+				callback
+			});
+			return app;
+		},
+		onTransform(callback) {
+			hooks.onTransform ??= [];
+			hooks.onTransform.push({
+				id: nextHookId(appId),
+				applyTo: "local",
+				callback
+			});
+			return app;
+		},
+		onBeforeHandle(callback) {
+			hooks.onBeforeHandle ??= [];
+			hooks.onBeforeHandle.push({
+				id: nextHookId(appId),
+				applyTo: "local",
+				callback
+			});
+			return app;
+		},
+		onAfterHandle(callback) {
+			hooks.onAfterHandle ??= [];
+			hooks.onAfterHandle.push({
+				id: nextHookId(appId),
+				applyTo: "local",
+				callback
+			});
+			return app;
+		},
+		onMapResponse(callback) {
+			hooks.onMapResponse ??= [];
+			hooks.onMapResponse.push({
+				id: nextHookId(appId),
+				applyTo: "local",
+				callback
+			});
+			return app;
+		},
+		onGlobalError(callback) {
+			hooks.onGlobalError ??= [];
+			hooks.onGlobalError.push({
+				id: nextHookId(appId),
+				applyTo: "global",
+				callback
+			});
+			return app;
+		},
+		onGlobalAfterResponse(callback) {
+			hooks.onGlobalAfterResponse ??= [];
+			hooks.onGlobalAfterResponse.push({
+				id: nextHookId(appId),
+				applyTo: "global",
+				callback
+			});
+			return app;
+		},
+		get: (...args) => app.method.apply(app, [Method.Get, ...args]),
+		post: (...args) => app.method.apply(app, [Method.Post, ...args]),
+		put: (...args) => app.method.apply(app, [Method.Put, ...args]),
+		delete: (...args) => app.method.apply(app, [Method.Delete, ...args]),
+		any: (...args) => app.method.apply(app, [Method.Any, ...args]),
+		method(method, path, ...args) {
+			const routeDef = args.length === 2 ? args[0] : void 0;
+			const handler = args[1] ?? args[0];
+			const route = `${prefix}${path}`;
+			const hooks = cloneHooks();
+			const def = mergeAppDefaults(routeDef, options);
+			addRoutesEntry(method, route, {
+				def,
+				route,
+				hooks,
+				compiledHandler: compileRouteHandler({
+					schemaAdapter: options?.schemaAdapter,
+					def,
+					hooks,
+					method,
+					route,
+					handler
+				}),
+				handler
+			});
+			return app;
+		},
+		mount(...args) {
+			let path = "";
+			let routeDef = {};
+			let fetch;
+			if (args.length === 1) fetch = args[0];
+			else if (args.length === 2) {
+				path = args[0];
+				fetch = args[1];
+			} else {
+				path = args[0];
+				routeDef = args[1];
+				fetch = args[2];
+			}
+			const route = `${prefix}${path}/**`;
+			const hooks = cloneHooks();
+			const def = mergeAppDefaults(routeDef, options);
+			const compiledHandler = compileRouteHandler({
+				schemaAdapter: options?.schemaAdapter,
+				hooks,
+				method: "ANY",
+				route,
+				fetch,
+				def
+			});
+			addRoutesEntry(Method.Any, route, {
+				def,
+				fetch,
+				route,
+				hooks,
+				compiledHandler
+			});
+			return app;
+		},
+		use: (childApp) => {
+			for (const [method, methodValue] of Object.entries(childApp["~zeta"].routes)) for (const [subRoute, routeValue] of Object.entries(methodValue)) {
+				const route = `${prefix}${subRoute}`;
+				addRoutesEntry(method, route, {
+					...routeValue,
+					route
+				});
+			}
+			for (const hookName of Object.keys(childApp["~zeta"].hooks)) for (const hook of childApp["~zeta"].hooks[hookName]) {
+				if (hook.applyTo !== "global" && !childApp["~zeta"].exported) continue;
+				if (hooks[hookName]) {
+					if (!hooks[hookName].includes(hook)) hooks[hookName].push(hook);
+				} else hooks[hookName] = [hook];
+			}
+			return app;
+		}
+	};
+	return app;
+}
+/**
+* Apply app-level defaults (tags, security) to a route definition.
+* Route-level values override app-level defaults.
+*/
+function mergeAppDefaults(routeDef, options) {
+	if (!options?.tags?.length && !options?.security?.length) return routeDef;
+	return {
+		tags: options.tags,
+		security: options.security,
+		...routeDef
+	};
+}
+var Method = /* @__PURE__ */ function(Method) {
+	Method["Get"] = "GET";
+	Method["Post"] = "POST";
+	Method["Put"] = "PUT";
+	Method["Delete"] = "DELETE";
+	Method["Any"] = "ANY";
+	return Method;
+}(Method || {});
+//#endregion
+export { BadGatewayHttpError, BadRequestHttpError, ConflictHttpError, ContentTooLargeHttpError, ErrorResponse, ExpectationFailedHttpError, FailedDependencyHttpError, ForbiddenHttpError, GatewayTimeoutHttpError, GoneHttpError, HttpError, HttpStatus, HttpVersionNotSupportedHttpError, ImATeapotHttpError, InsufficientStorageHttpError, InternalServerErrorHttpError, LengthRequiredHttpError, LockedHttpError, LoopDetectedHttpError, MethodNotAllowedHttpError, MisdirectedRequestHttpError, NetworkAuthenticationRequiredHttpError, NoResponse, NotAcceptableHttpError, NotExtendedHttpError, NotFoundHttpError, NotImplementedHttpError, PaymentRequiredHttpError, PreconditionFailedHttpError, PreconditionRequiredHttpError, ProxyAuthenticationRequiredHttpError, RangeNotSatisfiableHttpError, RequestHeaderFieldsTooLargeHttpError, RequestTimeoutHttpError, ServiceUnavailableHttpError, TooEarlyHttpError, TooManyRequestsHttpError, UnauthorizedHttpError, UnavailableForLegalReasonsHttpError, UnprocessableEntityHttpError, UnsupportedMediaTypeHttpError, UpgradeRequiredHttpError, UriTooLongHttpError, VariantAlsoNegotiatesHttpError, createApp, getHttpStatusName };