@kizunajs/next 2.0.0-beta.0

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,40 @@
+# @kizunajs/next
+
+`@kizunajs/next` connects a Kizuna API to the Next.js App Router, as a catch-all route handler.
+
+**Requires Next.js >= 16.**
+
+## Installation
+
+```sh
+pnpm add @kizunajs/next
+```
+
+## Usage
+
+```ts
+// kizuna.config.ts
+import { defineConfig } from 'kizunajs';
+import { nextAdapter } from '@kizunajs/next';
+import { routes } from './src/routes';
+
+export default defineConfig({
+    adapter: nextAdapter(),
+    routes,
+});
+```
+
+Export the handlers from a catch-all route:
+
+```ts
+// src/app/api/[...kizuna]/route.ts
+import kizuna from '../../../../kizuna.config';
+
+export const { GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS } = kizuna.api.mount({
+    basePath: '/api',
+});
+```
+
+## Documentation
+
+[Next.js adapter](https://kizunajs.com/docs/adapters/next)

package/dist/index.cjs

@@ -0,0 +1,219 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let kizunajs_adapter = require("kizunajs/adapter");
+let next_server_js = require("next/server.js");
+//#region src/server.ts
+const jsonResponse = (status, body, headers, raw = false) => new next_server_js.NextResponse(body === null || body === void 0 ? null : raw ? body : JSON.stringify(body), {
+	status,
+	headers
+});
+const handleNextRequest = async (request, routes, router, options, guards, schemes, requestContext, pluginExports, jobs) => {
+	const url = new URL(request.url);
+	const adapter = (0, kizunajs_adapter.createAdapter)({
+		buildHandlerContext: (adapterRequest) => ({ request: adapterRequest.request }),
+		respond: (result) => {
+			if (result.kind === "raw-response") return result.response;
+			const rendered = (0, kizunajs_adapter.renderJsonResult)(result, options?.formatError, request, request.method);
+			if (rendered.stream) return new next_server_js.NextResponse(rendered.stream({
+				signal: request.signal,
+				validate: options?.responseValidation
+			}), {
+				status: rendered.status,
+				headers: rendered.headers
+			});
+			return jsonResponse(rendered.status, rendered.body, rendered.headers, rendered.raw);
+		},
+		onError: async (error) => {
+			if (!options?.onError) {
+				console.error("[kizuna/next] handler error:", error);
+				return;
+			}
+			const override = await options.onError(error, request);
+			if (override) return {
+				kind: "raw-response",
+				response: override
+			};
+		}
+	});
+	if (jobs) {
+		const matchedJob = (0, kizunajs_adapter.matchRoute)(request.method, url.pathname, jobs.routes, options?.basePath);
+		if (matchedJob.kind === "matched") {
+			const jobRequest = {
+				request,
+				method: request.method,
+				resolution: {
+					kind: "pre-resolved",
+					routeKey: matchedJob.match.routeKey,
+					route: matchedJob.match.route,
+					params: matchedJob.match.params
+				},
+				query: Object.fromEntries(url.searchParams),
+				headers: (0, kizunajs_adapter.headersToObject)(request.headers),
+				readBody: (route) => (0, kizunajs_adapter.parseFetchBody)(request, route)
+			};
+			return adapter.handle({
+				routes: jobs.routes,
+				router: jobs.router,
+				request: jobRequest,
+				responseContext: {},
+				guards,
+				schemes,
+				requestContext,
+				pluginExports,
+				jobs: jobs.runner,
+				responseValidation: options?.responseValidation
+			});
+		}
+	}
+	const globalMiddleware = options?.requestMiddleware;
+	if (globalMiddleware && globalMiddleware.length > 0) {
+		const matched = (0, kizunajs_adapter.matchRoute)(request.method, url.pathname, routes, options?.basePath);
+		if (matched.kind === "matched") {
+			const middlewareRoute = {
+				path: matched.match.route.path,
+				method: matched.match.route.method
+			};
+			for (const handler of globalMiddleware) {
+				const result = await handler(request, middlewareRoute);
+				if (result instanceof Response) return new next_server_js.NextResponse(result.body, {
+					status: result.status,
+					statusText: result.statusText,
+					headers: result.headers
+				});
+			}
+			const adapterRequest = {
+				request,
+				method: request.method,
+				resolution: {
+					kind: "pre-resolved",
+					routeKey: matched.match.routeKey,
+					route: matched.match.route,
+					params: matched.match.params
+				},
+				query: Object.fromEntries(url.searchParams),
+				headers: (0, kizunajs_adapter.headersToObject)(request.headers),
+				readBody: (route) => (0, kizunajs_adapter.parseFetchBody)(request, route)
+			};
+			return adapter.handle({
+				routes,
+				router,
+				request: adapterRequest,
+				responseContext: {},
+				guards,
+				schemes,
+				requestContext,
+				jobs: jobs?.runner,
+				responseValidation: options?.responseValidation
+			});
+		}
+	}
+	const adapterRequest = {
+		request,
+		method: request.method,
+		resolution: {
+			kind: "core-match",
+			path: url.pathname
+		},
+		query: Object.fromEntries(url.searchParams),
+		headers: (0, kizunajs_adapter.headersToObject)(request.headers),
+		readBody: (route) => (0, kizunajs_adapter.parseFetchBody)(request, route)
+	};
+	return adapter.handle({
+		routes,
+		router,
+		request: adapterRequest,
+		responseContext: {},
+		guards,
+		schemes,
+		requestContext,
+		pluginExports,
+		jobs: jobs?.runner,
+		basePath: options?.basePath,
+		responseValidation: options?.responseValidation
+	});
+};
+/**
+* Create endpoints for a Next.js App Router catch-all route.
+*
+* @example
+* // app/api/[...kizuna]/route.ts
+* export const { GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS } = api.mount({
+*     basePath: '/api',
+* });
+*/
+function mountNext(api, options) {
+	const guards = api[kizunajs_adapter.GUARDS_META];
+	const schemes = api[kizunajs_adapter.SCHEMES_META];
+	const requestContext = api[kizunajs_adapter.REQUEST_CONTEXT_META];
+	const jobsMeta = api[kizunajs_adapter.JOBS_META];
+	const mountedJobs = jobsMeta ? {
+		routes: (0, kizunajs_adapter.jobRoutes)(jobsMeta),
+		router: (0, kizunajs_adapter.jobRouter)(jobsMeta),
+		runner: (0, kizunajs_adapter.jobRunnerFrom)(jobsMeta)
+	} : void 0;
+	const handlerOptions = {
+		basePath: options?.basePath,
+		onError: options?.onError,
+		requestMiddleware: options?.requestMiddleware,
+		responseValidation: options?.responseValidation
+	};
+	const pluginExports = (0, kizunajs_adapter.pluginExportsOf)(api);
+	const pluginRoutes = (0, kizunajs_adapter.pluginRoutesOf)(api);
+	const pluginRouter = (0, kizunajs_adapter.pluginRouterOf)(api);
+	const hasPluginRoutes = Object.keys(pluginRoutes).length > 0;
+	const handler = async (request) => {
+		if (hasPluginRoutes) {
+			const pathname = new URL(request.url).pathname;
+			if (!((0, kizunajs_adapter.matchRoute)(request.method, pathname, api.routes, options?.basePath).kind === "matched") && (0, kizunajs_adapter.matchRoute)(request.method, pathname, pluginRoutes, options?.basePath).kind === "matched") return handleNextRequest(request, pluginRoutes, pluginRouter, handlerOptions, guards, schemes, requestContext, pluginExports, void 0);
+		}
+		return handleNextRequest(request, api.routes, api[kizunajs_adapter.ROUTER_META], handlerOptions, guards, schemes, requestContext, pluginExports, mountedJobs);
+	};
+	return {
+		GET: handler,
+		HEAD: handler,
+		POST: handler,
+		PUT: handler,
+		PATCH: handler,
+		DELETE: handler,
+		OPTIONS: handler
+	};
+}
+/**
+* Serve an API on Next. What it takes is what every route is served with. Next
+* routes by file, so mounting returns the route handlers to re-export rather
+* than registering them on an app.
+*
+* @example
+* // kizuna.config.ts
+* export default defineConfig({
+*     adapter: nextAdapter(),
+*     routes,
+* });
+*
+* // src/app/api/[...kizuna]/route.ts
+* export const { GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS } = kizuna.api.mount({
+*     basePath: '/api',
+* });
+*/
+const nextAdapter = (defaults) => ({
+	name: "next",
+	mount: (api, options) => mountNext(api, {
+		...defaults,
+		...options
+	})
+});
+//#endregion
+Object.defineProperty(exports, "NextRequest", {
+	enumerable: true,
+	get: function() {
+		return next_server_js.NextRequest;
+	}
+});
+Object.defineProperty(exports, "NextResponse", {
+	enumerable: true,
+	get: function() {
+		return next_server_js.NextResponse;
+	}
+});
+exports.handleNextRequest = handleNextRequest;
+exports.mountNext = mountNext;
+exports.nextAdapter = nextAdapter;

package/dist/index.d.cts

@@ -0,0 +1,107 @@
+import { Adapter, ApiWithRouter, ErrorFormatter, GUARDS_META, GuardMap, JOBS_META, JobRunner, Jobs, REQUEST_CONTEXT_META, RequestContextMap, Router, Routes, SCHEMES_META } from "kizunajs/adapter";
+import { SecurityScheme } from "kizunajs";
+import { NextRequest, NextRequest as NextRequest$1, NextResponse, NextResponse as NextResponse$1 } from "next/server.js";
+
+//#region src/server.d.ts
+interface NextHandlerContext {
+  request: NextRequest$1;
+}
+/**
+ * An api's jobs paired with their handlers, both in the shape the request
+ * pipeline takes.
+ */
+interface MountedJobs {
+  routes: Routes;
+  router: Router<Routes, NextHandlerContext>;
+  runner: JobRunner<Jobs>;
+}
+/**
+ * Passed to each middleware function as the second argument.
+ */
+interface NextMiddlewareRoute {
+  path: string;
+  method: string;
+}
+type NextMiddlewareHandler = (request: NextRequest$1, route: NextMiddlewareRoute) => Response | void | Promise<Response | void>;
+interface NextHandlerOptions {
+  basePath?: string;
+  /**
+   * Map a thrown error into a response. Return a `NextResponse` (e.g. built
+   * from `problemDetails(...)`) to handle the error, or `void` to fall through
+   * to the default 500.
+   */
+  onError?: (error: unknown, request: NextRequest$1) => NextResponse$1 | Promise<NextResponse$1> | void | Promise<void>;
+  /**
+   * Reshape error (status >= 400) response bytes before they are sent. See
+   * {@link ErrorFormatter}.
+   */
+  formatError?: ErrorFormatter<NextRequest$1>;
+  /**
+   * Middleware functions that run after route matching but before the handler.
+   * Each receives `(request, route)`; return a `Response` to short-circuit.
+   * Authentication belongs in a guard.
+   */
+  requestMiddleware?: Array<NextMiddlewareHandler>;
+  /**
+   * Validate handler return values against the routes' response schemas.
+   * Mismatches surface as 500 errors. Intended for development; disable in
+   * production.
+   *
+   * @default false
+   */
+  responseValidation?: boolean;
+}
+declare const handleNextRequest: <T extends Routes>(request: NextRequest$1, routes: T, router: Router<T, NextHandlerContext>, options?: NextHandlerOptions, guards?: GuardMap<NextHandlerContext>, schemes?: Record<string, SecurityScheme>, requestContext?: RequestContextMap<NextHandlerContext>, pluginExports?: Record<string, unknown>, jobs?: MountedJobs) => Promise<NextResponse$1>;
+type HttpHandlers = {
+  GET: HttpHandler;
+  HEAD: HttpHandler;
+  POST: HttpHandler;
+  PUT: HttpHandler;
+  PATCH: HttpHandler;
+  DELETE: HttpHandler;
+  OPTIONS: HttpHandler;
+};
+type HttpHandler = (request: NextRequest$1) => Promise<NextResponse$1>;
+type NextApiWithRouter = ApiWithRouter & {
+  readonly [GUARDS_META]?: unknown;
+  readonly [SCHEMES_META]?: unknown;
+  readonly [REQUEST_CONTEXT_META]?: unknown;
+  readonly [JOBS_META]?: unknown;
+};
+type NextApi<R extends Routes = Routes> = ApiWithRouter<R> & {
+  readonly [GUARDS_META]?: unknown;
+  readonly [SCHEMES_META]?: unknown;
+  readonly [REQUEST_CONTEXT_META]?: unknown;
+  readonly [JOBS_META]?: unknown;
+  mount: (options?: NextHandlerOptions) => HttpHandlers;
+};
+/**
+ * Create endpoints for a Next.js App Router catch-all route.
+ *
+ * @example
+ * // app/api/[...kizuna]/route.ts
+ * export const { GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS } = api.mount({
+ *     basePath: '/api',
+ * });
+ */
+declare function mountNext(api: NextApiWithRouter, options?: NextHandlerOptions): HttpHandlers;
+/**
+ * Serve an API on Next. What it takes is what every route is served with. Next
+ * routes by file, so mounting returns the route handlers to re-export rather
+ * than registering them on an app.
+ *
+ * @example
+ * // kizuna.config.ts
+ * export default defineConfig({
+ *     adapter: nextAdapter(),
+ *     routes,
+ * });
+ *
+ * // src/app/api/[...kizuna]/route.ts
+ * export const { GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS } = kizuna.api.mount({
+ *     basePath: '/api',
+ * });
+ */
+declare const nextAdapter: (defaults?: NextHandlerOptions) => Adapter<NextHandlerContext, [options?: NextHandlerOptions], HttpHandlers>;
+//#endregion
+export { MountedJobs, NextApi, NextApiWithRouter, NextHandlerContext, NextHandlerOptions, NextMiddlewareHandler, NextMiddlewareRoute, NextRequest, NextResponse, handleNextRequest, mountNext, nextAdapter };

package/dist/index.d.mts

@@ -0,0 +1,107 @@
+import { Adapter, ApiWithRouter, ErrorFormatter, GUARDS_META, GuardMap, JOBS_META, JobRunner, Jobs, REQUEST_CONTEXT_META, RequestContextMap, Router, Routes, SCHEMES_META } from "kizunajs/adapter";
+import { NextRequest, NextRequest as NextRequest$1, NextResponse, NextResponse as NextResponse$1 } from "next/server.js";
+import { SecurityScheme } from "kizunajs";
+
+//#region src/server.d.ts
+interface NextHandlerContext {
+  request: NextRequest$1;
+}
+/**
+ * An api's jobs paired with their handlers, both in the shape the request
+ * pipeline takes.
+ */
+interface MountedJobs {
+  routes: Routes;
+  router: Router<Routes, NextHandlerContext>;
+  runner: JobRunner<Jobs>;
+}
+/**
+ * Passed to each middleware function as the second argument.
+ */
+interface NextMiddlewareRoute {
+  path: string;
+  method: string;
+}
+type NextMiddlewareHandler = (request: NextRequest$1, route: NextMiddlewareRoute) => Response | void | Promise<Response | void>;
+interface NextHandlerOptions {
+  basePath?: string;
+  /**
+   * Map a thrown error into a response. Return a `NextResponse` (e.g. built
+   * from `problemDetails(...)`) to handle the error, or `void` to fall through
+   * to the default 500.
+   */
+  onError?: (error: unknown, request: NextRequest$1) => NextResponse$1 | Promise<NextResponse$1> | void | Promise<void>;
+  /**
+   * Reshape error (status >= 400) response bytes before they are sent. See
+   * {@link ErrorFormatter}.
+   */
+  formatError?: ErrorFormatter<NextRequest$1>;
+  /**
+   * Middleware functions that run after route matching but before the handler.
+   * Each receives `(request, route)`; return a `Response` to short-circuit.
+   * Authentication belongs in a guard.
+   */
+  requestMiddleware?: Array<NextMiddlewareHandler>;
+  /**
+   * Validate handler return values against the routes' response schemas.
+   * Mismatches surface as 500 errors. Intended for development; disable in
+   * production.
+   *
+   * @default false
+   */
+  responseValidation?: boolean;
+}
+declare const handleNextRequest: <T extends Routes>(request: NextRequest$1, routes: T, router: Router<T, NextHandlerContext>, options?: NextHandlerOptions, guards?: GuardMap<NextHandlerContext>, schemes?: Record<string, SecurityScheme>, requestContext?: RequestContextMap<NextHandlerContext>, pluginExports?: Record<string, unknown>, jobs?: MountedJobs) => Promise<NextResponse$1>;
+type HttpHandlers = {
+  GET: HttpHandler;
+  HEAD: HttpHandler;
+  POST: HttpHandler;
+  PUT: HttpHandler;
+  PATCH: HttpHandler;
+  DELETE: HttpHandler;
+  OPTIONS: HttpHandler;
+};
+type HttpHandler = (request: NextRequest$1) => Promise<NextResponse$1>;
+type NextApiWithRouter = ApiWithRouter & {
+  readonly [GUARDS_META]?: unknown;
+  readonly [SCHEMES_META]?: unknown;
+  readonly [REQUEST_CONTEXT_META]?: unknown;
+  readonly [JOBS_META]?: unknown;
+};
+type NextApi<R extends Routes = Routes> = ApiWithRouter<R> & {
+  readonly [GUARDS_META]?: unknown;
+  readonly [SCHEMES_META]?: unknown;
+  readonly [REQUEST_CONTEXT_META]?: unknown;
+  readonly [JOBS_META]?: unknown;
+  mount: (options?: NextHandlerOptions) => HttpHandlers;
+};
+/**
+ * Create endpoints for a Next.js App Router catch-all route.
+ *
+ * @example
+ * // app/api/[...kizuna]/route.ts
+ * export const { GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS } = api.mount({
+ *     basePath: '/api',
+ * });
+ */
+declare function mountNext(api: NextApiWithRouter, options?: NextHandlerOptions): HttpHandlers;
+/**
+ * Serve an API on Next. What it takes is what every route is served with. Next
+ * routes by file, so mounting returns the route handlers to re-export rather
+ * than registering them on an app.
+ *
+ * @example
+ * // kizuna.config.ts
+ * export default defineConfig({
+ *     adapter: nextAdapter(),
+ *     routes,
+ * });
+ *
+ * // src/app/api/[...kizuna]/route.ts
+ * export const { GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS } = kizuna.api.mount({
+ *     basePath: '/api',
+ * });
+ */
+declare const nextAdapter: (defaults?: NextHandlerOptions) => Adapter<NextHandlerContext, [options?: NextHandlerOptions], HttpHandlers>;
+//#endregion
+export { MountedJobs, NextApi, NextApiWithRouter, NextHandlerContext, NextHandlerOptions, NextMiddlewareHandler, NextMiddlewareRoute, NextRequest, NextResponse, handleNextRequest, mountNext, nextAdapter };

package/dist/index.mjs

@@ -0,0 +1,204 @@
+import { GUARDS_META, JOBS_META, REQUEST_CONTEXT_META, ROUTER_META, SCHEMES_META, createAdapter, headersToObject, jobRouter, jobRoutes, jobRunnerFrom, matchRoute, parseFetchBody, pluginExportsOf, pluginRouterOf, pluginRoutesOf, renderJsonResult } from "kizunajs/adapter";
+import { NextRequest, NextResponse, NextResponse as NextResponse$1 } from "next/server.js";
+//#region src/server.ts
+const jsonResponse = (status, body, headers, raw = false) => new NextResponse$1(body === null || body === void 0 ? null : raw ? body : JSON.stringify(body), {
+	status,
+	headers
+});
+const handleNextRequest = async (request, routes, router, options, guards, schemes, requestContext, pluginExports, jobs) => {
+	const url = new URL(request.url);
+	const adapter = createAdapter({
+		buildHandlerContext: (adapterRequest) => ({ request: adapterRequest.request }),
+		respond: (result) => {
+			if (result.kind === "raw-response") return result.response;
+			const rendered = renderJsonResult(result, options?.formatError, request, request.method);
+			if (rendered.stream) return new NextResponse$1(rendered.stream({
+				signal: request.signal,
+				validate: options?.responseValidation
+			}), {
+				status: rendered.status,
+				headers: rendered.headers
+			});
+			return jsonResponse(rendered.status, rendered.body, rendered.headers, rendered.raw);
+		},
+		onError: async (error) => {
+			if (!options?.onError) {
+				console.error("[kizuna/next] handler error:", error);
+				return;
+			}
+			const override = await options.onError(error, request);
+			if (override) return {
+				kind: "raw-response",
+				response: override
+			};
+		}
+	});
+	if (jobs) {
+		const matchedJob = matchRoute(request.method, url.pathname, jobs.routes, options?.basePath);
+		if (matchedJob.kind === "matched") {
+			const jobRequest = {
+				request,
+				method: request.method,
+				resolution: {
+					kind: "pre-resolved",
+					routeKey: matchedJob.match.routeKey,
+					route: matchedJob.match.route,
+					params: matchedJob.match.params
+				},
+				query: Object.fromEntries(url.searchParams),
+				headers: headersToObject(request.headers),
+				readBody: (route) => parseFetchBody(request, route)
+			};
+			return adapter.handle({
+				routes: jobs.routes,
+				router: jobs.router,
+				request: jobRequest,
+				responseContext: {},
+				guards,
+				schemes,
+				requestContext,
+				pluginExports,
+				jobs: jobs.runner,
+				responseValidation: options?.responseValidation
+			});
+		}
+	}
+	const globalMiddleware = options?.requestMiddleware;
+	if (globalMiddleware && globalMiddleware.length > 0) {
+		const matched = matchRoute(request.method, url.pathname, routes, options?.basePath);
+		if (matched.kind === "matched") {
+			const middlewareRoute = {
+				path: matched.match.route.path,
+				method: matched.match.route.method
+			};
+			for (const handler of globalMiddleware) {
+				const result = await handler(request, middlewareRoute);
+				if (result instanceof Response) return new NextResponse$1(result.body, {
+					status: result.status,
+					statusText: result.statusText,
+					headers: result.headers
+				});
+			}
+			const adapterRequest = {
+				request,
+				method: request.method,
+				resolution: {
+					kind: "pre-resolved",
+					routeKey: matched.match.routeKey,
+					route: matched.match.route,
+					params: matched.match.params
+				},
+				query: Object.fromEntries(url.searchParams),
+				headers: headersToObject(request.headers),
+				readBody: (route) => parseFetchBody(request, route)
+			};
+			return adapter.handle({
+				routes,
+				router,
+				request: adapterRequest,
+				responseContext: {},
+				guards,
+				schemes,
+				requestContext,
+				jobs: jobs?.runner,
+				responseValidation: options?.responseValidation
+			});
+		}
+	}
+	const adapterRequest = {
+		request,
+		method: request.method,
+		resolution: {
+			kind: "core-match",
+			path: url.pathname
+		},
+		query: Object.fromEntries(url.searchParams),
+		headers: headersToObject(request.headers),
+		readBody: (route) => parseFetchBody(request, route)
+	};
+	return adapter.handle({
+		routes,
+		router,
+		request: adapterRequest,
+		responseContext: {},
+		guards,
+		schemes,
+		requestContext,
+		pluginExports,
+		jobs: jobs?.runner,
+		basePath: options?.basePath,
+		responseValidation: options?.responseValidation
+	});
+};
+/**
+* Create endpoints for a Next.js App Router catch-all route.
+*
+* @example
+* // app/api/[...kizuna]/route.ts
+* export const { GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS } = api.mount({
+*     basePath: '/api',
+* });
+*/
+function mountNext(api, options) {
+	const guards = api[GUARDS_META];
+	const schemes = api[SCHEMES_META];
+	const requestContext = api[REQUEST_CONTEXT_META];
+	const jobsMeta = api[JOBS_META];
+	const mountedJobs = jobsMeta ? {
+		routes: jobRoutes(jobsMeta),
+		router: jobRouter(jobsMeta),
+		runner: jobRunnerFrom(jobsMeta)
+	} : void 0;
+	const handlerOptions = {
+		basePath: options?.basePath,
+		onError: options?.onError,
+		requestMiddleware: options?.requestMiddleware,
+		responseValidation: options?.responseValidation
+	};
+	const pluginExports = pluginExportsOf(api);
+	const pluginRoutes = pluginRoutesOf(api);
+	const pluginRouter = pluginRouterOf(api);
+	const hasPluginRoutes = Object.keys(pluginRoutes).length > 0;
+	const handler = async (request) => {
+		if (hasPluginRoutes) {
+			const pathname = new URL(request.url).pathname;
+			if (!(matchRoute(request.method, pathname, api.routes, options?.basePath).kind === "matched") && matchRoute(request.method, pathname, pluginRoutes, options?.basePath).kind === "matched") return handleNextRequest(request, pluginRoutes, pluginRouter, handlerOptions, guards, schemes, requestContext, pluginExports, void 0);
+		}
+		return handleNextRequest(request, api.routes, api[ROUTER_META], handlerOptions, guards, schemes, requestContext, pluginExports, mountedJobs);
+	};
+	return {
+		GET: handler,
+		HEAD: handler,
+		POST: handler,
+		PUT: handler,
+		PATCH: handler,
+		DELETE: handler,
+		OPTIONS: handler
+	};
+}
+/**
+* Serve an API on Next. What it takes is what every route is served with. Next
+* routes by file, so mounting returns the route handlers to re-export rather
+* than registering them on an app.
+*
+* @example
+* // kizuna.config.ts
+* export default defineConfig({
+*     adapter: nextAdapter(),
+*     routes,
+* });
+*
+* // src/app/api/[...kizuna]/route.ts
+* export const { GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS } = kizuna.api.mount({
+*     basePath: '/api',
+* });
+*/
+const nextAdapter = (defaults) => ({
+	name: "next",
+	mount: (api, options) => mountNext(api, {
+		...defaults,
+		...options
+	})
+});
+//#endregion
+export { NextRequest, NextResponse, handleNextRequest, mountNext, nextAdapter };

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@kizunajs/next",
+  "version": "2.0.0-beta.0",
+  "description": "Next.js App Router adapter for Kizuna.js",
+  "keywords": [
+    "kizunajs",
+    "typescript",
+    "zod",
+    "openapi",
+    "spec-driven",
+    "type-safe",
+    "rest",
+    "api",
+    "nextjs",
+    "next",
+    "app-router",
+    "adapter"
+  ],
+  "license": "MIT",
+  "homepage": "https://kizunajs.com/docs/adapters/next",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kizunajs/kizuna.git",
+    "directory": "packages/next"
+  },
+  "bugs": "https://github.com/kizunajs/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": {
+    "next": ">=16.0.0",
+    "zod": "^4.0.0",
+    "kizunajs": "2.0.0-beta.0"
+  },
+  "devDependencies": {
+    "next": "^16.3.3",
+    "tsdown": "^0.21.0",
+    "typescript": "^6.0.3",
+    "zod": "^4.0.0",
+    "kizunajs": "2.0.0-beta.0"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts --format esm,cjs --dts --clean --external kizunajs --external zod",
+    "typecheck": "tsc --noEmit"
+  }
+}