@senrijs/senri 0.0.0-stage → 0.2.0

package/dist/src/app.js

@@ -0,0 +1,325 @@
+import { Context } from "./context.js";
+import { allowedMethods, checkParamNames, normalizeMethod, routeShape, splitPattern, startsWithSegments, } from "./router.js";
+import { compose } from "./compose.js";
+import { createMatcher } from "./matcher.js";
+import { routeHandler } from "./validate.js";
+import { groupEntries, joinPath } from "./group.js";
+import { defaultNotFound, defaultOnError, checkQueryRequest, handleError, HttpError, markConversionError, methodNotAllowed, senriError, } from "./errors.js";
+// 扱わないメソッド。ルートがあってもなくても 501 にする(app.all() でも受けない)
+const NOT_IMPLEMENTED = new Set(["CONNECT", "TRACE", "TRACK"]);
+// app.route(prefix, app) でつなげるように、アプリに登録されたものを横に置いておく
+const appEntries = new WeakMap();
+// 0.1 の createApp({ dev: true }) は使えなくなった。どう書き換えるかを案内する
+const DEV_TRUE = `createApp({ dev: true }) is no longer supported. Use devtools() from "@senrijs/senri/dev".
+createApp({ dev: true }) は使えなくなりました。@senrijs/senri/dev の devtools() を渡してください。
+
+  import { createApp } from "@senrijs/senri";
+  import { devtools } from "@senrijs/senri/dev";
+
+  const app = createApp({ dev: devtools() });`;
+// V はアプリの型。c.set / c.get で使う変数の型(createApp<{ user: User }>())か、
+// Workers の env も含めた形(createApp<{ Bindings: Env; Variables: { user: User } }>())で指定する(src/context.ts)
+export function createApp(options = {}) {
+    if (options.dev === true)
+        throw senriError("dev_true", DEV_TRUE);
+    const routes = [];
+    const matcher = createMatcher();
+    // prefix が null なら全部のリクエストで動く。["admin"] なら /admin とその下だけ
+    // anonymous: 無名の関数だった(名前を anonymous#番号 にした)。ダッシュボードで「名前を付けると出る」と案内する
+    const middlewares = [];
+    // 開発モードの処理。createApp の最後に devtools().install() で入る(渡さなければ undefined のまま)
+    let devHooks;
+    let onError = defaultOnError;
+    let notFound = defaultNotFound;
+    // 登録時のエラーに、開発モードでは日本語の説明を付ける
+    function guard(fn) {
+        return (...args) => {
+            try {
+                fn(...args);
+            }
+            catch (err) {
+                throw devHooks ? devHooks.explain(err) : err;
+            }
+        };
+    }
+    function method(name) {
+        return guard((path, a, b) => add(name, path, routeHandler(path, a, b), typeof a === "function" ? undefined : a));
+    }
+    function add(rawMethod, path, handler, schemas) {
+        // app.all() の印の "ALL" だけはそのまま。ほかは名前を確かめて大文字にする
+        const method = rawMethod === "ALL" ? rawMethod : normalizeMethod(rawMethod);
+        devHooks?.checkRoute(method, path, schemas);
+        const segments = splitPattern(path);
+        checkParamNames(path, segments);
+        // 同じメソッド + 同じ形のパスがあったら、あとから登録したほうは絶対に呼ばれないのでエラーにする
+        const shape = routeShape(segments);
+        const dup = routes.find((r) => r.method === method && routeShape(r.segments) === shape);
+        if (dup)
+            throw senriError("route_duplicate", `Duplicate route: ${method} ${path} (already: ${dup.method} ${dup.path})`);
+        const paramNames = segments.filter((s) => s.startsWith(":")).map((s) => s.slice(1));
+        const route = { path, segments, paramNames, method, handler };
+        // routes は一覧(routeList や 404 の「もしかして」)用で、登録順。探すのは matcher(Trie)で行う
+        routes.push(route);
+        matcher.add(route);
+    }
+    // マッチしたルートのパラメーターを、ルートごとの名前で組み立てる
+    function paramsOf(route, values) {
+        const params = {};
+        const names = route.paramNames;
+        for (let i = 0; i < names.length; i++)
+            params[names[i]] = values[i];
+        return params;
+    }
+    function resolve(c) {
+        let path;
+        try {
+            path = c.path;
+        }
+        catch (error) {
+            // エンコードが不正(HttpError 400)。ミドルウェアは動かしてから返す
+            return { kind: "badRequest", error };
+        }
+        const method = c.req.method;
+        if (NOT_IMPLEMENTED.has(method))
+            return { kind: "notImplemented" };
+        // 近道: パラメーターのないルートにぴったり合い、メソッドも合えば、それがいちばん優先される
+        // (この場合はパスを分割しなくて済む)
+        const exact = matcher.staticLeaf(path);
+        if (exact) {
+            for (const route of exact) {
+                if (route.method === method)
+                    return { kind: "route", route, params: {} };
+            }
+        }
+        // c.path が読めたので、ここで分割に失敗することはない
+        const segments = c.segments;
+        const find = (m) => {
+            const hit = matcher.first(segments, m);
+            return hit ? { kind: "route", route: hit.route, params: paramsOf(hit.route, hit.values) } : undefined;
+        };
+        // 1. メソッドが合うもの → 2. HEAD なら GET → 3. all の順に、優先順位の高いルートから探す
+        const hit = find(method) ?? (method === "HEAD" ? find("GET") : undefined) ?? find("ALL");
+        if (hit)
+            return hit;
+        // どれもなければ、パスが合うルートを全部集めて 404 か 405 かを決める
+        const matched = matcher.match(segments);
+        if (matched.length === 0)
+            return { kind: "notFound" };
+        const allow = allowedMethods(matched.flatMap((x) => x.leaf));
+        return method === "OPTIONS" ? { kind: "options", allow } : { kind: "methodNotAllowed", allow };
+    }
+    // ミドルウェアがないときに毎回配列を作らないよう、共有の空配列を返す(中身は変えない)
+    const NO_LAYERS = [];
+    function applicableMiddlewares(c) {
+        if (middlewares.length === 0)
+            return NO_LAYERS;
+        let segments;
+        try {
+            segments = c.segments;
+        }
+        catch {
+            // パスが不正なら、パス指定のミドルウェアは動かさない(どのみちルーターが 400 にする)
+            segments = null;
+        }
+        const layers = [];
+        for (let i = 0; i < middlewares.length; i++) {
+            const { name, mw, prefix } = middlewares[i];
+            if (prefix === null || (segments !== null && startsWithSegments(segments, prefix))) {
+                // order は登録順(1 から)。同じ関数を2回登録しても区別できるよう、配列の位置から決める
+                // (ダッシュボードで、名前ではなく登録順で集計するのに使う)
+                layers.push({ name, mw, order: i + 1 });
+            }
+        }
+        return layers;
+    }
+    const app = {
+        use: guard((pathOrMw, mw) => {
+            const path = typeof pathOrMw === "string" ? pathOrMw : null;
+            const fn = typeof pathOrMw === "string" ? mw : pathOrMw;
+            if (!fn)
+                throw senriError("no_middleware", `Missing middleware: ${path}`);
+            middlewares.push({
+                // 関数の名前を使う。無名の関数(その場で書いたアロー関数など)は登録順の番号で呼ぶ
+                name: fn.name || `anonymous#${middlewares.length + 1}`,
+                anonymous: !fn.name,
+                path,
+                prefix: path === null ? null : splitPattern(path),
+                mw: fn,
+            });
+        }),
+        onError(handler) {
+            onError = handler;
+        },
+        notFound(handler) {
+            notFound = handler;
+        },
+        // どれも app.get(path, handler) か、スキーマを付けた app.get(path, { params, query, body }, handler)(src/validate.ts)
+        get: method("GET"),
+        post: method("POST"),
+        put: method("PUT"),
+        patch: method("PATCH"),
+        delete: method("DELETE"),
+        // 登録しなければ GET を使う(ボディは送らない)。登録すれば GET より優先される
+        head: method("HEAD"),
+        // 登録しなければ 204 と Allow を自動で返す。登録すればそちらが優先される
+        options: method("OPTIONS"),
+        // どのメソッドでも動く。ただし、メソッドが合うルートがあればそちらが優先
+        all: method("ALL"),
+        // 任意のメソッド(QUERY や、PROPFIND などの WebDAV)を登録する。配列でまとめて登録もできる
+        // 小文字で書いても大文字にする。CONNECT / TRACE / TRACK は扱わない
+        on: guard((methods, path, a, b) => {
+            const list = typeof methods === "string" ? [methods] : methods;
+            if (list.length === 0)
+                throw senriError("no_method", `Missing method: ${path}`);
+            const handler = routeHandler(path, a, b);
+            for (const m of list) {
+                if (m.toUpperCase() === "ALL")
+                    throw senriError("on_all", "Use app.all() for every method");
+                add(m, path, handler, typeof a === "function" ? undefined : a);
+            }
+        }),
+        // K はテーブルのキーから推論される。各キーのパスからパラメーターの型が決まる
+        routes: guard((table) => {
+            for (const [key, handler] of Object.entries(table)) {
+                const [method, path] = key.split(" ");
+                if (!method || !path)
+                    throw senriError("route_key", `Invalid route key: "${key}" (e.g. "GET /hello")`);
+                add(method.toUpperCase(), path, handler);
+            }
+        }),
+        // createRouter() で作ったルーターをつなげる。ルーターに登録済みのものが、この時点でアプリに入る
+        // app.route(prefix, app) なら、別のアプリをプレフィックス付きでつなげる
+        // (つなぐ側のアプリでは、プレフィックスのパラメーターに型は付かない。型が必要なら createRouter を使う)
+        // つないだアプリの onError / notFound は使わず、こちらのものを使う
+        route: guard((routerOrPrefix, child) => {
+            // 先に全部読んでおく(ルーターの作りがおかしいときに、途中まで登録された状態にしない)
+            let list;
+            if (typeof routerOrPrefix === "string") {
+                const read = child ? appEntries.get(child) : undefined;
+                if (!read)
+                    throw senriError("not_app", new TypeError(`Not an app from createApp(): ${routerOrPrefix}`));
+                list = read().map((entry) => ({ ...entry, path: joinPath(routerOrPrefix, entry.path) }));
+            }
+            else {
+                list = groupEntries(routerOrPrefix);
+            }
+            for (const entry of list) {
+                if (entry.kind === "use")
+                    app.use(entry.path, entry.mw);
+                else
+                    add(entry.method, entry.path, entry.handler);
+            }
+        }),
+        middlewareList() {
+            return middlewares.map((m) => ({ name: m.name, path: m.path, anonymous: m.anonymous }));
+        },
+        routeList() {
+            return routes.map((r) => ({ method: r.method, path: r.path }));
+        },
+        // info: ランタイムが渡す2つ目の引数(Bun の server、Deno の info など)。接続元のアドレスを取るのに使う
+        // (形で見分けるので、Cloudflare Workers の env のような別のものが来ても壊れない。src/dev/dashboard/access.ts)
+        // ctx: Cloudflare Workers の3つ目の引数(c.executionCtx)。export default app で、Workers がそのまま呼ぶ
+        fetch(req, info, ctx) {
+            // 開発モードは計測・記録をするので別の道を通る(@senrijs/senri/dev)
+            if (devHooks)
+                return devHooks.fetch(req, info, ctx);
+            try {
+                const c = new Context(req, info, ctx);
+                const resolved = resolve(c);
+                if (resolved.kind === "route") {
+                    c.route = resolved.route.path;
+                    c.params = resolved.params;
+                }
+                const fail = (err) => handleError(err, c, onError);
+                const layers = applicableMiddlewares(c);
+                if (layers.length > 0) {
+                    return compose(layers, c, () => inner(c, resolved), fail).then((res) => c.finalize(res));
+                }
+                // 近道: ミドルウェアがなければ compose を通さない。同期のハンドラーなら、待たずにそのまま返す
+                let res;
+                try {
+                    res = inner(c, resolved);
+                }
+                catch (err) {
+                    res = fail(err);
+                }
+                if (res instanceof Promise)
+                    return res.catch(fail).then((r) => c.finalize(r));
+                return Promise.resolve(c.finalize(res));
+            }
+            catch (err) {
+                return Promise.reject(err);
+            }
+        },
+    };
+    // ミドルウェアを全部通ったあとに動く、いちばん内側の処理
+    // 同期で返せるときは Response をそのまま返す(Promise を作らない)
+    function inner(c, resolved) {
+        switch (resolved.kind) {
+            case "badRequest":
+                throw resolved.error;
+            case "route": {
+                const route = resolved.route;
+                // QUERY として登録したルートだけ、ボディと Content-Type を確かめる(app.all はハンドラーに任せる)
+                if (route.method === "QUERY") {
+                    return checkQueryRequest(c).then((invalid) => {
+                        if (invalid)
+                            throw invalid;
+                        return callHandler(c, route);
+                    });
+                }
+                return callHandler(c, route);
+            }
+            case "options":
+                return new Response(null, { status: 204, headers: { allow: resolved.allow } });
+            case "methodNotAllowed":
+                throw methodNotAllowed(resolved.allow);
+            case "notImplemented":
+                throw new HttpError(501, "501 Not Implemented");
+            case "notFound":
+                c.status(404);
+                return Promise.resolve(notFound(c)).then((value) => c.toResponse(value));
+        }
+    }
+    function callHandler(c, route) {
+        const value = route.handler(c.params, c);
+        // 同期のハンドラーなら待たない
+        return value instanceof Promise ? value.then((v) => respond(c, route, v)) : respond(c, route, value);
+    }
+    function respond(c, route, value) {
+        let res;
+        try {
+            res = c.toResponse(value);
+        }
+        catch (err) {
+            // どこが返した値かは、失敗したときだけ組み立てる
+            throw markConversionError(err, { kind: "handler", name: `${route.method} ${route.path}` });
+        }
+        if (c.req.method !== "HEAD")
+            return res;
+        // HEAD はヘッダーと status だけ返す(ボディは捨てる)
+        return (async () => {
+            await res.body?.cancel();
+            return new Response(null, { status: res.status, statusText: res.statusText, headers: res.headers });
+        })();
+    }
+    // ミドルウェアを先に、ルートはそのあと(どちらも登録順)
+    appEntries.set(app, () => [
+        ...middlewares.map((m) => ({ kind: "use", path: m.path ?? "/", mw: m.mw })),
+        ...routes.map((r) => ({ kind: "route", method: r.method, path: r.path, handler: r.handler })),
+    ]);
+    // 開発モード: 中身を渡して、開発用の fetch と既定の onError / notFound を受け取る
+    if (options.dev) {
+        devHooks = options.dev.install({
+            app,
+            resolve,
+            layers: applicableMiddlewares,
+            inner: inner,
+            fail: (err, c) => handleError(err, c, onError),
+            routes: () => routes,
+        });
+        onError = devHooks.onError;
+        notFound = devHooks.notFound;
+    }
+    return app;
+}

