@gusnips/server 0.1.0

package/dist/errors.js

@@ -0,0 +1,154 @@
+/**
+ * The one error a route throws, and the one function that turns any thrown value into words.
+ *
+ * Extracted from six backends whose copies of this file are byte-identical in the parts that
+ * matter: the envelope builder in four of them, `toMessage()` in six. Where they differ, the
+ * version carrying the production reason won — every comment below names a failure somebody
+ * shipped.
+ *
+ * Nothing here knows about the wire. That is deliberate and it is the fix to a live bug; see
+ * the note on {@link AppError}.
+ */
+import { narrowErrorLike } from "./logger/serialize.js";
+/**
+ * The one error type routes throw; {@link errorResponse} formats the envelope.
+ *
+ * `Code` is your product's error-code union and `Key` its message-key union. Neither is
+ * shipped here: across six donors the factory tables hold 46 distinct code names and exactly
+ * nine appear in all six. The codes are an API's vocabulary. What this package ships is the
+ * shape, the wire format and the mask.
+ *
+ * Prefer {@link createAppError} over `new AppError(…)`: it reads the status off your own
+ * code→status map, so no call site names a status and a code added without one is a build
+ * error.
+ *
+ * Constructing one directly is the one path where a 429 with no wait is still representable:
+ * the rule lives on the factory, because only the factory knows the map. That is the reason to
+ * prefer it, not a style note.
+ *
+ * **There is no `toJSON()`, on purpose**, and the reason is not the one first written here.
+ * `JSON.stringify` calls a value's own `toJSON()` BEFORE the replacer, so an error class that
+ * defines one hands a logger whatever that method returns instead of the error. Seven backends
+ * define one, and every one of them logs `{"error":{"error":{code,message}}}` — doubly nested,
+ * no `stack`, no `cause` — from a line that still looks like a log line.
+ *
+ * This file used to say a logger cannot fix that from its side. It can, and ours does: the
+ * replacer is called with the HOLDER as `this`, whose own property is still the untouched error
+ * (see `errorReplacer`). What remains true is the design: the wire body is built by
+ * `errorResponse`, where the mask lives anyway, so one function owns the shape a client sees —
+ * and this stays an ordinary Error to anything that serializes it.
+ */
+export class AppError extends Error {
+    statusCode;
+    code;
+    details;
+    messageKey;
+    params;
+    retryAfterSecs;
+    expose;
+    constructor(statusCode, code, message, opts = {}) {
+        super(message, { cause: opts.cause });
+        this.name = "AppError";
+        this.statusCode = statusCode;
+        this.code = code;
+        this.details = opts.details;
+        this.messageKey = opts.messageKey;
+        this.params = opts.params;
+        this.retryAfterSecs = opts.retryAfterSecs;
+        this.expose = opts.expose ?? false;
+    }
+}
+/**
+ * Binds your code→status map, and returns the factory your `errors.*` table calls.
+ *
+ * ```ts
+ * const ERROR_STATUS = {
+ *   NOT_FOUND: 404,
+ *   RATE_LIMIT_EXCEEDED: 429,
+ * } as const satisfies Record<ErrorCode, number>;
+ *
+ * const appError = createAppError<typeof ERROR_STATUS, MessageKey>(ERROR_STATUS);
+ *
+ * export const errors = {
+ *   notFound: (what = "Resource") => appError("NOT_FOUND", `${what} not found`),
+ *   rateLimit: (retryAfterSecs: number) =>
+ *     appError("RATE_LIMIT_EXCEEDED", "Too many requests", { retryAfterSecs }),
+ * };
+ * ```
+ *
+ * The `satisfies` on your map is what makes a code with no status a build error — one line,
+ * in your repo, and the only version of this that cannot drift. Three of the five newest
+ * donors pass the status at every call site instead, which compiles no matter what.
+ */
+export function createAppError(statusOf) {
+    return (code, message, ...opts) => 
+    // A code with no status is a build error at your `satisfies`. One reaching here anyway —
+    // a map assembled at runtime, a code narrowed off the wire — is our bug, not the caller's.
+    new AppError(statusOf[code] ?? 500, code, message, opts[0]);
+}
+/**
+ * `JSON.stringify` that never throws and never answers `"[object Object]"`.
+ *
+ * Private on purpose: it exists for {@link toMessage}'s last branch. A logger wants a richer
+ * one (an allow-list over an error's own fields), which is a different function.
+ */
+function safeStringify(value) {
+    const seen = new WeakSet();
+    try {
+        return (JSON.stringify(value, (_key, val) => {
+            if (val instanceof Error)
+                return { name: val.name, message: val.message };
+            if (typeof val === "bigint")
+                return val.toString();
+            if (typeof val === "object" && val !== null) {
+                if (seen.has(val))
+                    return "[Circular]";
+                seen.add(val);
+            }
+            return val;
+        }) ?? "null");
+    }
+    catch {
+        return "[unserializable]";
+    }
+}
+/**
+ * Turn any thrown value into a string.
+ *
+ * The single home for the `err instanceof Error ? err.message : String(err)` idiom, which is
+ * wrong twice over and shipped that way in six repos:
+ *
+ * 1. A data layer rejects with a PLAIN OBJECT — `{code, message, hint}` is what PostgREST and
+ *    several drivers throw — so the useful text is in `message` and `String()` never reads it.
+ *    Six donors fixed this half.
+ * 2. An object with no string `message` still flattens to `"[object Object]"`, which is the
+ *    real failure masked by a useless string. One donor fixed that half and named it exactly:
+ *    *"masking the real failure."* Its version is the one here.
+ */
+export function toMessage(err) {
+    if (err instanceof Error)
+        return err.message;
+    if (typeof err === "string")
+        return err;
+    if (typeof err === "object" && err !== null) {
+        const { message } = err;
+        if (typeof message === "string")
+            return message;
+        // With no message to read, the object itself has to say what failed — and it cannot be
+        // printed whole. This string becomes an Error's `message` in `errorBoundary`, and a message
+        // is printed, so an SDK that rejects with the request it sent would put that request in the
+        // log through here. Same allow-list as the log serializer, one step earlier.
+        const kept = narrowErrorLike(err);
+        if (Object.keys(kept).length > 0)
+            return safeStringify(kept);
+        // Nothing printable left. `{}` would be the "[object Object]" failure again in a new
+        // spelling: a useless string standing where the real failure was. The key names come from
+        // whoever threw, never from a caller, so they are the part that still identifies it.
+        const keys = Object.keys(err);
+        return keys.length > 0
+            ? `An object was thrown with no message. Its keys: ${keys.join(", ")}.`
+            : "An object was thrown with no message and no fields.";
+    }
+    return String(err);
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"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"}

