@dotpress/adapter-hono 0.0.0-stage → 2.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present Renaud Guyon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,93 @@
-# Temporary Holding Version
+# @dotpress/adapter-hono
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[Hono](https://hono.dev) adapter for [Dotpress](https://dotpress.dev), on Node.js and AWS Lambda. Supports Hono 4 (4.13 or later); Hono 5 is tested against its release candidate.
+
+> 🚧 Dotpress V2 is in alpha (`2.0.0-alpha`): the API may still change before 2.0.0.
+
+## On Node.js
+
+```sh
+pnpm add @dotpress/core @dotpress/adapter-hono hono @hono/node-server zod
+```
+
+```ts
+import { createApp, defineRoute } from '@dotpress/core'
+import { honoAdapter } from '@dotpress/adapter-hono/node'
+import { secureHeaders } from 'hono/secure-headers'
+
+defineRoute({ path: '/hello', handler: () => ({ message: 'Hello' }) })
+
+const app = await createApp({
+  adapter: honoAdapter({
+    // Native Hono middlewares, before the Dotpress routes
+    beforeRoutes: (app) => {
+      app.use('*', secureHeaders())
+    },
+  }),
+})
+
+await app.listen(3000)
+```
+
+`@dotpress/adapter-hono/node` serves the app with [`@hono/node-server`](https://github.com/honojs/node-server). `close()` waits for pending requests and closes the responses being streamed (Server-Sent Events); `adapter.server()` returns the Node.js HTTP server started by `listen()`.
+
+## On AWS Lambda
+
+```sh
+pnpm add @dotpress/core @dotpress/adapter-hono hono @hono/aws-lambda zod
+```
+
+```ts
+import { createApp } from '@dotpress/core'
+import { honoAdapter } from '@dotpress/adapter-hono'
+import { createLambdaHandler } from '@dotpress/adapter-hono/lambda'
+
+export const handler = createLambdaHandler(() =>
+  createApp({ adapter: honoAdapter(), plugins: [/* ... */] })
+)
+```
+
+`createLambdaHandler()` (based on [`@hono/aws-lambda`](https://github.com/honojs/middleware), which requires Hono 4.13.9 or later) handles the events of API Gateway REST APIs (payload v1), HTTP APIs and Function URLs (payload v2), and Application Load Balancers. Enable the multi-value headers of the target group to receive repeated query keys and send several cookies through a load balancer.
+
+- **Lazy creation.** The factory is called at the first invocation (cold start), and the app is reused by the next invocations of the execution environment. Invocations received meanwhile wait for the same app. The handler export stays synchronous: no top-level `await`.
+- **Recoverable failures.** When the factory fails, the error is logged (`logger` option, console by default), the invocation gets the standard `500` error, and the next invocation calls the factory again.
+- **Buffered responses.** Responses are sent once complete: `stream()` works for finite streams, but Server-Sent Events (`sse()`) are not supported, and a stream that fails makes the invocation fail (`502` from API Gateway) rather than sending a truncated response. Lambda response streaming is not supported yet.
+- **Binary responses** are sent in base64: every content type except text, JSON and XML by default, or as decided by the `isContentTypeBinary(contentType)` option.
+- **`ctx.req.ip`** is the source IP of API Gateway, or the last `X-Forwarded-For` entry behind a load balancer (appended by the load balancer). Behind CloudFront or another proxy, use the `getIp(c)` option of `honoAdapter()`.
+
+## Other runtimes
+
+The main entry, `@dotpress/adapter-hono`, only relies on Hono and Web-standard APIs: no Node.js server. `adapter.fetch` handles a Web `Request`, like `app.fetch` in Hono, for runtimes that take a `fetch` handler:
+
+```ts
+import { honoAdapter } from '@dotpress/adapter-hono'
+
+const adapter = honoAdapter()
+await createApp({ adapter })
+
+export default { fetch: adapter.fetch }
+```
+
+Outside Node.js, `ctx.req.ip` comes from the `getIp(c)` option. Dotpress V2.0 is only tested on Node.js: other runtimes are not officially supported yet.
+
+## Options
+
+| Option | Description |
+| --- | --- |
+| `app` | Existing Hono application. Defaults to `new Hono()`. |
+| `beforeRoutes(app)` | Registers native middlewares and routes before the Dotpress routes. |
+| `afterRoutes(app)` | Registers native middlewares and routes after the Dotpress routes, before the not-found handler. |
+| `bodyLimit` | Maximum request body size in bytes. Defaults to 1 MiB. |
+| `getIp(c)` | Client IP address (`ctx.req.ip`). Defaults to the address given by the runtime: the socket address on Node.js, see below for AWS Lambda. |
+
+## Behavior
+
+- Routes are matched by Dotpress, so they behave the same on every adapter (case-sensitive, static segments before parameters, Hono options such as `strict` do not apply). Use the `basePath` option of `createApp()` rather than `app.basePath()`.
+- Request bodies are read by the adapter: JSON, URL-encoded forms, text and multipart forms are parsed, other content types are exposed as `Uint8Array`. Bodies already read by a native middleware through Hono (`c.req.json()`, `c.req.parseBody()`…) are taken from its cache. Routes declared with `rawBody: true` need the exact bytes: the adapter must read the body, or a native middleware must read it with `c.req.arrayBuffer()` or `c.req.blob()`.
+- `HTTPException` client errors (4xx) thrown by native middlewares use the Dotpress error format and keep their status, message and headers (`WWW-Authenticate` of `bearerAuth()`…). Other errors are unexpected errors (`500`). The adapter takes over `app.notFound()` and `app.onError()`.
+- `ctx.req.ip` does not read proxy headers such as `X-Forwarded-For`: behind a proxy, read them in `getIp(c)`.
+- `ctx.raw` is the Hono context.
+
+## License
+
+MIT

package/dist/chunk-4EA3O2OL.js

@@ -0,0 +1,212 @@
+// src/index.ts
+import {
+  DEFAULT_BODY_LIMIT,
+  HttpError,
+  createRouteMatcher,
+  fromWebRequest,
+  parseRequestBody,
+  payloadTooLargeError,
+  readRequestBody,
+  toWebResponse
+} from "@dotpress/core";
+import { Hono } from "hono";
+var runtimeIp = (c) => {
+  const env = c.env;
+  const socket = env?.incoming?.socket?.remoteAddress;
+  if (typeof socket === "string") return socket;
+  const context = env?.requestContext;
+  const sourceIp = context?.identity?.sourceIp ?? context?.http?.sourceIp;
+  if (typeof sourceIp === "string") return sourceIp;
+  if (context?.elb !== void 0) {
+    const forwarded = c.req.header("x-forwarded-for")?.split(",").at(-1);
+    return forwarded?.trim() || void 0;
+  }
+  return void 0;
+};
+var CLIENT_ERRORS = {
+  400: ["BAD_REQUEST", "Bad Request"],
+  401: ["UNAUTHORIZED", "Unauthorized"],
+  403: ["FORBIDDEN", "Forbidden"],
+  404: ["NOT_FOUND", "Not Found"],
+  405: ["METHOD_NOT_ALLOWED", "Method Not Allowed"],
+  408: ["REQUEST_TIMEOUT", "Request Timeout"],
+  409: ["CONFLICT", "Conflict"],
+  413: ["PAYLOAD_TOO_LARGE", "Payload Too Large"],
+  415: ["UNSUPPORTED_MEDIA_TYPE", "Unsupported Media Type"],
+  422: ["UNPROCESSABLE_ENTITY", "Unprocessable Entity"],
+  429: ["TOO_MANY_REQUESTS", "Too Many Requests"]
+};
+var isHttpException = (error) => error instanceof Error && typeof error.status === "number" && typeof error.getResponse === "function";
+var fromNativeError = (error) => {
+  if (!isHttpException(error)) return error;
+  const { status, message } = error;
+  if (!Number.isInteger(status) || status < 400 || status > 499) return error;
+  const [code, defaultMessage] = CLIENT_ERRORS[status] ?? [
+    "CLIENT_ERROR",
+    "Client Error"
+  ];
+  return new HttpError(status, code, message || defaultMessage, void 0, {
+    cause: error
+  });
+};
+var addNativeHeaders = (response, error) => {
+  if (!error.res) return;
+  for (const [name, value] of error.res.headers) {
+    if (name.startsWith("content-")) continue;
+    if (name === "set-cookie") continue;
+    response.headers[name] = value;
+  }
+  const cookies = error.res.headers.getSetCookie();
+  if (cookies.length > 0) {
+    const current = response.headers["set-cookie"] ?? [];
+    response.headers["set-cookie"] = [
+      ...Array.isArray(current) ? current : [current],
+      ...cookies
+    ];
+  }
+};
+var encoder = new TextEncoder();
+var cachedBody = async (c, limit) => {
+  const cache = c.req.bodyCache;
+  const contentType = c.req.header("content-type");
+  let bytes;
+  let exact = false;
+  let type = contentType;
+  if (cache.arrayBuffer) {
+    bytes = new Uint8Array(await cache.arrayBuffer);
+    exact = true;
+  } else if (cache.blob) {
+    bytes = new Uint8Array(await (await cache.blob).arrayBuffer());
+    exact = true;
+  } else if (cache.text) {
+    bytes = encoder.encode(await cache.text);
+  } else if (cache.formData) {
+    const response = new Response(await cache.formData);
+    bytes = new Uint8Array(await response.arrayBuffer());
+    type = response.headers.get("content-type") ?? void 0;
+  } else {
+    throw new Error(
+      "The request body was read by a native middleware outside the cache of Hono (c.req.raw): read it with c.req.json(), c.req.text() or c.req.arrayBuffer()."
+    );
+  }
+  if (bytes.byteLength > limit) throw payloadTooLargeError();
+  const parsed = await parseRequestBody(bytes, type);
+  return { ...parsed, rawBody: exact ? bytes : void 0 };
+};
+var readBody = (c, limit) => c.req.raw.bodyUsed ? cachedBody(c, limit) : readRequestBody(c.req.raw, limit);
+var track = (body, controller, streams) => {
+  const reader = body.getReader();
+  let stop = () => {
+  };
+  return new ReadableStream({
+    start() {
+      stop = () => {
+        streams.delete(stop);
+        controller.abort();
+        reader.cancel().catch(() => {
+        });
+      };
+      streams.add(stop);
+    },
+    async pull(stream) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          streams.delete(stop);
+          stream.close();
+        } else {
+          stream.enqueue(value);
+        }
+      } catch (error) {
+        streams.delete(stop);
+        stream.error(error);
+      }
+    },
+    cancel(reason) {
+      streams.delete(stop);
+      controller.abort(reason);
+      return reader.cancel(reason);
+    }
+  });
+};
+function honoAdapter(options = {}) {
+  const bodyLimit = options.bodyLimit ?? DEFAULT_BODY_LIMIT;
+  if (!Number.isInteger(bodyLimit) || bodyLimit < 0) {
+    throw new RangeError(
+      "Invalid bodyLimit: expected a non-negative integer (bytes)."
+    );
+  }
+  const application = options.app ?? new Hono();
+  const app = application;
+  const getIp = options.getIp ?? runtimeIp;
+  let mounted = false;
+  const streams = /* @__PURE__ */ new Set();
+  const normalize = (c, signal) => fromWebRequest(c.req.raw, { ip: getIp(c), signal, raw: c });
+  const send = (c, response, controller) => {
+    const { body } = response;
+    if (controller && body instanceof ReadableStream) {
+      return toWebResponse(
+        { ...response, body: track(body, controller, streams) },
+        c.req.method
+      );
+    }
+    return toWebResponse(response, c.req.method);
+  };
+  const handleRoute = async (c, match, runtime) => {
+    const controller = new AbortController();
+    const signal = AbortSignal.any([c.req.raw.signal, controller.signal]);
+    const request = normalize(c, signal);
+    try {
+      const { body, files, rawBody } = await readBody(
+        c,
+        match.route.definition.bodyLimit ?? bodyLimit
+      );
+      request.body = body;
+      request.files = files;
+      request.rawBody = rawBody;
+    } catch (error) {
+      return send(c, await runtime.handleError(error, request));
+    }
+    request.params = match.params;
+    return send(c, await match.route.execute(request), controller);
+  };
+  return {
+    name: "hono",
+    mount: async (routes, runtime) => {
+      if (mounted) throw new Error("The Hono adapter is already mounted.");
+      mounted = true;
+      const matcher = createRouteMatcher(routes);
+      await options.beforeRoutes?.(application);
+      app.use("*", async (c, next) => {
+        const match = matcher.match(c.req.method, new URL(c.req.url).pathname);
+        if (!match) {
+          await next();
+          return;
+        }
+        return handleRoute(c, match, runtime);
+      });
+      await options.afterRoutes?.(application);
+      app.notFound(
+        async (c) => send(c, await runtime.handleNotFound(normalize(c)))
+      );
+      app.onError(async (error, c) => {
+        const converted = fromNativeError(error);
+        const response = await runtime.handleError(converted, normalize(c));
+        if (converted !== error) {
+          addNativeHeaders(response, error);
+        }
+        return send(c, response);
+      });
+    },
+    fetch: async (request, env, executionContext) => app.fetch(request, env, executionContext),
+    close: async () => {
+      for (const stop of [...streams]) stop();
+    },
+    native: () => application
+  };
+}
+
+export {
+  honoAdapter
+};
+//# sourceMappingURL=chunk-4EA3O2OL.js.map

package/dist/chunk-4EA3O2OL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import {\n  DEFAULT_BODY_LIMIT,\n  HttpError,\n  createRouteMatcher,\n  fromWebRequest,\n  parseRequestBody,\n  payloadTooLargeError,\n  readRequestBody,\n  toWebResponse,\n  type CompiledRoute,\n  type DotpressRuntime,\n  type HttpAdapter,\n  type NormalizedRequest,\n  type NormalizedResponse,\n  type RequestBody,\n  type RouteMatch,\n} from '@dotpress/core'\nimport { Hono, type Context } from 'hono'\n\n/**\n * Minimal shape of a Hono application (Hono 4 or 5). The types of Hono 5\n * differ from those of Hono 4, hence the loose signatures.\n */\nexport interface HonoApplication {\n  use: (...args: never[]) => unknown\n  notFound: (...args: never[]) => unknown\n  onError: (...args: never[]) => unknown\n  fetch: (\n    request: Request,\n    env?: never,\n    executionContext?: never\n  ) => Response | Promise<Response>\n}\n\n/** Members of the Hono application used by the adapter. */\ninterface MountableApp {\n  use(\n    path: string,\n    handler: (c: Context, next: () => Promise<void>) => Promise<Response | void>\n  ): unknown\n  notFound(handler: (c: Context) => Promise<Response>): unknown\n  onError(handler: (error: Error, c: Context) => Promise<Response>): unknown\n  fetch(\n    request: Request,\n    env?: unknown,\n    executionContext?: unknown\n  ): Response | Promise<Response>\n}\n\nexport interface HonoAdapterOptions<TApp extends HonoApplication> {\n  /** Hono application to mount the routes on. Defaults to `new Hono()`. */\n  app?: TApp\n  /** Registers native middlewares before the Dotpress routes. */\n  beforeRoutes?: (app: TApp) => void | Promise<void>\n  /**\n   * Registers native middlewares and routes after the Dotpress routes,\n   * before the not-found handler.\n   */\n  afterRoutes?: (app: TApp) => void | Promise<void>\n  /**\n   * Maximum request body size, in bytes. Defaults to 1 MiB. Routes can\n   * override it with their own `bodyLimit`.\n   */\n  bodyLimit?: number\n  /**\n   * Client IP address of a request (`ctx.req.ip`). Defaults to the address\n   * given by the runtime: the socket on Node.js, the source IP of API\n   * Gateway, the last `X-Forwarded-For` entry behind an Application Load\n   * Balancer (added by the load balancer). Proxy headers are not read\n   * otherwise: behind another proxy (CloudFront…), read them here.\n   */\n  getIp?: (c: Context) => string | undefined\n}\n\nexport interface HonoAdapter<\n  TApp extends HonoApplication = Hono,\n> extends HttpAdapter<TApp> {\n  /**\n   * Handles a Web request, like `app.native().fetch()`: for runtimes that\n   * take a `fetch` handler, and for tests.\n   */\n  fetch(\n    request: Request,\n    env?: unknown,\n    executionContext?: unknown\n  ): Promise<Response>\n  /** Closes the responses being streamed (their `req.signal` is aborted). */\n  close(): Promise<void>\n}\n\n/** Environment given by `@hono/node-server` and `@hono/aws-lambda`. */\ninterface RuntimeEnv {\n  readonly incoming?: { readonly socket?: { readonly remoteAddress?: unknown } }\n  readonly requestContext?: {\n    readonly identity?: { readonly sourceIp?: unknown }\n    readonly http?: { readonly sourceIp?: unknown }\n    readonly elb?: unknown\n  }\n}\n\n/**\n * Client address given by the runtime: the socket on Node.js, the source\n * IP of API Gateway (REST and HTTP APIs, Function URLs), or the address\n * appended to `X-Forwarded-For` by an Application Load Balancer.\n */\nconst runtimeIp = (c: Context): string | undefined => {\n  const env = c.env as RuntimeEnv | undefined\n\n  const socket = env?.incoming?.socket?.remoteAddress\n  if (typeof socket === 'string') return socket\n\n  const context = env?.requestContext\n  const sourceIp = context?.identity?.sourceIp ?? context?.http?.sourceIp\n  if (typeof sourceIp === 'string') return sourceIp\n\n  if (context?.elb !== undefined) {\n    const forwarded = c.req.header('x-forwarded-for')?.split(',').at(-1)\n    return forwarded?.trim() || undefined\n  }\n  return undefined\n}\n\n/** Code and default message of client errors. */\nconst CLIENT_ERRORS: Record<number, readonly [string, string]> = {\n  400: ['BAD_REQUEST', 'Bad Request'],\n  401: ['UNAUTHORIZED', 'Unauthorized'],\n  403: ['FORBIDDEN', 'Forbidden'],\n  404: ['NOT_FOUND', 'Not Found'],\n  405: ['METHOD_NOT_ALLOWED', 'Method Not Allowed'],\n  408: ['REQUEST_TIMEOUT', 'Request Timeout'],\n  409: ['CONFLICT', 'Conflict'],\n  413: ['PAYLOAD_TOO_LARGE', 'Payload Too Large'],\n  415: ['UNSUPPORTED_MEDIA_TYPE', 'Unsupported Media Type'],\n  422: ['UNPROCESSABLE_ENTITY', 'Unprocessable Entity'],\n  429: ['TOO_MANY_REQUESTS', 'Too Many Requests'],\n}\n\ninterface HttpExceptionLike {\n  readonly status: number\n  readonly message: string\n  readonly res?: Response\n  getResponse(): Response\n}\n\n/** `HTTPException` of Hono 4 or 5, recognized by its shape. */\nconst isHttpException = (error: unknown): error is HttpExceptionLike =>\n  error instanceof Error &&\n  typeof (error as Partial<HttpExceptionLike>).status === 'number' &&\n  typeof (error as Partial<HttpExceptionLike>).getResponse === 'function'\n\n/**\n * Converts the client errors (4xx) raised by native middlewares\n * (`HTTPException`) into Dotpress errors, with the same status. Anything\n * else is an unexpected error.\n */\nconst fromNativeError = (error: unknown): unknown => {\n  if (!isHttpException(error)) return error\n\n  const { status, message } = error\n  if (!Number.isInteger(status) || status < 400 || status > 499) return error\n\n  const [code, defaultMessage] = CLIENT_ERRORS[status] ?? [\n    'CLIENT_ERROR',\n    'Client Error',\n  ]\n  return new HttpError(status, code, message || defaultMessage, undefined, {\n    cause: error,\n  })\n}\n\n/**\n * Adds the headers of the custom response of an `HTTPException`\n * (`WWW-Authenticate`…) to the Dotpress error response.\n */\nconst addNativeHeaders = (\n  response: NormalizedResponse,\n  error: HttpExceptionLike\n) => {\n  if (!error.res) return\n  for (const [name, value] of error.res.headers) {\n    if (name.startsWith('content-')) continue\n    if (name === 'set-cookie') continue\n    response.headers[name] = value\n  }\n  const cookies = error.res.headers.getSetCookie()\n  if (cookies.length > 0) {\n    const current = response.headers['set-cookie'] ?? []\n    response.headers['set-cookie'] = [\n      ...(Array.isArray(current) ? current : [current]),\n      ...cookies,\n    ]\n  }\n}\n\nconst encoder = new TextEncoder()\n\n/**\n * Body already read by a native middleware, from the cache of Hono\n * (`c.req.json()`, `c.req.parseBody()`…). Only an `ArrayBuffer` or a\n * `Blob` keeps the exact bytes (`rawBody`).\n */\nconst cachedBody = async (c: Context, limit: number): Promise<RequestBody> => {\n  const cache = c.req.bodyCache as Partial<\n    Record<'arrayBuffer' | 'blob' | 'text' | 'formData', Promise<unknown>>\n  >\n  const contentType = c.req.header('content-type')\n\n  let bytes: Uint8Array\n  let exact = false\n  let type = contentType\n\n  if (cache.arrayBuffer) {\n    bytes = new Uint8Array((await cache.arrayBuffer) as ArrayBuffer)\n    exact = true\n  } else if (cache.blob) {\n    bytes = new Uint8Array(await ((await cache.blob) as Blob).arrayBuffer())\n    exact = true\n  } else if (cache.text) {\n    bytes = encoder.encode((await cache.text) as string)\n  } else if (cache.formData) {\n    // Serialized again, with a new boundary.\n    const response = new Response((await cache.formData) as FormData)\n    bytes = new Uint8Array(await response.arrayBuffer())\n    type = response.headers.get('content-type') ?? undefined\n  } else {\n    throw new Error(\n      'The request body was read by a native middleware outside the cache of Hono (c.req.raw): read it with c.req.json(), c.req.text() or c.req.arrayBuffer().'\n    )\n  }\n\n  if (bytes.byteLength > limit) throw payloadTooLargeError()\n  const parsed = await parseRequestBody(bytes, type)\n  return { ...parsed, rawBody: exact ? bytes : undefined }\n}\n\n// Reading the body through Hono consumes the request.\nconst readBody = (c: Context, limit: number): Promise<RequestBody> =>\n  c.req.raw.bodyUsed ? cachedBody(c, limit) : readRequestBody(c.req.raw, limit)\n\n/**\n * Closes the streamed body when the adapter is closed, and aborts the\n * request signal when the client cancels it.\n */\nconst track = (\n  body: ReadableStream<Uint8Array>,\n  controller: AbortController,\n  streams: Set<() => void>\n): ReadableStream<Uint8Array> => {\n  const reader = body.getReader()\n  let stop: () => void = () => {}\n\n  return new ReadableStream<Uint8Array>({\n    start() {\n      // The cancelled reader ends the stream (see `pull()`).\n      stop = () => {\n        streams.delete(stop)\n        controller.abort()\n        reader.cancel().catch(() => {})\n      }\n      streams.add(stop)\n    },\n    async pull(stream) {\n      try {\n        const { done, value } = await reader.read()\n        if (done) {\n          streams.delete(stop)\n          stream.close()\n        } else {\n          stream.enqueue(value)\n        }\n      } catch (error) {\n        streams.delete(stop)\n        stream.error(error)\n      }\n    },\n    cancel(reason) {\n      streams.delete(stop)\n      controller.abort(reason)\n      return reader.cancel(reason)\n    },\n  })\n}\n\n/**\n * Creates the Hono adapter. The main entry is runtime-agnostic: serve\n * `adapter.fetch` with the runtime, or use `honoAdapter()` of\n * `@dotpress/adapter-hono/node` to listen on Node.js.\n *\n * @example\n * const adapter = honoAdapter()\n * await createApp({ adapter })\n * export default { fetch: adapter.fetch }\n */\nexport function honoAdapter(options?: HonoAdapterOptions<Hono>): HonoAdapter\nexport function honoAdapter<TApp extends HonoApplication>(\n  options: HonoAdapterOptions<TApp> & { app: TApp }\n): HonoAdapter<TApp>\nexport function honoAdapter<TApp extends HonoApplication>(\n  options: HonoAdapterOptions<TApp> = {}\n): HonoAdapter<TApp> {\n  const bodyLimit = options.bodyLimit ?? DEFAULT_BODY_LIMIT\n\n  if (!Number.isInteger(bodyLimit) || bodyLimit < 0) {\n    throw new RangeError(\n      'Invalid bodyLimit: expected a non-negative integer (bytes).'\n    )\n  }\n\n  const application = options.app ?? (new Hono() as unknown as TApp)\n  const app = application as unknown as MountableApp\n  const getIp = options.getIp ?? runtimeIp\n  let mounted = false\n  /** Closes the responses being streamed, so that `close()` can complete. */\n  const streams = new Set<() => void>()\n\n  const normalize = (c: Context, signal?: AbortSignal): NormalizedRequest =>\n    fromWebRequest(c.req.raw, { ip: getIp(c), signal, raw: c })\n\n  const send = (\n    c: Context,\n    response: NormalizedResponse,\n    controller?: AbortController\n  ): Promise<Response> => {\n    const { body } = response\n    if (controller && body instanceof ReadableStream) {\n      return toWebResponse(\n        { ...response, body: track(body, controller, streams) },\n        c.req.method\n      )\n    }\n    return toWebResponse(response, c.req.method)\n  }\n\n  const handleRoute = async (\n    c: Context,\n    match: RouteMatch,\n    runtime: DotpressRuntime\n  ): Promise<Response> => {\n    const controller = new AbortController()\n    const signal = AbortSignal.any([c.req.raw.signal, controller.signal])\n    const request = normalize(c, signal)\n\n    try {\n      const { body, files, rawBody } = await readBody(\n        c,\n        match.route.definition.bodyLimit ?? bodyLimit\n      )\n      request.body = body\n      request.files = files\n      request.rawBody = rawBody\n    } catch (error) {\n      return send(c, await runtime.handleError(error, request))\n    }\n\n    request.params = match.params\n    return send(c, await match.route.execute(request), controller)\n  }\n\n  return {\n    name: 'hono',\n\n    mount: async (\n      routes: readonly CompiledRoute[],\n      runtime: DotpressRuntime\n    ) => {\n      if (mounted) throw new Error('The Hono adapter is already mounted.')\n      mounted = true\n\n      const matcher = createRouteMatcher(routes)\n\n      await options.beforeRoutes?.(application)\n\n      app.use('*', async (c, next) => {\n        const match = matcher.match(c.req.method, new URL(c.req.url).pathname)\n        if (!match) {\n          await next()\n          return\n        }\n        return handleRoute(c, match, runtime)\n      })\n\n      await options.afterRoutes?.(application)\n\n      app.notFound(async (c) =>\n        send(c, await runtime.handleNotFound(normalize(c)))\n      )\n\n      app.onError(async (error, c) => {\n        const converted = fromNativeError(error)\n        const response = await runtime.handleError(converted, normalize(c))\n        if (converted !== error) {\n          addNativeHeaders(response, error as unknown as HttpExceptionLike)\n        }\n        return send(c, response)\n      })\n    },\n\n    fetch: async (request, env, executionContext) =>\n      app.fetch(request, env, executionContext),\n\n    close: async () => {\n      for (const stop of [...streams]) stop()\n    },\n\n    native: () => application,\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,63 @@
+import { HttpAdapter } from '@dotpress/core';
+import { Hono, Context } from 'hono';
+
+/**
+ * Minimal shape of a Hono application (Hono 4 or 5). The types of Hono 5
+ * differ from those of Hono 4, hence the loose signatures.
+ */
+interface HonoApplication {
+    use: (...args: never[]) => unknown;
+    notFound: (...args: never[]) => unknown;
+    onError: (...args: never[]) => unknown;
+    fetch: (request: Request, env?: never, executionContext?: never) => Response | Promise<Response>;
+}
+interface HonoAdapterOptions<TApp extends HonoApplication> {
+    /** Hono application to mount the routes on. Defaults to `new Hono()`. */
+    app?: TApp;
+    /** Registers native middlewares before the Dotpress routes. */
+    beforeRoutes?: (app: TApp) => void | Promise<void>;
+    /**
+     * Registers native middlewares and routes after the Dotpress routes,
+     * before the not-found handler.
+     */
+    afterRoutes?: (app: TApp) => void | Promise<void>;
+    /**
+     * Maximum request body size, in bytes. Defaults to 1 MiB. Routes can
+     * override it with their own `bodyLimit`.
+     */
+    bodyLimit?: number;
+    /**
+     * Client IP address of a request (`ctx.req.ip`). Defaults to the address
+     * given by the runtime: the socket on Node.js, the source IP of API
+     * Gateway, the last `X-Forwarded-For` entry behind an Application Load
+     * Balancer (added by the load balancer). Proxy headers are not read
+     * otherwise: behind another proxy (CloudFront…), read them here.
+     */
+    getIp?: (c: Context) => string | undefined;
+}
+interface HonoAdapter<TApp extends HonoApplication = Hono> extends HttpAdapter<TApp> {
+    /**
+     * Handles a Web request, like `app.native().fetch()`: for runtimes that
+     * take a `fetch` handler, and for tests.
+     */
+    fetch(request: Request, env?: unknown, executionContext?: unknown): Promise<Response>;
+    /** Closes the responses being streamed (their `req.signal` is aborted). */
+    close(): Promise<void>;
+}
+/**
+ * Creates the Hono adapter. The main entry is runtime-agnostic: serve
+ * `adapter.fetch` with the runtime, or use `honoAdapter()` of
+ * `@dotpress/adapter-hono/node` to listen on Node.js.
+ *
+ * @example
+ * const adapter = honoAdapter()
+ * await createApp({ adapter })
+ * export default { fetch: adapter.fetch }
+ */
+declare function honoAdapter(options?: HonoAdapterOptions<Hono>): HonoAdapter;
+declare function honoAdapter<TApp extends HonoApplication>(options: HonoAdapterOptions<TApp> & {
+    app: TApp;
+}): HonoAdapter<TApp>;
+
+export { honoAdapter };
+export type { HonoAdapter, HonoAdapterOptions, HonoApplication };

package/dist/index.js

@@ -0,0 +1,7 @@
+import {
+  honoAdapter
+} from "./chunk-4EA3O2OL.js";
+export {
+  honoAdapter
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/lambda.d.ts

@@ -0,0 +1,43 @@
+import { App, Logger } from '@dotpress/core';
+import { LambdaEvent, LambdaContext, APIGatewayProxyResult } from '@hono/aws-lambda';
+export { APIGatewayProxyResult, LambdaContext, LambdaEvent } from '@hono/aws-lambda';
+import { HonoApplication } from './index.js';
+import 'hono';
+
+interface LambdaHandlerOptions {
+    /** Logs the failures to create the app. Defaults to a console logger. */
+    logger?: Logger;
+    /**
+     * Whether a response content type is binary (sent in base64). Defaults to
+     * the rule of `@hono/aws-lambda`: everything except text, JSON and XML.
+     */
+    isContentTypeBinary?: (contentType: string) => boolean;
+}
+/**
+ * AWS Lambda handler: API Gateway REST (payload v1) and HTTP APIs (payload
+ * v2), Function URLs, Application Load Balancer.
+ */
+type LambdaHandler = (event: LambdaEvent, context?: LambdaContext) => Promise<APIGatewayProxyResult>;
+/** App of the factory, created with `honoAdapter()`. */
+type LambdaApp = Pick<App<HonoApplication>, 'native'>;
+/**
+ * Creates the AWS Lambda handler of an app (`@hono/aws-lambda`).
+ *
+ * The app is created by the factory at the first invocation (cold start),
+ * then reused by the next invocations of the execution environment.
+ * Invocations received meanwhile wait for the same app. When the factory
+ * fails, the error is logged, the invocation gets a `500` error, and the
+ * next invocation calls the factory again.
+ *
+ * Responses are sent once complete: streamed responses (`stream()`) are
+ * buffered, and Server-Sent Events are not supported.
+ *
+ * @example
+ * export const handler = createLambdaHandler(() =>
+ *   createApp({ adapter: honoAdapter(), plugins: [authPlugin(auth)] })
+ * )
+ */
+declare const createLambdaHandler: (factory: () => LambdaApp | Promise<LambdaApp>, options?: LambdaHandlerOptions) => LambdaHandler;
+
+export { createLambdaHandler };
+export type { LambdaApp, LambdaHandler, LambdaHandlerOptions };

package/dist/lambda.js

@@ -0,0 +1,55 @@
+// src/lambda.ts
+import {
+  createConsoleLogger,
+  internalError,
+  toErrorBody
+} from "@dotpress/core";
+import {
+  handle
+} from "@hono/aws-lambda";
+import { Hono } from "hono";
+var failureApp = () => new Hono().all(
+  "*",
+  () => new Response(JSON.stringify(toErrorBody(internalError())), {
+    status: 500,
+    headers: { "content-type": "application/json; charset=utf-8" }
+  })
+);
+var createLambdaHandler = (factory, options = {}) => {
+  const logger = options.logger ?? createConsoleLogger();
+  const toHandler = (app) => handle(app, {
+    isContentTypeBinary: options.isContentTypeBinary
+  });
+  let ready;
+  let failure;
+  const init = async () => {
+    const app = await factory();
+    const native = app?.native?.();
+    if (typeof native?.fetch !== "function") {
+      throw new TypeError(
+        "createLambdaHandler() expects an app created with honoAdapter() of @dotpress/adapter-hono."
+      );
+    }
+    return toHandler(native);
+  };
+  return async (event, context) => {
+    const current = ready ??= init();
+    let handler;
+    try {
+      handler = await current;
+    } catch (error) {
+      if (ready === current) ready = void 0;
+      logger.error(
+        error instanceof Error ? error : { error },
+        "Failed to create the app"
+      );
+      failure ??= toHandler(failureApp());
+      return failure(event, context);
+    }
+    return handler(event, context);
+  };
+};
+export {
+  createLambdaHandler
+};
+//# sourceMappingURL=lambda.js.map

package/dist/lambda.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lambda.ts"],"sourcesContent":["import {\n  createConsoleLogger,\n  internalError,\n  toErrorBody,\n  type App,\n  type Logger,\n} from '@dotpress/core'\nimport {\n  handle,\n  type APIGatewayProxyResult,\n  type LambdaContext,\n  type LambdaEvent,\n} from '@hono/aws-lambda'\nimport { Hono } from 'hono'\nimport type { HonoApplication } from './index.js'\n\nexport type { APIGatewayProxyResult, LambdaContext, LambdaEvent }\n\nexport interface LambdaHandlerOptions {\n  /** Logs the failures to create the app. Defaults to a console logger. */\n  logger?: Logger\n  /**\n   * Whether a response content type is binary (sent in base64). Defaults to\n   * the rule of `@hono/aws-lambda`: everything except text, JSON and XML.\n   */\n  isContentTypeBinary?: (contentType: string) => boolean\n}\n\n/**\n * AWS Lambda handler: API Gateway REST (payload v1) and HTTP APIs (payload\n * v2), Function URLs, Application Load Balancer.\n */\nexport type LambdaHandler = (\n  event: LambdaEvent,\n  context?: LambdaContext\n) => Promise<APIGatewayProxyResult>\n\n/** App of the factory, created with `honoAdapter()`. */\nexport type LambdaApp = Pick<App<HonoApplication>, 'native'>\n\n/** Answers `500 INTERNAL_ERROR` when the app cannot be created. */\nconst failureApp = () =>\n  new Hono().all(\n    '*',\n    () =>\n      new Response(JSON.stringify(toErrorBody(internalError())), {\n        status: 500,\n        headers: { 'content-type': 'application/json; charset=utf-8' },\n      })\n  )\n\n/**\n * Creates the AWS Lambda handler of an app (`@hono/aws-lambda`).\n *\n * The app is created by the factory at the first invocation (cold start),\n * then reused by the next invocations of the execution environment.\n * Invocations received meanwhile wait for the same app. When the factory\n * fails, the error is logged, the invocation gets a `500` error, and the\n * next invocation calls the factory again.\n *\n * Responses are sent once complete: streamed responses (`stream()`) are\n * buffered, and Server-Sent Events are not supported.\n *\n * @example\n * export const handler = createLambdaHandler(() =>\n *   createApp({ adapter: honoAdapter(), plugins: [authPlugin(auth)] })\n * )\n */\nexport const createLambdaHandler = (\n  factory: () => LambdaApp | Promise<LambdaApp>,\n  options: LambdaHandlerOptions = {}\n): LambdaHandler => {\n  const logger = options.logger ?? createConsoleLogger()\n  const toHandler = (app: HonoApplication) =>\n    handle(app as unknown as Hono, {\n      isContentTypeBinary: options.isContentTypeBinary,\n    }) as LambdaHandler\n\n  let ready: Promise<LambdaHandler> | undefined\n  let failure: LambdaHandler | undefined\n\n  const init = async (): Promise<LambdaHandler> => {\n    const app = await factory()\n    const native: unknown = app?.native?.()\n    if (typeof (native as Partial<HonoApplication>)?.fetch !== 'function') {\n      throw new TypeError(\n        'createLambdaHandler() expects an app created with honoAdapter() of @dotpress/adapter-hono.'\n      )\n    }\n    return toHandler(native as HonoApplication)\n  }\n\n  return async (event, context) => {\n    const current = (ready ??= init())\n    let handler: LambdaHandler\n    try {\n      handler = await current\n    } catch (error) {\n      // Retried at the next invocation.\n      if (ready === current) ready = undefined\n      logger.error(\n        error instanceof Error ? error : { error },\n        'Failed to create the app'\n      )\n      failure ??= toHandler(failureApp() as unknown as HonoApplication)\n      return failure(event, context)\n    }\n    return handler(event, context)\n  }\n}\n"],"mappings":";AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAGK;AACP;AAAA,EACE;AAAA,OAIK;AACP,SAAS,YAAY;AA4BrB,IAAM,aAAa,MACjB,IAAI,KAAK,EAAE;AAAA,EACT;AAAA,EACA,MACE,IAAI,SAAS,KAAK,UAAU,YAAY,cAAc,CAAC,CAAC,GAAG;AAAA,IACzD,QAAQ;AAAA,IACR,SAAS,EAAE,gBAAgB,kCAAkC;AAAA,EAC/D,CAAC;AACL;AAmBK,IAAM,sBAAsB,CACjC,SACA,UAAgC,CAAC,MACf;AAClB,QAAM,SAAS,QAAQ,UAAU,oBAAoB;AACrD,QAAM,YAAY,CAAC,QACjB,OAAO,KAAwB;AAAA,IAC7B,qBAAqB,QAAQ;AAAA,EAC/B,CAAC;AAEH,MAAI;AACJ,MAAI;AAEJ,QAAM,OAAO,YAAoC;AAC/C,UAAM,MAAM,MAAM,QAAQ;AAC1B,UAAM,SAAkB,KAAK,SAAS;AACtC,QAAI,OAAQ,QAAqC,UAAU,YAAY;AACrE,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AACA,WAAO,UAAU,MAAyB;AAAA,EAC5C;AAEA,SAAO,OAAO,OAAO,YAAY;AAC/B,UAAM,UAAW,UAAU,KAAK;AAChC,QAAI;AACJ,QAAI;AACF,gBAAU,MAAM;AAAA,IAClB,SAAS,OAAO;AAEd,UAAI,UAAU,QAAS,SAAQ;AAC/B,aAAO;AAAA,QACL,iBAAiB,QAAQ,QAAQ,EAAE,MAAM;AAAA,QACzC;AAAA,MACF;AACA,kBAAY,UAAU,WAAW,CAA+B;AAChE,aAAO,QAAQ,OAAO,OAAO;AAAA,IAC/B;AACA,WAAO,QAAQ,OAAO,OAAO;AAAA,EAC/B;AACF;","names":[]}

package/dist/node.d.ts

@@ -0,0 +1,31 @@
+import { Server } from 'node:http';
+import { Hono } from 'hono';
+import { HonoApplication, HonoAdapter, HonoAdapterOptions } from './index.js';
+import '@dotpress/core';
+
+interface NodeHonoAdapter<TApp extends HonoApplication = Hono> extends HonoAdapter<TApp> {
+    /** Starts an HTTP server (`@hono/node-server`). */
+    listen(port: number, host?: string): Promise<void>;
+    /**
+     * Stops the HTTP server: waits for pending requests, and closes the
+     * responses being streamed (their `req.signal` is aborted).
+     */
+    close(): Promise<void>;
+    /** HTTP server started by `listen()`, if any. */
+    server(): Server | undefined;
+}
+/**
+ * Creates the Hono adapter for Node.js: the adapter of
+ * `@dotpress/adapter-hono`, with an HTTP server (`@hono/node-server`).
+ *
+ * @example
+ * const app = await createApp({ adapter: honoAdapter() })
+ * await app.listen(3000)
+ */
+declare function honoAdapter(options?: HonoAdapterOptions<Hono>): NodeHonoAdapter;
+declare function honoAdapter<TApp extends HonoApplication>(options: HonoAdapterOptions<TApp> & {
+    app: TApp;
+}): NodeHonoAdapter<TApp>;
+
+export { HonoAdapter, HonoAdapterOptions, HonoApplication, honoAdapter };
+export type { NodeHonoAdapter };

package/dist/node.js

@@ -0,0 +1,70 @@
+import {
+  honoAdapter
+} from "./chunk-4EA3O2OL.js";
+
+// src/node.ts
+import { createAdaptorServer } from "@hono/node-server";
+var trackConnections = (server) => {
+  const sockets = /* @__PURE__ */ new Set();
+  let closing = false;
+  server.on("connection", (socket) => {
+    sockets.add(socket);
+    socket.once("close", () => sockets.delete(socket));
+  });
+  server.on(
+    "request",
+    (_request, response) => {
+      response.once("finish", () => {
+        if (closing) server.closeIdleConnections();
+      });
+    }
+  );
+  return () => {
+    closing = true;
+    for (const socket of sockets) {
+      if (socket.bytesRead === 0) socket.destroy();
+    }
+  };
+};
+function honoAdapter2(options = {}) {
+  const adapter = honoAdapter(
+    options
+  );
+  let server;
+  let closeConnections = () => {
+  };
+  return {
+    ...adapter,
+    listen: async (port, host) => {
+      if (server) throw new Error("The Hono adapter is already listening.");
+      const created = createAdaptorServer({ fetch: adapter.fetch });
+      await new Promise((resolve, reject) => {
+        created.once("error", reject);
+        created.listen(port, host, () => {
+          created.off("error", reject);
+          resolve();
+        });
+      });
+      server = created;
+      closeConnections = trackConnections(created);
+    },
+    close: async () => {
+      const current = server;
+      server = void 0;
+      if (!current) {
+        await adapter.close();
+        return;
+      }
+      await new Promise((resolve, reject) => {
+        current.close((error) => error ? reject(error) : resolve());
+        closeConnections();
+        void adapter.close();
+      });
+    },
+    server: () => server
+  };
+}
+export {
+  honoAdapter2 as honoAdapter
+};
+//# sourceMappingURL=node.js.map

package/dist/node.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/node.ts"],"sourcesContent":["import type { IncomingMessage, Server, ServerResponse } from 'node:http'\nimport type { Socket } from 'node:net'\nimport { createAdaptorServer } from '@hono/node-server'\nimport type { Hono } from 'hono'\nimport {\n  honoAdapter as createHonoAdapter,\n  type HonoAdapter,\n  type HonoAdapterOptions,\n  type HonoApplication,\n} from './index.js'\n\nexport * from './index.js'\n\nexport interface NodeHonoAdapter<\n  TApp extends HonoApplication = Hono,\n> extends HonoAdapter<TApp> {\n  /** Starts an HTTP server (`@hono/node-server`). */\n  listen(port: number, host?: string): Promise<void>\n  /**\n   * Stops the HTTP server: waits for pending requests, and closes the\n   * responses being streamed (their `req.signal` is aborted).\n   */\n  close(): Promise<void>\n  /** HTTP server started by `listen()`, if any. */\n  server(): Server | undefined\n}\n\n/**\n * Lets `close()` complete as soon as the pending requests are served, and\n * returns the function to call on close. Before Node.js 26, `server.close()`\n * waits for the connections that have sent nothing yet (a browser\n * preconnect…) until `headersTimeout`; and, whatever the version, the\n * connections of the pending requests stay open once served, until\n * `keepAliveTimeout`.\n */\nconst trackConnections = (server: Server) => {\n  const sockets = new Set<Socket>()\n  let closing = false\n  server.on('connection', (socket: Socket) => {\n    sockets.add(socket)\n    socket.once('close', () => sockets.delete(socket))\n  })\n  server.on(\n    'request',\n    (_request: IncomingMessage, response: ServerResponse) => {\n      response.once('finish', () => {\n        if (closing) server.closeIdleConnections()\n      })\n    }\n  )\n  return () => {\n    closing = true\n    for (const socket of sockets) {\n      if (socket.bytesRead === 0) socket.destroy()\n    }\n  }\n}\n\n/**\n * Creates the Hono adapter for Node.js: the adapter of\n * `@dotpress/adapter-hono`, with an HTTP server (`@hono/node-server`).\n *\n * @example\n * const app = await createApp({ adapter: honoAdapter() })\n * await app.listen(3000)\n */\nexport function honoAdapter(options?: HonoAdapterOptions<Hono>): NodeHonoAdapter\nexport function honoAdapter<TApp extends HonoApplication>(\n  options: HonoAdapterOptions<TApp> & { app: TApp }\n): NodeHonoAdapter<TApp>\nexport function honoAdapter<TApp extends HonoApplication>(\n  options: HonoAdapterOptions<TApp> = {}\n): NodeHonoAdapter<TApp> {\n  const adapter = createHonoAdapter(\n    options as HonoAdapterOptions<TApp> & { app: TApp }\n  )\n  let server: Server | undefined\n  let closeConnections = () => {}\n\n  return {\n    ...adapter,\n\n    listen: async (port: number, host?: string) => {\n      if (server) throw new Error('The Hono adapter is already listening.')\n\n      const created = createAdaptorServer({ fetch: adapter.fetch }) as Server\n      await new Promise<void>((resolve, reject) => {\n        created.once('error', reject)\n        created.listen(port, host, () => {\n          created.off('error', reject)\n          resolve()\n        })\n      })\n      server = created\n      closeConnections = trackConnections(created)\n    },\n\n    close: async () => {\n      const current = server\n      server = undefined\n      if (!current) {\n        await adapter.close()\n        return\n      }\n\n      await new Promise<void>((resolve, reject) => {\n        // Also closes the idle connections.\n        current.close((error) => (error ? reject(error) : resolve()))\n        closeConnections()\n        // Streams never end by themselves: close them.\n        void adapter.close()\n      })\n    },\n\n    server: () => server,\n  }\n}\n"],"mappings":";;;;;AAEA,SAAS,2BAA2B;AAiCpC,IAAM,mBAAmB,CAAC,WAAmB;AAC3C,QAAM,UAAU,oBAAI,IAAY;AAChC,MAAI,UAAU;AACd,SAAO,GAAG,cAAc,CAAC,WAAmB;AAC1C,YAAQ,IAAI,MAAM;AAClB,WAAO,KAAK,SAAS,MAAM,QAAQ,OAAO,MAAM,CAAC;AAAA,EACnD,CAAC;AACD,SAAO;AAAA,IACL;AAAA,IACA,CAAC,UAA2B,aAA6B;AACvD,eAAS,KAAK,UAAU,MAAM;AAC5B,YAAI,QAAS,QAAO,qBAAqB;AAAA,MAC3C,CAAC;AAAA,IACH;AAAA,EACF;AACA,SAAO,MAAM;AACX,cAAU;AACV,eAAW,UAAU,SAAS;AAC5B,UAAI,OAAO,cAAc,EAAG,QAAO,QAAQ;AAAA,IAC7C;AAAA,EACF;AACF;AAcO,SAASA,aACd,UAAoC,CAAC,GACd;AACvB,QAAM,UAAU;AAAA,IACd;AAAA,EACF;AACA,MAAI;AACJ,MAAI,mBAAmB,MAAM;AAAA,EAAC;AAE9B,SAAO;AAAA,IACL,GAAG;AAAA,IAEH,QAAQ,OAAO,MAAc,SAAkB;AAC7C,UAAI,OAAQ,OAAM,IAAI,MAAM,wCAAwC;AAEpE,YAAM,UAAU,oBAAoB,EAAE,OAAO,QAAQ,MAAM,CAAC;AAC5D,YAAM,IAAI,QAAc,CAAC,SAAS,WAAW;AAC3C,gBAAQ,KAAK,SAAS,MAAM;AAC5B,gBAAQ,OAAO,MAAM,MAAM,MAAM;AAC/B,kBAAQ,IAAI,SAAS,MAAM;AAC3B,kBAAQ;AAAA,QACV,CAAC;AAAA,MACH,CAAC;AACD,eAAS;AACT,yBAAmB,iBAAiB,OAAO;AAAA,IAC7C;AAAA,IAEA,OAAO,YAAY;AACjB,YAAM,UAAU;AAChB,eAAS;AACT,UAAI,CAAC,SAAS;AACZ,cAAM,QAAQ,MAAM;AACpB;AAAA,MACF;AAEA,YAAM,IAAI,QAAc,CAAC,SAAS,WAAW;AAE3C,gBAAQ,MAAM,CAAC,UAAW,QAAQ,OAAO,KAAK,IAAI,QAAQ,CAAE;AAC5D,yBAAiB;AAEjB,aAAK,QAAQ,MAAM;AAAA,MACrB,CAAC;AAAA,IACH;AAAA,IAEA,QAAQ,MAAM;AAAA,EAChB;AACF;","names":["honoAdapter"]}

package/package.json

@@ -1,6 +1,78 @@
 {
   "name": "@dotpress/adapter-hono",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "2.0.0-alpha.1",
+  "description": "Hono adapter for Dotpress, on Node.js and AWS Lambda",
+  "author": "Renaud Guyon",
+  "license": "MIT",
+  "homepage": "https://dotpress.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dotpressjs/dotpress.git",
+    "directory": "packages/adapter-hono"
+  },
+  "bugs": {
+    "url": "https://github.com/dotpressjs/dotpress/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "default": "./dist/node.js"
+    },
+    "./lambda": {
+      "types": "./dist/lambda.d.ts",
+      "default": "./dist/lambda.js"
+    }
+  },
+  "engines": {
+    "node": ">=22.12"
+  },
+  "peerDependencies": {
+    "@dotpress/core": "^2.0.0-alpha.1",
+    "@hono/aws-lambda": "^1.0.0",
+    "@hono/node-server": "^2.1.0",
+    "hono": "^4.13.0"
+  },
+  "peerDependenciesMeta": {
+    "@hono/aws-lambda": {
+      "optional": true
+    },
+    "@hono/node-server": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@dotpress/core": "2.0.0-alpha.1",
+    "@dotpress/testing": "2.0.0-alpha.1",
+    "@hono/aws-lambda": "^1.0.1",
+    "@hono/node-server": "^2.1.6",
+    "hono": "^4.13.17",
+    "hono-5": "npm:hono@5.0.0-rc.1",
+    "zod": "^4.6.7"
+  },
+  "keywords": [
+    "dotpress",
+    "hono",
+    "adapter",
+    "aws-lambda",
+    "typescript",
+    "zod"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.node.json && tsc --noEmit -p tsconfig.test.json",
+    "lint": "eslint src test",
+    "test": "vitest run",
+    "test:watch": "vitest watch"
+  }
 }