@aklinker1/zeta 2.1.3 → 2.2.1

package/dist/app-C2QYhuOT.mjs

@@ -0,0 +1,1228 @@
+import { ErrorResponseJsonSchema, isZetaSchema } from "./schema.mjs";
+import { n as smartSerialize, t as smartDeserialize } from "./serialization-0dai2wUm.mjs";
+import { createFetchTransport } from "./transports/fetch-transport.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 decodeUrlString(request.url.slice(start, i));
+	return decodeUrlString(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)] = decodeUrlString(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 cleanupCompiledWhitespace(code) {
+	return code.replace(/^ +$/gm, "").replace(/\n\n+/gm, "\n\n").replaceAll("{\n\n", "{\n");
+}
+function decodeUrlString(text) {
+	return decodeURIComponent(text.replaceAll("+", " "));
+}
+//#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${options.transport?.decorate ? ", ...args" : ""}) => {
+  const path = utils.getRawPathname(request);
+  const ctx = new utils.Context(request, path, utils.origin);
+  ${options.transport?.decorate ? `utils.transport.decorate(ctx, request, ...args);` : ""}
+  ${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,
+		transport: options.transport
+	});
+}
+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 = {};
+	let _transport;
+	const getTransport = () => _transport ??= options?.transport ?? createFetchTransport();
+	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,
+				transport: getTransport()
+			});
+		},
+		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) => {
+			getTransport().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 { RangeNotSatisfiableHttpError as A, UpgradeRequiredHttpError as B, NotExtendedHttpError as C, PreconditionFailedHttpError as D, PaymentRequiredHttpError as E, TooManyRequestsHttpError as F, VariantAlsoNegotiatesHttpError as H, UnauthorizedHttpError as I, UnavailableForLegalReasonsHttpError as L, RequestTimeoutHttpError as M, ServiceUnavailableHttpError as N, PreconditionRequiredHttpError as O, TooEarlyHttpError as P, UnprocessableEntityHttpError as R, NotAcceptableHttpError as S, NotImplementedHttpError as T, HttpStatus as U, UriTooLongHttpError as V, getHttpStatusName as W, LockedHttpError as _, ContentTooLargeHttpError as a, MisdirectedRequestHttpError as b, ForbiddenHttpError as c, HttpError as d, HttpVersionNotSupportedHttpError as f, LengthRequiredHttpError as g, InternalServerErrorHttpError as h, ConflictHttpError as i, RequestHeaderFieldsTooLargeHttpError as j, ProxyAuthenticationRequiredHttpError as k, GatewayTimeoutHttpError as l, InsufficientStorageHttpError as m, BadGatewayHttpError as n, ExpectationFailedHttpError as o, ImATeapotHttpError as p, BadRequestHttpError as r, FailedDependencyHttpError as s, createApp as t, GoneHttpError as u, LoopDetectedHttpError as v, NotFoundHttpError as w, NetworkAuthenticationRequiredHttpError as x, MethodNotAllowedHttpError as y, UnsupportedMediaTypeHttpError as z };