package/dist/hono/errors.d.ts

@@ -0,0 +1,46 @@
+import type { Context, ErrorHandler, MiddlewareHandler, NotFoundHandler } from "hono";
+import type { Logger } from "../logger/index.ts";
+import type { ErrorAnswer } from "../responses.ts";
+import type { RequestVariables } from "./request-logger.ts";
+/**
+ * The app's own env, taken from the `onError` / `notFound` call it is passed to, so its bindings
+ * and variables fit as they are. The code type comes from its `errorCode`, which is what stops
+ * `errorResponse` from answering a code that slot cannot hold.
+ */
+type ErrorEnv = {
+    Variables: RequestVariables;
+};
+type CodeOf<E extends ErrorEnv> = NonNullable<E["Variables"]["errorCode"]>;
+/**
+ * Turns a thrown non-`Error` into an `Error`, so it reaches `onError`.
+ *
+ * Hono hands `onError` only what is `instanceof Error`. Anything else is rethrown past every
+ * layer and escapes as an unhandled rejection: no answer, a dropped connection, and a browser that
+ * reports it as a CORS failure — which sends whoever reads it to the wrong layer. A PostgREST
+ * client rejects with plain objects, so this is not hypothetical. The original rides as `cause`.
+ *
+ * Mount it right after `requestLogger`.
+ */
+export declare const errorBoundary: MiddlewareHandler;
+export interface ErrorHandlerOptions<E extends ErrorEnv> {
+    /** Your bound `createErrorResponse(...)`. */
+    errorResponse: (err: unknown) => ErrorAnswer<CodeOf<E>>;
+    logger: Logger;
+    /**
+     * Called for a throw nobody raised on purpose, which is where an alert belongs. It runs inside
+     * `onError`, so it must not throw, and anything slow should be sent without being awaited.
+     */
+    onUnexpected?: (err: unknown, c: Context<E>) => void;
+}
+/**
+ * `app.onError(errorHandler({ errorResponse, logger }))`.
+ *
+ * A refusal under 500 writes no line of its own: its code rides on the request line, because one
+ * line per wrong password buries the failures that need a human. A 5xx and an escaped throw are
+ * logged with the raw error, stack and cause included.
+ */
+export declare function errorHandler<E extends ErrorEnv>({ errorResponse, logger, onUnexpected, }: ErrorHandlerOptions<E>): ErrorHandler<E>;
+/** `app.notFound(notFoundHandler(errorResponse(errors.notFound("Route"))))`. */
+export declare const notFoundHandler: <E extends ErrorEnv>(answer: ErrorAnswer<CodeOf<E>>) => NotFoundHandler<E>;
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/hono/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/hono/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AAGtF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D;;;;GAIG;AACH,KAAK,QAAQ,GAAG;IAAE,SAAS,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAChD,KAAK,MAAM,CAAC,CAAC,SAAS,QAAQ,IAAI,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC;AAE3E;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,EAAE,iBAO3B,CAAC;AAEF,MAAM,WAAW,mBAAmB,CAAC,CAAC,SAAS,QAAQ;IACrD,6CAA6C;IAC7C,aAAa,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IACxD,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;CACtD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,QAAQ,EAAE,EAC/C,aAAa,EACb,MAAM,EACN,YAAY,GACb,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAY1C;AAED,gFAAgF;AAChF,eAAO,MAAM,eAAe,GACzB,CAAC,SAAS,QAAQ,EAAE,QAAQ,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAG,eAAe,CAAC,CAAC,CAEnD,CAAC"}

