@senrijs/senri 0.0.0-stage → 0.1.0

package/dist/src/app.js

@@ -0,0 +1,375 @@
+import { Context } from "./context.js";
+import { compareRoutes, allowedMethods, checkParamNames, normalizeMethod, routeShape, splitPattern, startsWithSegments, } from "./router.js";
+import { compose } from "./compose.js";
+import { createMatcher } from "./matcher.js";
+import { isWorkers } from "./runtime.js";
+import { groupEntries, joinPath, routeHandler } from "./group.js";
+import { defaultNotFound, defaultOnError, checkQueryRequest, handleError, HttpError, markConversionError, methodNotAllowed, } from "./errors.js";
+// パスが /_senri か /_senri/... なら、"_senri" より後ろのセグメント。そうでなければ null
+function underDashboard(c) {
+    try {
+        return c.segments[0] === "_senri" ? c.segments.slice(1) : null;
+    }
+    catch {
+        return null;
+    }
+}
+// 計測で、いちばん内側の層に付ける名前(ダッシュボードの玉ねぎタイムラインに出る)
+const INNER_NAME = {
+    route: "handler",
+    notFound: "notFound",
+    methodNotAllowed: "405",
+    options: "options",
+    badRequest: "400",
+    notImplemented: "501",
+};
+// 扱わないメソッド。ルートがあってもなくても 501 にする(app.all() でも受けない)
+const NOT_IMPLEMENTED = new Set(["CONNECT", "TRACE", "TRACK"]);
+// app.route(prefix, app) でつなげるように、アプリに登録されたものを横に置いておく
+const appEntries = new WeakMap();
+// V はアプリの型。c.set / c.get で使う変数の型(createApp<{ user: User }>())か、
+// Workers の env も含めた形(createApp<{ Bindings: Env; Variables: { user: User } }>())で指定する(src/context.ts)
+export function createApp(options = {}) {
+    const dev = options.dev ?? false;
+    const routes = [];
+    const matcher = createMatcher();
+    // prefix が null なら全部のリクエストで動く。["admin"] なら /admin とその下だけ
+    // anonymous: 無名の関数だった(名前を anonymous#番号 にした)。ダッシュボードで「名前を付けると出る」と案内する
+    const middlewares = [];
+    // 開発モードだけで使うもの(エラーページ、ダッシュボード)。ビルド済みの HTML など大きいので、
+    // 本番では読み込まないよう dev のときだけ import() する(src/dev/index.ts)
+    const devTools = dev ? import("./dev/index.js") : null;
+    // 開発モードでは、ブラウザから開いた 5xx を HTML のエラーページにする(src/dev/pages.ts)
+    const baseOnError = defaultOnError(dev);
+    let onError = devTools
+        ? async (err, c) => (await devTools).withErrorPage(baseOnError, true)(err, c)
+        : baseOnError;
+    let notFound = defaultNotFound(routes, dev);
+    function method(name) {
+        return ((path, a, b) => add(name, path, routeHandler(path, a, b)));
+    }
+    function add(rawMethod, path, handler) {
+        // app.all() の印の "ALL" だけはそのまま。ほかは名前を確かめて大文字にする
+        const method = rawMethod === "ALL" ? rawMethod : normalizeMethod(rawMethod);
+        const segments = splitPattern(path);
+        checkParamNames(path, segments);
+        // 開発モードでは /_senri 以下はダッシュボードが使うので、登録しても呼ばれない。気づけるようにエラーにする
+        if (dev && segments[0] === "_senri") {
+            throw new Error(`${method} ${path}: /_senri 以下は、開発モードではダッシュボード用に予約されています`);
+        }
+        // 同じメソッド + 同じ形のパスがあったら、あとから登録したほうは絶対に呼ばれないのでエラーにする
+        const shape = routeShape(segments);
+        const dup = routes.find((r) => r.method === method && routeShape(r.segments) === shape);
+        if (dup) {
+            const samePath = dup.segments.join("/") === segments.join("/");
+            throw new Error(samePath
+                ? `${method} ${path} はすでに登録されています`
+                : `${method} ${path} は、登録済みの ${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);
+        routes.sort(compareRoutes);
+        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(pathOrMw, mw) {
+            const path = typeof pathOrMw === "string" ? pathOrMw : null;
+            const fn = typeof pathOrMw === "string" ? mw : pathOrMw;
+            if (!fn)
+                throw new Error(`app.use("${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: ((methods, path, a, b) => {
+            const list = typeof methods === "string" ? [methods] : methods;
+            if (list.length === 0)
+                throw new Error(`app.on(..., "${path}") にメソッドがありません`);
+            const handler = routeHandler(path, a, b);
+            for (const m of list) {
+                if (m.toUpperCase() === "ALL")
+                    throw new Error("すべてのメソッドで動かすには app.all() を使ってください");
+                add(m, path, handler);
+            }
+        }),
+        // K はテーブルのキーから推論される。各キーのパスからパラメーターの型が決まる
+        routes(table) {
+            for (const [key, handler] of Object.entries(table)) {
+                const [method, path] = key.split(" ");
+                if (!method || !path) {
+                    throw new Error(`ルートの書き方が違います: "${key}"\n例: "GET /hello"`);
+                }
+                add(method.toUpperCase(), path, handler);
+            }
+        },
+        // createRouter() で作ったルーターをつなげる。ルーターに登録済みのものが、この時点でアプリに入る
+        // app.route(prefix, app) なら、別のアプリをプレフィックス付きでつなげる
+        // (つなぐ側のアプリでは、プレフィックスのパラメーターに型は付かない。型が必要なら createRouter を使う)
+        // つないだアプリの onError / notFound は使わず、こちらのものを使う
+        route(routerOrPrefix, child) {
+            // 先に全部読んでおく(ルーターの作りがおかしいときに、途中まで登録された状態にしない)
+            let list;
+            if (typeof routerOrPrefix === "string") {
+                const read = child ? appEntries.get(child) : undefined;
+                if (!read)
+                    throw new TypeError(`app.route("${routerOrPrefix}", app) には createApp() で作ったアプリを渡してください`);
+                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) {
+            // 開発モードは計測・記録をするので別の道を通る。本番では、その分のコードを一切通らない
+            if (devTools)
+                return devFetch(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, dev).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(c, c.path, resolved.allow, dev);
+            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 });
+        })();
+    }
+    // 開発モードの fetch。層ごとの時間を測り、エラーページ・Server-Timing・ダッシュボードの記録を付ける
+    async function devFetch(req, info, ctx) {
+        // 計測の基準になるリクエストの開始時刻
+        const origin = performance.now();
+        const time = Date.now();
+        const c = new Context(req, info, ctx);
+        const dashboard = dashboardPromise ? await dashboardPromise : null;
+        // /_senri 以下はダッシュボード。localhost から開いたときだけ、ミドルウェアを通さずに処理する
+        // (開けないときは普通の処理に回すので、/_senri はないものとして 404 になる)。どちらも記録はしない
+        const dashboardPath = underDashboard(c);
+        if (dashboard && dashboardPath && dashboard.canOpen(req, info)) {
+            return dashboard.handle(req, dashboardPath);
+        }
+        if (!dashboardPath)
+            dashboard?.begin(c, info);
+        const fail = (err) => handleError(err, c, onError);
+        // ミドルウェアより先にマッチして、c.route / c.params を見られるようにしておく
+        const resolved = resolve(c);
+        if (resolved.kind === "route") {
+            c.route = resolved.route.path;
+            c.params = resolved.params;
+        }
+        // ハンドラー・notFound・toResponse のどこで投げても、compose が onError に集める
+        const layers = applicableMiddlewares(c);
+        const innerName = INNER_NAME[resolved.kind];
+        const measure = { timings: c.timings, origin, innerName };
+        const res = await compose(layers, c, () => inner(c, resolved), fail, measure);
+        // ミドルウェアを全部通ったあとなので、ここなら「通った順番」が揃っている
+        const tools = await devTools;
+        const page = await tools.finishErrorPage(c, res);
+        // 層ごとの時間を Server-Timing に載せる(ブラウザの開発者ツールで見られる)
+        const desc = resolved.kind === "route" ? `${resolved.route.method} ${resolved.route.path}` : innerName;
+        const final = tools.withServerTiming(c.finalize(page), tools.serverTimingHeader(c.timings, { name: innerName, desc }, performance.now() - origin));
+        // ダッシュボードに記録する(失敗してもレスポンスには影響しない)
+        await dashboard?.record(c, final, time, [
+            ...layers.map((l) => ({ name: l.name, order: l.order ?? null })),
+            { name: innerName, order: null },
+        ]);
+        return final;
+    }
+    // ミドルウェアを先に(登録順のまま)、ルートはそのあと。ルートの順番は add() が並べ直すので関係ない
+    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 })),
+    ]);
+    // 開発モードでは、ダッシュボードを作ってアプリに結び付けておく
+    // Cloudflare Workers では作らない(接続元が分からず localhost 制限で開けないうえ、
+    // リクエストごとに別の isolate で動くことがあり、記録が残らない)。/_senri はふつうの 404 になる
+    const dashboardPromise = isWorkers() ? null : devTools?.then((m) => {
+        const dashboard = m.createDashboard({
+            routes: () => app.routeList(),
+            middlewares: () => app.middlewareList(),
+        });
+        m.registerDashboard(app, dashboard);
+        return dashboard;
+    });
+    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 Measure = {
+    timings: Timing[];
+    origin: number;
+    innerName: string;
+};
+export declare function compose(layers: Layer[], c: Context, handle: () => Response | Promise<Response>, onError: (err: unknown) => Promise<Response>, measure?: Measure): Promise<Response>;

