elysia 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/compile/lexer.js

@@ -1,9 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/compile/lexer.ts
-const isSpace = (ch) => ch === " " || ch === "\n" || ch === "	" || ch === "\r";
-const isIdentChar = (ch) => ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_" || ch === "$";
-const isIdentCharCode = (code) => code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57 || code === 95 || code === 36;
 function skipString(src, start) {
 	const quote = src[start];
 	let i = start + 1;
@@ -45,9 +42,274 @@ function skipString(src, start) {
 	}
 	return i;
 }
+const prefixKeywords = new Set([
+	"await",
+	"case",
+	"delete",
+	"do",
+	"else",
+	"in",
+	"instanceof",
+	"new",
+	"of",
+	"return",
+	"throw",
+	"typeof",
+	"void",
+	"yield"
+]);
+const isSpace = (char) => char === 32 || char >= 9 && char <= 13 || char >= 128 && /\s/.test(String.fromCharCode(char));
+const isIdentifierStart = (char) => char >= 65 && char <= 90 || char >= 97 && char <= 122 || char === 36 || char === 95 || char >= 128 && !isSpace(char);
+const isIdentifierPart = (char) => isIdentifierStart(char) || char >= 48 && char <= 57;
+function isHeader(tokens) {
+	let keyword = tokens.length - 1;
+	if (keyword > 0 && tokens[keyword].value === "await" && tokens[keyword - 1].value === "for") keyword--;
+	if (keyword < 0) return false;
+	const { k, value: v } = tokens[keyword];
+	if (k !== "i" || v !== "if" && v !== "while" && v !== "for" && v !== "with") return false;
+	if (keyword === 0) return true;
+	const before = tokens[keyword - 1];
+	return !(before.k === "p" && (before.value === "." || before.value === "?." || before.value === "#"));
+}
+function scanTokens(source) {
+	const tokens = [];
+	let index = 0;
+	let canEndExpression = false;
+	const headers = [];
+	const skipUnicodeEscape = () => {
+		index += 2;
+		if (source.charCodeAt(index) === 123) {
+			const end = source.indexOf("}", index + 1);
+			if (end === -1) return false;
+			index = end + 1;
+			return true;
+		}
+		for (let digit = 0; digit < 4; digit++) {
+			const hex = source.charCodeAt(index + digit);
+			if (!(hex >= 48 && hex <= 57 || hex >= 65 && hex <= 70 || hex >= 97 && hex <= 102)) return false;
+		}
+		index += 4;
+		return true;
+	};
+	const scanCode = (templateExpression = false) => {
+		let templateDepth = 0;
+		while (index < source.length) {
+			const char = source.charCodeAt(index);
+			if (isSpace(char)) {
+				index++;
+				continue;
+			}
+			if (char === 92 && source.charCodeAt(index + 1) !== 117) return false;
+			if (char === 47) {
+				const next = source.charCodeAt(index + 1);
+				if (next === 47) {
+					index += 2;
+					while (index < source.length && source.charCodeAt(index) !== 10 && source.charCodeAt(index) !== 13 && source.charCodeAt(index) !== 8232 && source.charCodeAt(index) !== 8233) index++;
+					continue;
+				}
+				if (next === 42) {
+					index += 2;
+					while (index + 1 < source.length && !(source.charCodeAt(index) === 42 && source.charCodeAt(index + 1) === 47)) index++;
+					if (index + 1 >= source.length) return false;
+					index += 2;
+					continue;
+				}
+				if (!canEndExpression) {
+					const previous = tokens.length ? tokens[tokens.length - 1] : void 0;
+					if (previous?.k === "i" && (previous.value === "of" || previous.value === "await" || previous.value === "yield")) return false;
+					index++;
+					let escaped = false;
+					let characterClass = false;
+					let closed = false;
+					while (index < source.length) {
+						const regexChar = source.charCodeAt(index++);
+						if (escaped) {
+							escaped = false;
+							continue;
+						}
+						if (regexChar === 92) {
+							escaped = true;
+							continue;
+						}
+						if (regexChar === 91) characterClass = true;
+						else if (regexChar === 93) characterClass = false;
+						else if (regexChar === 47 && !characterClass) {
+							closed = true;
+							break;
+						} else if (regexChar === 10 || regexChar === 13) return false;
+					}
+					if (!closed) return false;
+					while (isIdentifierPart(source.charCodeAt(index))) index++;
+					canEndExpression = true;
+					continue;
+				}
+				const previous = tokens.length ? tokens[tokens.length - 1] : void 0;
+				if (previous?.k === "p" && previous.value === "}") return false;
+				tokens.push({
+					k: "p",
+					value: "/",
+					at: index
+				});
+				index++;
+				canEndExpression = false;
+				continue;
+			}
+			if (char === 34 || char === 39) {
+				const quote = char;
+				const start = ++index;
+				let escaped = false;
+				while (index < source.length) {
+					const stringChar = source.charCodeAt(index);
+					if (escaped) escaped = false;
+					else if (stringChar === 92) escaped = true;
+					else if (stringChar === quote) break;
+					else if (stringChar === 10 || stringChar === 13) return false;
+					index++;
+				}
+				if (index >= source.length) return false;
+				tokens.push({
+					k: "s",
+					value: source.slice(start, index),
+					at: start - 1
+				});
+				index++;
+				canEndExpression = true;
+				continue;
+			}
+			if (char === 96) {
+				index++;
+				let closed = false;
+				while (index < source.length) {
+					const templateChar = source.charCodeAt(index);
+					if (templateChar === 92) {
+						index += 2;
+						continue;
+					}
+					if (templateChar === 96) {
+						index++;
+						closed = true;
+						break;
+					}
+					if (templateChar === 36 && source.charCodeAt(index + 1) === 123) {
+						index += 2;
+						canEndExpression = false;
+						if (!scanCode(true)) return false;
+						continue;
+					}
+					index++;
+				}
+				if (!closed) return false;
+				canEndExpression = true;
+				continue;
+			}
+			if (isIdentifierStart(char) || char === 92 && source.charCodeAt(index + 1) === 117) {
+				const start = index;
+				if (char === 92) {
+					if (!skipUnicodeEscape()) return false;
+				} else index++;
+				while (index < source.length) {
+					const identifierChar = source.charCodeAt(index);
+					if (isIdentifierPart(identifierChar)) {
+						index++;
+						continue;
+					}
+					if (identifierChar === 92 && source.charCodeAt(index + 1) === 117) {
+						if (!skipUnicodeEscape()) return false;
+						continue;
+					}
+					break;
+				}
+				const identifierText = source.slice(start, index);
+				let value;
+				if (!identifierText.includes("\\u")) value = identifierText;
+				else {
+					let decoded = "";
+					let failed = false;
+					for (let i = 0; i < identifierText.length; i++) {
+						if (identifierText.charCodeAt(i) !== 92 || identifierText.charCodeAt(i + 1) !== 117) {
+							decoded += identifierText[i];
+							continue;
+						}
+						i += 2;
+						let hex;
+						if (identifierText.charCodeAt(i) === 123) {
+							const end = identifierText.indexOf("}", i + 1);
+							if (end === -1) {
+								failed = true;
+								break;
+							}
+							hex = identifierText.slice(i + 1, end);
+							i = end;
+						} else {
+							hex = identifierText.slice(i, i + 4);
+							if (hex.length !== 4) {
+								failed = true;
+								break;
+							}
+							i += 3;
+						}
+						const codePoint = Number.parseInt(hex, 16);
+						if (!Number.isFinite(codePoint) || codePoint > 1114111) {
+							failed = true;
+							break;
+						}
+						decoded += String.fromCodePoint(codePoint);
+					}
+					value = failed ? void 0 : decoded;
+				}
+				if (value === void 0) return false;
+				canEndExpression = !prefixKeywords.has(value);
+				if (!canEndExpression && tokens.length) {
+					const previous = tokens[tokens.length - 1];
+					canEndExpression = previous.k === "p" && (previous.value === "." || previous.value === "?." || previous.value === "#");
+				}
+				tokens.push({
+					k: "i",
+					value,
+					at: start
+				});
+				continue;
+			}
+			const leadingDot = char === 46 && source.charCodeAt(index + 1) >= 48 && source.charCodeAt(index + 1) <= 57;
+			if (char >= 48 && char <= 57 || leadingDot) {
+				index++;
+				while (isIdentifierPart(source.charCodeAt(index))) index++;
+				if (!leadingDot && source.charCodeAt(index) === 46) {
+					index++;
+					while (isIdentifierPart(source.charCodeAt(index))) index++;
+				}
+				canEndExpression = true;
+				continue;
+			}
+			if (templateExpression) {
+				if (char === 123) templateDepth++;
+				else if (char === 125) {
+					if (templateDepth === 0) {
+						index++;
+						return true;
+					}
+					templateDepth--;
+				}
+			}
+			let value = source[index];
+			const pair = source.slice(index, index + 2);
+			const triple = source.slice(index, index + 3);
+			if (triple === "...") value = triple;
+			else if (pair === "?." || pair === "=>" || pair === "++" || pair === "--") value = pair;
+			if (value === "(") headers.push(isHeader(tokens));
+			tokens.push({
+				k: "p",
+				value,
+				at: index
+			});
+			index += value.length;
+			if (value !== "++" && value !== "--") canEndExpression = value === ")" && !headers.pop() || value === "]" || value === "}";
+		}
+		return !templateExpression;
+	};
+	return scanCode() ? tokens : void 0;
+}
 
 //#endregion