package/dist/hono/errors.js

@@ -0,0 +1,54 @@
+import { toMessage } from "../errors.js";
+/**
+ * Turns a thrown non-`Error` into an `Error`, so it reaches `onError`.
+ *
+ * Hono hands `onError` only what is `instanceof Error`. Anything else is rethrown past every
+ * layer and escapes as an unhandled rejection: no answer, a dropped connection, and a browser that
+ * reports it as a CORS failure — which sends whoever reads it to the wrong layer. A PostgREST
+ * client rejects with plain objects, so this is not hypothetical. The original rides as `cause`.
+ *
+ * Mount it right after `requestLogger`.
+ */
+export const errorBoundary = async (_c, next) => {
+    try {
+        await next();
+    }
+    catch (err) {
+        if (err instanceof Error)
+            throw err;
+        throw new Error(toMessage(err), { cause: err });
+    }
+};
+/**
+ * `app.onError(errorHandler({ errorResponse, logger }))`.
+ *
+ * A refusal under 500 writes no line of its own: its code rides on the request line, because one
+ * line per wrong password buries the failures that need a human. A 5xx and an escaped throw are
+ * logged with the raw error, stack and cause included.
+ */
+export function errorHandler({ errorResponse, logger, onUnexpected, }) {
+    return (err, c) => {
+        const answer = errorResponse(err);
+        if (answer.kind !== "client")
+            logger.error("request failed", {
+                requestId: c.get("requestId"),
+                kind: answer.kind,
+                error: err,
+            });
+        if (answer.kind === "unexpected")
+            onUnexpected?.(err, c);
+        return respond(c, answer);
+    };
+}
+/** `app.notFound(notFoundHandler(errorResponse(errors.notFound("Route"))))`. */
+export const notFoundHandler = (answer) => (c) => respond(c, answer);
+function respond(c, answer) {
+    // An error answered as a 2xx reads as success to every client. Thrown instead, it comes back
+    // through onError as the unexpected throw it is: the generic 500, logged, and alerted on.
+    if (!isErrorStatus(answer.status))
+        throw new RangeError(`An error answered ${answer.status}.`);
+    c.set("errorCode", answer.body.error.code);
+    return c.json(answer.body, answer.status, answer.headers);
+}
+const isErrorStatus = (status) => status >= 400 && status <= 599;
+//# sourceMappingURL=errors.js.map

