@gusnips/server 0.1.0 → 0.2.0

package/dist/responses.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gusnips/server",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "The layer under a TypeScript backend: one error shape, one response envelope, one retry rule, one logger.",
   "type": "module",
   "license": "MIT",

package/src/hono/index.ts

@@ -6,6 +6,11 @@
  *     app.onError(errorHandler({ errorResponse, logger }));
  *     app.notFound(notFoundHandler(errorResponse(errors.notFound("Route"))));
  *
+ * `ok`, `created`, `paginated` and `noContent` are the success half: they take the `Context` and
+ * put the envelope on the wire, so no route has to unwrap the `{ status, body }` answer that the
+ * framework-free builders return. Three adopters wrote them by hand and one got that unwrap wrong
+ * in production — see `responses.ts` beside this file.
+ *
  * and, in a test of the real app, `assertEveryRouteGuarded(app, { isPublic })`, with the rule the
  * app itself uses for what anyone may call.
  */
@@ -13,5 +18,6 @@ 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 { created, noContent, ok, paginated } from "./responses.ts";
 export { requestLogger } from "./request-logger.ts";
 export type { RequestLoggerOptions, RequestVariables } from "./request-logger.ts";

package/src/hono/request-logger.test.ts

@@ -7,20 +7,92 @@ import {
   type RequestVariables,
 } from "./request-logger.ts";
 
