@ts-kizuna/hono 1.49.5

package/LICENSE.MD

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Sondre Ørland
+
+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

@@ -0,0 +1,35 @@
+# @ts-kizuna/hono
+
+`@ts-kizuna/hono` connects a ts-kizuna API to a Hono application. Hono runs on Cloudflare Workers, Deno, Bun, Node.js, and other runtimes.
+
+**Requires Hono >= 4.**
+
+## Installation
+
+```sh
+pnpm add @ts-kizuna/hono hono
+```
+
+## Usage
+
+```ts
+import { Hono } from 'hono';
+import { KizunaServer } from '@ts-kizuna/hono';
+import { contract } from './contract';
+import { router } from './router';
+
+const server = new KizunaServer(contract);
+
+const api = server.api({
+    router,
+});
+
+const app = new Hono();
+api.mount(app);
+
+export default app;
+```
+
+## Documentation
+
+[Hono adapter](https://ts-kizuna.com/docs/adapters/hono)

package/dist/index.cjs

@@ -0,0 +1,121 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _ts_kizuna_core_adapter = require("@ts-kizuna/core/adapter");
+//#region src/server.ts
+const honoAdapter = (0, _ts_kizuna_core_adapter.createAdapter)({
+	buildHandlerContext: (_adapterRequest, { c }) => ({ c }),
+	respond: (result, { c, formatError }) => {
+		if (result.kind === "handler-error") throw result.error;
+		if (result.kind === "raw-response") return result.response;
+		const rendered = (0, _ts_kizuna_core_adapter.renderJsonResult)(result, formatError, c.req.raw);
+		if (rendered.body === void 0) return c.body(null, rendered.status, rendered.headers);
+		if (rendered.raw) return c.body(rendered.body, rendered.status, rendered.headers);
+		return c.json(rendered.body, rendered.status, rendered.headers);
+	}
+});
+/**
+* Mount a ts-kizuna API onto a Hono app.
+*
+* @example
+* const app = new Hono();
+* api.mount(app);
+*/
+function mountHono(api, app, options) {
+	const guards = api[_ts_kizuna_core_adapter.GUARDS_META];
+	const schemes = api[_ts_kizuna_core_adapter.SCHEMES_META];
+	const requestContext = api[_ts_kizuna_core_adapter.REQUEST_CONTEXT_META];
+	const pluginExports = (0, _ts_kizuna_core_adapter.pluginExportsOf)(api);
+	const jobsMeta = api[_ts_kizuna_core_adapter.JOBS_META];
+	const jobRunner = (0, _ts_kizuna_core_adapter.jobRunnerFrom)(jobsMeta);
+	const mountRoute = (routeKey, route, lane, resolvedRouter) => {
+		const method = route.method.toLowerCase();
+		const kizunaHandler = async (c) => {
+			const url = new URL(c.req.url);
+			const adapterRequest = {
+				request: c.req.raw,
+				method: c.req.method,
+				resolution: {
+					kind: "pre-resolved",
+					routeKey,
+					route,
+					params: c.req.param()
+				},
+				query: Object.fromEntries(url.searchParams),
+				headers: (0, _ts_kizuna_core_adapter.headersToObject)(c.req.raw.headers),
+				readBody: (r) => (0, _ts_kizuna_core_adapter.parseFetchBody)(c.req.raw, r)
+			};
+			return honoAdapter.handle({
+				routes: lane,
+				router: resolvedRouter,
+				request: adapterRequest,
+				responseContext: {
+					c,
+					formatError: options?.formatError
+				},
+				guards,
+				schemes,
+				requestContext,
+				pluginExports,
+				jobs: jobRunner,
+				responseValidation: options?.responseValidation
+			});
+		};
+		app.on(method, route.path, kizunaHandler);
+	};
+	const mountLane = (lane, resolvedRouter) => {
+		for (const { routeKey, route } of honoAdapter.eachRoute(lane, resolvedRouter)) mountRoute(routeKey, route, lane, resolvedRouter);
+	};
+	mountLane(api.routes, api[_ts_kizuna_core_adapter.ROUTER_META]);
+	mountLane((0, _ts_kizuna_core_adapter.pluginRoutesOf)(api), (0, _ts_kizuna_core_adapter.pluginRouterOf)(api));
+	if (jobsMeta) {
+		const routes = (0, _ts_kizuna_core_adapter.jobRoutes)(jobsMeta);
+		const router = (0, _ts_kizuna_core_adapter.jobRouter)(jobsMeta);
+		for (const [routeKey, route] of Object.entries(routes)) mountRoute(routeKey, route, routes, router);
+	}
+}
+const createServerSurface = (contract, options) => {
+	(0, _ts_kizuna_core_adapter.warnUnsupportedJobOptions)(contract.jobs, options?.jobTransport);
+	return {
+		guard: (_name, run) => run,
+		requestContext: (_name, run) => run,
+		router: (groupOrRouter, groupRouter) => groupRouter ?? groupOrRouter,
+		jobs: (handlers) => handlers,
+		api: ({ jobs, ...parts }) => {
+			const api = Object.assign((0, _ts_kizuna_core_adapter.assembleApi)(contract, parts), { [_ts_kizuna_core_adapter.JOBS_META]: contract.jobs ? {
+				jobs: contract.jobs,
+				handlers: jobs ?? {},
+				config: contract.jobsConfig,
+				transport: options?.jobTransport,
+				onError: options?.onJobError
+			} : void 0 });
+			return Object.assign(api, { mount: (app, mountOptions) => mountHono(api, app, mountOptions) });
+		}
+	};
+};
+/**
+* Turn a contract into a server handle: the serving counterpart to `Kizuna`.
+* Keep the instance and use `server.guard` to define guards, `server.router`
+* to write typed handlers, and `server.api` to assemble them.
+*
+* @example
+* const server = new KizunaServer(contract);
+*
+* const requireUser = server.guard('user', ({ bearer, deny }) => {
+*     const session = bearer && sessions.get(bearer.token);
+*     return session ? { userId: session.userId } : deny(401, 'Unauthorized');
+* });
+*
+* export const api = server.api({
+*     router,
+*     guards: {
+*         user: requireUser,
+*     },
+* });
+*/
+var KizunaServer = class {
+	constructor(contract, options) {
+		Object.assign(this, createServerSurface(contract, options));
+	}
+};
+//#endregion
+exports.KizunaServer = KizunaServer;
+exports.mountHono = mountHono;

package/dist/index.d.cts

@@ -0,0 +1,182 @@
+import { Context, Env, Hono } from "hono";
+import { ApiWithRouter, ContractPlugins, ErrorFormatter, GUARDS_META, GuardDenial, GuardDeny, GuardParams, GuardRun, HandlersFromAuth, JOBS_META, Jobs, PluginArgs, PluginImplementations, REQUEST_CONTEXT_META, RequestContextRun, RequestContextValues, RouteDefinition, RouteHandler as RouteHandler$1, Router as Router$1, Routes, SCHEMES_META, ServerOptions } from "@ts-kizuna/core/adapter";
+import { z } from "zod";
+import { Contract, CredentialOf, GuardSuccess, JobHandlers, JobsArg, RequestContextHeaderValues, RequestContextSchema, SecurityScheme, TagOptions } from "@ts-kizuna/core";
+
+//#region src/server.d.ts
+type HonoApi<R extends Routes = Routes> = ApiWithRouter<R> & {
+  readonly [GUARDS_META]?: unknown;
+  readonly [SCHEMES_META]?: unknown;
+  readonly [REQUEST_CONTEXT_META]?: unknown;
+  readonly [JOBS_META]?: unknown;
+  /**
+   * Register every contract route on a Hono app.
+   */
+  mount: <E extends Env = Env>(app: Hono<E>, options?: HonoOptions) => void;
+};
+interface HonoHandlerContext<E extends Env = Env> {
+  c: Context<E>;
+}
+/**
+ * The handler type for a single route, typed against its contract definition.
+ */
+type RouteHandler<R extends RouteDefinition, E extends Env = Env> = RouteHandler$1<R, HonoHandlerContext<E>>;
+/**
+ * The handler tree for a contract or route group, typed against it. Preserves
+ * Hono's {@link Env} generic for the handler context. Routes secured by the
+ * contract's `auth` map additionally receive each required identity's context
+ * in their handler args, under `auth`, keyed by the identity's name.
+ */
+type Router<C, E extends Env = Env> = C extends Contract<infer R, infer _Tags, infer _Codes, infer Schemes, infer Auth, infer RequestContext, infer Plugins, infer J> ? HandlersFromAuth<R, HonoHandlerContext<E> & RequestContextValues<RequestContext> & PluginArgs<Plugins> & JobsArg<J>, Schemes, Auth> : C extends Routes ? Router$1<C, HonoHandlerContext<E>> : never;
+/**
+ * The handler for each of a contract's scheduled jobs, typed against it. Each
+ * receives only the job's `input`, so the same handler can be run in process.
+ */
+type JobsRouter<C> = C extends Contract<infer _R, infer _Tags, infer _Codes, infer _Schemes, infer _Auth, infer _RequestContext, infer _Plugins, infer J> ? JobHandlers<J> : never;
+/**
+ * The handlers for a group named on the contract, or for a bare route group.
+ * Both forms resolve through one signature: a second candidate of the same
+ * arity costs zero-argument handlers their contextual type.
+ */
+type GroupRouter<Source, GroupOrRoutes, E extends Env> = GroupOrRoutes extends string ? Router<Source, E>[Extract<GroupOrRoutes, keyof Router<Source, E>>] : Router<GroupOrRoutes, E>;
+interface HonoOptions {
+  /**
+   * Validate handler return values against the routes' response schemas.
+   * Mismatches surface as 500 errors. Intended for development; disable in
+   * production.
+   *
+   * @default false
+   */
+  responseValidation?: boolean;
+  /**
+   * Reshape error (status >= 400) response bytes before they are sent. See
+   * {@link ErrorFormatter}.
+   */
+  formatError?: ErrorFormatter<Request>;
+}
+/**
+ * A guard per identity, keyed by name. Each receives the handler context, a
+ * `deny` helper, and the matched route's required scopes, and returns that
+ * identity's {@link GuardSuccess} (its context and access fields) or a `deny(...)`
+ * result. Keying by name lets each guard's return be typed against its own
+ * identity, so access values narrow without an annotation. An
+ * authentication-only identity (no context, no access) returns nothing on
+ * success, or `deny(...)`.
+ */
+type GuardFns<Schemes extends Record<string, SecurityScheme>, Params, E extends Env> = { [Name in keyof Schemes]: (args: HonoHandlerContext<E> & CredentialOf<Schemes[Name]> & {
+  params: Params;
+  deny: GuardDeny;
+  scopes: string[];
+}) => [keyof GuardSuccess<Schemes[Name]>] extends [never] ? void | GuardDenial | Promise<void | GuardDenial> : GuardSuccess<Schemes[Name]> | GuardDenial | Promise<GuardSuccess<Schemes[Name]> | GuardDenial> };
+/**
+ * One guard per identity declared on the contract.
+ */
+type GuardsForSchemes<Schemes extends Record<string, SecurityScheme>, E extends Env> = { [Name in keyof Schemes]: GuardRun<HonoHandlerContext<E>> };
+/**
+ * The resolver functions for the request context schemas declared on `kizuna`,
+ * keyed by name. Each runs on every route and returns its schema's value.
+ */
+type RequestResolverFns<RequestContext extends Record<string, RequestContextSchema>, E extends Env> = { [Name in keyof RequestContext]: (args: HonoHandlerContext<E> & {
+  params: Record<string, string>;
+  headers: RequestContextHeaderValues<RequestContext[Name]>;
+}) => z.output<RequestContext[Name]['context']> | Promise<z.output<RequestContext[Name]['context']>> };
+/**
+ * Mount a ts-kizuna API onto a Hono app.
+ *
+ * @example
+ * const app = new Hono();
+ * api.mount(app);
+ */
+declare function mountHono<E extends Env = Env>(api: HonoApi, app: Hono<E>, options?: HonoOptions): void;
+type ServerContract<R extends Routes, Schemes extends Record<string, SecurityScheme>, Auth, RequestContext extends Record<string, RequestContextSchema>, Plugins extends ContractPlugins, J extends Jobs = Jobs> = Contract<R, Record<string, TagOptions>, string, Schemes, Auth, RequestContext, Plugins, J>;
+interface Server<R extends Routes, Schemes extends Record<string, SecurityScheme>, Auth, RequestContext extends Record<string, RequestContextSchema>, Plugins extends ContractPlugins, E extends Env = Env, J extends Jobs = Jobs> {
+  /**
+   * Define a guard for one of the contract's identities. It runs before the
+   * handlers of every route whose `auth` entry requires the identity, and
+   * receives the credential its method extracted (`bearer`, `apiKey`, or
+   * `basic`, `null` when absent). Return the identity's context and access
+   * fields to allow the request, or call `deny(status, detail)`.
+   */
+  guard<const Name extends Extract<keyof Schemes, string>>(name: Name, run: GuardFns<Schemes, GuardParams<R, Auth, Name>, E>[Name]): GuardRun<HonoHandlerContext<E>>;
+  /**
+   * Define a request context resolver declared on the contract. It runs on
+   * every route, public ones included, and never denies.
+   */
+  requestContext<const Name extends Extract<keyof RequestContext, string>>(name: Name, run: RequestResolverFns<RequestContext, E>[Name]): RequestContextRun<HonoHandlerContext<E>>;
+  /**
+   * Write typed handlers for the contract or one of its route groups.
+   */
+  router: {
+    <const GroupOrRoutes extends Extract<keyof Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, E>, string> | Routes>(group: GroupOrRoutes, router: GroupRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, GroupOrRoutes, E>): GroupRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, GroupOrRoutes, E>;
+    (router: Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, E>): Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, E>;
+  };
+  /**
+   * Write a handler for each of the contract's jobs.
+   *
+   * Pass a `transport` to say where a queued job goes. Without one, `queue`
+   * runs the job in this process and it is lost on a crash.
+   *
+   * @example
+   * export const jobs = server.jobs({
+   *     sendDigests: async () => ({
+   *         status: 200,
+   *         body: {
+   *             sent: await sendPendingDigests(),
+   *         },
+   *     }),
+   * });
+   */
+  jobs(handlers: JobsRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>): JobsRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>;
+  /**
+   * Assemble the router, guards, and job handlers into the api object.
+   */
+  api(options: {
+    router: Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, E>;
+  } & (string extends keyof Schemes ? {
+    guards?: undefined;
+  } : {
+    guards: NoInfer<GuardsForSchemes<Schemes, E>>;
+  }) & (string extends keyof J ? {
+    jobs?: undefined;
+  } : {
+    jobs: NoInfer<JobsRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>>;
+  }) & (string extends keyof RequestContext ? {
+    requestContext?: undefined;
+  } : {
+    requestContext: NoInfer<{ [Name in keyof RequestContext]: RequestContextRun<HonoHandlerContext<E>> }>;
+  }) & (string extends keyof Plugins ? {
+    plugins?: undefined;
+  } : {
+    plugins: PluginImplementations<Plugins, HonoHandlerContext<E>>;
+  })): HonoApi<R>;
+}
+/**
+ * Turn a contract into a server handle: the serving counterpart to `Kizuna`.
+ * Keep the instance and use `server.guard` to define guards, `server.router`
+ * to write typed handlers, and `server.api` to assemble them.
+ *
+ * @example
+ * const server = new KizunaServer(contract);
+ *
+ * const requireUser = server.guard('user', ({ bearer, deny }) => {
+ *     const session = bearer && sessions.get(bearer.token);
+ *     return session ? { userId: session.userId } : deny(401, 'Unauthorized');
+ * });
+ *
+ * export const api = server.api({
+ *     router,
+ *     guards: {
+ *         user: requireUser,
+ *     },
+ * });
+ */
+declare class KizunaServer<const R extends Routes, Schemes extends Record<string, SecurityScheme>, Auth, RequestContext extends Record<string, RequestContextSchema>, Plugins extends ContractPlugins, E extends Env = Env, J extends Jobs = Jobs> implements Server<R, Schemes, Auth, RequestContext, Plugins, E, J> {
+  readonly guard: Server<R, Schemes, Auth, RequestContext, Plugins, E, J>['guard'];
+  readonly requestContext: Server<R, Schemes, Auth, RequestContext, Plugins, E, J>['requestContext'];
+  readonly router: Server<R, Schemes, Auth, RequestContext, Plugins, E, J>['router'];
+  readonly jobs: Server<R, Schemes, Auth, RequestContext, Plugins, E, J>['jobs'];
+  readonly api: Server<R, Schemes, Auth, RequestContext, Plugins, E, J>['api'];
+  constructor(contract: ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, options?: ServerOptions);
+}
+//#endregion
+export { HonoApi, HonoHandlerContext, HonoOptions, JobsRouter, KizunaServer, RouteHandler, Router, Server, mountHono };

package/dist/index.d.mts

@@ -0,0 +1,182 @@
+import { ApiWithRouter, ContractPlugins, ErrorFormatter, GUARDS_META, GuardDenial, GuardDeny, GuardParams, GuardRun, HandlersFromAuth, JOBS_META, Jobs, PluginArgs, PluginImplementations, REQUEST_CONTEXT_META, RequestContextRun, RequestContextValues, RouteDefinition, RouteHandler as RouteHandler$1, Router as Router$1, Routes, SCHEMES_META, ServerOptions } from "@ts-kizuna/core/adapter";
+import { Context, Env, Hono } from "hono";
+import { z } from "zod";
+import { Contract, CredentialOf, GuardSuccess, JobHandlers, JobsArg, RequestContextHeaderValues, RequestContextSchema, SecurityScheme, TagOptions } from "@ts-kizuna/core";
+
+//#region src/server.d.ts
+type HonoApi<R extends Routes = Routes> = ApiWithRouter<R> & {
+  readonly [GUARDS_META]?: unknown;
+  readonly [SCHEMES_META]?: unknown;
+  readonly [REQUEST_CONTEXT_META]?: unknown;
+  readonly [JOBS_META]?: unknown;
+  /**
+   * Register every contract route on a Hono app.
+   */
+  mount: <E extends Env = Env>(app: Hono<E>, options?: HonoOptions) => void;
+};
+interface HonoHandlerContext<E extends Env = Env> {
+  c: Context<E>;
+}
+/**
+ * The handler type for a single route, typed against its contract definition.
+ */
+type RouteHandler<R extends RouteDefinition, E extends Env = Env> = RouteHandler$1<R, HonoHandlerContext<E>>;
+/**
+ * The handler tree for a contract or route group, typed against it. Preserves
+ * Hono's {@link Env} generic for the handler context. Routes secured by the
+ * contract's `auth` map additionally receive each required identity's context
+ * in their handler args, under `auth`, keyed by the identity's name.
+ */
+type Router<C, E extends Env = Env> = C extends Contract<infer R, infer _Tags, infer _Codes, infer Schemes, infer Auth, infer RequestContext, infer Plugins, infer J> ? HandlersFromAuth<R, HonoHandlerContext<E> & RequestContextValues<RequestContext> & PluginArgs<Plugins> & JobsArg<J>, Schemes, Auth> : C extends Routes ? Router$1<C, HonoHandlerContext<E>> : never;
+/**
+ * The handler for each of a contract's scheduled jobs, typed against it. Each
+ * receives only the job's `input`, so the same handler can be run in process.
+ */
+type JobsRouter<C> = C extends Contract<infer _R, infer _Tags, infer _Codes, infer _Schemes, infer _Auth, infer _RequestContext, infer _Plugins, infer J> ? JobHandlers<J> : never;
+/**
+ * The handlers for a group named on the contract, or for a bare route group.
+ * Both forms resolve through one signature: a second candidate of the same
+ * arity costs zero-argument handlers their contextual type.
+ */
+type GroupRouter<Source, GroupOrRoutes, E extends Env> = GroupOrRoutes extends string ? Router<Source, E>[Extract<GroupOrRoutes, keyof Router<Source, E>>] : Router<GroupOrRoutes, E>;
+interface HonoOptions {
+  /**
+   * Validate handler return values against the routes' response schemas.
+   * Mismatches surface as 500 errors. Intended for development; disable in
+   * production.
+   *
+   * @default false
+   */
+  responseValidation?: boolean;
+  /**
+   * Reshape error (status >= 400) response bytes before they are sent. See
+   * {@link ErrorFormatter}.
+   */
+  formatError?: ErrorFormatter<Request>;
+}
+/**
+ * A guard per identity, keyed by name. Each receives the handler context, a
+ * `deny` helper, and the matched route's required scopes, and returns that
+ * identity's {@link GuardSuccess} (its context and access fields) or a `deny(...)`
+ * result. Keying by name lets each guard's return be typed against its own
+ * identity, so access values narrow without an annotation. An
+ * authentication-only identity (no context, no access) returns nothing on
+ * success, or `deny(...)`.
+ */
+type GuardFns<Schemes extends Record<string, SecurityScheme>, Params, E extends Env> = { [Name in keyof Schemes]: (args: HonoHandlerContext<E> & CredentialOf<Schemes[Name]> & {
+  params: Params;
+  deny: GuardDeny;
+  scopes: string[];
+}) => [keyof GuardSuccess<Schemes[Name]>] extends [never] ? void | GuardDenial | Promise<void | GuardDenial> : GuardSuccess<Schemes[Name]> | GuardDenial | Promise<GuardSuccess<Schemes[Name]> | GuardDenial> };
+/**
+ * One guard per identity declared on the contract.
+ */
+type GuardsForSchemes<Schemes extends Record<string, SecurityScheme>, E extends Env> = { [Name in keyof Schemes]: GuardRun<HonoHandlerContext<E>> };
+/**
+ * The resolver functions for the request context schemas declared on `kizuna`,
+ * keyed by name. Each runs on every route and returns its schema's value.
+ */
+type RequestResolverFns<RequestContext extends Record<string, RequestContextSchema>, E extends Env> = { [Name in keyof RequestContext]: (args: HonoHandlerContext<E> & {
+  params: Record<string, string>;
+  headers: RequestContextHeaderValues<RequestContext[Name]>;
+}) => z.output<RequestContext[Name]['context']> | Promise<z.output<RequestContext[Name]['context']>> };
+/**
+ * Mount a ts-kizuna API onto a Hono app.
+ *
+ * @example
+ * const app = new Hono();
+ * api.mount(app);
+ */
+declare function mountHono<E extends Env = Env>(api: HonoApi, app: Hono<E>, options?: HonoOptions): void;
+type ServerContract<R extends Routes, Schemes extends Record<string, SecurityScheme>, Auth, RequestContext extends Record<string, RequestContextSchema>, Plugins extends ContractPlugins, J extends Jobs = Jobs> = Contract<R, Record<string, TagOptions>, string, Schemes, Auth, RequestContext, Plugins, J>;
+interface Server<R extends Routes, Schemes extends Record<string, SecurityScheme>, Auth, RequestContext extends Record<string, RequestContextSchema>, Plugins extends ContractPlugins, E extends Env = Env, J extends Jobs = Jobs> {
+  /**
+   * Define a guard for one of the contract's identities. It runs before the
+   * handlers of every route whose `auth` entry requires the identity, and
+   * receives the credential its method extracted (`bearer`, `apiKey`, or
+   * `basic`, `null` when absent). Return the identity's context and access
+   * fields to allow the request, or call `deny(status, detail)`.
+   */
+  guard<const Name extends Extract<keyof Schemes, string>>(name: Name, run: GuardFns<Schemes, GuardParams<R, Auth, Name>, E>[Name]): GuardRun<HonoHandlerContext<E>>;
+  /**
+   * Define a request context resolver declared on the contract. It runs on
+   * every route, public ones included, and never denies.
+   */
+  requestContext<const Name extends Extract<keyof RequestContext, string>>(name: Name, run: RequestResolverFns<RequestContext, E>[Name]): RequestContextRun<HonoHandlerContext<E>>;
+  /**
+   * Write typed handlers for the contract or one of its route groups.
+   */
+  router: {
+    <const GroupOrRoutes extends Extract<keyof Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, E>, string> | Routes>(group: GroupOrRoutes, router: GroupRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, GroupOrRoutes, E>): GroupRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, GroupOrRoutes, E>;
+    (router: Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, E>): Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, E>;
+  };
+  /**
+   * Write a handler for each of the contract's jobs.
+   *
+   * Pass a `transport` to say where a queued job goes. Without one, `queue`
+   * runs the job in this process and it is lost on a crash.
+   *
+   * @example
+   * export const jobs = server.jobs({
+   *     sendDigests: async () => ({
+   *         status: 200,
+   *         body: {
+   *             sent: await sendPendingDigests(),
+   *         },
+   *     }),
+   * });
+   */
+  jobs(handlers: JobsRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>): JobsRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>;
+  /**
+   * Assemble the router, guards, and job handlers into the api object.
+   */
+  api(options: {
+    router: Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, E>;
+  } & (string extends keyof Schemes ? {
+    guards?: undefined;
+  } : {
+    guards: NoInfer<GuardsForSchemes<Schemes, E>>;
+  }) & (string extends keyof J ? {
+    jobs?: undefined;
+  } : {
+    jobs: NoInfer<JobsRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>>;
+  }) & (string extends keyof RequestContext ? {
+    requestContext?: undefined;
+  } : {
+    requestContext: NoInfer<{ [Name in keyof RequestContext]: RequestContextRun<HonoHandlerContext<E>> }>;
+  }) & (string extends keyof Plugins ? {
+    plugins?: undefined;
+  } : {
+    plugins: PluginImplementations<Plugins, HonoHandlerContext<E>>;
+  })): HonoApi<R>;
+}
+/**
+ * Turn a contract into a server handle: the serving counterpart to `Kizuna`.
+ * Keep the instance and use `server.guard` to define guards, `server.router`
+ * to write typed handlers, and `server.api` to assemble them.
+ *
+ * @example
+ * const server = new KizunaServer(contract);
+ *
+ * const requireUser = server.guard('user', ({ bearer, deny }) => {
+ *     const session = bearer && sessions.get(bearer.token);
+ *     return session ? { userId: session.userId } : deny(401, 'Unauthorized');
+ * });
+ *
+ * export const api = server.api({
+ *     router,
+ *     guards: {
+ *         user: requireUser,
+ *     },
+ * });
+ */
+declare class KizunaServer<const R extends Routes, Schemes extends Record<string, SecurityScheme>, Auth, RequestContext extends Record<string, RequestContextSchema>, Plugins extends ContractPlugins, E extends Env = Env, J extends Jobs = Jobs> implements Server<R, Schemes, Auth, RequestContext, Plugins, E, J> {
+  readonly guard: Server<R, Schemes, Auth, RequestContext, Plugins, E, J>['guard'];
+  readonly requestContext: Server<R, Schemes, Auth, RequestContext, Plugins, E, J>['requestContext'];
+  readonly router: Server<R, Schemes, Auth, RequestContext, Plugins, E, J>['router'];
+  readonly jobs: Server<R, Schemes, Auth, RequestContext, Plugins, E, J>['jobs'];
+  readonly api: Server<R, Schemes, Auth, RequestContext, Plugins, E, J>['api'];
+  constructor(contract: ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, options?: ServerOptions);
+}
+//#endregion
+export { HonoApi, HonoHandlerContext, HonoOptions, JobsRouter, KizunaServer, RouteHandler, Router, Server, mountHono };

package/dist/index.mjs

@@ -0,0 +1,119 @@
+import { GUARDS_META, JOBS_META, REQUEST_CONTEXT_META, ROUTER_META, SCHEMES_META, assembleApi, createAdapter, headersToObject, jobRouter, jobRoutes, jobRunnerFrom, parseFetchBody, pluginExportsOf, pluginRouterOf, pluginRoutesOf, renderJsonResult, warnUnsupportedJobOptions } from "@ts-kizuna/core/adapter";
+//#region src/server.ts
+const honoAdapter = createAdapter({
+	buildHandlerContext: (_adapterRequest, { c }) => ({ c }),
+	respond: (result, { c, formatError }) => {
+		if (result.kind === "handler-error") throw result.error;
+		if (result.kind === "raw-response") return result.response;
+		const rendered = renderJsonResult(result, formatError, c.req.raw);
+		if (rendered.body === void 0) return c.body(null, rendered.status, rendered.headers);
+		if (rendered.raw) return c.body(rendered.body, rendered.status, rendered.headers);
+		return c.json(rendered.body, rendered.status, rendered.headers);
+	}
+});
+/**
+* Mount a ts-kizuna API onto a Hono app.
+*
+* @example
+* const app = new Hono();
+* api.mount(app);
+*/
+function mountHono(api, app, options) {
+	const guards = api[GUARDS_META];
+	const schemes = api[SCHEMES_META];
+	const requestContext = api[REQUEST_CONTEXT_META];
+	const pluginExports = pluginExportsOf(api);
+	const jobsMeta = api[JOBS_META];
+	const jobRunner = jobRunnerFrom(jobsMeta);
+	const mountRoute = (routeKey, route, lane, resolvedRouter) => {
+		const method = route.method.toLowerCase();
+		const kizunaHandler = async (c) => {
+			const url = new URL(c.req.url);
+			const adapterRequest = {
+				request: c.req.raw,
+				method: c.req.method,
+				resolution: {
+					kind: "pre-resolved",
+					routeKey,
+					route,
+					params: c.req.param()
+				},
+				query: Object.fromEntries(url.searchParams),
+				headers: headersToObject(c.req.raw.headers),
+				readBody: (r) => parseFetchBody(c.req.raw, r)
+			};
+			return honoAdapter.handle({
+				routes: lane,
+				router: resolvedRouter,
+				request: adapterRequest,
+				responseContext: {
+					c,
+					formatError: options?.formatError
+				},
+				guards,
+				schemes,
+				requestContext,
+				pluginExports,
+				jobs: jobRunner,
+				responseValidation: options?.responseValidation
+			});
+		};
+		app.on(method, route.path, kizunaHandler);
+	};
+	const mountLane = (lane, resolvedRouter) => {
+		for (const { routeKey, route } of honoAdapter.eachRoute(lane, resolvedRouter)) mountRoute(routeKey, route, lane, resolvedRouter);
+	};
+	mountLane(api.routes, api[ROUTER_META]);
+	mountLane(pluginRoutesOf(api), pluginRouterOf(api));
+	if (jobsMeta) {
+		const routes = jobRoutes(jobsMeta);
+		const router = jobRouter(jobsMeta);
+		for (const [routeKey, route] of Object.entries(routes)) mountRoute(routeKey, route, routes, router);
+	}
+}
+const createServerSurface = (contract, options) => {
+	warnUnsupportedJobOptions(contract.jobs, options?.jobTransport);
+	return {
+		guard: (_name, run) => run,
+		requestContext: (_name, run) => run,
+		router: (groupOrRouter, groupRouter) => groupRouter ?? groupOrRouter,
+		jobs: (handlers) => handlers,
+		api: ({ jobs, ...parts }) => {
+			const api = Object.assign(assembleApi(contract, parts), { [JOBS_META]: contract.jobs ? {
+				jobs: contract.jobs,
+				handlers: jobs ?? {},
+				config: contract.jobsConfig,
+				transport: options?.jobTransport,
+				onError: options?.onJobError
+			} : void 0 });
+			return Object.assign(api, { mount: (app, mountOptions) => mountHono(api, app, mountOptions) });
+		}
+	};
+};
+/**
+* Turn a contract into a server handle: the serving counterpart to `Kizuna`.
+* Keep the instance and use `server.guard` to define guards, `server.router`
+* to write typed handlers, and `server.api` to assemble them.
+*
+* @example
+* const server = new KizunaServer(contract);
+*
+* const requireUser = server.guard('user', ({ bearer, deny }) => {
+*     const session = bearer && sessions.get(bearer.token);
+*     return session ? { userId: session.userId } : deny(401, 'Unauthorized');
+* });
+*
+* export const api = server.api({
+*     router,
+*     guards: {
+*         user: requireUser,
+*     },
+* });
+*/
+var KizunaServer = class {
+	constructor(contract, options) {
+		Object.assign(this, createServerSurface(contract, options));
+	}
+};
+//#endregion
+export { KizunaServer, mountHono };

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@ts-kizuna/hono",
+  "version": "1.49.5",
+  "description": "Hono adapter for ts-kizuna",
+  "keywords": [
+    "ts-kizuna",
+    "typescript",
+    "zod",
+    "openapi",
+    "contract-first",
+    "type-safe",
+    "rest",
+    "api",
+    "hono",
+    "adapter",
+    "server"
+  ],
+  "license": "MIT",
+  "homepage": "https://ts-kizuna.com/docs/adapters/hono",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ts-kizuna/kizuna.git",
+    "directory": "packages/hono"
+  },
+  "bugs": "https://github.com/ts-kizuna/kizuna/issues",
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "kizuna": {
+    "entries": {
+      ".": "server"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "hono": "^4.0.0",
+    "zod": "^4.0.0",
+    "@ts-kizuna/core": "1.49.5"
+  },
+  "devDependencies": {
+    "hono": "^4.7.0",
+    "tsdown": "^0.21.0",
+    "typescript": "^5.6.3",
+    "zod": "^4.0.0",
+    "@ts-kizuna/core": "1.49.5"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts --format esm,cjs --dts --clean --external @ts-kizuna/core --external hono --external zod",
+    "typecheck": "tsc --noEmit"
+  }
+}