package/dist/hono/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/hono/errors.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAazC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,aAAa,GAAsB,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE;IACjE,IAAI,CAAC;QACH,MAAM,IAAI,EAAE,CAAC;IACf,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,IAAI,GAAG,YAAY,KAAK;YAAE,MAAM,GAAG,CAAC;QACpC,MAAM,IAAI,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;IAClD,CAAC;AACH,CAAC,CAAC;AAaF;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAqB,EAC/C,aAAa,EACb,MAAM,EACN,YAAY,GACW;IACvB,OAAO,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE;QAChB,MAAM,MAAM,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ;YAC1B,MAAM,CAAC,KAAK,CAAC,gBAAgB,EAAE;gBAC7B,SAAS,EAAE,CAAC,CAAC,GAAG,CAAC,WAAW,CAAC;gBAC7B,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,KAAK,EAAE,GAAG;aACX,CAAC,CAAC;QACL,IAAI,MAAM,CAAC,IAAI,KAAK,YAAY;YAAE,YAAY,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QACzD,OAAO,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IAC5B,CAAC,CAAC;AACJ,CAAC;AAED,gFAAgF;AAChF,MAAM,CAAC,MAAM,eAAe,GAC1B,CAAqB,MAA8B,EAAsB,EAAE,CAC3E,CAAC,CAAC,EAAE,EAAE,CACJ,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AAEvB,SAAS,OAAO,CAAqB,CAAa,EAAE,MAA8B;IAChF,6FAA6F;IAC7F,0FAA0F;IAC1F,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,qBAAqB,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;IAC/F,CAAC,CAAC,GAAG,CAAC,WAAW,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3C,OAAO,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;AAC5D,CAAC;AAED,MAAM,aAAa,GAAG,CAAC,MAAc,EAAkC,EAAE,CACvE,MAAM,IAAI,GAAG,IAAI,MAAM,IAAI,GAAG,CAAC"}

package/dist/hono/guards.d.ts

@@ -0,0 +1,45 @@
+import type { Hono, MiddlewareHandler } from "hono";
+/**
+ * Marks a middleware as one that decides who may pass, for `assertEveryRouteGuarded`. Returns the
+ * same function. Mark it where it is defined, so every place it is mounted counts.
+ *
+ *     export const requireAdmin = guard(async (c, next) => { … });
+ */
+export declare function guard<H extends MiddlewareHandler>(middleware: H): H;
+export interface GuardCheckOptions {
+    /**
+     * The app's own rule for what anyone may call, asked with the path a request would carry:
+     * `/people/:id` is asked as `/people/probe`, `/reports/:id{[0-9]+}` as `/reports/1`. Pass the
+     * predicate or the list the app itself uses, never a second one kept for the test: an exemption
+     * list nothing else reads is the next thing to drift. `underAny(list)` reads a list as prefixes.
+     */
+    isPublic: (path: string) => boolean;
+}
+/**
+ * "Under one of these", reading each entry as a prefix whichever pattern form it holds:
+ * `/feedback` and `/feedback/*` both cover `/feedback` and `/feedback/mine`, and neither covers
+ * `/feedbacks`. Hono reads `use("/feedback")` as that one path, which is how the route under it
+ * once shipped public while the list said it was guarded.
+ */
+export declare function underAny(prefixes: readonly string[]): (path: string) => boolean;
+/**
+ * Throws, naming every endpoint no guard runs in front of, and every guard that runs in front of
+ * nothing. Build the real app, and call it in a test once every route is registered: the first
+ * match freezes Hono's router.
+ *
+ * It asks Hono's own router what would run for each of the app's real routes, and in what order,
+ * rather than comparing patterns. A pattern list cannot see order, and order is the whole bug: a
+ * `use()` registered after its route matches that route and never runs for it, because the
+ * handler answers first. Only the matcher tells a guard that never fires from one that does.
+ *
+ * A guard in front of nothing is the trace a router leaves when it mounted no routes, which is
+ * what a stand-in dependency's router does in a test: its routes drop out of the check, and the
+ * check would pass by having nothing to ask. A guard inside that router drops out with it, so a
+ * stand-in that yields a router should throw when Hono reads its `routes`.
+ *
+ * An endpoint is what Hono's own route inspector calls one, a handler taking fewer than two
+ * arguments. So a `(c, next)` handler that answers is not checked, and a path whose parameter
+ * pattern rejects the probe is reported as unprobeable rather than passed.
+ */
+export declare function assertEveryRouteGuarded(app: Pick<Hono, "routes" | "router">, { isPublic }: GuardCheckOptions): void;
+//# sourceMappingURL=guards.d.ts.map

