@senrijs/senri 0.0.0-stage → 0.1.0

package/dist/src/group.js

@@ -0,0 +1,83 @@
+import { normalizeMethod, splitPattern } from "./router.js";
+import { checkSchemas, withValidation } from "./validate.js";
+// 2つ目の引数がスキーマなら、確かめてからハンドラーを呼ぶものにする(app.ts と同じ)
+export function routeHandler(path, a, b) {
+    if (typeof a === "function")
+        return a;
+    if (typeof b !== "function")
+        throw new TypeError(`${path}: ハンドラーがありません`);
+    checkSchemas(path, a);
+    return withValidation(a, b);
+}
+const entries = new WeakMap();
+export function joinPath(...parts) {
+    return "/" + parts.flatMap(splitPattern).join("/");
+}
+// ルーターに登録されたものを、プレフィックスを付けたパスで返す
+export function groupEntries(router) {
+    const list = entries.get(router);
+    if (!list)
+        throw new TypeError("app.route() には createRouter() で作ったルーターを渡してください");
+    return list("");
+}
+// V は c.set / c.get で使う変数の型。アプリと同じものを指定する: createRouter<"/admin", Vars>("/admin")
+export function createRouter(prefix) {
+    // 子のルーターは、つなげた時点ではなく app.route の時点で中身を読む(あとから足したルートも入る)
+    const items = [];
+    const push = (name, path, handler) => {
+        items.push({ kind: "entry", entry: { kind: "route", method: name, path, handler } });
+    };
+    const method = (name) => ((path, a, b) => push(name, path, routeHandler(path, a, b)));
+    const router = {
+        prefix,
+        use(pathOrMw, mw) {
+            const path = typeof pathOrMw === "string" ? pathOrMw : "/";
+            const fn = typeof pathOrMw === "string" ? mw : pathOrMw;
+            if (!fn)
+                throw new Error(`router.use("${path}", ...) にミドルウェアがありません`);
+            items.push({ kind: "entry", entry: { kind: "use", path, mw: fn } });
+        },
+        get: method("GET"),
+        post: method("POST"),
+        put: method("PUT"),
+        patch: method("PATCH"),
+        delete: method("DELETE"),
+        all: method("ALL"),
+        head: method("HEAD"),
+        options: method("OPTIONS"),
+        on: ((methods, path, a, b) => {
+            const list = typeof methods === "string" ? [methods] : methods;
+            if (list.length === 0)
+                throw new Error(`router.on(..., "${path}") にメソッドがありません`);
+            const handler = routeHandler(path, a, b);
+            for (const m of list) {
+                if (m.toUpperCase() === "ALL")
+                    throw new Error("すべてのメソッドで動かすには all() を使ってください");
+                // 名前の確認(CONNECT などの拒否)は、ここで先にしておく(app.route まで待たない)
+                push(normalizeMethod(m), path, handler);
+            }
+        }),
+        route(child) {
+            if (!entries.has(child))
+                throw new TypeError("route() には createRouter() で作ったルーターを渡してください");
+            items.push({ kind: "router", router: child });
+        },
+    };
+    const seen = new Set();
+    entries.set(router, (base) => {
+        // ルーターが自分自身を(間接的にでも)含んでいると終わらないので止める
+        if (seen.has(router))
+            throw new Error(`ルーター ${prefix} が自分自身を含んでいます`);
+        seen.add(router);
+        try {
+            const here = joinPath(base, prefix);
+            return items.flatMap((item) => item.kind === "router"
+                ? entries.get(item.router)(here)
+                : [{ ...item.entry, path: joinPath(here, item.entry.path) }]);
+        }
+        finally {
+            seen.delete(router);
+        }
+    });
+    return router;
+}

package/dist/src/health.d.ts

@@ -0,0 +1,9 @@
+import type { Middleware } from "./context.ts";
+export type HealthOptions = {
+    path?: string | false;
+    readyPath?: string | false;
+    ready?: () => boolean | Promise<boolean>;
+};
+export declare function setDraining(value: boolean): void;
+export declare function isDraining(): boolean;
+export declare function health(options?: HealthOptions): Middleware;

package/dist/src/health.js

