@senrijs/senri 0.0.0-stage → 0.2.0

package/dist/src/context.js

@@ -0,0 +1,235 @@
+import { requestPathname, splitPath } from "./router.js";
+import { isConnectionInfo } from "./connection.js";
+import { readBody } from "./body.js";
+import { senriError } from "./errors.js";
+function isBodyValue(value) {
+    return (value instanceof Blob ||
+        value instanceof ArrayBuffer ||
+        ArrayBuffer.isView(value) ||
+        value instanceof ReadableStream ||
+        value instanceof FormData ||
+        value instanceof URLSearchParams);
+}
+// ボディの種類から決まる Content-Type。Bun は Headers に入れてくれないので、ランタイム差が出ないよう自分で入れる
+// FormData は boundary 付きの値を Response が作るので、ここでは決めない
+function contentTypeOf(value) {
+    if (value instanceof Blob)
+        return value.type || undefined;
+    if (value instanceof URLSearchParams)
+        return "application/x-www-form-urlencoded;charset=UTF-8";
+    return undefined;
+}
+// c.text() / c.json() の既定の Content-Type。Response は渡された Headers をコピーして使うので、共有してよい
+// (オブジェクトリテラルを渡すより速い。毎回 Headers に変換しなくて済むため)
+const TEXT_HEADERS = new Headers({ "content-type": "text/plain; charset=utf-8" });
+const JSON_HEADERS = new Headers({ "content-type": "application/json" });
+// init のオブジェクトは毎回作る。Bun.serve では、同じ init を使い回した Response を返すと
+// HTTP のスループットが数分の1に落ちる(プロセス内で fetch を呼ぶだけでは差が出ない。bench/http.ts で確認)
+function initOf(status, type, headers) {
+    return { status, headers: type ? { "content-type": type } : headers };
+}
+// スキーマで確かめた値(src/validate.ts が入れる)。c.valid() で読む
+const validated = new WeakMap();
+export function setValidated(c, target, value) {
+    let values = validated.get(c);
+    if (!values)
+        validated.set(c, (values = {}));
+    values[target] = value;
+}
+// app.fetch に渡された元のリクエストと2つ目の引数を読む(Context の外から。@senrijs/senri/ip で使う)
+// Context のメソッドにしないのは、使わないアプリのバンドルに入れないため
+export let connectionOf;
+export class Context {
+    req;
+    #status = 200;
+    // c.header() で初めて作る(ほとんどのリクエストでは使わないので、毎回作らない)
+    #headers;
+    #segments;
+    // 取り出したままの pathname と、正規化したパス(c.path)
+    #pathname;
+    #path;
+    // c.set() で初めて作る
+    #vars;
+    // 一度読んだボディ(ミドルウェアとハンドラーの両方から読めるように覚えておく)
+    #body;
+    #query;
+    error = undefined;
+    // マッチしたルートのパターン("/users/:id")。見つからなければ undefined
+    // ミドルウェアより先にマッチするので、next() の前から読める(ログやダッシュボードの集計用)
+    route = undefined;
+    // パスパラメーター。ハンドラーでは第1引数でも受け取れる
+    params = {};
+    #timings;
+    // app.fetch に渡された元のリクエストと2つ目の引数(@senrijs/senri/ip の getIp で使う)
+    // Bun の requestIP は元のリクエストでしか答えないので、c.req が差し替えられても元のほうで聞く
+    #original;
+    #info;
+    static {
+        connectionOf = (c) => ({ req: c.#original, info: c.#info });
+    }
+    #ctx;
+    constructor(req, info, ctx) {
+        this.req = req;
+        this.#original = req;
+        this.#info = info;
+        this.#ctx = ctx;
+    }
+    // Cloudflare Workers の env(KV や環境変数などのバインディング)。型は createApp<{ Bindings: ... }>() で決める
+    // Bun の server や Deno の info(接続元を知るためのもの)は env ではないので、そのときは undefined
+    get env() {
+        return (isConnectionInfo(this.#info) ? undefined : this.#info);
+    }
+    // Cloudflare Workers の ctx(waitUntil など)。Workers 以外では渡されないので、読むとエラーにする
+    get executionCtx() {
+        if (!this.#ctx) {
+            throw senriError("no_execution_ctx", "c.executionCtx is only available on Cloudflare Workers");
+        }
+        return this.#ctx;
+    }
+    // パスをデコードして "/" で分けたもの。ルーターもミドルウェアもこれを見る
+    // 初めて読んだときに1回だけ作る。エンコードが不正なら HttpError(400) を投げる
+    get segments() {
+        this.#segments ??= splitPath(this.#rawPathname());
+        return this.#segments;
+    }
+    // req.url から取り出したままの pathname(1回だけ取り出す)。おかしなリクエストなら HttpError(400) を投げる
+    #rawPathname() {
+        this.#pathname ??= requestPathname(this.req);
+        return this.#pathname;
+    }
+    // 正規化・デコード済みのパス("//admin/" → "/admin"、"/%61dmin" → "/admin")
+    // パスで判定するミドルウェアは、req.url ではなくこちらを使うこと
+    get path() {
+        if (this.#path === undefined) {
+            const p = this.#rawPathname();
+            // エンコードも、連続・末尾のスラッシュもなければ、取り出したままのものと同じ(分割もつなぎ直しもしない)
+            // ("." のセグメントは requestPathname が new URL() で解決済みなので、ここには来ない)
+            const clean = !p.includes("%") && !p.includes("//") && (p.length === 1 || !p.endsWith("/"));
+            this.#path = clean ? p : "/" + this.segments.join("/");
+        }
+        return this.#path;
+    }
+    // 開発モードのときだけ、ミドルウェアとハンドラーの通過時間が入る(外側から順)
+    // 自分より内側の層は、next() が終わったあとに読める
+    get timings() {
+        return (this.#timings ??= []);
+    }
+    // ルートに渡したスキーマで確かめた値。c.valid("body") / c.valid("query")
+    // (スキーマを渡していないものは型エラー。JS から呼んだときは、分かりやすいエラーにする)
+    valid(target) {
+        const values = validated.get(this);
+        if (!values || !(target in values)) {
+            throw senriError("no_valid", `c.valid("${target}"): no schema for ${target}`);
+        }
+        return values[target];
+    }
+    // ミドルウェアからハンドラーへ値を渡す(ログインしたユーザーなど)
+    set(key, value) {
+        (this.#vars ??= new Map()).set(key, value);
+        return this;
+    }
+    // set していなければ undefined(ミドルウェアが動かなかったときなど)
+    get(key) {
+        return this.#vars?.get(key);
+    }
+    // --- クエリ ---
+    #searchParams() {
+        this.#query ??= new URL(this.req.url).searchParams;
+        return this.#query;
+    }
+    query(name) {
+        const params = this.#searchParams();
+        if (name !== undefined) {
+            const all = params.getAll(name);
+            return all.length > 0 ? all[all.length - 1] : undefined;
+        }
+        return Object.fromEntries(params);
+    }
+    // 同じ名前のものを全部(?tag=a&tag=b → ["a", "b"])
+    queries(name) {
+        return this.#searchParams().getAll(name);
+    }
+    // --- ボディ ---
+    // Content-Type に合わせて読む(JSON / フォーム / テキスト / それ以外は ArrayBuffer。src/body.ts)
+    // 一度読んだら覚えておくので、何度呼んでもよい
+    body() {
+        this.#body ??= readBody(this.req);
+        return this.#body;
+    }
+    status(code) {
+        this.#status = code;
+        return this;
+    }
+    // ここで設定したヘッダーは、最後に finalize() で1回だけレスポンスに足される
+    // なので、Response を直接返したときも、エラーのときも、next() のあとに設定しても効く
+    header(name, value) {
+        // Set-Cookie は1つのレスポンスに何個も付けるものなので、上書きせずに足す
+        const headers = (this.#headers ??= new Headers());
+        if (name.toLowerCase() === "set-cookie") {
+            headers.append(name, value);
+        }
+        else {
+            headers.set(name, value);
+        }
+        return this;
+    }
+    // json() と text() は Content-Type と status だけ決める(ほかのヘッダーは finalize() で足す)
+    // 共有の #headers を書き換えないので、json() のあとに text() しても Content-Type が混ざらない
+    json(data, status) {
+        const init = initOf(status ?? this.#status, this.#headers?.get("content-type"), JSON_HEADERS);
+        return new Response(JSON.stringify(data), init);
+    }
+    text(body, status) {
+        // 明示しないと、Bun は Headers に Content-Type を入れない(Node / Deno は入れる)のでランタイムで差が出る
+        const init = initOf(status ?? this.#status, this.#headers?.get("content-type"), TEXT_HEADERS);
+        return new Response(body, init);
+    }
+    // c.header() で設定したヘッダーを res に足す。app が最後に1回だけ呼ぶ
+    // - c.header() の値が優先。ただし Content-Type だけはレスポンス自身のものが優先
+    // - Set-Cookie は足す
+    // - c.status() は使わない(Response を直接返したなら、その status を尊重する)
+    finalize(res) {
+        const own = this.#headers;
+        // 何もなければ作り直さない。101(WebSocket のアップグレード)なども作り直すと壊れる
+        if (own === undefined || res.status < 200)
+            return res;
+        let hasHeaders = false;
+        own.forEach(() => (hasHeaders = true));
+        if (!hasHeaders)
+            return res;
+        // fetch() や Response.redirect() の Response はヘッダーを変更できないので、新しく作る
+        const headers = new Headers(res.headers);
+        own.forEach((value, key) => {
+            if (key === "set-cookie")
+                return;
+            if (key === "content-type" && headers.has(key))
+                return;
+            headers.set(key, value);
+        });
+        for (const cookie of own.getSetCookie()) {
+            headers.append("set-cookie", cookie);
+        }
+        return new Response(res.body, { status: res.status, statusText: res.statusText, headers });
+    }
+    toResponse(value) {
+        if (value instanceof Response) {
+            return value;
+        }
+        if (typeof value === "string") {
+            return this.text(value);
+        }
+        if (isBodyValue(value)) {
+            const contentType = this.#headers?.get("content-type") ?? contentTypeOf(value);
+            // headers: undefined は渡さない(exactOptionalPropertyTypes の利用者の型チェックで、エラーになるので)
+            return new Response(value, contentType ? { status: this.#status, headers: { "content-type": contentType } } : { status: this.#status });
+        }
+        // 型では防いでいるが、JS から使ったときや as で無理やり通したときのために実行時にも確かめる
+        if (typeof value === "function") {
+            throw senriError("returned_function", new TypeError("Handler returned a function"));
+        }
+        if (value === undefined || value === null) {
+            throw senriError("returned_nothing", new TypeError("Handler returned undefined or null"));
+        }
+        return this.json(value);
+    }
+}

package/dist/src/cookie.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from "./context.ts";
+export type CookieOptions = {
+    maxAge?: number;
+    expires?: Date;
+    domain?: string;
+    path?: string;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: "Strict" | "Lax" | "None";
+    partitioned?: boolean;
+};
+export declare function parseCookies(header: string | null): Record<string, string>;
+export declare function serializeCookie(name: string, value: string, options?: CookieOptions): string;
+export declare function deletionCookie(name: string, options?: Pick<CookieOptions, "path" | "domain">): string;
+export declare function getCookie(c: Context): Record<string, string>;
+export declare function getCookie(c: Context, name: string): string | undefined;
+export declare function setCookie(c: Context, name: string, value: string, options?: CookieOptions): void;
+export declare function deleteCookie(c: Context, name: string, options?: Pick<CookieOptions, "path" | "domain">): void;

package/dist/src/cookie.js

@@ -0,0 +1,73 @@
+import { senriError } from "./errors.js";
+// Cookie の名前に使える文字(RFC 6265 の token)
+const NAME = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+// "Cookie: a=1; b=2" を { a: "1", b: "2" } に。値はデコードする(できなければそのまま)
+export function parseCookies(header) {
+    // プロトタイプのないオブジェクト(ふつうの {} だと "constructor" などの名前が継承したものと混ざる)
+    const out = Object.create(null);
+    if (!header)
+        return out;
+    for (const part of header.split(";")) {
+        const eq = part.indexOf("=");
+        if (eq === -1)
+            continue;
+        const name = part.slice(0, eq).trim();
+        if (!name || name in out)
+            continue;
+        let value = part.slice(eq + 1).trim();
+        if (value.startsWith('"') && value.endsWith('"'))
+            value = value.slice(1, -1);
+        try {
+            out[name] = decodeURIComponent(value);
+        }
+        catch {
+            out[name] = value;
+        }
+    }
+    return out;
+}
+export function serializeCookie(name, value, options = {}) {
+    if (!NAME.test(name)) {
+        throw senriError("cookie_name", new TypeError(`Invalid cookie name: ${JSON.stringify(name)}`));
+    }
+    const parts = [`${name}=${encodeURIComponent(value)}`];
+    if (options.maxAge !== undefined)
+        parts.push(`Max-Age=${Math.floor(options.maxAge)}`);
+    if (options.expires)
+        parts.push(`Expires=${options.expires.toUTCString()}`);
+    if (options.domain)
+        parts.push(`Domain=${options.domain}`);
+    parts.push(`Path=${options.path ?? "/"}`);
+    if (options.httpOnly ?? true)
+        parts.push("HttpOnly");
+    // __Secure- / __Host- で始まる名前は、Secure がないとブラウザに捨てられる
+    if (options.secure || name.startsWith("__Secure-") || name.startsWith("__Host-"))
+        parts.push("Secure");
+    parts.push(`SameSite=${options.sameSite ?? "Lax"}`);
+    if (options.partitioned)
+        parts.push("Partitioned");
+    return parts.join("; ");
+}
+// 消すための Set-Cookie。Path と Domain は、付けたときと同じものを指定する
+export function deletionCookie(name, options = {}) {
+    if (!NAME.test(name)) {
+        throw senriError("cookie_name", new TypeError(`Invalid cookie name: ${JSON.stringify(name)}`));
+    }
+    const parts = [`${name}=`, "Max-Age=0", "Expires=Thu, 01 Jan 1970 00:00:00 GMT"];
+    if (options.domain)
+        parts.push(`Domain=${options.domain}`);
+    parts.push(`Path=${options.path ?? "/"}`);
+    return parts.join("; ");
+}
+export function getCookie(c, name) {
+    const all = parseCookies(c.req.headers.get("cookie"));
+    return name === undefined ? { ...all } : all[name];
+}
+// 既定は Path=/・HttpOnly・SameSite=Lax。最後に1回だけレスポンスに足される(c.header と同じ)
+export function setCookie(c, name, value, options) {
+    c.header("set-cookie", serializeCookie(name, value, options));
+}
+// Path と Domain は、付けたときと同じものを指定する
+export function deleteCookie(c, name, options) {
+    c.header("set-cookie", deletionCookie(name, options));
+}

package/dist/src/dev/dashboard/access.d.ts

@@ -0,0 +1,6 @@
+import { remoteAddress } from "../../connection.ts";
+export { remoteAddress };
+export declare function isLoopback(address: string | null): boolean;
+export declare function isLocalHost(host: string | null): boolean;
+export declare function canOpenDashboard(req: Request, info: unknown): boolean;
+export declare function sameOrigin(req: Request): boolean;

package/dist/src/dev/dashboard/access.js

@@ -0,0 +1,46 @@
+// ダッシュボード(/_senri)を開いてよいリクエストかを決める
+//
+// ダッシュボードには、リクエストのヘッダーやエラーの中身(ソースコード)が出るので、
+// 同じ PC(ループバック)からのアクセスだけに絞る。接続元のアドレスは src/connection.ts で取り出す
+// (取り出せなければ「接続元不明」として、ダッシュボードだけ拒否し、ほかは普通に動く)
+import { remoteAddress } from "../../connection.js";
+export { remoteAddress };
+// 127.0.0.0/8 と ::1(IPv4 を IPv6 の形で書いた ::ffff:127.x.x.x も)
+export function isLoopback(address) {
+    if (!address)
+        return false;
+    const a = address.toLowerCase().replace(/^\[|\]$/g, "");
+    if (a === "::1" || a === "0:0:0:0:0:0:0:1")
+        return true;
+    const v4 = a.startsWith("::ffff:") ? a.slice("::ffff:".length) : a;
+    return /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(v4);
+}
+// Host ヘッダーが localhost 系か(DNS リバインディング対策)
+// 悪意のあるサイトが自分のドメインを 127.0.0.1 に向けると、ブラウザは接続元がループバックのまま
+// Host: evil.example でアクセスしてくる。接続元だけでなく Host も見ることで、これを防ぐ
+export function isLocalHost(host) {
+    if (!host)
+        return false;
+    const h = host.toLowerCase();
+    if (h === "[::1]" || h.startsWith("[::1]:"))
+        return true;
+    const name = h.replace(/:\d+$/, "");
+    return name === "localhost" || name.endsWith(".localhost") || /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(name);
+}
+export function canOpenDashboard(req, info) {
+    return isLoopback(remoteAddress(req, info)) && isLocalHost(req.headers.get("host"));
+}
+// 状態を変えるリクエスト(クリアなど)は、ダッシュボード自身のページから来たものだけ受け付ける
+// (ほかのサイトのページから、こっそり POST させられないように)
+export function sameOrigin(req) {
+    const origin = req.headers.get("origin");
+    const host = req.headers.get("host");
+    if (!origin || !host)
+        return false;
+    try {
+        return new URL(origin).host === host;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/dev/dashboard/index.d.ts

@@ -0,0 +1,27 @@
+import type { Context } from "../../context.ts";
+import { RequestLog } from "./log.ts";
+import { type DashboardRecord } from "./record.ts";
+export type DashboardSource = {
+    routes(): {
+        method: string;
+        path: string;
+    }[];
+    middlewares(): {
+        name: string;
+        path: string | null;
+        anonymous: boolean;
+    }[];
+};
+export declare function createDashboard(source: DashboardSource): {
+    log: RequestLog<DashboardRecord>;
+    source: DashboardSource;
+    canOpen(req: Request, info: unknown): boolean;
+    handle(req: Request, segments: readonly string[]): Promise<Response>;
+    begin(c: Context, info: unknown): string;
+    idOf(c: Context): string | undefined;
+    record(c: Context, res: Response, time: number, layerNames: {
+        name: string;
+        order: number | null;
+    }[]): Promise<void>;
+};
+export type Dashboard = ReturnType<typeof createDashboard>;

package/dist/src/dev/dashboard/index.js

@@ -0,0 +1,51 @@
+import { canOpenDashboard } from "./access.js";
+import { setDashboardLink } from "./links.js";
+import { RequestLog } from "./log.js";
+import { buildRecord } from "./record.js";
+import { handleDashboard } from "./routes.js";
+import { eventStream } from "./sse.js";
+export function createDashboard(source) {
+    const log = new RequestLog();
+    // SSE(/_senri/api/events)。記録が増えるたびに、開いているダッシュボードへ知らせる
+    const events = (req) => eventStream(log, req);
+    // リクエストごとの id。エラーページの「/_senri で詳しく見る」から、そのリクエストを開くのに使う
+    const ids = new WeakMap();
+    let nextId = 1;
+    const dashboard = {
+        log,
+        source,
+        // localhost から開いたときだけ(src/dev/dashboard/access.ts)
+        canOpen(req, info) {
+            return canOpenDashboard(req, info);
+        },
+        // segments: パスの "_senri" より後ろ
+        handle(req, segments) {
+            return handleDashboard(dashboard, req, segments, events);
+        },
+        // リクエストの最初に呼ぶ。id を振る(/_senri へのリクエストには呼ばないので、記録されない)
+        // info: app.fetch の2つ目の引数。localhost からのリクエストなら、エラーページなどにリンクを出す
+        begin(c, info) {
+            const id = String(nextId++);
+            ids.set(c, id);
+            if (canOpenDashboard(c.req, info))
+                setDashboardLink(c, `/_senri#requests/${id}`);
+            return id;
+        },
+        idOf(c) {
+            return ids.get(c);
+        },
+        // レスポンスを返す直前に呼ぶ。記録に失敗しても、リクエストには影響させない
+        async record(c, res, time, layerNames) {
+            const id = ids.get(c);
+            if (id === undefined)
+                return;
+            try {
+                log.add(await buildRecord({ id, time, c, res, layerNames }));
+            }
+            catch {
+                // 記録はおまけなので、失敗しても黙って捨てる
+            }
+        },
+    };
+    return dashboard;
+}

package/dist/src/dev/dashboard/links.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from "../../context.ts";
+export declare function setDashboardLink(c: Context, url: string): void;
+export declare function dashboardLinkOf(c: Context): string | null;

package/dist/src/dev/dashboard/links.js

@@ -0,0 +1,8 @@
+const links = new WeakMap();
+export function setDashboardLink(c, url) {
+    links.set(c, url);
+}
+// 開けないとき(localhost 以外、接続元不明、本番)は null
+export function dashboardLinkOf(c) {
+    return links.get(c) ?? null;
+}

package/dist/src/dev/dashboard/log.d.ts

@@ -0,0 +1,20 @@
+export type LogEvent<T> = {
+    type: "request";
+    item: T;
+} | {
+    type: "clear";
+};
+export declare class RequestLog<T extends {
+    id: string;
+}> {
+    #private;
+    readonly max: number;
+    constructor(max?: number);
+    get size(): number;
+    get listenerCount(): number;
+    add(item: T): void;
+    list(): T[];
+    get(id: string): T | undefined;
+    clear(): void;
+    subscribe(listener: (event: LogEvent<T>) => void): () => void;
+}

package/dist/src/dev/dashboard/log.js

@@ -0,0 +1,53 @@
+// ダッシュボードに出すリクエストの記録(メモリ上。再起動で消える)
+// 直近の max 件だけを持ち、それより古いものから捨てる。追加とクリアは購読者(SSE)に知らせる
+export class RequestLog {
+    max;
+    // 古い順。新しいものは末尾に足す
+    #items = [];
+    #listeners = new Set();
+    constructor(max = 200) {
+        this.max = max;
+    }
+    get size() {
+        return this.#items.length;
+    }
+    get listenerCount() {
+        return this.#listeners.size;
+    }
+    add(item) {
+        this.#items.push(item);
+        // 上限を超えた分を、古いほう(先頭)から捨てる
+        if (this.#items.length > this.max) {
+            this.#items.splice(0, this.#items.length - this.max);
+        }
+        this.#emit({ type: "request", item });
+    }
+    // 新しい順
+    list() {
+        return [...this.#items].reverse();
+    }
+    get(id) {
+        return this.#items.find((item) => item.id === id);
+    }
+    clear() {
+        this.#items = [];
+        this.#emit({ type: "clear" });
+    }
+    // 戻り値の関数を呼ぶと購読をやめる(SSE の接続が切れたときに呼ぶ)
+    subscribe(listener) {
+        this.#listeners.add(listener);
+        return () => {
+            this.#listeners.delete(listener);
+        };
+    }
+    #emit(event) {
+        for (const listener of this.#listeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // 1つの購読者が壊れていても、記録やほかの購読者は止めない
+            }
+        }
+    }
+}

package/dist/src/dev/dashboard/mask.d.ts

@@ -0,0 +1,4 @@
+export declare const MASK = "***";
+export declare function isSecretHeader(name: string): boolean;
+export declare function maskQuery(search: string): string;
+export declare function maskHeaders(headers: Headers): [string, string][];

package/dist/src/dev/dashboard/mask.js

@@ -0,0 +1,43 @@
+// ダッシュボードに出すヘッダーのうち、機密になりうるものを *** に伏せる
+// (画面を人に見せたり、スクリーンショットを貼ったりしても漏れないように)
+// 名前で決まっているもの
+const SECRET_NAMES = new Set(["authorization", "proxy-authorization", "cookie", "set-cookie"]);
+// 名前にこれらを含むもの(x-api-key、x-auth-token、x-session-id など)
+const SECRET_PATTERN = /token|secret|passw(or)?d|api[-_]?key|session|signature|credential/i;
+export const MASK = "***";
+export function isSecretHeader(name) {
+    const n = name.toLowerCase();
+    return SECRET_NAMES.has(n) || SECRET_PATTERN.test(n);
+}
+// クエリ文字列("?token=abc&page=2")のうち、名前が機密っぽいパラメーターの値を *** にする
+// (ヘッダーと同じ名前のルール。?token=... や ?api_key=... は、コールバックの URL などによく付く)
+// URL を組み立て直すとエンコードが変わってしまうので、"名前=値" の値の部分だけを置き換える
+export function maskQuery(search) {
+    if (search === "" || search === "?")
+        return search;
+    const pairs = search.replace(/^\?/, "").split("&");
+    const masked = pairs.map((pair) => {
+        const eq = pair.indexOf("=");
+        // 値のないもの("?debug")は伏せるものがない
+        if (eq === -1)
+            return pair;
+        const rawName = pair.slice(0, eq);
+        let name = rawName;
+        try {
+            name = decodeURIComponent(rawName.replaceAll("+", " "));
+        }
+        catch {
+            // デコードできない名前は、そのままの形で判定する
+        }
+        return isSecretHeader(name) ? `${rawName}=${MASK}` : pair;
+    });
+    return `?${masked.join("&")}`;
+}
+// [名前, 値] の配列(名前の順)。Set-Cookie は1つずつ並ぶので、何個付いたかは分かる
+export function maskHeaders(headers) {
+    const out = [];
+    for (const [name, value] of headers) {
+        out.push([name, isSecretHeader(name) ? MASK : value]);
+    }
+    return out.sort((a, b) => a[0].localeCompare(b[0]));
+}

package/dist/src/dev/dashboard/record.d.ts

@@ -0,0 +1,37 @@
+import type { Context } from "../../context.ts";
+import type { ErrorPageData } from "../page-data.ts";
+export type LayerState = "ok" | "stopped" | "failed" | "skipped";
+export type RecordLayer = {
+    name: string;
+    order: number | null;
+    depth: number;
+    start: number;
+    total: number;
+    self: number;
+    state: LayerState;
+};
+export type DashboardRecord = {
+    id: string;
+    time: number;
+    method: string;
+    path: string;
+    query: string;
+    route: string | null;
+    params: Record<string, string>;
+    status: number;
+    durationMs: number;
+    layers: RecordLayer[];
+    requestHeaders: [string, string][];
+    responseHeaders: [string, string][];
+    error: ErrorPageData | null;
+};
+export declare function buildRecord(input: {
+    id: string;
+    time: number;
+    c: Context;
+    res: Response;
+    layerNames: {
+        name: string;
+        order: number | null;
+    }[];
+}): Promise<DashboardRecord>;