@nxgt/openapi-hono 0.1.0

package/dist/engine.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The runtime behind `hono.ts`. Each route is registered on a Hono app as
+ * `[...middlewares, validator, handler]`: the validator reads the parameters
+ * and the body with the validators of `operations.ts`, hands the results
+ * to `c.req.valid()`, and answers every issue at once when there is one.
+ */
+import type { Context } from 'hono';
+import { type SchemaIssue } from './errors';
+import type { Api, ApiOptions, ApiSpec, Method } from './types';
+/** What the engine asks of a validator: Zod's `safeParse`. */
+export interface Validator {
+    safeParse(value: unknown): {
+        success: true;
+        data: unknown;
+    } | {
+        success: false;
+        error: {
+            issues: readonly SchemaIssue[];
+        };
+    };
+}
+export interface RuntimeMedia {
+    readonly kind: 'json' | 'form' | 'text' | 'binary' | 'sse' | 'jsonl';
+    readonly schema?: Validator;
+    /** `sse`: each event's data, by name: a validator for JSON, `null` for text. */
+    readonly events?: {
+        readonly [event: string]: Validator | null;
+    };
+    /** `jsonl`: each item. */
+    readonly item?: Validator;
+}
+/** An entry of the `operations` table in `operations.ts`. */
+export interface RuntimeOperation {
+    readonly method: Method;
+    readonly path: string;
+    readonly honoPath: string;
+    readonly tags: readonly string[];
+    readonly parameters: readonly {
+        readonly name: string;
+        readonly in: 'path' | 'query' | 'header';
+        readonly list: boolean;
+        readonly explode: boolean;
+    }[];
+    readonly param: Validator;
+    readonly query: Validator;
+    readonly header: Validator;
+    readonly body?: {
+        readonly required: boolean;
+        readonly content: {
+            readonly [mediaType: string]: RuntimeMedia;
+        };
+    };
+    readonly responses: {
+        readonly [status: number]: {
+            readonly [mediaType: string]: RuntimeMedia;
+        };
+    };
+}
+/** The `operations` table, keyed by `operationId`. */
+export type OperationTable = {
+    readonly [operationId: string]: RuntimeOperation;
+};
+/** The route a request runs: what `streamEvents()` and `streamLines()` read in its handler. */
+export interface RunningRoute {
+    readonly id: string;
+    readonly operation: RuntimeOperation;
+    readonly settings: ApiOptions;
+}
+export declare const runningRoute: (c: Context) => RunningRoute | undefined;
+/**
+ * One registry for a spec: `routes(app)` for each app or module, then
+ * `assertComplete()`. `hono.ts` calls it with the spec's table.
+ */
+export declare function createApi<S extends ApiSpec>(operations: OperationTable, defaults?: ApiOptions): Api<S>;
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,OAAO,EAAiC,MAAM,MAAM,CAAC;AACnE,OAAO,EACN,KAAK,WAAW,EAMhB,MAAM,UAAU,CAAC;AAElB,OAAO,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAU,MAAM,SAAS,CAAC;AAExE,8DAA8D;AAC9D,MAAM,WAAW,SAAS;IACzB,SAAS,CACR,KAAK,EAAE,OAAO,GAEZ;QAAE,OAAO,EAAE,IAAI,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,GAChC;QAAE,OAAO,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE;YAAE,MAAM,EAAE,SAAS,WAAW,EAAE,CAAA;SAAE,CAAA;KAAE,CAAC;CACjE;AAED,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,OAAO,CAAC;IACrE,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;IAC5B,gFAAgF;IAChF,QAAQ,CAAC,MAAM,CAAC,EAAE;QAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAA;KAAE,CAAC;IACjE,0BAA0B;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC;CAC1B;AAED,6DAA6D;AAC7D,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,SAAS;QAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;QACzC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;QACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;KAC1B,EAAE,CAAC;IACJ,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,IAAI,CAAC,EAAE;QACf,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;QAC3B,QAAQ,CAAC,OAAO,EAAE;YAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY,CAAA;SAAE,CAAC;KACjE,CAAC;IACF,QAAQ,CAAC,SAAS,EAAE;QACnB,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG;YAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY,CAAA;SAAE,CAAC;KAC1E,CAAC;CACF;AAED,sDAAsD;AACtD,MAAM,MAAM,cAAc,GAAG;IAC5B,QAAQ,EAAE,WAAW,EAAE,MAAM,GAAG,gBAAgB,CAAC;CACjD,CAAC;AA2BF,+FAA+F;AAC/F,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;CAC9B;AAKD,eAAO,MAAM,YAAY,GAAI,GAAG,OAAO,KAAG,YAAY,GAAG,SAC1C,CAAC;AAQhB;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,OAAO,EAC1C,UAAU,EAAE,cAAc,EAC1B,QAAQ,GAAE,UAAe,GACvB,GAAG,CAAC,CAAC,CAAC,CAqHR"}