package/dist/hono/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../src/hono/guards.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAOpD;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,iBAAiB,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,CAGnE;AAED,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;CACrC;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAG/E;AAID;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,IAAI,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAC,EACpC,EAAE,QAAQ,EAAE,EAAE,iBAAiB,GAC9B,IAAI,CA2CN"}

package/dist/hono/guards.js

@@ -0,0 +1,88 @@
+import { METHODS } from "hono/router";
+import { findTargetHandler, isMiddleware } from "hono/utils/handler";
+const GUARD = Symbol.for("@gusnips/server/hono:guard");
+/**
+ * Marks a middleware as one that decides who may pass, for `assertEveryRouteGuarded`. Returns the
+ * same function. Mark it where it is defined, so every place it is mounted counts.
+ *
+ *     export const requireAdmin = guard(async (c, next) => { … });
+ */
+export function guard(middleware) {
+    Object.defineProperty(middleware, GUARD, { value: true });
+    return middleware;
+}
+/**
+ * "Under one of these", reading each entry as a prefix whichever pattern form it holds:
+ * `/feedback` and `/feedback/*` both cover `/feedback` and `/feedback/mine`, and neither covers
+ * `/feedbacks`. Hono reads `use("/feedback")` as that one path, which is how the route under it
+ * once shipped public while the list said it was guarded.
+ */
+export function underAny(prefixes) {
+    const bases = prefixes.map((prefix) => prefix.replace(/\/\*$/, ""));
+    return (path) => bases.some((base) => path === base || path.startsWith(`${base}/`));
+}
+const isGuard = (handler) => GUARD in findTargetHandler(handler);
+/**
+ * Throws, naming every endpoint no guard runs in front of, and every guard that runs in front of
+ * nothing. Build the real app, and call it in a test once every route is registered: the first
+ * match freezes Hono's router.
+ *
+ * It asks Hono's own router what would run for each of the app's real routes, and in what order,
+ * rather than comparing patterns. A pattern list cannot see order, and order is the whole bug: a
+ * `use()` registered after its route matches that route and never runs for it, because the
+ * handler answers first. Only the matcher tells a guard that never fires from one that does.
+ *
+ * A guard in front of nothing is the trace a router leaves when it mounted no routes, which is
+ * what a stand-in dependency's router does in a test: its routes drop out of the check, and the
+ * check would pass by having nothing to ask. A guard inside that router drops out with it, so a
+ * stand-in that yields a router should throw when Hono reads its `routes`.
+ *
+ * An endpoint is what Hono's own route inspector calls one, a handler taking fewer than two
+ * arguments. So a `(c, next)` handler that answers is not checked, and a path whose parameter
+ * pattern rejects the probe is reported as unprobeable rather than passed.
+ */
+export function assertEveryRouteGuarded(app, { isPublic }) {
+    const endpoints = app.routes.filter((route) => !isMiddleware(findTargetHandler(route.handler)));
+    if (endpoints.length === 0)
+        throw new Error("The app has no endpoints to check, so the check would pass by asking nothing.");
+    const idle = new Set(app.routes.filter((route) => isGuard(route.handler)));
+    const unguarded = new Set();
+    for (const route of endpoints) {
+        const { method, path } = route;
+        const probe = path.replace(/:\w+\{[^}]*\}\??/g, "1").replace(/:\w+\??|\*/g, "probe");
+        const open = isPublic(probe);
+        for (const each of method === "ALL" ? METHODS.map((m) => m.toUpperCase()) : [method]) {
+            const [matched] = app.router.match(each, probe);
+            const at = matched.findIndex(([[, candidate]]) => candidate === route);
+            const ahead = matched.slice(0, Math.max(at, 0)).filter(([[handler]]) => isGuard(handler));
+            for (const [[, guardRoute]] of ahead)
+                idle.delete(guardRoute);
+            if (open)
+                continue;
+            if (at === -1)
+                unguarded.add(`${method} ${path} (could not be probed at ${probe})`);
+            else if (ahead.length === 0)
+                unguarded.add(`${method} ${path}`);
+        }
+    }
+    if (unguarded.size === 0 && idle.size === 0)
+        return;
+    const list = (lines) => [...new Set(lines)]
+        .sort()
+        .map((line) => `  ${line}\n`)
+        .join("");
+    const idleLines = [...idle].map((route) => `${route.method} ${route.path}`);
+    throw new Error((unguarded.size > 0
+        ? `${String(unguarded.size)} endpoint(s) answer with no guard running in front of them:\n` +
+            list(unguarded)
+        : "") +
+        (idle.size > 0
+            ? `${String(new Set(idleLines).size)} guard(s) run in front of no endpoint:\n` +
+                list(idleLines)
+            : "") +
+        "A guard counts when it is wrapped in guard() and registered BEFORE its routes: a use() " +
+        "added after them never runs for them. A guard in front of nothing sits after its routes, " +
+        "or over a router that mounted none. Move it up, build that router for real, or have " +
+        "isPublic say so if anyone may call the path.");
+}
+//# sourceMappingURL=guards.js.map