package/dist/src/body.d.ts

@@ -0,0 +1,3 @@
+export type FormValue = string | File;
+export type FormBody = Record<string, FormValue | FormValue[]>;
+export declare function readBody(req: Request): Promise<unknown>;

package/dist/src/body.js

@@ -0,0 +1,45 @@
+// リクエストのボディを、Content-Type に合わせて読む
+import { HttpError } from "./errors.js";
+function mediaType(req) {
+    return (req.headers.get("content-type") ?? "").split(";")[0].trim().toLowerCase();
+}
+// フィールド名は送る側が決められるので、プロトタイプのないオブジェクトに入れる
+// (ふつうの {} だと "__proto__" でプロトタイプが差し替わり、"constructor" は継承した関数と混ざる)
+function formToObject(form) {
+    const out = Object.create(null);
+    for (const [name, value] of form) {
+        const prev = out[name];
+        if (prev === undefined)
+            out[name] = value;
+        else
+            out[name] = Array.isArray(prev) ? [...prev, value] : [prev, value];
+    }
+    return out;
+}
+// - application/json と、+json で終わるもの → JSON(壊れていたら 400)
+// - application/x-www-form-urlencoded と multipart/form-data → フォーム
+// - text/* → 文字列
+// - それ以外 → ArrayBuffer
+export async function readBody(req) {
+    const type = mediaType(req);
+    if (type === "application/json" || type.endsWith("+json")) {
+        const text = await req.text();
+        try {
+            return JSON.parse(text);
+        }
+        catch (err) {
+            throw new HttpError(400, "400 Bad Request: JSON が正しくありません", { cause: err });
+        }
+    }
+    if (type === "application/x-www-form-urlencoded" || type === "multipart/form-data") {
+        try {
+            return formToObject(await req.formData());
+        }
+        catch (err) {
+            throw new HttpError(400, "400 Bad Request: フォームが正しくありません", { cause: err });
+        }
+    }
+    if (type.startsWith("text/"))
+        return req.text();
+    return req.arrayBuffer();
+}