-function setup(options: Omit<RequestLoggerOptions, "logger"> = {}) {
+function setup<E extends { Variables: RequestVariables } = { Variables: RequestVariables }>(
+  options: Omit<RequestLoggerOptions<E>, "logger"> = {},
+) {
   const lines: Array<Record<string, unknown>> = [];
   const logger = createLogger({
     level: "debug",
     write: (line) => lines.push(JSON.parse(line) as Record<string, unknown>),
   });
-  const app = new Hono<{ Variables: RequestVariables }>();
-  app.use(requestLogger({ logger, ...options }));
+  const app = new Hono<E>();
+  app.use(requestLogger<E>({ logger, ...options }));
   return { app, lines };
 }
 
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 
+type AppEnv = {
+  Variables: RequestVariables<"DENIED"> & { actorId: string };
+};
+
 describe("the request line", () => {
+  it("adds typed adopter fields after the response exists", async () => {
+    const { app, lines } = setup<AppEnv>({
+      fields: (c) => ({ actorId: c.get("actorId"), responseStatus: c.res.status }),
+    });
+    app.post("/items", (c) => {
+      c.set("actorId", "user_1");
+      return c.text("created", 201);
+    });
+
+    await app.request("/items", { method: "POST" });
+
+    expect(lines[0]).toMatchObject({ actorId: "user_1", responseStatus: 201 });
+  });
+
+  it("keeps every canonical request field when adopter fields use the same names", async () => {
+    const { app, lines } = setup<AppEnv>({
+      fields: () => ({
+        actorId: "user_1",
+        requestId: "wrong",
+        method: "DELETE",
+        route: "/wrong",
+        status: 599,
+        ms: -1,
+        errorCode: "WRONG",
+      }),
+    });
+    app.post("/items/:id", (c) => {
+      c.set("errorCode", "DENIED");
+      return c.text("no", 403);
+    });
+
+    await app.request("/items/secret", {
+      method: "POST",
+      headers: { "X-Request-ID": "trace_1" },
+    });
+
+    expect(lines[0]).toMatchObject({
+      actorId: "user_1",
+      requestId: "trace_1",
+      method: "POST",
+      route: "/items/:id",
+      status: 403,
+      errorCode: "DENIED",
+    });
+    expect(lines[0]!.ms).not.toBe(-1);
+  });
+
+  it("does not let a broken adopter field hook lose the response or its request line", async () => {
+    const { app, lines } = setup<AppEnv>({
+      fields: () => {
+        throw new Error("field hook broke");
+      },
+    });
+    app.get("/items", (c) => c.text("ok"));
+
+    const response = await app.request("/items");
+
+    expect(response.status).toBe(200);
+    expect(lines[0]).toMatchObject({
+      requestFieldsFailed: true,
+      method: "GET",
+      route: "/items",
+      status: 200,
+    });
+  });
+
   it("names the route template, never the path", async () => {
     // A path carries whatever the caller put in it. In one backend that was a customer's national
     // id number, and the request line carried it into the log and on into an analytics event.

package/src/hono/request-logger.ts

@@ -1,4 +1,4 @@
-import type { MiddlewareHandler } from "hono";
+import type { Context, MiddlewareHandler } from "hono";
 import { routePath } from "hono/route";
 import type { Logger } from "../logger/index.ts";
 
@@ -9,8 +9,20 @@ export interface RequestVariables<Code extends string = string> {
   errorCode: Code | null;
 }
 
-export interface RequestLoggerOptions {
+type RequestLoggerEnv = { Variables: RequestVariables };
+
+export interface RequestLoggerOptions<E extends RequestLoggerEnv = RequestLoggerEnv> {
   logger: Logger;
+  /**
+   * Sanitized product fields to add to the request line. Runs after the response exists, so it can
+   * read downstream variables and `c.res`. Keep caller-controlled values bounded; never return a
+   * raw path, query, header set, body or authentication object.
+   *
+   * Return plain data, not live objects: a throw from this hook is caught, but a value whose own
+   * `toJSON` throws is caught by the logger instead, which costs the whole line rather than the
+   * field.
+   */
+  fields?: (c: Context<E>) => Record<string, unknown>;
   /**
    * 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.
@@ -25,6 +37,20 @@ export interface RequestLoggerOptions {
  */
 const REQUEST_ID = /^[A-Za-z0-9._-]{1,64}$/;
 
+function collectFields<E extends RequestLoggerEnv>(
+  fields: RequestLoggerOptions<E>["fields"],
+  c: Context<E>,
+): Record<string, unknown> {
+  if (fields === undefined) return {};
+  try {
+    // Materialize here too: a throwing getter is just as capable of losing the request line as a
+    // throwing callback. Logging metadata must never change the response it describes.
+    return { ...fields(c) };
+  } catch {
+    return { requestFieldsFailed: true };
+  }
+}
+
 /**
  * One line per request, and the request id.
  *
@@ -36,10 +62,11 @@ const REQUEST_ID = /^[A-Za-z0-9._-]{1,64}$/;
  * 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({
+export function requestLogger<E extends RequestLoggerEnv = RequestLoggerEnv>({
   logger,
+  fields,
   skipPaths = ["/health"],
-}: RequestLoggerOptions): MiddlewareHandler<{ Variables: RequestVariables }> {
+}: RequestLoggerOptions<E>): MiddlewareHandler<E> {
   return async (c, next) => {
     const supplied = c.req.header("X-Request-ID");
     const requestId = supplied && REQUEST_ID.test(supplied) ? supplied : crypto.randomUUID();
@@ -72,6 +99,7 @@ export function requestLogger({
     // 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));
+    if (method !== "OPTIONS" && !skipped)
+      logger.info("request", { ...collectFields(fields, c), ...line(c.res.status) });
   };
 }

package/src/hono/responses.test.ts

@@ -0,0 +1,50 @@
+import { Hono } from "hono";
+import { describe, expect, it } from "vitest";
+import { created, noContent, ok, paginated } from "./responses.ts";
+
+/**
+ * Every assertion here reads the BYTES off a real request, never the return value of a builder.
+ * That is the point: the outage this file exists to prevent was invisible to any test that calls
+ * the module, because the wrong value was still a perfectly good JSON value.
+ */
+const app = new Hono()
+  .get("/ok", (c) => ok(c, { id: "a" }))
+  .get("/accepted", (c) => ok(c, { id: "a" }, 202))
+  .post("/created", (c) => created(c, { id: "a" }))
+  .get("/page", (c) => paginated(c, [1, 2], { total: 9, limit: 2, offset: 0 }))
+  .get("/last-page", (c) => paginated(c, [9], { total: 9, limit: 2, offset: 8 }))
+  .delete("/gone", (c) => noContent(c));
+
+describe("the Hono success adapters", () => {
+  it("answers the envelope itself, never the { status, body } wrapper around it", async () => {
+    const res = await app.request("/ok");
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ data: { id: "a" } });
+  });
+
+  it("keeps the status the route asked for", async () => {
+    expect((await app.request("/accepted")).status).toBe(202);
+    expect((await app.request("/created", { method: "POST" })).status).toBe(201);
+    expect(await (await app.request("/created", { method: "POST" })).json()).toEqual({
+      data: { id: "a" },
+    });
+  });
+
+  it("computes hasMore from the rows returned, not from the limit", async () => {
+    expect(await (await app.request("/page")).json()).toEqual({
+      data: [1, 2],
+      meta: { total: 9, limit: 2, offset: 0, hasMore: true },
+    });
+    expect(await (await app.request("/last-page")).json()).toEqual({
+      data: [9],
+      meta: { total: 9, limit: 2, offset: 8, hasMore: false },
+    });
+  });
+
+  it("sends a 204 with no body and no content-type", async () => {
+    const res = await app.request("/gone", { method: "DELETE" });
+    expect(res.status).toBe(204);
+    expect(res.headers.get("content-type")).toBeNull();
+    expect(await res.text()).toBe("");
+  });
+});

package/src/hono/responses.ts

@@ -0,0 +1,41 @@
+/**
+ * The success half of the Hono edge: four adapters that put the envelope on the wire.
+ *
+ * They exist because the builders in `../responses.ts` return an ANSWER — `{ status, body }` —
+ * and every Hono adopter therefore has to unwrap one before `c.json` sees it. Three of three
+ * wrote these same four functions by hand, and one of the three wrote `c.json(ok(data))` instead
+ * of `c.json(ok(data).body)`: every 200 from a live API answered
+ * `{"status":200,"body":{"data":…}}` for fifty minutes. Nothing caught it. `c.json` takes any
+ * JSON value, so the types were satisfied; the status was still 200, so every probe and every
+ * deploy gate was satisfied; and a test that calls the module never sees the body its caller
+ * sends. A client found it, because a client is the only reader that parses the envelope.
+ *
+ * A doc comment would have been read by whoever was already careful. These make the wrong line
+ * unreachable, which is the only fix available to a package that owns both sides of the seam.
+ */
+import type { PaginationMeta } from "@gusnips/http";
+import type { Context } from "hono";
+import type { ContentfulStatusCode } from "hono/utils/http-status";
+import { ok as okBody, paginated as paginatedBody } from "../responses.ts";
+
+/** `return ok(c, user)` — or `ok(c, job, 202)` where the route accepted rather than answered. */
+export function ok<T>(c: Context, data: T, status: ContentfulStatusCode = 200) {
+  return c.json(okBody(data).body, status);
+}
+
+export function created<T>(c: Context, data: T) {
+  return ok(c, data, 201);
+}
+
+/** `hasMore` is computed from the rows actually returned — see `paginated` in `../responses.ts`. */
+export function paginated<T>(c: Context, rows: T[], meta: Omit<PaginationMeta, "hasMore">) {
+  return c.json(paginatedBody(rows, meta).body, 200);
+}
+
+/**
+ * `c.body(null, 204)`, not `c.json`: a 204 carries no body, and `c.json(null, 204)` writes the
+ * four bytes `null` and a `content-type` header under a status that promises neither.
+ */
+export function noContent(c: Context) {
+  return c.body(null, 204);
+}

package/src/index.ts

@@ -1,6 +1,18 @@
 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 {
+  created,
+  createErrorResponse,
+  noContent,
+  ok,
+  paginated,
+  validationIssues,
+} from "./responses.ts";
+export type {
+  CannedError,
+  ErrorAnswer,
+  ErrorResponseOptions,
+  ValidationIssue,
+} from "./responses.ts";
 export { createLogger, errorReplacer, keptErrorFields } from "./logger/index.ts";
 export type { Logger, LoggerOptions, LogLevel, LogThreshold } from "./logger/index.ts";

package/src/logger/serialize.test.ts

@@ -221,6 +221,53 @@ describe("what an Error contributes to a log line", () => {
     expect(JSON.stringify(line)).not.toContain("4242");
   });
 
+  it("keeps the stack of an error that crossed a queue and arrived as a plain object", () => {
+    // A job queue stores a failed job's error through a serializer, so the dead-letter handler is
+    // handed a plain object — and the stack is the whole of the "why" in a line whose job is to
+    // say which job died and why. Everything the SDK hung beside it still goes.
+    const stored = {
+      name: "HttpError",
+      message: "Not Found",
+      stack: "HttpError: Not Found\n    at workers.ts:1:1",
+      status: 404,
+      request: { method: "GET", body: '{"query":"private"}' },
+    };
+
+    const line = JSON.parse(JSON.stringify({ error: stored }, errorReplacer())) as Record<
+      string,
+      Record<string, unknown>
+    >;
+
+    expect(line.error).toEqual({
+      name: "HttpError",
+      message: "Not Found",
+      stack: "HttpError: Not Found\n    at workers.ts:1:1",
+      status: 404,
+    });
+  });
+
+  it("allow-lists a thrown plain object passed directly as the error", () => {
+    // Hono wraps a non-Error throw as a cause, but workers, fire-and-forget catches and a database
+    // client's `{ code, message, details }` rejection reach the logger directly. `error` is the
+    // raw-error slot the logger documents; an ordinary metadata object under another key stays
+    // ordinary metadata.
+    const rejection = {
+      message: "insert failed",
+      code: "23514",
+      detail: "Failing row contains (someone@example.com, 4242424242424242).",
+      payload: '{"customer_email":"someone@example.com"}',
+    };
+
+    const line = serialized(rejection);
+
+    expect(line).toEqual({
+      message: "insert failed",
+      code: "23514",
+      detail: "[row omitted: Postgres DETAIL for this error is the whole failing row]",
+    });
+    expect(entryFor({ context: rejection }).context).toEqual(rejection);
+  });
+
   it("survives a chain of plain-object causes that holds itself", () => {
     // The Error branch has had this guard since it was written; the narrowing builds a new object
     // and so needs its own, or a self-referencing rejection recurses until the stack ends — inside

package/src/logger/serialize.ts

@@ -91,9 +91,18 @@ function keptValue(key: string, value: unknown): unknown {
  * a PostgREST client rejects with plain objects. So in a Hono app the cause slot is precisely where
  * a vendor's rejection object ends up, and a leak there reads as if the list had run.
  *
- * `cause` means "the error this one came from", so whatever sits in it is in the error slot and
- * gets the same treatment. `name` and `message` come along because a rejection object usually
- * carries them and a line with neither says nothing at all.
+ * A plain object passed directly as `meta.error` is the other door. Hono wraps it, but a worker,
+ * a fire-and-forget catch or a database client outside Hono does not. `error` is the raw-error slot
+ * the logger documents, so it gets the same treatment as `cause`; an ordinary metadata object under
+ * any other key stays untouched. `name`, `message` and `stack` come along because a rejection
+ * object usually carries them and a line with none of them says nothing at all.
+ *
+ * `stack` is here because an adopter's queue found it missing. A job that dies is stored by its
+ * queue through a serializer, so the error reaching the dead-letter handler is a plain object with
+ * its stack in a string — and that stack is the whole of the "why" in a line whose job is to say
+ * which job died and why. The Error branch below has always written `stack` unfiltered; leaving it
+ * out here was an asymmetry, not a decision. It is a conventional field name, not one an SDK hangs
+ * its own inputs off, which is what the allow-list exists to stop.
  *
  * Deliberate state it does NOT keep: context an app attaches on purpose. That belongs in the
  * logger's `meta`, which is untouched — `cause` is not the place for it, and one incident of a
@@ -106,13 +115,15 @@ export function narrowErrorLike(value: object): Record<string, unknown> {
 function narrow(value: object, seen: WeakSet<object>): Record<string, unknown> {
   seen.add(value);
   const out: Record<string, unknown> = {};
-  const { name, message, cause } = value as {
+  const { name, message, stack, cause } = value as {
     name?: unknown;
     message?: unknown;
+    stack?: unknown;
     cause?: unknown;
   };
   if (typeof name === "string") out.name = name;
   if (typeof message === "string") out.message = message;
+  if (typeof stack === "string") out.stack = stack;
   for (const [k, v] of Object.entries(value)) {
     if (KEPT_ERROR_FIELDS.has(k)) out[k] = keptValue(k, v);
   }
@@ -139,6 +150,9 @@ function narrowCause(cause: unknown, seen: WeakSet<object>): unknown {
  *   `JSON.stringify(err)` is `{}` — which is how a logger ends up printing nothing about the
  *   failure it was called to report. They are added explicitly, and the allow-listed extras ride
  *   along beside them.
+ * - A plain object in the root `error` slot is narrowed through the same allow-list. Hono's
+ *   boundary turns one into an Error cause, but workers and swallowed catches log it directly.
+ *   Other metadata objects stay untouched.
  * - A nested `cause` is followed, and so is an `AggregateError`'s `errors`. Both are
  *   non-enumerable, so both are invisible to the loop above; without this line "all attempts
  *   failed" is the whole log entry. Each one goes back through this replacer, so the allow-list
@@ -170,12 +184,17 @@ function narrowCause(cause: unknown, seen: WeakSet<object>): unknown {
  */
 export function errorReplacer(): (this: unknown, key: string, value: unknown) => unknown {
   const seen = new WeakSet<object>();
+  let root: object | undefined;
   return function (key, value) {
     const held =
       typeof this === "object" && this !== null
         ? (this as Record<string, unknown>)[key]
         : undefined;
+    if (key === "" && typeof held === "object" && held !== null) root = held;
     if (held instanceof Error) value = held;
+    else if (this === root && key === "error" && typeof held === "object" && held !== null) {
+      return seen.has(held) ? "[Circular]" : narrow(held, seen);
+    }
     if (typeof value === "bigint") return value.toString();
     if (value instanceof Error) {
       if (seen.has(value)) return "[Circular]";

package/src/responses.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { z } from "zod";
+import { type ValidationIssue, validationIssues } from "./index.ts";
 import { AppError, createAppError } from "./errors.ts";
 import { created, createErrorResponse, noContent, ok, paginated } from "./responses.ts";
 
@@ -110,6 +111,43 @@ describe("a validation failure is a 400 that reflects nothing back", () => {
     .object({ days: z.enum(["7", "30"]), timeoutMs: z.number().max(30_000) })
     .strict();
 
+  it("exports the safe issue projection for every door that validates input", () => {
+    const validationError = {
+      issues: [
+        {
+          path: ["items", 0, Symbol("field"), Symbol()],
+          code: "too_big",
+          maximum: 10,
+          minimum: 1,
+          received: "secret",
+          values: ["private", "schema"],
+          message: "Expected a private schema value",
+        },
+        { path: ["amount"], code: "too_big", maximum: 10n, minimum: "1" },
+      ],
+    } as const;
+    const projected: ValidationIssue[] = validationIssues(validationError);
+
+    expect(projected).toEqual([
+      { path: ["items", 0, "field", ""], code: "too_big", maximum: 10, minimum: 1 },
+      { path: ["amount"], code: "too_big" },
+    ]);
+    expect(() => JSON.stringify(projected)).not.toThrow();
+    expect(JSON.stringify(projected)).not.toContain("secret");
+    expect(JSON.stringify(projected)).not.toContain("private");
+  });
+
+  it("answers rather than throws when an issue arrives without a usable path", () => {
+    // The gate admits anything named ZodError with an array of issues, so an element that lost a
+    // field crossing a queue or a tool boundary reaches the projection. Throwing here throws
+    // inside the function whose whole job is to turn a thrown thing into an answer.
+    for (const issue of [{ code: "custom" }, null, { path: "amount", code: "too_big" }]) {
+      const answer = errorResponse({ name: "ZodError", issues: [issue] });
+      expect(answer.status).toBe(400);
+      expect(answer.body.error.details).toEqual([{ path: [], code: issue?.code ?? "" }]);
+    }
+  });
+
   it("answers 400 with the path and the rule", () => {
     const parsed = schema.safeParse({ days: "90", timeoutMs: 1 });
     const answer = errorResponse(parsed.error);

package/src/responses.ts

@@ -13,7 +13,20 @@
 import type { ApiError, ApiSuccess, PaginationMeta } from "@gusnips/http";
 import { AppError } from "./errors.ts";
 
-/** Every 2xx body is `{ data }`, or `{ data, meta }` where a route has counts to report. */
+/**
+ * The `body` is `{ data }`, or `{ data, meta }` where a route has counts to report.
+ *
+ * What comes back is an ANSWER — `{ status, body }` — not a body, because this layer is
+ * framework-free and has to hand its caller a status too. An adapter takes `.body`:
+ *
+ *     return c.json(ok(data), status);        // WRONG: {"status":200,"body":{"data":…}}
+ *     return c.json(ok(data).body, status);   // the envelope
+ *
+ * Nothing catches the first line — `c.json` takes any JSON value, the status is still whatever
+ * you passed, and a test that calls this module never sees the body its caller sends. It shipped,
+ * and a client found it. On Hono, import `ok` from `@gusnips/server/hono` instead: the four
+ * adapters there take the `Context`, and the question does not arise.
+ */
 export function ok<T, M = PaginationMeta>(data: T, meta?: M) {
   const body: ApiSuccess<T, M> = meta === undefined ? { data } : { data, meta };
   return { status: 200 as const, body };
@@ -152,11 +165,27 @@ function envelope<Code extends string, Key extends string>(
   };
 }
 
+/**
+ * What an issue MIGHT carry — every field optional, because the gate below proves only that
+ * `issues` is an array and nothing at all about an element. Typing the element as certain is
+ * what turned this projection into a throw: `path.map` on an issue that arrived without one.
+ */
 interface RawIssue {
-  path?: unknown;
-  code?: unknown;
-  maximum?: unknown;
-  minimum?: unknown;
+  readonly path?: unknown;
+  readonly code?: unknown;
+  readonly maximum?: unknown;
+  readonly minimum?: unknown;
+}
+
+/** One rejected field: enough to fix the call, and nothing about the schema. */
+export interface ValidationIssue {
+  /** The field that failed, as the caller spelled it. */
+  path: (string | number)[];
+  /** The rule that rejected it, such as `too_big`. */
+  code: string;
+  /** The numeric bound, when the rule has one. */
+  maximum?: number;
+  minimum?: number;
 }
 
 /**
@@ -174,6 +203,18 @@ function zodIssues(err: unknown): RawIssue[] | null {
   return issues as RawIssue[];
 }
 
+/**
+ * One path segment, as something that survives `JSON.stringify`.
+ *
+ * A symbol keyed a field the caller cannot name back at us, so its description is the only
+ * useful thing in it — and an unnamed symbol has none, which is an empty segment rather than
+ * the `null` that `JSON.stringify` would otherwise write.
+ */
+function pathSegment(segment: unknown): string | number {
+  if (typeof segment === "symbol") return segment.description ?? "";
+  return typeof segment === "number" ? segment : String(segment);
+}
+
 /**
  * The field path, the rule it failed, and — for a range — the BOUND it failed against.
  *
@@ -187,14 +228,24 @@ function zodIssues(err: unknown): RawIssue[] | null {
  *
  * The bound is the exception, and it belongs to the caller: it is the published contract, and
  * a `too_big` without it costs somebody a bisect to rediscover a number our own docs state.
+ *
+ * Total on purpose: this runs inside the function that turns a thrown thing into an answer, and
+ * it is advertised to the queue and tool doors, where an issue list has crossed a serialization
+ * hop. An allow-list that throws on a malformed issue sends its caller back to shipping the
+ * validator's issues raw, which is the disclosure it exists to prevent.
  */
-function safeIssues(issues: RawIssue[]): unknown[] {
-  return issues.map((issue) => ({
-    path: issue.path,
-    code: issue.code,
-    ...(typeof issue.maximum === "number" && { maximum: issue.maximum }),
-    ...(typeof issue.minimum === "number" && { minimum: issue.minimum }),
-  }));
+export function validationIssues(error: {
+  readonly issues: readonly RawIssue[];
+}): ValidationIssue[] {
+  return error.issues.map((issue): ValidationIssue => {
+    const { path, code, maximum, minimum } = issue ?? {};
+    return {
+      path: Array.isArray(path) ? path.map(pathSegment) : [],
+      code: typeof code === "string" ? code : "",
+      ...(typeof maximum === "number" && { maximum }),
+      ...(typeof minimum === "number" && { minimum }),
+    };
+  });
 }
 
 /**
@@ -233,7 +284,7 @@ export function createErrorResponse<Code extends string = string, Key extends st
     if (issues !== null) {
       return {
         status: 400,
-        body: envelope(opts.validation, safeIssues(issues)),
+        body: envelope(opts.validation, validationIssues({ issues })),
         headers: {},
         kind: "client",
       };