-exports.isIdentChar = isIdentChar;
-exports.isIdentCharCode = isIdentCharCode;
-exports.isSpace = isSpace;
+exports.scanTokens = scanTokens;
 exports.skipString = skipString;

package/dist/compile/lexer.mjs

@@ -1,7 +1,4 @@
 //#region src/compile/lexer.ts
-const isSpace = (ch) => ch === " " || ch === "\n" || ch === "	" || ch === "\r";
-const isIdentChar = (ch) => ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_" || ch === "$";
-const isIdentCharCode = (code) => code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57 || code === 95 || code === 36;
 function skipString(src, start) {
 	const quote = src[start];
 	let i = start + 1;
@@ -43,6 +40,273 @@ function skipString(src, start) {
 	}
 	return i;
 }
+const prefixKeywords = new Set([
+	"await",
+	"case",
+	"delete",
+	"do",
+	"else",
+	"in",
+	"instanceof",
+	"new",
+	"of",
+	"return",
+	"throw",
+	"typeof",
+	"void",
+	"yield"
+]);
+const isSpace = (char) => char === 32 || char >= 9 && char <= 13 || char >= 128 && /\s/.test(String.fromCharCode(char));
+const isIdentifierStart = (char) => char >= 65 && char <= 90 || char >= 97 && char <= 122 || char === 36 || char === 95 || char >= 128 && !isSpace(char);
+const isIdentifierPart = (char) => isIdentifierStart(char) || char >= 48 && char <= 57;
+function isHeader(tokens) {
+	let keyword = tokens.length - 1;
+	if (keyword > 0 && tokens[keyword].value === "await" && tokens[keyword - 1].value === "for") keyword--;
+	if (keyword < 0) return false;
+	const { k, value: v } = tokens[keyword];
+	if (k !== "i" || v !== "if" && v !== "while" && v !== "for" && v !== "with") return false;
+	if (keyword === 0) return true;
+	const before = tokens[keyword - 1];
+	return !(before.k === "p" && (before.value === "." || before.value === "?." || before.value === "#"));
+}
+function scanTokens(source) {
+	const tokens = [];
+	let index = 0;
+	let canEndExpression = false;
+	const headers = [];
+	const skipUnicodeEscape = () => {
+		index += 2;
+		if (source.charCodeAt(index) === 123) {
+			const end = source.indexOf("}", index + 1);
+			if (end === -1) return false;
+			index = end + 1;
+			return true;
+		}
+		for (let digit = 0; digit < 4; digit++) {
+			const hex = source.charCodeAt(index + digit);
+			if (!(hex >= 48 && hex <= 57 || hex >= 65 && hex <= 70 || hex >= 97 && hex <= 102)) return false;
+		}
+		index += 4;
+		return true;
+	};
+	const scanCode = (templateExpression = false) => {
+		let templateDepth = 0;
+		while (index < source.length) {
+			const char = source.charCodeAt(index);
+			if (isSpace(char)) {
+				index++;
+				continue;
+			}
+			if (char === 92 && source.charCodeAt(index + 1) !== 117) return false;
+			if (char === 47) {
+				const next = source.charCodeAt(index + 1);
+				if (next === 47) {
+					index += 2;
+					while (index < source.length && source.charCodeAt(index) !== 10 && source.charCodeAt(index) !== 13 && source.charCodeAt(index) !== 8232 && source.charCodeAt(index) !== 8233) index++;
+					continue;
+				}
+				if (next === 42) {
+					index += 2;
+					while (index + 1 < source.length && !(source.charCodeAt(index) === 42 && source.charCodeAt(index + 1) === 47)) index++;
+					if (index + 1 >= source.length) return false;
+					index += 2;
+					continue;
+				}
+				if (!canEndExpression) {
+					const previous = tokens.length ? tokens[tokens.length - 1] : void 0;
+					if (previous?.k === "i" && (previous.value === "of" || previous.value === "await" || previous.value === "yield")) return false;
+					index++;
+					let escaped = false;
+					let characterClass = false;
+					let closed = false;
+					while (index < source.length) {
+						const regexChar = source.charCodeAt(index++);
+						if (escaped) {
+							escaped = false;
+							continue;
+						}
+						if (regexChar === 92) {
+							escaped = true;
+							continue;
+						}
+						if (regexChar === 91) characterClass = true;
+						else if (regexChar === 93) characterClass = false;
+						else if (regexChar === 47 && !characterClass) {
+							closed = true;
+							break;
+						} else if (regexChar === 10 || regexChar === 13) return false;
+					}
+					if (!closed) return false;
+					while (isIdentifierPart(source.charCodeAt(index))) index++;
+					canEndExpression = true;
+					continue;
+				}
+				const previous = tokens.length ? tokens[tokens.length - 1] : void 0;
+				if (previous?.k === "p" && previous.value === "}") return false;
+				tokens.push({
+					k: "p",
+					value: "/",
+					at: index
+				});
+				index++;
+				canEndExpression = false;
+				continue;
+			}
+			if (char === 34 || char === 39) {
+				const quote = char;
+				const start = ++index;
+				let escaped = false;
+				while (index < source.length) {
+					const stringChar = source.charCodeAt(index);
+					if (escaped) escaped = false;
+					else if (stringChar === 92) escaped = true;
+					else if (stringChar === quote) break;
+					else if (stringChar === 10 || stringChar === 13) return false;
+					index++;
+				}
+				if (index >= source.length) return false;
+				tokens.push({
+					k: "s",
+					value: source.slice(start, index),
+					at: start - 1
+				});
+				index++;
+				canEndExpression = true;
+				continue;
+			}
+			if (char === 96) {
+				index++;
+				let closed = false;
+				while (index < source.length) {
+					const templateChar = source.charCodeAt(index);
+					if (templateChar === 92) {
+						index += 2;
+						continue;
+					}
+					if (templateChar === 96) {
+						index++;
+						closed = true;
+						break;
+					}
+					if (templateChar === 36 && source.charCodeAt(index + 1) === 123) {
+						index += 2;
+						canEndExpression = false;
+						if (!scanCode(true)) return false;
+						continue;
+					}
+					index++;
+				}
+				if (!closed) return false;
+				canEndExpression = true;
+				continue;
+			}
+			if (isIdentifierStart(char) || char === 92 && source.charCodeAt(index + 1) === 117) {
+				const start = index;
+				if (char === 92) {
+					if (!skipUnicodeEscape()) return false;
+				} else index++;
+				while (index < source.length) {
+					const identifierChar = source.charCodeAt(index);
+					if (isIdentifierPart(identifierChar)) {
+						index++;
+						continue;
+					}
+					if (identifierChar === 92 && source.charCodeAt(index + 1) === 117) {
+						if (!skipUnicodeEscape()) return false;
+						continue;
+					}
+					break;
+				}
+				const identifierText = source.slice(start, index);
+				let value;
+				if (!identifierText.includes("\\u")) value = identifierText;
+				else {
+					let decoded = "";
+					let failed = false;
+					for (let i = 0; i < identifierText.length; i++) {
+						if (identifierText.charCodeAt(i) !== 92 || identifierText.charCodeAt(i + 1) !== 117) {
+							decoded += identifierText[i];
+							continue;
+						}
+						i += 2;
+						let hex;
+						if (identifierText.charCodeAt(i) === 123) {
+							const end = identifierText.indexOf("}", i + 1);
+							if (end === -1) {
+								failed = true;
+								break;
+							}
+							hex = identifierText.slice(i + 1, end);
+							i = end;
+						} else {
+							hex = identifierText.slice(i, i + 4);
+							if (hex.length !== 4) {
+								failed = true;
+								break;
+							}
+							i += 3;
+						}
+						const codePoint = Number.parseInt(hex, 16);
+						if (!Number.isFinite(codePoint) || codePoint > 1114111) {
+							failed = true;
+							break;
+						}
+						decoded += String.fromCodePoint(codePoint);
+					}
+					value = failed ? void 0 : decoded;
+				}
+				if (value === void 0) return false;
+				canEndExpression = !prefixKeywords.has(value);
+				if (!canEndExpression && tokens.length) {
+					const previous = tokens[tokens.length - 1];
+					canEndExpression = previous.k === "p" && (previous.value === "." || previous.value === "?." || previous.value === "#");
+				}
+				tokens.push({
+					k: "i",
+					value,
+					at: start
+				});
+				continue;
+			}
+			const leadingDot = char === 46 && source.charCodeAt(index + 1) >= 48 && source.charCodeAt(index + 1) <= 57;
+			if (char >= 48 && char <= 57 || leadingDot) {
+				index++;
+				while (isIdentifierPart(source.charCodeAt(index))) index++;
+				if (!leadingDot && source.charCodeAt(index) === 46) {
+					index++;
+					while (isIdentifierPart(source.charCodeAt(index))) index++;
+				}
+				canEndExpression = true;
+				continue;
+			}
+			if (templateExpression) {
+				if (char === 123) templateDepth++;
+				else if (char === 125) {
+					if (templateDepth === 0) {
+						index++;
+						return true;
+					}
+					templateDepth--;
+				}
+			}
+			let value = source[index];
+			const pair = source.slice(index, index + 2);
+			const triple = source.slice(index, index + 3);
+			if (triple === "...") value = triple;
+			else if (pair === "?." || pair === "=>" || pair === "++" || pair === "--") value = pair;
+			if (value === "(") headers.push(isHeader(tokens));
+			tokens.push({
+				k: "p",
+				value,
+				at: index
+			});
+			index += value.length;
+			if (value !== "++" && value !== "--") canEndExpression = value === ")" && !headers.pop() || value === "]" || value === "}";
+		}
+		return !templateExpression;
+	};
+	return scanCode() ? tokens : void 0;
+}
 
 //#endregion