package/dist/src/compose.d.ts

@@ -0,0 +1,22 @@
+import type { Context, HandlerResult, Middleware } from "./context.ts";
+import { type ConversionOrigin } from "./errors.ts";
+export declare function toResponseOf(c: Context, value: HandlerResult, origin: ConversionOrigin): Response;
+export type Layer = {
+    name: string;
+    mw: Middleware;
+    order?: number;
+};
+export type Timing = {
+    name: string;
+    total: number;
+    self: number;
+    failed: boolean;
+    start: number;
+    stopped: boolean;
+};
+export type Trace = {
+    enter(i: number): void;
+    down(i: number): () => void;
+    leave(i: number, failed: boolean, stopped: boolean): void;
+};
+export declare function compose(layers: Layer[], c: Context, handle: () => Response | Promise<Response>, onError: (err: unknown) => Promise<Response>, trace?: Trace): Promise<Response>;

package/dist/src/compose.js

@@ -0,0 +1,80 @@
+import { markConversionError, senriError } from "./errors.js";
+// 返した値をレスポンスにする。失敗したら、どこが返した値だったかをエラーに覚えさせてから投げ直す
+export function toResponseOf(c, value, origin) {
+    try {
+        return c.toResponse(value);
+    }
+    catch (err) {
+        throw markConversionError(err, origin);
+    }
+}
+// ミドルウェアを順に通して、最後に handle を呼ぶ
+// 例外は(ミドルウェアでもハンドラーでも)onError に渡してレスポンスにしてもらう
+export function compose(layers, c, handle, onError, trace) {
+    // 近道: ミドルウェアがなく、計測もしないなら、いちばん内側の処理を呼ぶだけ(下の dispatch と同じ結果になる)
+    if (layers.length === 0 && !trace) {
+        try {
+            return Promise.resolve(handle()).catch(onError);
+        }
+        catch (err) {
+            return onError(err);
+        }
+    }
+    // どの層で例外が起きたか(層の番号)
+    let failedAt = -1;
+    const fail = (err, i) => {
+        failedAt = i;
+        return onError(err);
+    };
+    const dispatch = async (i) => {
+        trace?.enter(i);
+        // next() を呼ばずに値を返して終わったか
+        let stopped = false;
+        try {
+            return await step(i, () => (stopped = true));
+        }
+        finally {
+            trace?.leave(i, failedAt === i, stopped);
+        }
+    };
+    const step = async (i, markStopped) => {
+        const layer = layers[i];
+        if (!layer) {
+            try {
+                return await handle();
+            }
+            catch (err) {
+                return fail(err, i);
+            }
+        }
+        // next() が返す Promise。呼ばれていなければ undefined
+        let downstream;
+        let result;
+        try {
+            result = await layer.mw(c, () => {
+                // 2回目を許すと、ハンドラーや後ろのミドルウェアが2回動いてしまう
+                if (downstream)
+                    throw senriError("next_twice", "next() called twice");
+                // 下流に入る時刻は、dispatch を始める前に取る(下流が最初の await までに同期で使った時間も、下流の時間にする)
+                const up = trace?.down(i);
+                const d = dispatch(i + 1);
+                downstream = up ? d.finally(up) : d;
+                return downstream;
+            });
+            // toResponse も JSON.stringify で投げることがあるので try の中で
+            if (result !== undefined) {
+                if (!downstream)
+                    markStopped();
+                return toResponseOf(c, result, { kind: "middleware", name: layer.name });
+            }
+            // 何も返さず next() 済みなら、下流を使う(await し忘れていても、ここで待つ)
+            if (downstream)
+                return await downstream;
+        }
+        catch (err) {
+            return fail(err, i);
+        }
+        return fail(senriError("no_response", "Middleware returned nothing and did not call next()"), i);
+    };
+    return dispatch(0);
+}