package/dist/errors.d.ts

@@ -0,0 +1,50 @@
+import type { Context } from 'hono';
+/**
+ * Where a request value was read: a location Hono's `c.req.valid()` knows, or
+ * `body` for a text body, which a handler reads with `c.req.text()`.
+ */
+export type ValidationTarget = 'param' | 'query' | 'header' | 'json' | 'form' | 'body';
+export interface ValidationIssue {
+    target: ValidationTarget | 'response';
+    /** Inside the target: `['items', 0, 'name']`, or `[]` for the whole of it. */
+    path: (string | number)[];
+    /**
+     * Zod's issue code, or one of the engine's own: `invalid_json`,
+     * `invalid_form`, `invalid_content_type`, `missing_body`,
+     * `repeated_parameter`, `undeclared_status`.
+     */
+    code: string;
+    message: string;
+}
+export interface ValidationFailure {
+    /** A request the spec refuses, or, with `validateResponses`, a reply it does not declare. */
+    kind: 'request' | 'response';
+    operationId: string;
+    method: string;
+    /** As the spec writes it: `/employees/{id}`. */
+    path: string;
+    /** The reply's status, for a `response` failure. */
+    status?: number;
+    /** Every issue, from every target at once. */
+    issues: ValidationIssue[];
+}
+/**
+ * Answers a failure. Return a `Response` to send it, throw to hand the
+ * failure to `app.onError`, or return nothing for the default answer.
+ */
+export type ValidationErrorHook = (failure: ValidationFailure, c: Context) => Response | undefined | Promise<Response | undefined>;
+/**
+ * The default answer: 400 for a request, shaped like `ErrorResponse` with the
+ * issues added. A reply that fails is a 500 without them, since they name
+ * what the reply held (an unrecognized `passwordHash`…): they go to
+ * `console.error` instead.
+ */
+export declare const validationErrorHandler: (failure: ValidationFailure, c: Context) => Response;
+/** What the engine reads of a Zod issue. */
+export interface SchemaIssue {
+    readonly path: readonly PropertyKey[];
+    readonly code: string;
+    readonly message: string;
+}
+export declare const toIssues: (target: ValidationIssue["target"], issues: readonly SchemaIssue[]) => ValidationIssue[];
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GACzB,OAAO,GACP,OAAO,GACP,QAAQ,GACR,MAAM,GACN,MAAM,GACN,MAAM,CAAC;AAEV,MAAM,WAAW,eAAe;IAC/B,MAAM,EAAE,gBAAgB,GAAG,UAAU,CAAC;IACtC,8EAA8E;IAC9E,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAC1B;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IACjC,6FAA6F;IAC7F,IAAI,EAAE,SAAS,GAAG,UAAU,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,oDAAoD;IACpD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,MAAM,EAAE,eAAe,EAAE,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,CACjC,OAAO,EAAE,iBAAiB,EAC1B,CAAC,EAAE,OAAO,KACN,QAAQ,GAAG,SAAS,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GAClC,SAAS,iBAAiB,EAC1B,GAAG,OAAO,KACR,QAqBF,CAAC;AAEF,4CAA4C;AAC5C,MAAM,WAAW,WAAW;IAC3B,QAAQ,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CACzB;AAED,eAAO,MAAM,QAAQ,GACpB,QAAQ,eAAe,CAAC,QAAQ,CAAC,EACjC,QAAQ,SAAS,WAAW,EAAE,KAC5B,eAAe,EAQd,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `@nxgt/openapi-hono`: the runtime `hono.ts` binds to its spec.
+ * Import `createApi` and `createRoutes` from `hono.ts`, not from here.
+ */
+export { createApi, type OperationTable, type RuntimeMedia, type RuntimeOperation, type Validator, } from './engine';
+export { type SchemaIssue, type ValidationErrorHook, type ValidationFailure, type ValidationIssue, type ValidationTarget, validationErrorHandler, } from './errors';
+export { type EventWriter, type LineWriter, streamEvents, streamLines, } from './streams';
+export type { Api, ApiOptions, ApiSpec, Chain, Method, RouteHandler, Routes, RoutesOptions, Scope, ScopeOf, Tagged, Whole, } from './types';
+//# 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;;;GAGG;AACH,OAAO,EACN,SAAS,EACT,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,SAAS,GACd,MAAM,UAAU,CAAC;AAClB,OAAO,EACN,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,sBAAsB,GACtB,MAAM,UAAU,CAAC;AAClB,OAAO,EACN,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,YAAY,EACZ,WAAW,GACX,MAAM,WAAW,CAAC;AACnB,YAAY,EACX,GAAG,EACH,UAAU,EACV,OAAO,EACP,KAAK,EACL,MAAM,EACN,YAAY,EACZ,MAAM,EACN,aAAa,EACb,KAAK,EACL,OAAO,EACP,MAAM,EACN,KAAK,GACL,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,545 @@
+// src/errors.ts
+var validationErrorHandler = (failure, c) => {
+  const timestamp = new Date().toISOString();
+  if (failure.kind === "response") {
+    console.error(`${failure.operationId} (${failure.method.toUpperCase()} ${failure.path}) replied ${failure.status} as the spec does not declare:`, failure.issues);
+    return c.json({ status: 500, message: "errors.response-validation-failed", timestamp }, 500);
+  }
+  return c.json({
+    status: 400,
+    message: "errors.validation-failed",
+    timestamp,
+    issues: failure.issues
+  }, 400);
+};
+var toIssues = (target, issues) => issues.map((issue) => ({
+  target,
+  path: issue.path.filter((key) => typeof key !== "symbol"),
+  code: issue.code,
+  message: issue.message
+}));
+
+// src/routable.ts
+function unroutable(operation) {
+  if (operation.method === "head") {
+    return `Hono answers HEAD with the GET route of ${operation.path}, so a HEAD handler would never run. Register GET ${operation.path} instead`;
+  }
+  const mixed = operation.path.split("/").find((segment) => segment.includes("{") && !/^\{[^{}]+\}$/.test(segment));
+  if (mixed !== undefined) {
+    return `Hono cannot route ${operation.path}: a path parameter must fill its whole segment, and ${mixed} does not. Serve it with app.on() and validate it yourself`;
+  }
+  return;
+}
+
+// src/engine.ts
+var METHODS = [
+  "get",
+  "put",
+  "post",
+  "delete",
+  "options",
+  "head",
+  "patch",
+  "trace",
+  "query"
+];
+var VALIDATE = async () => {
+  throw new Error("routes.validate marks where a routes chain validates the request; it cannot run anywhere else");
+};
+var running = new WeakMap;
+var runningRoute = (c) => running.get(c);
+var onApp = new WeakMap;
+function createApi(operations, defaults = {}) {
+  const done = new Set;
+  const byRoute = new Map;
+  for (const [id, operation] of Object.entries(operations)) {
+    byRoute.set(`${operation.method} ${operation.path}`, id);
+  }
+  const label = (id, operation) => `${id} (${operation.method.toUpperCase()} ${operation.path})`;
+  const register = (app, id, chain, settings) => {
+    const operation = operations[id];
+    if (!operation)
+      throw new Error(`${id} is not an operationId of the spec`);
+    const name = label(id, operation);
+    const why = unroutable(operation);
+    if (why !== undefined)
+      throw new Error(`${name}: ${why}`);
+    if (done.has(id))
+      throw new Error(`${name} already has a route`);
+    if (settings.tag !== undefined && !operation.tags.includes(settings.tag)) {
+      throw new Error(`${name} is not tagged ${settings.tag}`);
+    }
+    const handler = chain.at(-1);
+    const middlewares = chain.slice(0, -1);
+    if (typeof handler !== "function" || handler === VALIDATE) {
+      throw new Error(`${name}: the last argument must be the handler`);
+    }
+    const marker = middlewares.indexOf(VALIDATE);
+    if (marker !== middlewares.lastIndexOf(VALIDATE)) {
+      throw new Error(`${name}: routes.validate appears twice`);
+    }
+    const path = localPath(operation, settings.prefix, name);
+    const routes = onApp.get(app) ?? [];
+    for (const earlier of routes) {
+      if (earlier.method === operation.method && shadows(earlier.path, path)) {
+        throw new Error(`${name} would never be reached: ${earlier.label}, registered before it, matches ${path} first. Register ${id} before it`);
+      }
+    }
+    const at = marker < 0 ? middlewares.length : marker;
+    const on = app.on;
+    on.call(app, operation.method.toUpperCase(), path, ...middlewares.slice(0, at), validation(id, operation, settings), ...middlewares.slice(marker < 0 ? at : at + 1), reply(id, operation, handler, settings));
+    routes.push({ method: operation.method, path, label: name });
+    onApp.set(app, routes);
+    done.add(id);
+  };
+  const make = (app, settings) => {
+    const routes = {
+      validate: VALIDATE,
+      with: (options) => make(app, { ...settings, ...options }),
+      operation: (id, ...chain) => {
+        register(app, id, chain, settings);
+        return routes;
+      }
+    };
+    for (const method of METHODS) {
+      routes[method] = (path, ...chain) => {
+        const id = byRoute.get(`${method} ${path}`);
+        if (id === undefined) {
+          throw new Error(`The spec has no ${method.toUpperCase()} ${path} operation`);
+        }
+        register(app, id, chain, settings);
+        return routes;
+      };
+    }
+    return routes;
+  };
+  const missing = (tag) => Object.entries(operations).filter(([id, operation]) => !done.has(id) && unroutable(operation) === undefined && (tag === undefined || operation.tags.includes(tag))).map(([id]) => id);
+  return {
+    routes: (app, options = {}) => make(app, { ...defaults, ...options }),
+    missing,
+    assertComplete(tag) {
+      const left = missing(tag);
+      if (left.length === 0)
+        return;
+      throw new Error(`${left.length} operation(s)${tag === undefined ? "" : ` tagged ${tag}`} have no route:
+${left.map((id) => `  ${label(id, operations[id])}`).join(`
+`)}`);
+    }
+  };
+}
+function localPath(operation, prefix, name) {
+  if (!prefix)
+    return operation.honoPath;
+  const mount = prefix.replace(/\{([^}]+)\}/g, ":$1").replace(/\/$/, "");
+  const path = operation.honoPath;
+  if (path !== mount && !path.startsWith(`${mount}/`)) {
+    throw new Error(`${name}: its path ${operation.path} is not under the prefix ${prefix}`);
+  }
+  return path.slice(mount.length) || "/";
+}
+function shadows(earlier, later) {
+  const a = earlier.split("/");
+  const b = later.split("/");
+  if (a.length !== b.length)
+    return false;
+  for (const [i, segment] of a.entries()) {
+    if (segment !== b[i] && !segment.startsWith(":"))
+      return false;
+  }
+  return true;
+}
+function validation(id, operation, settings) {
+  return async (c, next) => {
+    const issues = [];
+    const check = (target, validator, value) => {
+      const result = validator.safeParse(value);
+      if (!result.success) {
+        issues.push(...toIssues(target, result.error.issues));
+      } else if (target !== "body") {
+        c.req.addValidatedData(target, result.data);
+      }
+    };
+    check("param", operation.param, c.req.param());
+    check("query", operation.query, readQuery(c, operation, issues));
+    check("header", operation.header, readHeaders(c, operation));
+    if (operation.body)
+      await readBody(c, operation.body, issues, check);
+    if (issues.length > 0) {
+      return fail(c, settings, {
+        kind: "request",
+        operationId: id,
+        method: operation.method,
+        path: operation.path,
+        issues
+      });
+    }
+    await next();
+  };
+}
+function readQuery(c, operation, issues) {
+  const query = {};
+  for (const param of operation.parameters) {
+    if (param.in !== "query")
+      continue;
+    if (param.list && param.explode) {
+      const values = c.req.queries(param.name);
+      if (values !== undefined)
+        query[param.name] = values;
+      continue;
+    }
+    const sent = c.req.queries(param.name)?.length ?? 0;
+    if (sent > 1) {
+      issues.push({
+        target: "query",
+        path: [param.name],
+        code: "repeated_parameter",
+        message: `${param.name} is sent ${sent} times, and takes one value`
+      });
+    }
+    const value = c.req.query(param.name);
+    if (value !== undefined) {
+      query[param.name] = param.list ? value.split(",") : value;
+    }
+  }
+  return query;
+}
+function readHeaders(c, operation) {
+  const headers = {};
+  for (const param of operation.parameters) {
+    if (param.in !== "header")
+      continue;
+    const value = c.req.header(param.name);
+    if (value === undefined)
+      continue;
+    headers[param.name.toLowerCase()] = param.list ? value.split(",").map((item) => item.trim()) : value;
+  }
+  return headers;
+}
+var mediaType = (header) => (header.split(";")[0] ?? "").trim().toLowerCase();
+function match(content, type) {
+  for (const [key, media] of Object.entries(content)) {
+    if (key.toLowerCase() === type)
+      return media;
+  }
+  return content[`${type.split("/")[0]}/*`] ?? content["*/*"];
+}
+var targetOf = (kind) => kind === "json" ? "json" : kind === "form" ? "form" : "body";
+async function readBody(c, body, issues, check) {
+  const declared = Object.keys(body.content).join(", ");
+  const target = targetOf(Object.values(body.content)[0]?.kind);
+  const absent = (at) => {
+    if (body.required) {
+      issues.push({
+        target: at,
+        path: [],
+        code: "missing_body",
+        message: `A request body is required: ${declared}`
+      });
+    } else if (at === "json" || at === "form") {
+      c.req.addValidatedData(at, undefined);
+    }
+  };
+  const header = c.req.header("content-type");
+  if (header === undefined) {
+    if (await read(c, () => c.req.text()) === "")
+      absent(target);
+    else {
+      issues.push({
+        target,
+        path: [],
+        code: "invalid_content_type",
+        message: `A request body needs a Content-Type: ${declared}`
+      });
+    }
+    return;
+  }
+  const type = mediaType(header);
+  const media = match(body.content, type);
+  if (!media) {
+    issues.push({
+      target,
+      path: [],
+      code: "invalid_content_type",
+      message: `Content-Type ${type} is not one of ${declared}`
+    });
+    return;
+  }
+  switch (media.kind) {
+    case "json": {
+      const text = await read(c, () => c.req.text());
+      if (text === "")
+        return absent("json");
+      let value;
+      try {
+        value = JSON.parse(text);
+      } catch {
+        issues.push({
+          target: "json",
+          path: [],
+          code: "invalid_json",
+          message: "The request body is not valid JSON"
+        });
+        return;
+      }
+      if (media.schema)
+        check("json", media.schema, value);
+      else
+        c.req.addValidatedData("json", value);
+      return;
+    }
+    case "form": {
+      const bytes = await read(c, () => c.req.arrayBuffer());
+      if (bytes.byteLength === 0)
+        return absent("form");
+      let value;
+      try {
+        value = await c.req.parseBody({ all: true });
+      } catch {
+        issues.push({
+          target: "form",
+          path: [],
+          code: "invalid_form",
+          message: `The request body is not a valid ${type} form`
+        });
+        return;
+      }
+      if (media.schema)
+        check("form", media.schema, value);
+      else
+        c.req.addValidatedData("form", value);
+      return;
+    }
+    case "text": {
+      const text = await read(c, () => c.req.text());
+      if (text === "")
+        return absent("body");
+      if (media.schema)
+        check("body", media.schema, text);
+      return;
+    }
+    default:
+      if (c.req.header("content-length") === "0")
+        absent("body");
+      return;
+  }
+}
+async function read(c, body) {
+  try {
+    return await body();
+  } catch (error) {
+    if (!c.req.raw.bodyUsed)
+      throw error;
+    throw new Error("A middleware read the request body through c.req.raw before validation. Read it with c.req.json(), c.req.text() or c.req.arrayBuffer(), which Hono caches for the next reader", { cause: error });
+  }
+}
+async function fail(c, settings, failure) {
+  const answer = await settings.onValidationError?.(failure, c);
+  return answer instanceof Response ? answer : validationErrorHandler(failure, c);
+}
+function reply(id, operation, handler, settings) {
+  return async (c, next) => {
+    running.set(c, { id, operation, settings });
+    const response = await handler(c, next);
+    if (!settings.validateResponses || !(response instanceof Response)) {
+      return response;
+    }
+    const issues = await checkReply(id, operation, response);
+    if (issues.length === 0)
+      return response;
+    return fail(c, settings, {
+      kind: "response",
+      operationId: id,
+      method: operation.method,
+      path: operation.path,
+      status: response.status,
+      issues
+    });
+  };
+}
+var STREAMS = new Set([
+  "text/event-stream",
+  "application/x-ndjson",
+  "application/jsonl",
+  "application/json-seq"
+]);
+function sentBy(content, type) {
+  const kind = type === "application/json" ? "json" : type === "text/plain" ? "text" : undefined;
+  return Object.values(content).find((media) => media.kind === kind);
+}
+async function checkReply(id, operation, response) {
+  const issue = (code, message) => [
+    { target: "response", path: [], code, message }
+  ];
+  const declared = operation.responses[response.status];
+  if (!declared) {
+    return issue("undeclared_status", `${id} declares no ${response.status} reply`);
+  }
+  const types = Object.keys(declared);
+  if (types.length === 0)
+    return [];
+  const header = response.headers.get("content-type");
+  const type = header === null ? undefined : mediaType(header);
+  const media = type === undefined ? undefined : match(declared, type) ?? sentBy(declared, type);
+  if (!media) {
+    return issue("invalid_content_type", `A ${response.status} reply of ${id} is ${types.join(" or ")}, not ${header ?? "untyped"}`);
+  }
+  if (!media.schema || media.kind !== "json" && media.kind !== "text" || STREAMS.has(type ?? "")) {
+    return [];
+  }
+  const text = await response.clone().text();
+  let value = text;
+  if (media.kind === "json") {
+    try {
+      value = JSON.parse(text);
+    } catch {
+      return issue("invalid_json", "The reply body is not valid JSON");
+    }
+  }
+  const result = media.schema.safeParse(value);
+  return result.success ? [] : toIssues("response", result.error.issues);
+}
+// src/streams.ts
+var RS = String.fromCharCode(30);
+function streamOf(c, id, kind) {
+  const route = runningRoute(c);
+  if (route?.id !== id) {
+    throw new Error(`${id}: stream its reply from the handler of its own route, registered with routes`);
+  }
+  for (const [status, content] of Object.entries(route.operation.responses)) {
+    const code = Number(status);
+    if (code < 200 || code > 299)
+      continue;
+    for (const [type, media] of Object.entries(content)) {
+      if (media.kind === kind)
+        return { route, code, type, media };
+    }
+  }
+  throw new Error(`${id} does not reply with ${kind === "sse" ? "server-sent events" : "JSON lines"}`);
+}
+function streamed(c, status, headers, run) {
+  const { readable, writable } = new TransformStream;
+  const writer = writable.getWriter();
+  const encoder = new TextEncoder;
+  const listeners = [];
+  let aborted = false;
+  const abort = () => {
+    if (aborted)
+      return;
+    aborted = true;
+    for (const listener of listeners)
+      listener();
+  };
+  writer.closed.catch(abort);
+  c.req.raw.signal?.addEventListener("abort", abort);
+  const controls = {
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    get aborted() {
+      return aborted;
+    },
+    onAbort: (listener) => {
+      listeners.push(listener);
+    }
+  };
+  const send = async (text) => {
+    if (aborted)
+      return;
+    await writer.write(encoder.encode(text)).catch(abort);
+  };
+  (async () => {
+    try {
+      await run(send, controls);
+    } catch (error) {
+      console.error(error);
+    } finally {
+      await writer.close().catch(() => {});
+    }
+  })();
+  return c.body(readable, status, headers);
+}
+async function check(c, route, status, validator, json, what) {
+  if (!route.settings.validateResponses || !validator)
+    return;
+  const result = validator.safeParse(JSON.parse(json));
+  if (result.success)
+    return;
+  const { method, path } = route.operation;
+  const failure = {
+    kind: "response",
+    operationId: route.id,
+    method,
+    path,
+    status,
+    issues: toIssues("response", result.error.issues)
+  };
+  await route.settings.onValidationError?.(failure, c);
+  throw new Error(`${route.id} (${method.toUpperCase()} ${path}) streamed ${what} the spec does not declare; the stream ends`, { cause: failure });
+}
+function frame(event, data) {
+  for (const [field, value] of [
+    ["event", event.event],
+    ["id", event.id]
+  ]) {
+    if (value !== undefined && /[\r\n]/.test(value)) {
+      throw new Error(`An event's \`${field}\` cannot hold a line break`);
+    }
+  }
+  const lines = [
+    event.event === undefined ? undefined : `event: ${event.event}`,
+    ...data.split(/\r\n|\r|\n/).map((line) => `data: ${line}`),
+    event.id === undefined ? undefined : `id: ${event.id}`,
+    event.retry === undefined ? undefined : `retry: ${event.retry}`
+  ];
+  return `${lines.filter((line) => line !== undefined).join(`
+`)}
+
+`;
+}
+function streamEvents(c, id, write) {
+  const { route, code, media } = streamOf(c, id, "sse");
+  const headers = {
+    "content-type": "text/event-stream",
+    "cache-control": "no-cache"
+  };
+  return streamed(c, code, headers, (send, controls) => write({
+    ...controls,
+    get aborted() {
+      return controls.aborted;
+    },
+    async write(given) {
+      const event = given;
+      const name = event.event ?? "message";
+      const validator = media.events?.[name];
+      if (media.events && validator === undefined) {
+        throw new Error(`${id} declares no \`${name}\` event`);
+      }
+      const data = validator ? JSON.stringify(event.data) : String(event.data);
+      await check(c, route, code, validator, data, `a \`${name}\` event`);
+      await send(frame(event, data));
+    }
+  }));
+}
+function streamLines(c, id, write) {
+  const { route, code, type, media } = streamOf(c, id, "jsonl");
+  const prefix = type.toLowerCase().startsWith("application/json-seq") ? RS : "";
+  return streamed(c, code, { "content-type": type }, (send, controls) => write({
+    ...controls,
+    get aborted() {
+      return controls.aborted;
+    },
+    async write(item) {
+      const json = JSON.stringify(item);
+      await check(c, route, code, media.item, json, "a line");
+      await send(`${prefix}${json}
+`);
+    }
+  }));
+}
+export {
+  createApi,
+  streamEvents,
+  streamLines,
+  validationErrorHandler
+};
+
+//# debugId=BB964DB307280C7064756E2164756E21
+//# sourceMappingURL=index.js.map