package/dist/src/compose.js

@@ -0,0 +1,95 @@
+import { markConversionError } from "./errors.js";
+// 返した値をレスポンスにする。失敗したら、どこが返した値だったかをエラーに覚えさせてから投げ直す
+export function toResponseOf(c, value, origin) {
+    try {
+        return c.toResponse(value);
+    }
+    catch (err) {
+        throw markConversionError(err, origin);
+    }
+}
+// ミドルウェアを順に通して、最後に handle を呼ぶ
+// 例外は(ミドルウェアでもハンドラーでも)onError に渡してレスポンスにしてもらう
+// measure を渡したときだけ、各層の時間を timings[i] に記録する(i = 層の順番、最後がいちばん内側)
+export function compose(layers, c, handle, onError, measure) {
+    // 近道: ミドルウェアがなく、計測もしないなら、いちばん内側の処理を呼ぶだけ(下の dispatch と同じ結果になる)
+    if (layers.length === 0 && !measure) {
+        try {
+            return Promise.resolve(handle()).catch(onError);
+        }
+        catch (err) {
+            return onError(err);
+        }
+    }
+    const timings = measure?.timings;
+    // 計測しないときは時計を読まない
+    const now = timings ? () => performance.now() : () => 0;
+    // どの層で例外が起きたか(層の番号)
+    let failedAt = -1;
+    const fail = (err, i) => {
+        failedAt = i;
+        return onError(err);
+    };
+    const dispatch = async (i) => {
+        const start = now();
+        // next() の中(下流)で待っていた時間
+        let inner = 0;
+        // next() を呼ばずに値を返して終わったか
+        let stopped = false;
+        try {
+            return await step(i, (ms) => (inner += ms), () => (stopped = true));
+        }
+        finally {
+            if (measure) {
+                const total = now() - start;
+                measure.timings[i] = {
+                    name: layers[i]?.name ?? measure.innerName,
+                    total,
+                    self: total - inner,
+                    failed: failedAt === i,
+                    start: start - measure.origin,
+                    stopped,
+                };
+            }
+        }
+    };
+    const step = async (i, addInner, 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, () => {
+                if (downstream) {
+                    // 2回目を許すと、ハンドラーや後ろのミドルウェアが2回動いてしまう
+                    throw new Error("next() が2回呼ばれました。1つのミドルウェアで呼べるのは1回だけです");
+                }
+                const nextStart = now();
+                downstream = dispatch(i + 1).finally(() => addInner(now() - nextStart));
+                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(new Error("ミドルウェアが何も返さず、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,60 @@
+import type { Timing } from "./compose.ts";
+import { type CookieOptions } from "./cookie.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 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 ip(): string | null;
+    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>;
+    cookie(): Record<string, string>;
+    cookie(name: string): string | undefined;
+    setCookie(name: string, value: string, options?: CookieOptions): this;
+    deleteCookie(name: string, options?: Pick<CookieOptions, "path" | "domain">): this;
+    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 {};