package/dist/hono/guards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.js","sourceRoot":"","sources":["../../src/hono/guards.ts"],"names":[],"mappings":"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"}

package/dist/hono/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `@gusnips/server/hono`: the package mounted on a Hono app.
+ *
+ *     app.use(requestLogger({ logger }));
+ *     app.use(errorBoundary);
+ *     app.onError(errorHandler({ errorResponse, logger }));
+ *     app.notFound(notFoundHandler(errorResponse(errors.notFound("Route"))));
+ *
+ * and, in a test of the real app, `assertEveryRouteGuarded(app, { isPublic })`, with the rule the
+ * app itself uses for what anyone may call.
+ */
+export { errorBoundary, errorHandler, notFoundHandler } from "./errors.ts";
+export type { ErrorHandlerOptions } from "./errors.ts";
+export { assertEveryRouteGuarded, guard, underAny } from "./guards.ts";
+export type { GuardCheckOptions } from "./guards.ts";
+export { requestLogger } from "./request-logger.ts";
+export type { RequestLoggerOptions, RequestVariables } from "./request-logger.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/hono/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hono/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC3E,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,uBAAuB,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvE,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,YAAY,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/hono/index.js

@@ -0,0 +1,15 @@
+/**
+ * `@gusnips/server/hono`: the package mounted on a Hono app.
+ *
+ *     app.use(requestLogger({ logger }));
+ *     app.use(errorBoundary);
+ *     app.onError(errorHandler({ errorResponse, logger }));
+ *     app.notFound(notFoundHandler(errorResponse(errors.notFound("Route"))));
+ *
+ * and, in a test of the real app, `assertEveryRouteGuarded(app, { isPublic })`, with the rule the
+ * app itself uses for what anyone may call.
+ */
+export { errorBoundary, errorHandler, notFoundHandler } from "./errors.js";
+export { assertEveryRouteGuarded, guard, underAny } from "./guards.js";
+export { requestLogger } from "./request-logger.js";
+//# sourceMappingURL=index.js.map

package/dist/hono/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/hono/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE3E,OAAO,EAAE,uBAAuB,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/hono/request-logger.d.ts

@@ -0,0 +1,31 @@
+import type { MiddlewareHandler } from "hono";
+import type { Logger } from "../logger/index.ts";
+/** The two variables this adapter writes. Put them in your app's `Variables`. */
+export interface RequestVariables<Code extends string = string> {
+    requestId: string;
+    /** The code of the refusal this request got, for the request line. `null` until one happens. */
+    errorCode: Code | null;
+}
+export interface RequestLoggerOptions {
+    logger: Logger;
+    /**
+     * Paths answered but never logged, each with everything under it: `/health` covers
+     * `/health/db` and not `/healthz`. Defaults to `["/health"]`. A throw is logged anyway.
+     */
+    skipPaths?: readonly string[];
+}
+/**
+ * One line per request, and the request id.
+ *
+ * Mount it first, so it times and sees everything under it:
+ *
+ *     app.use(requestLogger({ logger }));
+ *
+ * The id goes back on `X-Request-ID`, which is where the browser client reads it from, on every
+ * answer including `onError`'s and `notFound`'s. Cross-origin, list that header in your CORS
+ * `exposeHeaders` or the browser hides it from the page.
+ */
+export declare function requestLogger({ logger, skipPaths, }: RequestLoggerOptions): MiddlewareHandler<{
+    Variables: RequestVariables;
+}>;
+//# sourceMappingURL=request-logger.d.ts.map