package/dist/src/connection.d.ts

@@ -0,0 +1,3 @@
+export declare function remoteAddress(req: Request, info: unknown): string | null;
+export declare function isConnectionInfo(info: unknown): boolean;
+export declare function clientIp(req: Request, info: unknown): string | null;

package/dist/src/connection.js

@@ -0,0 +1,49 @@
+// 接続元のアドレスを、app.fetch の2つ目の引数から取り出す(c.ip と、ダッシュボードの localhost 制限で使う)
+//
+// Web 標準の Request には接続元が入っていないので、ランタイムが渡すものから取る:
+// - Bun:  Bun.serve({ fetch: app.fetch }) は server を渡す → server.requestIP(req)
+// - Deno: Deno.serve(app.fetch) は info を渡す → info.remoteAddr.hostname
+// - Node: senri/node のアダプターが Deno と同じ形 { remoteAddr: { hostname } } で渡す
+// 型ではなく「形」で見分けるので、Cloudflare Workers の fetch(req, env, ctx) の env のような
+// 別のものが来ても壊れず、「接続元不明」(null)になる
+import { isWorkers } from "./runtime.js";
+export function remoteAddress(req, info) {
+    try {
+        if (typeof info !== "object" || info === null)
+            return null;
+        const bun = info;
+        if (typeof bun.requestIP === "function") {
+            const address = bun.requestIP(req)?.address;
+            return typeof address === "string" ? address : null;
+        }
+        const deno = info;
+        const hostname = typeof deno.remoteAddr === "object" && deno.remoteAddr !== null ? deno.remoteAddr.hostname : undefined;
+        return typeof hostname === "string" ? hostname : null;
+    }
+    catch {
+        // プロパティを読んだだけで例外を投げるような値でも、壊れずに「不明」にする
+        return null;
+    }
+}
+// Bun の server か、Deno の info(Node のアダプターも同じ形)か。そうでなければ Workers の env などほかのもの
+export function isConnectionInfo(info) {
+    try {
+        if (typeof info !== "object" || info === null)
+            return false;
+        const value = info;
+        return typeof value.requestIP === "function" || (typeof value.remoteAddr === "object" && value.remoteAddr !== null);
+    }
+    catch {
+        return false;
+    }
+}
+// c.ip 用。IPv4 を IPv6 の形で書いたもの(::ffff:192.0.2.1)は IPv4 にそろえる
+// Cloudflare Workers には接続元を渡す引数がないので、Cloudflare が付ける CF-Connecting-IP を読む
+// (Cloudflare を通ったリクエストでは、クライアントが送った同名のヘッダーは Cloudflare が上書きする)
+export function clientIp(req, info) {
+    const address = remoteAddress(req, info) ?? (isWorkers() ? req.headers.get("cf-connecting-ip") : null);
+    if (address === null)
+        return null;
+    const lower = address.toLowerCase();
+    return lower.startsWith("::ffff:") && lower.includes(".") ? address.slice("::ffff:".length) : address;
+}