@@ -0,0 +1,40 @@
+// serve() が止まり始めた(SIGTERM などを受けた)か。プロセス全体で1つ
+let draining = false;
+export function setDraining(value) {
+    draining = value;
+}
+export function isDraining() {
+    return draining;
+}
+const plain = (body, status) => new Response(body, { status, headers: { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store" } });
+export function health(options = {}) {
+    const live = options.path === undefined ? "/healthz" : options.path;
+    const ready = options.readyPath === undefined ? "/readyz" : options.readyPath;
+    return async function health(c, next) {
+        const method = c.req.method;
+        if (method !== "GET" && method !== "HEAD")
+            return next();
+        let path;
+        try {
+            path = c.path;
+        }
+        catch {
+            return next();
+        }
+        if (path === live)
+            return plain("ok", 200);
+        if (path !== ready)
+            return next();
+        if (draining)
+            return plain("shutting down", 503);
+        try {
+            if (options.ready && !(await options.ready()))
+                return plain("not ready", 503);
+        }
+        catch {
+            // 確かめる処理が失敗したなら、受けられるとは言えない(中身は外に出さない)
+            return plain("not ready", 503);
+        }
+        return plain("ready", 200);
+    };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,13 @@
+export { createApp, type App, type AppOptions, type MountableApp } from "./app.ts";
+export { createRouter, type Router } from "./group.ts";
+export { Context, type BindingsOf, type ExecutionContext, type Handler, type HandlerResult, type Middleware, type Next, type VariablesOf, } from "./context.ts";
+export { HttpError, type ErrorHandler, type NotFoundHandler } from "./errors.ts";
+export { ValidationError, type InferOutput, type RouteSchemas, type StandardIssue, type StandardSchemaV1, type ValidationTarget, } from "./validate.ts";
+export type { CookieOptions } from "./cookie.ts";
+export type { FormBody, FormValue } from "./body.ts";
+export type { Timing } from "./compose.ts";
+export { logger, showRoutes } from "./logger.ts";
+export { health, type HealthOptions } from "./health.ts";
+export { cors, type CorsOptions } from "./middleware/cors.ts";
+export { secureHeaders, type SecureHeadersOptions } from "./middleware/secure-headers.ts";
+export { bodyLimit, type BodyLimitOptions } from "./middleware/body-limit.ts";

package/dist/src/index.js

@@ -0,0 +1,10 @@
+export { createApp } from "./app.js";
+export { createRouter } from "./group.js";
+export { Context, } from "./context.js";
+export { HttpError } from "./errors.js";
+export { ValidationError, } from "./validate.js";
+export { logger, showRoutes } from "./logger.js";
+export { health } from "./health.js";
+export { cors } from "./middleware/cors.js";
+export { secureHeaders } from "./middleware/secure-headers.js";
+export { bodyLimit } from "./middleware/body-limit.js";

package/dist/src/logger.d.ts

@@ -0,0 +1,18 @@
+import type { Middleware } from "./context.ts";
+type LoggerOptions = {
+    format?: "pretty" | "json";
+    color?: boolean;
+    slow?: number;
+};
+export declare function logger(options?: LoggerOptions): Middleware;
+type RouteInfo = {
+    method: string;
+    path: string;
+};
+export declare function showRoutes(app: {
+    routeList(): RouteInfo[];
+}, url: string, options?: {
+    color?: boolean;
+    note?: string;
+}): void;
+export {};

package/dist/src/logger.js

@@ -0,0 +1,110 @@
+const C = {
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    bold: "\x1b[1m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+};
+const METHOD_COLOR = {
+    GET: C.green,
+    POST: C.cyan,
+    PUT: C.yellow,
+    DELETE: C.red,
+    PATCH: C.magenta,
+};
+// ログには、届いたままのパスを出す(c.path はデコード済みで、不正なリクエストだと 400 を投げるため)
+// Bun は不正な Host のとき req.url を相対 URL にするので、URL として読めなければそのまま出す
+function rawPath(req) {
+    try {
+        return new URL(req.url).pathname;
+    }
+    catch {
+        return req.url;
+    }
+}
+export function logger(options = {}) {
+    const format = options.format ?? "pretty";
+    const color = options.color ?? true;
+    const slow = options.slow ?? 500;
+    const paint = (code, text) => color ? `${code}${text}${C.reset}` : text;
+    function statusColor(status) {
+        if (status >= 500)
+            return C.red;
+        if (status >= 400)
+            return C.yellow;
+        if (status >= 300)
+            return C.cyan;
+        return C.green;
+    }
+    function pinoLevel(status) {
+        if (status >= 500)
+            return 50;
+        if (status >= 400)
+            return 40;
+        return 30;
+    }
+    // 名前付きの関数にしておくと、ダッシュボードなどで "logger" と表示できる
+    return async function logger(c, next) {
+        const start = Date.now();
+        const res = await next();
+        const ms = Date.now() - start;
+        const method = c.req.method;
+        const path = rawPath(c.req);
+        // pino 形式のエラー(エラーがなければ undefined)
+        const err = c.error instanceof Error
+            ? { type: c.error.name, message: c.error.message, stack: c.error.stack }
+            : c.error !== undefined
+                ? { message: String(c.error) }
+                : undefined;
+        if (format === "json") {
+            console.log(JSON.stringify({
+                level: pinoLevel(res.status),
+                time: Date.now(),
+                req: { method, url: path },
+                res: { statusCode: res.status },
+                responseTime: ms,
+                err,
+                msg: err ? "request errored" : "request completed",
+            }));
+            return;
+        }
+        const time = new Date().toTimeString().slice(0, 8);
+        console.log([
+            paint(C.dim, time),
+            paint(METHOD_COLOR[method] ?? C.bold, method.padEnd(7)),
+            path.padEnd(24),
+            paint(statusColor(res.status), String(res.status)),
+            paint(ms > slow ? C.red : C.dim, `${ms}ms`.padStart(6)),
+        ].join(" "));
+        // エラーがあったら、その下に赤で詳細を出す
+        if (err) {
+            console.log(paint(C.red, `  ${err.stack ?? err.message}`));
+        }
+    };
+}
+const ACCENT = "\x1b[38;2;227;65;43m";
+export function showRoutes(app, url, 
+// note: URL の横に薄く出す補足(serve() は、ポートをどこから決めたかを出す)
+options = {}) {
+    const color = options.color ?? true;
+    const paint = (code, text) => color ? `${code}${text}${C.reset}` : text;
+    // パスのアルファベット順 → 同じパスならメソッド順
+    const list = [...app.routeList()].sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method));
+    // ":id" みたいなパラメーター部分だけ色を付ける
+    const highlight = (path) => path
+        .split("/")
+        .map((seg) => (seg.startsWith(":") ? paint(C.cyan, seg) : seg))
+        .join("/");
+    console.log("");
+    const note = options.note ? `  ${paint(C.dim, `(${options.note})`)}` : "";
+    console.log(`  ${paint(C.bold, "senr")}${paint(ACCENT, "/")}  ${paint(C.green, "ready")}  ${url}${note}`);
+    console.log("");
+    for (const r of list) {
+        console.log(`    ${paint(METHOD_COLOR[r.method] ?? C.bold, r.method.padEnd(7))} ${highlight(r.path)}`);
+    }
+    console.log("");
+}

package/dist/src/matcher.d.ts

@@ -0,0 +1,16 @@
+import type { Route } from "./router.ts";
+export type Leaf = Route[];
+export type Match = {
+    leaf: Leaf;
+    values: string[];
+};
+export type Matcher = {
+    add(route: Route): void;
+    staticLeaf(path: string): Leaf | undefined;
+    match(segments: readonly string[]): Match[];
+    first(segments: readonly string[], method: string): {
+        route: Route;
+        values: string[];
+    } | null;
+};
+export declare function createMatcher(): Matcher;

package/dist/src/matcher.js

@@ -0,0 +1,86 @@
+const node = () => ({ statics: null, param: null, leaf: null });
+const NO_VALUES = [];
+export function createMatcher() {
+    const root = node();
+    // パラメーターのないルートだけ。キーは "/users/me" の形(c.path と同じ)
+    const statics = new Map();
+    const leafOf = (route) => {
+        let n = root;
+        for (const segment of route.segments) {
+            if (segment.startsWith(":")) {
+                n = n.param ??= node();
+            }
+            else {
+                n.statics ??= new Map();
+                let child = n.statics.get(segment);
+                if (!child)
+                    n.statics.set(segment, (child = node()));
+                n = child;
+            }
+        }
+        return (n.leaf ??= []);
+    };
+    const walk = (n, segments, i, values, out) => {
+        if (i === segments.length) {
+            if (n.leaf)
+                out.push({ leaf: n.leaf, values: values.length > 0 ? values.slice() : NO_VALUES });
+            return;
+        }
+        const segment = segments[i];
+        const next = n.statics?.get(segment);
+        if (next)
+            walk(next, segments, i + 1, values, out);
+        if (n.param) {
+            values.push(segment);
+            walk(n.param, segments, i + 1, values, out);
+            values.pop();
+        }
+    };
+    // walk と同じ順番でたどり、メソッドが合うルートを見つけたらそこで止める
+    const seek = (n, segments, i, method, values) => {
+        if (i === segments.length) {
+            if (n.leaf) {
+                for (const route of n.leaf)
+                    if (route.method === method)
+                        return route;
+            }
+            return null;
+        }
+        const segment = segments[i];
+        const next = n.statics?.get(segment);
+        if (next) {
+            const found = seek(next, segments, i + 1, method, values);
+            if (found)
+                return found;
+        }
+        if (n.param) {
+            values.push(segment);
+            const found = seek(n.param, segments, i + 1, method, values);
+            if (found)
+                return found;
+            values.pop();
+        }
+        return null;
+    };
+    return {
+        add(route) {
+            const leaf = leafOf(route);
+            leaf.push(route);
+            if (!route.segments.some((s) => s.startsWith(":")))
+                statics.set("/" + route.segments.join("/"), leaf);
+        },
+        staticLeaf(path) {
+            return statics.get(path);
+        },
+        match(segments) {
+            const out = [];
+            walk(root, segments, 0, [], out);
+            return out;
+        },
+        first(segments, method) {
+            const values = [];
+            const route = seek(root, segments, 0, method, values);
+            return route ? { route, values } : null;
+        },
+    };
+}

package/dist/src/middleware/body-limit.d.ts

@@ -0,0 +1,6 @@
+import type { Context, HandlerResult, Middleware } from "../context.ts";
+export type BodyLimitOptions = {
+    maxSize: number;
+    onError?: (c: Context) => HandlerResult | Promise<HandlerResult>;
+};
+export declare function bodyLimit(options: BodyLimitOptions): Middleware;

package/dist/src/middleware/body-limit.js

@@ -0,0 +1,47 @@
+import { HttpError } from "../errors.js";
+export function bodyLimit(options) {
+    const max = options.maxSize;
+    if (typeof max !== "number" || !Number.isFinite(max) || max < 0) {
+        throw new Error(`bodyLimit(): maxSize には 0 以上のバイト数を指定してください(${String(max)})`);
+    }
+    const tooLarge = (c) => options.onError ? options.onError(c) : new Response("413 Content Too Large", { status: 413 });
+    return async function bodyLimit(c, next) {
+        const body = c.req.body;
+        if (body === null)
+            return next();
+        // Content-Length があれば、読む前に決められる(ランタイムが、それより長いボディは受け取らない)
+        const length = c.req.headers.get("content-length");
+        if (length !== null) {
+            // 数字でない値(ふつうはランタイムの HTTP パーサーがはじく)は、長さが分からないので通さない
+            if (!/^\s*\d+\s*$/.test(length))
+                return new Response("400 Bad Request", { status: 400 });
+            return Number(length) > max ? tooLarge(c) : next();
+        }
+        // ない(チャンク転送など)ときは、読みながら数える。超えたらストリームをエラーにして、それ以上は読まない
+        let exceeded = false;
+        let size = 0;
+        const reader = body.getReader();
+        const limited = new ReadableStream({
+            async pull(controller) {
+                const { done, value } = await reader.read();
+                if (done)
+                    return controller.close();
+                size += value.byteLength;
+                if (size > max) {
+                    exceeded = true;
+                    controller.error(new HttpError(413, "413 Content Too Large"));
+                    await reader.cancel();
+                    return;
+                }
+                controller.enqueue(value);
+            },
+            cancel(reason) {
+                return reader.cancel(reason);
+            },
+        });
+        c.req = new Request(c.req, { body: limited, duplex: "half" });
+        const res = await next();
+        // ハンドラーがエラーを握りつぶしていても、超えていたら 413 にする
+        return exceeded ? tooLarge(c) : res;
+    };
+}

package/dist/src/middleware/cors.d.ts

@@ -0,0 +1,10 @@
+import type { Context, Middleware } from "../context.ts";
+export type CorsOptions = {
+    origin?: string | readonly string[] | ((origin: string, c: Context) => boolean | string | null | undefined);
+    allowMethods?: readonly string[];
+    allowHeaders?: readonly string[];
+    exposeHeaders?: readonly string[];
+    credentials?: boolean;
+    maxAge?: number;
+};
+export declare function cors(options?: CorsOptions): Middleware;

package/dist/src/middleware/cors.js

@@ -0,0 +1,79 @@
+import { appendVary, editable } from "./response.js";
+const DEFAULT_METHODS = ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH", "QUERY"];
+export function cors(options = {}) {
+    const origin = options.origin ?? "*";
+    if (options.credentials && origin === "*") {
+        throw new Error('cors(): credentials: true のときは origin: "*" は使えません。許可するオリジンを指定してください');
+    }
+    const methods = (options.allowMethods ?? DEFAULT_METHODS).join(", ");
+    const expose = options.exposeHeaders?.join(", ");
+    // "*" 以外は、リクエストのオリジンによって答えが変わるので Vary: Origin が要る
+    const varies = origin !== "*";
+    const allowOrigin = (requestOrigin, c) => {
+        if (origin === "*")
+            return "*";
+        if (typeof origin === "string")
+            return origin === requestOrigin ? origin : null;
+        if (typeof origin === "function") {
+            const result = origin(requestOrigin, c);
+            return result === true ? requestOrigin : typeof result === "string" ? result : null;
+        }
+        return origin.includes(requestOrigin) ? requestOrigin : null;
+    };
+    return async function cors(c, next) {
+        const requestOrigin = c.req.headers.get("origin");
+        if (requestOrigin === null) {
+            if (!varies)
+                return next();
+            // 許可するオリジンがリクエストで変わるなら、Origin のないレスポンスにも Vary: Origin を付ける
+            // (付けないと、共有キャッシュが CORS ヘッダーのないこのレスポンスを、ほかのオリジンにも返してしまう)
+            const downstream = await next();
+            if (downstream.status < 200)
+                return downstream;
+            const res = editable(downstream);
+            appendVary(res.headers, "Origin");
+            return res;
+        }
+        const allowed = allowOrigin(requestOrigin, c);
+        // プリフライト(本番のリクエストの前に、ブラウザが「送ってよいか」を OPTIONS で聞いてくるもの)には、ここで答える
+        const requestMethod = c.req.headers.get("access-control-request-method");
+        if (c.req.method === "OPTIONS" && requestMethod !== null) {
+            const headers = new Headers();
+            if (varies)
+                appendVary(headers, "Origin");
+            if (allowed !== null) {
+                headers.set("access-control-allow-origin", allowed);
+                headers.set("access-control-allow-methods", methods);
+                if (options.allowHeaders) {
+                    headers.set("access-control-allow-headers", options.allowHeaders.join(", "));
+                }
+                else {
+                    const requested = c.req.headers.get("access-control-request-headers");
+                    if (requested)
+                        headers.set("access-control-allow-headers", requested);
+                    appendVary(headers, "Access-Control-Request-Headers");
+                }
+                if (options.credentials)
+                    headers.set("access-control-allow-credentials", "true");
+                if (options.maxAge !== undefined)
+                    headers.set("access-control-max-age", String(Math.floor(options.maxAge)));
+            }
+            return new Response(null, { status: 204, headers });
+        }
+        const downstream = await next();
+        // 101(WebSocket のアップグレード)などは作り直すと壊れるので触らない(finalize() と同じ)
+        if (downstream.status < 200)
+            return downstream;
+        const res = editable(downstream);
+        if (varies)
+            appendVary(res.headers, "Origin");
+        if (allowed !== null) {
+            res.headers.set("access-control-allow-origin", allowed);
+            if (options.credentials)
+                res.headers.set("access-control-allow-credentials", "true");
+            if (expose)
+                res.headers.set("access-control-expose-headers", expose);
+        }
+        return res;
+    };
+}

package/dist/src/middleware/response.d.ts

@@ -0,0 +1,2 @@
+export declare function editable(res: Response): Response;
+export declare function appendVary(headers: Headers, ...names: string[]): void;

package/dist/src/middleware/response.js

@@ -0,0 +1,28 @@
+// 標準ミドルウェアが、next() のあとでレスポンスのヘッダーを足すときに使う
+// ヘッダーを変更できるレスポンスにする
+// fetch() や Response.redirect() の Response はヘッダーを変更できないので、そのときだけ作り直す
+export function editable(res) {
+    try {
+        // 同じ値を入れ直すだけ。変更できなければここで TypeError になる
+        res.headers.set("vary", res.headers.get("vary") ?? "");
+        if (res.headers.get("vary") === "")
+            res.headers.delete("vary");
+        return res;
+    }
+    catch {
+        return new Response(res.body, { status: res.status, statusText: res.statusText, headers: new Headers(res.headers) });
+    }
+}
+// Vary に足す(すでにあれば足さない。* なら何もしない)
+export function appendVary(headers, ...names) {
+    const current = headers.get("vary");
+    if (current?.trim() === "*")
+        return;
+    const list = current ? current.split(",").map((v) => v.trim()).filter(Boolean) : [];
+    for (const name of names) {
+        if (!list.some((v) => v.toLowerCase() === name.toLowerCase()))
+            list.push(name);
+    }
+    if (list.length > 0)
+        headers.set("vary", list.join(", "));
+}

package/dist/src/middleware/secure-headers.d.ts

@@ -0,0 +1,19 @@
+import type { Middleware } from "../context.ts";
+type HeaderValue = string | boolean;
+export type SecureHeadersOptions = {
+    contentSecurityPolicy?: HeaderValue;
+    crossOriginEmbedderPolicy?: HeaderValue;
+    crossOriginOpenerPolicy?: HeaderValue;
+    crossOriginResourcePolicy?: HeaderValue;
+    originAgentCluster?: HeaderValue;
+    referrerPolicy?: HeaderValue;
+    strictTransportSecurity?: HeaderValue;
+    xContentTypeOptions?: HeaderValue;
+    xDnsPrefetchControl?: HeaderValue;
+    xDownloadOptions?: HeaderValue;
+    xFrameOptions?: HeaderValue;
+    xPermittedCrossDomainPolicies?: HeaderValue;
+    xXssProtection?: HeaderValue;
+};
+export declare function secureHeaders(options?: SecureHeadersOptions): Middleware;
+export {};

package/dist/src/middleware/secure-headers.js

@@ -0,0 +1,46 @@
+import { editable } from "./response.js";
+// [オプション名, ヘッダー名, 既定の値(null なら既定では付けない)]
+const HEADERS = [
+    ["contentSecurityPolicy", "content-security-policy", null],
+    ["crossOriginEmbedderPolicy", "cross-origin-embedder-policy", null],
+    ["crossOriginOpenerPolicy", "cross-origin-opener-policy", "same-origin"],
+    ["crossOriginResourcePolicy", "cross-origin-resource-policy", "same-origin"],
+    ["originAgentCluster", "origin-agent-cluster", "?1"],
+    ["referrerPolicy", "referrer-policy", "no-referrer"],
+    ["strictTransportSecurity", "strict-transport-security", "max-age=15552000; includeSubDomains"],
+    ["xContentTypeOptions", "x-content-type-options", "nosniff"],
+    ["xDnsPrefetchControl", "x-dns-prefetch-control", "off"],
+    ["xDownloadOptions", "x-download-options", "noopen"],
+    ["xFrameOptions", "x-frame-options", "SAMEORIGIN"],
+    ["xPermittedCrossDomainPolicies", "x-permitted-cross-domain-policies", "none"],
+    ["xXssProtection", "x-xss-protection", "0"],
+];
+export function secureHeaders(options = {}) {
+    const headers = [];
+    for (const [key, name, fallback] of HEADERS) {
+        const value = options[key];
+        if (value === false)
+            continue;
+        if (typeof value === "string")
+            headers.push([name, value]);
+        else if (fallback !== null)
+            headers.push([name, fallback]);
+        else if (value === true) {
+            throw new Error(`secureHeaders(): ${key} には既定の値がないので、文字列で指定してください`);
+        }
+    }
+    return async function secureHeaders(c, next) {
+        // next() のあとでレスポンスに足す。ハンドラーが Response に付けたものは上書きしない
+        // (c.header() で付けたものは、このあと finalize() で入るので、そちらが勝つ)
+        const downstream = await next();
+        // 101(WebSocket のアップグレード)などは作り直すと壊れるので触らない(finalize() と同じ)
+        if (downstream.status < 200)
+            return downstream;
+        const res = editable(downstream);
+        for (const [name, value] of headers) {
+            if (!res.headers.has(name))
+                res.headers.set(name, value);
+        }
+        return res;
+    };
+}