-export { isIdentChar, isIdentCharCode, isSpace, skipString };
+export { scanTokens, skipString };

package/dist/compile/utils.js

@@ -4,14 +4,17 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 function isAsyncFunction(fn) {
 	return fn.constructor.name === "AsyncFunction" || fn.constructor.name === "AsyncGeneratorFunction";
 }
-const matchResponseClone = /=>\s*response\.clone\(/;
-const matchFnReturn = /(?:return|=>)\s*(?:new\s+)?[\w$.][\w$.]*\s*\(|a(?:sync|wait)/;
+const matchArrow = /^(?:[\w$]+|\([\w$\s,.[\]{}:]*\))\s*=>([\s\S]*)$/;
+const matchFunction = /^(?:function(?:\s+[\w$]+)?|[\w$]+)\s*\([\w$\s,.[\]{}:]*\)\s*(\{[\s\S]*\})$/;
+const matchLiteral = /^(?:true|false|null|-?\d+(?:\.\d+)?|'[^'\\]*'|"[^"\\]*")$/;
 const mayReturnPromiseCache = /* @__PURE__ */ new WeakMap();
 function mayReturnPromise(fn) {
 	let result = mayReturnPromiseCache.get(fn);
 	if (result !== void 0) return result;
-	const literal = fn.toString();
-	result = matchResponseClone.test(literal) ? false : matchFnReturn.test(literal);
+	const literal = Function.prototype.toString.call(fn).trim();
+	const arrow = matchArrow.exec(literal);
+	const body = (arrow?.[1] ?? matchFunction.exec(literal)?.[1])?.trimStart();
+	result = literal.includes("[native code]") || !(body?.startsWith("{") && body.endsWith("}") && !/\breturn\b/.test(body) || arrow && matchLiteral.test(body));
 	mayReturnPromiseCache.set(fn, result);
 	return result;
 }

package/dist/compile/utils.mjs

@@ -2,14 +2,17 @@
 function isAsyncFunction(fn) {
 	return fn.constructor.name === "AsyncFunction" || fn.constructor.name === "AsyncGeneratorFunction";
 }
-const matchResponseClone = /=>\s*response\.clone\(/;
-const matchFnReturn = /(?:return|=>)\s*(?:new\s+)?[\w$.][\w$.]*\s*\(|a(?:sync|wait)/;
+const matchArrow = /^(?:[\w$]+|\([\w$\s,.[\]{}:]*\))\s*=>([\s\S]*)$/;
+const matchFunction = /^(?:function(?:\s+[\w$]+)?|[\w$]+)\s*\([\w$\s,.[\]{}:]*\)\s*(\{[\s\S]*\})$/;
+const matchLiteral = /^(?:true|false|null|-?\d+(?:\.\d+)?|'[^'\\]*'|"[^"\\]*")$/;
 const mayReturnPromiseCache = /* @__PURE__ */ new WeakMap();
 function mayReturnPromise(fn) {
 	let result = mayReturnPromiseCache.get(fn);
 	if (result !== void 0) return result;
-	const literal = fn.toString();
-	result = matchResponseClone.test(literal) ? false : matchFnReturn.test(literal);
+	const literal = Function.prototype.toString.call(fn).trim();
+	const arrow = matchArrow.exec(literal);
+	const body = (arrow?.[1] ?? matchFunction.exec(literal)?.[1])?.trimStart();
+	result = literal.includes("[native code]") || !(body?.startsWith("{") && body.endsWith("}") && !/\breturn\b/.test(body) || arrow && matchLiteral.test(body));
 	mayReturnPromiseCache.set(fn, result);
 	return result;
 }

package/dist/compiled.d.ts

@@ -7,7 +7,6 @@ import { HandlerManifest, ValidatorManifest } from "./compile/aot.js";
  * A build plugin (`elysia/plugin/*`) redirects this specifier to a module
  * generated by `compileToSource`, which self-registers the frozen validator +
  * handler manifest. Without a plugin it resolves here and is a harmless no-op.
- * Both named exports mirror what `compileToSource` emits.
  *
  * @see compileToSource
  */

package/dist/compiled.js

@@ -7,7 +7,6 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 * A build plugin (`elysia/plugin/*`) redirects this specifier to a module
 * generated by `compileToSource`, which self-registers the frozen validator +
 * handler manifest. Without a plugin it resolves here and is a harmless no-op.
-* Both named exports mirror what `compileToSource` emits.
 *
 * @see compileToSource
 */

package/dist/compiled.mjs

@@ -5,7 +5,6 @@
 * A build plugin (`elysia/plugin/*`) redirects this specifier to a module
 * generated by `compileToSource`, which self-registers the frozen validator +
 * handler manifest. Without a plugin it resolves here and is a harmless no-op.
-* Both named exports mirror what `compileToSource` emits.
 *
 * @see compileToSource
 */

package/dist/context.d.ts

@@ -1,15 +1,15 @@
 import { BaseCookie } from "./cookie/types.js";
-import { Cookie } from "./cookie/cookie.js";
 import { StatusMap } from "./constants.js";
-import { Server } from "./universal/server.js";
+import { SelectiveProblem, SelectiveStatus, problem, status } from "./error.js";
 import { redirect } from "./utils.js";
+import { Server } from "./universal/server.js";
+import { Cookie } from "./cookie/cookie.js";
 import { AfterResponseHandler, DefaultSingleton, HTTPHeaders, InputSchema, MaybePromise, Prettify, ResolvePath, RouteSchema, SingletonBase } from "./types.js";
-import { SelectiveStatus, status } from "./error.js";
 import { AnyElysia } from "./base.js";
 
 //#region src/context.d.ts
 declare function createBaseContext(app: AnyElysia): any;
-declare function clearContextCache(): void;
+declare function clearContextCache(app?: AnyElysia): void;
 declare function createContext(app: AnyElysia): new (request: Request) => Context;
 interface ContextBase<in out Route extends RouteSchema, in out Singleton extends SingletonBase> {
   server: Server | null;
@@ -23,8 +23,13 @@ interface ContextBase<in out Route extends RouteSchema, in out Singleton extends
      * Use `Context.cookie` instead
      */
     cookie?: Record<string, BaseCookie>;
+    /**
+     * @deprecated Removed in 2.0, return `redirect(url)` instead
+     */
+    redirect?: never;
   };
   status: {} extends Route['response'] ? typeof status : SelectiveStatus<Route['response']>;
+  problem: {} extends Route['response'] ? typeof problem : SelectiveProblem<Route['response']>;
   /**
    * Append a callback to run after the response is sent
    */
@@ -85,8 +90,13 @@ type PreContext<in out Singleton extends SingletonBase = {
   set: {
     headers: HTTPHeaders;
     status?: number;
+    /**
+     * @deprecated Removed in 2.0, return `redirect(url)` instead
+     */
+    redirect?: never;
   };
   status: typeof status;
+  problem: typeof problem;
 } & Singleton['decorator']>;
 //#endregion
 export { Context, ErrorContext, LifecycleContext, PreContext, clearContextCache, createBaseContext, createContext };