package/dist/src/context.d.ts

@@ -0,0 +1,58 @@
+import type { Timing } from "./compose.ts";
+export type BodyValue = Blob | ArrayBuffer | ArrayBufferView<ArrayBuffer> | ReadableStream | FormData | URLSearchParams;
+export type JsonObject = object & {
+    call?: never;
+    then?: never;
+};
+export type HandlerResult = Response | string | BodyValue | JsonObject;
+export type ExecutionContext = {
+    waitUntil(promise: Promise<unknown>): void;
+    passThroughOnException(): void;
+};
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type EnvForm = {
+    Bindings: object;
+} | {
+    Variables: object;
+};
+export type VariablesOf<E> = IsAny<E> extends true ? any : E extends EnvForm ? (E extends {
+    Variables: infer V extends object;
+} ? V : Record<string, unknown>) : E;
+export type BindingsOf<E> = IsAny<E> extends true ? any : E extends {
+    Bindings: infer B extends object;
+} ? B : unknown;
+export type Handler<P = Record<string, string>, V extends object = any, I extends object = {}> = (params: P, c: Context<V, I>) => HandlerResult | Promise<HandlerResult>;
+export type Next = () => Promise<Response>;
+export type Middleware<V extends object = any> = (c: Context<V>, next: Next) => HandlerResult | void | Promise<HandlerResult | void>;
+export declare function setValidated(c: Context, target: string, value: unknown): void;
+export declare let connectionOf: (c: Context) => {
+    req: Request;
+    info: unknown;
+};
+export declare class Context<V extends object = any, I extends object = {}> {
+    #private;
+    req: Request;
+    error: unknown;
+    route: string | undefined;
+    params: Record<string, string>;
+    constructor(req: Request, info?: unknown, ctx?: ExecutionContext);
+    get env(): BindingsOf<V>;
+    get executionCtx(): ExecutionContext;
+    get segments(): readonly string[];
+    get path(): string;
+    get timings(): Timing[];
+    valid<K extends keyof I & string>(target: K): I[K];
+    set<K extends keyof VariablesOf<V> & string>(key: K, value: VariablesOf<V>[K]): this;
+    get<K extends keyof VariablesOf<V> & string>(key: K): VariablesOf<V>[K] | undefined;
+    query(): Record<string, string>;
+    query(name: string): string | undefined;
+    queries(name: string): string[];
+    body<T = unknown>(): Promise<T>;
+    status(code: number): this;
+    header(name: string, value: string): this;
+    json(data: unknown, status?: number): Response;
+    text(body: string, status?: number): Response;
+    finalize(res: Response): Response;
+    toResponse(value: HandlerResult): Response;
+}
+export {};