package/dist/hono/request-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-logger.d.ts","sourceRoot":"","sources":["../../src/hono/request-logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAE9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD,iFAAiF;AACjF,MAAM,WAAW,gBAAgB,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM;IAC5D,SAAS,EAAE,MAAM,CAAC;IAClB,gGAAgG;IAChG,SAAS,EAAE,IAAI,GAAG,IAAI,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/B;AASD;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,EAC5B,MAAM,EACN,SAAuB,GACxB,EAAE,oBAAoB,GAAG,iBAAiB,CAAC;IAAE,SAAS,EAAE,gBAAgB,CAAA;CAAE,CAAC,CAmC3E"}

package/dist/hono/request-logger.js

@@ -0,0 +1,57 @@
+import { routePath } from "hono/route";
+/**
+ * A caller's id is echoed back and written into every line, so it is kept only in a shape that
+ * cannot carry anything else: 64 characters of `A-Z a-z 0-9 . _ -`. Anything else is replaced, not
+ * trimmed, so the id in the log is always either the caller's or ours.
+ */
+const REQUEST_ID = /^[A-Za-z0-9._-]{1,64}$/;
+/**
+ * One line per request, and the request id.
+ *
+ * Mount it first, so it times and sees everything under it:
+ *
+ *     app.use(requestLogger({ logger }));
+ *
+ * The id goes back on `X-Request-ID`, which is where the browser client reads it from, on every
+ * answer including `onError`'s and `notFound`'s. Cross-origin, list that header in your CORS
+ * `exposeHeaders` or the browser hides it from the page.
+ */
+export function requestLogger({ logger, skipPaths = ["/health"], }) {
+    return async (c, next) => {
+        const supplied = c.req.header("X-Request-ID");
+        const requestId = supplied && REQUEST_ID.test(supplied) ? supplied : crypto.randomUUID();
+        c.set("requestId", requestId);
+        c.set("errorCode", null);
+        const { method, path } = c.req;
+        const start = Date.now();
+        // The route TEMPLATE, never the path: a path carries whatever the caller put in it, and in one
+        // backend that was a national id number, which the request line carried into an analytics
+        // event. The last matched route rather than the deepest one that ran, so a 401 from an auth
+        // middleware is filed under the endpoint it protected.
+        const line = (status) => ({
+            requestId,
+            method,
+            route: routePath(c, -1),
+            status,
+            ms: Date.now() - start,
+            errorCode: c.get("errorCode") ?? undefined,
+        });
+        try {
+            await next();
+        }
+        catch (err) {
+            // Only what Hono would not hand to onError gets here: a non-`Error` with no `errorBoundary`
+            // above it, or a throw from onError itself. Nothing answered it, so the runtime will, and
+            // the request that most needs a line is the one that would otherwise never get one.
+            logger.error("request", { ...line(500), error: err });
+            throw err;
+        }
+        // After `next()`, not before: a header set earlier lives on a draft Hono drops when a handler
+        // returns a Response it built itself.
+        c.header("X-Request-ID", requestId);
+        const skipped = skipPaths.some((skip) => path === skip || path.startsWith(`${skip}/`));
+        if (method !== "OPTIONS" && !skipped)
+            logger.info("request", line(c.res.status));
+    };
+}
+//# sourceMappingURL=request-logger.js.map

