@senrijs/senri 0.1.0 → 0.2.0

package/dist/src/context.d.ts

@@ -1,5 +1,4 @@
 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;
@@ -26,6 +25,10 @@ export type Handler<P = Record<string, string>, V extends object = any, I extend
 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;
@@ -35,7 +38,6 @@ export declare class Context<V extends object = any, I extends object = {}> {
     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[];
@@ -46,10 +48,6 @@ export declare class Context<V extends object = any, I extends object = {}> {
     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;

package/dist/src/context.js

@@ -1,7 +1,7 @@
 import { requestPathname, splitPath } from "./router.js";
-import { clientIp, isConnectionInfo } from "./connection.js";
+import { isConnectionInfo } from "./connection.js";
 import { readBody } from "./body.js";
-import { deletionCookie, parseCookies, serializeCookie } from "./cookie.js";
+import { senriError } from "./errors.js";
 function isBodyValue(value) {
     return (value instanceof Blob ||
         value instanceof ArrayBuffer ||
@@ -36,6 +36,9 @@ export function setValidated(c, target, value) {
         validated.set(c, (values = {}));
     values[target] = value;
 }
+// app.fetch に渡された元のリクエストと2つ目の引数を読む(Context の外から。@senrijs/senri/ip で使う)
+// Context のメソッドにしないのは、使わないアプリのバンドルに入れないため
+export let connectionOf;
 export class Context {
     req;
     #status = 200;
@@ -50,7 +53,6 @@ export class Context {
     // 一度読んだボディ(ミドルウェアとハンドラーの両方から読めるように覚えておく)
     #body;
     #query;
-    #cookies;
     error = undefined;
     // マッチしたルートのパターン("/users/:id")。見つからなければ undefined
     // ミドルウェアより先にマッチするので、next() の前から読める(ログやダッシュボードの集計用)
@@ -58,11 +60,13 @@ export class Context {
     // パスパラメーター。ハンドラーでは第1引数でも受け取れる
     params = {};
     #timings;
-    // app.fetch に渡された元のリクエストと2つ目の引数(c.ip で使う)
+    // app.fetch に渡された元のリクエストと2つ目の引数(@senrijs/senri/ip の getIp で使う)
     // Bun の requestIP は元のリクエストでしか答えないので、c.req が差し替えられても元のほうで聞く
     #original;
     #info;
-    #ip;
+    static {
+        connectionOf = (c) => ({ req: c.#original, info: c.#info });
+    }
     #ctx;
     constructor(req, info, ctx) {
         this.req = req;
@@ -78,17 +82,10 @@ export class Context {
     // Cloudflare Workers の ctx(waitUntil など)。Workers 以外では渡されないので、読むとエラーにする
     get executionCtx() {
         if (!this.#ctx) {
-            throw new Error("c.executionCtx がありません。Cloudflare Workers で、app.fetch(req, env, ctx) として呼ばれたときだけ使えます");
+            throw senriError("no_execution_ctx", "c.executionCtx is only available on Cloudflare Workers");
         }
         return this.#ctx;
     }
-    // 接続元の IP アドレス。分からなければ null(Cloudflare Workers や、app.fetch を直接呼んだときなど)
-    // X-Forwarded-For などのヘッダーは偽装できるので読まない。プロキシの後ろでは、プロキシが付けるヘッダーを自分で読む
-    get ip() {
-        if (this.#ip === undefined)
-            this.#ip = clientIp(this.#original, this.#info);
-        return this.#ip;
-    }
     // パスをデコードして "/" で分けたもの。ルーターもミドルウェアもこれを見る
     // 初めて読んだときに1回だけ作る。エンコードが不正なら HttpError(400) を投げる
     get segments() {
@@ -122,7 +119,7 @@ export class Context {
     valid(target) {
         const values = validated.get(this);
         if (!values || !(target in values)) {
-            throw new Error(`c.valid("${target}") の値がありません。ルートに { ${target}: スキーマ } を渡すと使えます`);
+            throw senriError("no_valid", `c.valid("${target}"): no schema for ${target}`);
         }
         return values[target];
     }
@@ -159,20 +156,6 @@ export class Context {
         this.#body ??= readBody(this.req);
         return this.#body;
     }
-    cookie(name) {
-        this.#cookies ??= parseCookies(this.req.headers.get("cookie"));
-        return name === undefined ? { ...this.#cookies } : this.#cookies[name];
-    }
-    // 既定は Path=/・HttpOnly・SameSite=Lax(src/cookie.ts)
-    setCookie(name, value, options) {
-        this.header("set-cookie", serializeCookie(name, value, options));
-        return this;
-    }
-    // Path と Domain は、付けたときと同じものを指定する
-    deleteCookie(name, options) {
-        this.header("set-cookie", deletionCookie(name, options));
-        return this;
-    }
     status(code) {
         this.#status = code;
         return this;
@@ -237,17 +220,15 @@ export class Context {
         }
         if (isBodyValue(value)) {
             const contentType = this.#headers?.get("content-type") ?? contentTypeOf(value);
-            return new Response(value, {
-                status: this.#status,
-                headers: contentType ? { "content-type": contentType } : undefined,
-            });
+            // 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 new TypeError("ハンドラーが関数を返しました。呼び出し忘れではありませんか？");
+            throw senriError("returned_function", new TypeError("Handler returned a function"));
         }
         if (value === undefined || value === null) {
-            throw new TypeError("ハンドラーが何も返していません(undefined / null)");
+            throw senriError("returned_nothing", new TypeError("Handler returned undefined or null"));
         }
         return this.json(value);
     }

package/dist/src/cookie.d.ts

@@ -1,3 +1,4 @@
+import type { Context } from "./context.ts";
 export type CookieOptions = {
     maxAge?: number;
     expires?: Date;
@@ -11,3 +12,7 @@ export type CookieOptions = {
 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

@@ -1,4 +1,4 @@
-// Cookie の読み書き(RFC 6265)
+import { senriError } from "./errors.js";
 // Cookie の名前に使える文字(RFC 6265 の token)
 const NAME = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
 // "Cookie: a=1; b=2" を { a: "1", b: "2" } に。値はデコードする(できなければそのまま)
@@ -28,7 +28,7 @@ export function parseCookies(header) {
 }
 export function serializeCookie(name, value, options = {}) {
     if (!NAME.test(name)) {
-        throw new TypeError(`Cookie の名前に使えない文字があります: ${JSON.stringify(name)}`);
+        throw senriError("cookie_name", new TypeError(`Invalid cookie name: ${JSON.stringify(name)}`));
     }
     const parts = [`${name}=${encodeURIComponent(value)}`];
     if (options.maxAge !== undefined)
@@ -51,7 +51,7 @@ export function serializeCookie(name, value, options = {}) {
 // 消すための Set-Cookie。Path と Domain は、付けたときと同じものを指定する
 export function deletionCookie(name, options = {}) {
     if (!NAME.test(name)) {
-        throw new TypeError(`Cookie の名前に使えない文字があります: ${JSON.stringify(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)
@@ -59,3 +59,15 @@ export function deletionCookie(name, options = {}) {
     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/explain.d.ts

@@ -0,0 +1,2 @@
+export declare function explainText(err: unknown): string | null;
+export declare function explain(err: unknown): unknown;

package/dist/src/dev/explain.js

@@ -0,0 +1,37 @@
+// 本体が投げるエラー(短い英語 + code)に、開発モードで日本語の説明を付ける
+// 本体を小さくするため、長い説明はこちらに置いている(src/errors.ts の senriError)
+import { errorCode } from "../errors.js";
+const JA = {
+    route_duplicate: "同じメソッド・同じ形のパスが、すでに登録されています(パラメーター名だけが違うものも同じとみなします)。あとから登録したほうは呼ばれません",
+    param_empty: "パラメーター名が空です(\":\" のあとに名前を書いてください)",
+    param_twice: "1つのパスで、同じパラメーター名が2回使われています",
+    method_invalid: "メソッド名に使えない文字があります",
+    method_unsupported: "CONNECT / TRACE / TRACK は扱いません(登録できません)",
+    no_handler: "ハンドラーがありません。app.get(path, { params, query, body }, handler) のように、スキーマのあとにハンドラーを渡してください",
+    no_middleware: "ミドルウェアがありません",
+    no_method: "メソッドがありません",
+    on_all: "すべてのメソッドで動かすには app.all() を使ってください",
+    route_key: "ルートの書き方が違います。\"GET /hello\" のように、メソッドとパスの間にスペースを入れてください",
+    not_app: "app.route(prefix, app) には createApp() で作ったアプリを渡してください",
+    not_router: "createRouter() で作ったルーターを渡してください",
+    router_cycle: "ルーターが自分自身を含んでいます",
+    cookie_name: "Cookie の名前に使えない文字があります",
+    no_valid: "c.valid() で読めるのは、ルートに { query } や { body } のスキーマを渡したものだけです",
+    no_execution_ctx: "c.executionCtx は Cloudflare Workers で、app.fetch(req, env, ctx) として呼ばれたときだけ使えます",
+    returned_function: "ハンドラーが関数を返しました。呼び出し忘れではありませんか？",
+    returned_nothing: "ハンドラーが何も返していません(undefined / null)",
+    next_twice: "next() が2回呼ばれました。1つのミドルウェアで呼べるのは1回だけです",
+    no_response: "ミドルウェアが何も返さず、next() も呼んでいません",
+};
+// 日本語の説明(なければ null)
+export function explainText(err) {
+    const code = errorCode(err);
+    return code ? (JA[code] ?? null) : null;
+}
+// エラーの message の前に、日本語の説明を付ける(code や種類はそのまま)
+export function explain(err) {
+    const ja = explainText(err);
+    if (ja && err instanceof Error && !err.message.startsWith(ja))
+        err.message = `${ja}\n${err.message}`;
+    return err;
+}

package/dist/src/dev/hints.js

@@ -1,3 +1,6 @@
+// よくあるエラーに、直し方のヒントを付ける(ルールベース。当てはまらなければ何も出さない)
+// エラーメッセージの書き方はランタイムで違う(Bun と、V8 の Node / Deno)ので、両方を見る
+import { errorCode } from "../errors.js";
 // 利用者のコードが投げたエラーか(ランタイム内部のフレームは飛ばして、いちばん上を見る)
 // スタックが分からなければ、利用者のものとして扱う
 function thrownByUser(frames) {
@@ -16,16 +19,16 @@ function propertyOfNothing(message) {
 }
 const rules = [
     // Senri 自身が投げるエラー
-    (err) => err.message.startsWith("next() が2回呼ばれました")
+    (err) => errorCode(err) === "next_twice"
         ? {
             text: "1つのミドルウェアで `next()` を2回呼んでいます。`await next()` は1回だけにして、結果を変数に入れて使ってください。",
             code: "const res = await next();",
         }
         : null,
-    (err) => err.message.startsWith("ハンドラーが関数を返しました")
+    (err) => errorCode(err) === "returned_function"
         ? { text: "関数を呼び出さずに返しています。`()` を付けて呼び出した結果を返してください。", code: "return getUser();" }
         : null,
-    (err) => err.message.startsWith("ハンドラーが何も返していません")
+    (err) => errorCode(err) === "returned_nothing"
         ? { text: "ハンドラーが値を返していません。`return` を忘れていないか確かめてください。", code: 'return "ok";' }
         : null,
     // undefined / null のプロパティを読んだ

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

@@ -1,6 +1,3 @@
-import type { Dashboard } from "./dashboard/index.ts";
-export { finishErrorPage, withErrorPage } from "./pages.ts";
-export { createDashboard, type Dashboard } from "./dashboard/index.ts";
-export { serverTimingHeader, withServerTiming } from "./server-timing.ts";
-export declare function registerDashboard(app: object, dashboard: Dashboard): void;
-export declare function dashboardOf(app: object): Promise<Dashboard | undefined>;
+import type { DevHooks } from "../app.ts";
+export declare function devtools(): DevHooks | undefined;
+export declare function isLocalUrl(url: string): boolean;

package/dist/src/dev/index.js

@@ -1,11 +1,185 @@
-export { finishErrorPage, withErrorPage } from "./pages.js";
-export { createDashboard } from "./dashboard/index.js";
-export { serverTimingHeader, withServerTiming } from "./server-timing.js";
-// アプリとダッシュボードの対応(テストで中身を確かめるのに使う)
-const dashboards = new WeakMap();
-export function registerDashboard(app, dashboard) {
-    dashboards.set(app, dashboard);
-}
-export async function dashboardOf(app) {
-    return dashboards.get(app);
+import { Context } from "../context.js";
+import { compose } from "../compose.js";
+import { defaultNotFound, defaultOnError, errorCode, HttpError } from "../errors.js";
+import { compareRoutes } from "../router.js";
+import * as runtime from "../runtime.js";
+import { ValidationError } from "../validate.js";
+import { createDashboard } from "./dashboard/index.js";
+import { registerDashboard } from "./registry.js";
+import { explain } from "./explain.js";
+import { devNotFound } from "./not-found.js";
+import { finishErrorPage, withErrorPage } from "./pages.js";
+import { serverTimingHeader, withServerTiming } from "./server-timing.js";
+import { checkSchemas, describeValidation } from "./validation.js";
+// 計測で、いちばん内側の層に付ける名前(ダッシュボードの玉ねぎタイムラインに出る)
+const INNER_NAME = {
+    route: "handler",
+    notFound: "notFound",
+    methodNotAllowed: "405",
+    options: "options",
+    badRequest: "400",
+    notImplemented: "501",
+};
+// 開発モードのフックを作る。本番(NODE_ENV=production)では undefined を返すので、開発モードにならない
+// Deno で NODE_ENV を読む許可がないときは、本番かどうか分からないので、開発モードにしない(案内を1行出す)
+export function devtools() {
+    if (!runtime.canReadEnv("NODE_ENV")) {
+        console.warn("[senri] devtools() is off: NODE_ENV is not readable. Run with --allow-env=NODE_ENV to enable it. / NODE_ENV を読めないので devtools() は無効です。--allow-env=NODE_ENV を付けると使えます");
+        return undefined;
+    }
+    if (runtime.env("NODE_ENV") === "production")
+        return undefined;
+    // Workers(nodejs_compat で process があっても、NODE_ENV はふつう入っていない)とブラウザは、本番かどうか分からない
+    const localOnly = runtime.isWorkers() || typeof globalThis.process === "undefined";
+    return { install: (core) => install(core, localOnly) };
+}
+// request.url のホスト名が localhost か(Host や X-Forwarded-Host などのヘッダーは見ない。だれでも付けられるので)
+// - Workers: Cloudflare は登録されたドメインのリクエストしか渡さないので、本番に localhost は来ない。wrangler dev は localhost
+// - ブラウザ: Service Worker が受けるリクエストの URL は、そのサイトのオリジン。開発中だけ localhost になる
+export function isLocalUrl(url) {
+    let host;
+    try {
+        host = new URL(url).hostname.toLowerCase();
+    }
+    catch {
+        return false;
+    }
+    return (host === "localhost" ||
+        host.endsWith(".localhost") ||
+        host === "[::1]" ||
+        /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(host));
+}
+// パスが /_senri か /_senri/... なら、"_senri" より後ろのセグメント。そうでなければ null
+function underDashboard(c) {
+    try {
+        return c.segments[0] === "_senri" ? c.segments.slice(1) : null;
+    }
+    catch {
+        return null;
+    }
+}
+// 層ごとの時間を c.timings に記録する(src/compose.ts の Trace)
+function measure(c, origin, layers, innerName) {
+    const starts = [];
+    const inner = [];
+    return {
+        enter(i) {
+            starts[i] = performance.now();
+            inner[i] = 0;
+        },
+        down(i) {
+            const start = performance.now();
+            return () => (inner[i] += performance.now() - start);
+        },
+        leave(i, failed, stopped) {
+            const total = performance.now() - starts[i];
+            c.timings[i] = {
+                name: layers[i]?.name ?? innerName,
+                total,
+                self: total - inner[i],
+                failed,
+                start: starts[i] - origin,
+                stopped,
+            };
+        },
+    };
+}
+// 開発モードの既定の onError。本番の固定の文言の代わりに、詳しい文言を返す
+// (ブラウザから開いた 5xx は、withErrorPage がエラーページにする)
+const devOnError = (err, c) => {
+    if (err instanceof ValidationError)
+        return c.text(describeValidation(err));
+    if (err instanceof HttpError) {
+        switch (errorCode(err)) {
+            case "method_not_allowed":
+                return c.text(`405 Method Not Allowed: ${c.req.method} ${c.path}\n${err.headers.get("allow")} ならあります`);
+            case "query_no_body":
+                return c.text("400 Bad Request: QUERY リクエストにボディがありません\nQUERY は、検索の条件をボディに入れて送るメソッドです");
+            case "query_no_type":
+                return c.text("415 Unsupported Media Type: QUERY リクエストに Content-Type がありません\nボディの形式を指定してください(例: Content-Type: application/json)");
+        }
+        return c.text(err.message);
+    }
+    explain(err);
+    return c.text(`500 Internal Server Error: ${err instanceof Error ? err.message : String(err)}`);
+};
+// localOnly: localhost へのリクエストのときだけ開発用の出力をする(Workers とブラウザ)
+function install(core, localOnly) {
+    const { app } = core;
+    // 本番と同じに振る舞うリクエスト(localOnly で、localhost でないもの)
+    const quiet = new WeakSet();
+    // 一覧は優先順位の順(静的なセグメントが先)。本体は登録順に持っている
+    const sortedRoutes = () => [...core.routes()].sort(compareRoutes);
+    // ダッシュボード。Cloudflare Workers では作らない(接続元が分からず localhost 制限で開けないうえ、
+    // リクエストごとに別の isolate で動くことがあり、記録が残らない)。/_senri はふつうの 404 になる
+    const dashboard = runtime.isWorkers()
+        ? null
+        : createDashboard({
+            routes: () => sortedRoutes().map((r) => ({ method: r.method, path: r.path })),
+            middlewares: () => app.middlewareList(),
+        });
+    if (dashboard)
+        registerDashboard(app, dashboard);
+    async function fetch(req, info, ctx) {
+        // 計測の基準になるリクエストの開始時刻
+        const origin = performance.now();
+        const time = Date.now();
+        const c = new Context(req, info, ctx);
+        if (localOnly && !isLocalUrl(req.url))
+            return quietFetch(c);
+        // /_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);
+        // ミドルウェアより先にマッチして、c.route / c.params を見られるようにしておく
+        const resolved = core.resolve(c);
+        if (resolved.kind === "route") {
+            c.route = resolved.route.path;
+            c.params = resolved.params;
+        }
+        // ハンドラー・notFound・toResponse のどこで投げても、compose が onError に集める
+        const layers = core.layers(c);
+        const innerName = INNER_NAME[resolved.kind];
+        const res = await compose(layers, c, () => core.inner(c, resolved), (err) => core.fail(err, c), measure(c, origin, layers, innerName));
+        // ミドルウェアを全部通ったあとなので、ここなら「通った順番」が揃っている
+        const page = await finishErrorPage(c, res);
+        // 層ごとの時間を Server-Timing に載せる(ブラウザの開発者ツールで見られる)
+        const desc = resolved.kind === "route" ? `${resolved.route.method} ${resolved.route.path}` : innerName;
+        const final = withServerTiming(c.finalize(page), 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;
+    }
+    // 本番の fetch と同じ流れ(計測・記録・エラーページ・Server-Timing なし。onError / notFound も本番の既定になる)
+    function quietFetch(c) {
+        quiet.add(c);
+        const resolved = core.resolve(c);
+        if (resolved.kind === "route") {
+            c.route = resolved.route.path;
+            c.params = resolved.params;
+        }
+        return compose(core.layers(c), c, () => core.inner(c, resolved), (err) => core.fail(err, c)).then((res) => c.finalize(res));
+    }
+    const pageOnError = withErrorPage(devOnError, true);
+    return {
+        fetch,
+        onError: (err, c) => (quiet.has(c) ? defaultOnError(err, c) : pageOnError(err, c)),
+        notFound: (c) => (quiet.has(c) ? defaultNotFound(c) : devNotFound(c, sortedRoutes())),
+        checkRoute(method, path, schemas) {
+            if (schemas)
+                checkSchemas(path, schemas);
+            // /_senri 以下はダッシュボードが使うので、登録しても呼ばれない。気づけるようにエラーにする
+            if (dashboard && /^\/*_senri(\/|$)/.test(path)) {
+                throw new Error(`${method} ${path}: /_senri 以下は、開発モードではダッシュボード用に予約されています`);
+            }
+        },
+        explain,
+    };
 }

package/dist/src/dev/not-found.d.ts

@@ -0,0 +1,3 @@
+import type { Context, HandlerResult } from "../context.ts";
+import type { Route } from "../router.ts";
+export declare function devNotFound(c: Context, routes: Route[]): HandlerResult | Promise<HandlerResult>;

package/dist/src/dev/not-found.js

@@ -0,0 +1,15 @@
+import { notFoundPage } from "./not-found-page.js";
+import { wantsHtml } from "./render.js";
+import { suggest } from "./suggest.js";
+export function devNotFound(c, routes) {
+    if (wantsHtml(c.req))
+        return notFoundPage(c, routes);
+    // ルートと同じく、デコード・正規化したパスで比べる(notFound に来るのはデコードできたリクエストだけ)
+    const path = c.path;
+    let message = `404 Not Found: ${c.req.method} ${path}`;
+    const closest = suggest(routes, path);
+    if (closest) {
+        message += `\nもしかして: ${closest.method} ${closest.path} ?`;
+    }
+    return c.text(message);
+}

package/dist/src/dev/registry.d.ts

@@ -0,0 +1,3 @@
+import type { Dashboard } from "./dashboard/index.ts";
+export declare function registerDashboard(app: object, dashboard: Dashboard): void;
+export declare function dashboardOf(app: object): Promise<Dashboard | undefined>;

package/dist/src/dev/registry.js

@@ -0,0 +1,7 @@
+const dashboards = new WeakMap();
+export function registerDashboard(app, dashboard) {
+    dashboards.set(app, dashboard);
+}
+export async function dashboardOf(app) {
+    return dashboards.get(app);
+}

package/dist/src/dev/validation.d.ts

@@ -0,0 +1,3 @@
+import type { RouteSchemas, ValidationError } from "../validate.ts";
+export declare function describeValidation(err: ValidationError): string;
+export declare function checkSchemas(path: string, schemas: RouteSchemas): void;

package/dist/src/dev/validation.js

@@ -0,0 +1,47 @@
+// バリデーションの、開発モードだけの部分(本体を小さくするため、本体の src/validate.ts から分けている)
+// - 登録した時点で、スキーマの書き間違いに気づけるようにする
+// - 通らなかったとき、どこが違うかを一覧にする
+import { senriError } from "../errors.js";
+const LABEL = {
+    params: "パスパラメーター",
+    query: "クエリ",
+    body: "ボディ",
+};
+// ["user", 0, "name"] → "user[0].name"
+function issuePath(issue) {
+    let out = "";
+    for (const part of issue.path ?? []) {
+        const key = typeof part === "object" ? part.key : part;
+        if (typeof key === "number")
+            out += `[${key}]`;
+        else
+            out += out ? `.${String(key)}` : String(key);
+    }
+    return out;
+}
+// 開発モードで返す、どこが違うかの一覧
+export function describeValidation(err) {
+    const lines = err.issues.map((issue) => {
+        const path = issuePath(issue);
+        return `- ${path ? `${path}: ` : ""}${issue.message}`;
+    });
+    return [`400 Bad Request: ${LABEL[err.target]}が、スキーマに合いません`, ...lines].join("\n");
+}
+// ArkType のスキーマは関数なので、オブジェクトでも関数でもよい
+function isSchema(value) {
+    return (typeof value === "object" || typeof value === "function") && value !== null && "~standard" in value;
+}
+// スキーマを確かめておく(書き間違いに、登録した時点で気づけるように)
+export function checkSchemas(path, schemas) {
+    if (typeof schemas !== "object" || schemas === null) {
+        throw senriError("schema_shape", new TypeError(`${path}: 2つ目の引数には { params, query, body } のスキーマかハンドラーを渡してください`));
+    }
+    for (const [key, schema] of Object.entries(schemas)) {
+        if (key !== "params" && key !== "query" && key !== "body") {
+            throw senriError("schema_key", new TypeError(`${path}: スキーマに渡せるのは params / query / body だけです("${key}" は使えません)`));
+        }
+        if (schema !== undefined && !isSchema(schema)) {
+            throw senriError("schema_type", new TypeError(`${path}: ${key} が Standard Schema のスキーマではありません(Zod・Valibot・ArkType などのスキーマを渡してください)`));
+        }
+    }
+}

package/dist/src/errors.d.ts

@@ -1,5 +1,4 @@
 import type { Context, HandlerResult } from "./context.ts";
-import type { Route } from "./router.ts";
 export declare class HttpError extends Error {
     status: number;
     headers: Headers;
@@ -17,7 +16,10 @@ export declare function conversionOriginOf(err: unknown): ConversionOrigin | nul
 export type ErrorHandler<V extends object = any> = (err: unknown, c: Context<V>) => HandlerResult | Promise<HandlerResult>;
 export type NotFoundHandler<V extends object = any> = (c: Context<V>) => HandlerResult | Promise<HandlerResult>;
 export declare function handleError(err: unknown, c: Context, onError: ErrorHandler): Promise<Response>;
-export declare function defaultOnError(dev: boolean): ErrorHandler;
-export declare function methodNotAllowed(c: Context, path: string, methods: string, dev: boolean): HttpError;
-export declare function checkQueryRequest(c: Context, dev: boolean): Promise<HttpError | null>;
-export declare function defaultNotFound(routes: Route[], dev: boolean): NotFoundHandler;
+export declare function senriError<E extends Error>(code: string, error: E): E;
+export declare function senriError(code: string, message: string): Error;
+export declare function errorCode(err: unknown): string | undefined;
+export declare const defaultOnError: ErrorHandler;
+export declare const defaultNotFound: NotFoundHandler;
+export declare function methodNotAllowed(methods: string): HttpError;
+export declare function checkQueryRequest(c: Context): Promise<HttpError | null>;