package/dist/hono/request-logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-logger.js","sourceRoot":"","sources":["../../src/hono/request-logger.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAmBvC;;;;GAIG;AACH,MAAM,UAAU,GAAG,wBAAwB,CAAC;AAE5C;;;;;;;;;;GAUG;AACH,MAAM,UAAU,aAAa,CAAC,EAC5B,MAAM,EACN,SAAS,GAAG,CAAC,SAAS,CAAC,GACF;IACrB,OAAO,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE;QACvB,MAAM,QAAQ,GAAG,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;QAC9C,MAAM,SAAS,GAAG,QAAQ,IAAI,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;QACzF,CAAC,CAAC,GAAG,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;QAC9B,CAAC,CAAC,GAAG,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;QACzB,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC;QAC/B,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACzB,+FAA+F;QAC/F,0FAA0F;QAC1F,4FAA4F;QAC5F,uDAAuD;QACvD,MAAM,IAAI,GAAG,CAAC,MAAc,EAAE,EAAE,CAAC,CAAC;YAChC,SAAS;YACT,MAAM;YACN,KAAK,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YACvB,MAAM;YACN,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK;YACtB,SAAS,EAAE,CAAC,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,SAAS;SAC3C,CAAC,CAAC;QACH,IAAI,CAAC;YACH,MAAM,IAAI,EAAE,CAAC;QACf,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,4FAA4F;YAC5F,0FAA0F;YAC1F,oFAAoF;YACpF,MAAM,CAAC,KAAK,CAAC,SAAS,EAAE,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;YACtD,MAAM,GAAG,CAAC;QACZ,CAAC;QACD,8FAA8F;QAC9F,sCAAsC;QACtC,CAAC,CAAC,MAAM,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC;QACpC,MAAM,OAAO,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC;QACvF,IAAI,MAAM,KAAK,SAAS,IAAI,CAAC,OAAO;YAAE,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACnF,CAAC,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { AppError, createAppError, toMessage } from "./errors.ts";
+export type { AppErrorOptions } from "./errors.ts";
+export { created, createErrorResponse, noContent, ok, paginated } from "./responses.ts";
+export type { CannedError, ErrorAnswer, ErrorResponseOptions } from "./responses.ts";
+export { createLogger, errorReplacer, keptErrorFields } from "./logger/index.ts";
+export type { Logger, LoggerOptions, LogLevel, LogThreshold } from "./logger/index.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAClE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AACxF,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACrF,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACjF,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { AppError, createAppError, toMessage } from "./errors.js";
+export { created, createErrorResponse, noContent, ok, paginated } from "./responses.js";
+export { createLogger, errorReplacer, keptErrorFields } from "./logger/index.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAElE,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAExF,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/logger/index.d.ts

@@ -0,0 +1,44 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+/** A threshold, which is a level or "silent". "silent" is not a level: nothing logs AT it. */
+export type LogThreshold = LogLevel | "silent";
+export interface Logger {
+    debug(message: string, meta?: Record<string, unknown>): void;
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    error(message: string, meta?: Record<string, unknown>): void;
+}
+export interface LoggerOptions {
+    /**
+     * The lowest level that gets written. Defaults to "info".
+     *
+     * It is an argument rather than a `process.env.LOG_LEVEL` read, and that is the boundary this
+     * package is built on: a Cloudflare Worker has no `process` at all, so a module-scope read makes
+     * the package Node-only by accident. The adopter writes the read:
+     *
+     *     export const logger = createLogger({ level: process.env.LOG_LEVEL });
+     *
+     * and a Worker writes `createLogger({ level: env.LOG_LEVEL })` from its handler argument.
+     *
+     * Typed `string` on purpose, so passing `process.env.LOG_LEVEL` needs no cast. An unrecognized
+     * value throws — see `resolveThreshold`.
+     */
+    level?: string | undefined;
+    /**
+     * Where a finished line goes. Defaults to the console, `error`/`warn` to stderr.
+     *
+     * This is a seam, not a transport — the package ships none. It exists because one backend in
+     * the fleet needs the line twice (stdout and a batched exporter it flushes on SIGTERM), and
+     * because without it every test of anything that logs has to monkey-patch a global.
+     */
+    write?: (line: string, level: LogLevel) => void;
+}
+/**
+ * Build a logger. Call it once, at boot, and pass the result to everything that logs.
+ *
+ *     const logger = createLogger({ level: process.env.LOG_LEVEL });
+ *     logger.info("server started", { port: 3000 });
+ *     logger.error("charge failed", { orderId, error: err });   // the RAW error, never String(err)
+ */
+export declare function createLogger(options?: LoggerOptions): Logger;
+export { errorReplacer, keptErrorFields } from "./serialize.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/logger/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/logger/index.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE3D,8FAA8F;AAC9F,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE/C,MAAM,WAAW,MAAM;IACrB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC7D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC5D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC5D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC9D;AAED,MAAM,WAAW,aAAa;IAC5B;;;;;;;;;;;;;OAaG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,KAAK,IAAI,CAAC;CACjD;AAyBD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAE,aAAkB,GAAG,MAAM,CA6BhE;AAED,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC"}