@ts-kizuna/fastify 1.49.7 → 1.51.0

package/dist/index.cjs

@@ -127,21 +127,15 @@ const fastifyKizuna = (0, fastify_plugin.default)(async (app, options) => {
 		for (const [routeKey, route] of Object.entries(routes)) mountRoute(routeKey, route, routes, router);
 	}
 }, { name: "@ts-kizuna/fastify" });
-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 });
+/**
+* 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.
+*/
+var KizunaServer = class {
+	constructor(contract, options) {
+		Object.assign(this, (0, _ts_kizuna_core_adapter.createServerSurface)(contract, options, (assembled) => {
+			const api = assembled;
 			const plugin = (0, fastify_plugin.default)(async (app, pluginOptions) => {
 				await fastifyKizuna(app, {
 					...pluginOptions,
@@ -154,32 +148,7 @@ const createServerSurface = (contract, options) => {
 					await app.register(plugin, 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

package/dist/index.d.cts

@@ -1,7 +1,6 @@
 import { FastifyInstance, FastifyPluginAsync, FastifyReply, FastifyRequest } from "fastify";
-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";
+import { ApiWithRouter, ContractJobsRouter, ContractRouter, ErrorFormatter, GUARDS_META, JOBS_META, REQUEST_CONTEXT_META, RouteDefinition, RouteHandler as RouteHandler$1, Routes, SCHEMES_META, Server as Server$1, ServerOptions } from "@ts-kizuna/core/adapter";
+import { Contract, RoutesOf } from "@ts-kizuna/core";
 
 //#region src/server.d.ts
 type FastifyApi<R extends Routes = Routes> = ApiWithRouter<R> & {
@@ -33,18 +32,12 @@ type RouteHandler<R extends RouteDefinition> = RouteHandler$1<R, FastifyHandlerC
  * 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> = C extends Contract<infer R, infer _Tags, infer _Codes, infer Schemes, infer Auth, infer RequestContext, infer Plugins, infer J> ? HandlersFromAuth<R, FastifyHandlerContext & RequestContextValues<RequestContext> & PluginArgs<Plugins> & JobsArg<J>, Schemes, Auth> : C extends Routes ? Router$1<C, FastifyHandlerContext> : never;
+type Router<C> = ContractRouter<C, FastifyHandlerContext>;
 /**
  * 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> = GroupOrRoutes extends string ? Router<Source>[Extract<GroupOrRoutes, keyof Router<Source>>] : Router<GroupOrRoutes>;
+type JobsRouter<C> = ContractJobsRouter<C>;
 declare module 'fastify' {
   interface FastifyRequest {
     kizunaRoute?: RouteDefinition;
@@ -66,32 +59,6 @@ interface FastifyOptions {
    */
   formatError?: ErrorFormatter<FastifyRequest>;
 }
-/**
- * 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> = { [Name in keyof Schemes]: (args: FastifyHandlerContext & 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>> = { [Name in keyof Schemes]: GuardRun<FastifyHandlerContext> };
-/**
- * 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>> = { [Name in keyof RequestContext]: (args: FastifyHandlerContext & {
-  params: Record<string, string>;
-  headers: RequestContextHeaderValues<RequestContext[Name]>;
-}) => z.output<RequestContext[Name]['context']> | Promise<z.output<RequestContext[Name]['context']>> };
 interface KizunaPluginOptions extends FastifyOptions {
   /**
    * The API object built by `server.api`.
@@ -106,95 +73,19 @@ interface KizunaPluginOptions extends FastifyOptions {
  * await api.mount(app);
  */
 declare const fastifyKizuna: (app: FastifyInstance, options: KizunaPluginOptions) => Promise<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, 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>>[Name]): GuardRun<FastifyHandlerContext>;
-  /**
-   * 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>[Name]): RequestContextRun<FastifyHandlerContext>;
-  /**
-   * 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>>, string> | Routes>(group: GroupOrRoutes, router: GroupRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, GroupOrRoutes>): GroupRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, GroupOrRoutes>;
-    (router: Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>): Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>;
-  };
-  /**
-   * 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>>;
-  } & (string extends keyof Schemes ? {
-    guards?: undefined;
-  } : {
-    guards: NoInfer<GuardsForSchemes<Schemes>>;
-  }) & (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<FastifyHandlerContext> }>;
-  }) & (string extends keyof Plugins ? {
-    plugins?: undefined;
-  } : {
-    plugins: PluginImplementations<Plugins, FastifyHandlerContext>;
-  })): FastifyApi<R>;
-}
+interface Server<C extends Contract> extends Server$1<C, FastifyHandlerContext, FastifyApi<RoutesOf<C>>> {}
 /**
  * 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, J extends Jobs = Jobs> implements Server<R, Schemes, Auth, RequestContext, Plugins, J> {
-  readonly guard: Server<R, Schemes, Auth, RequestContext, Plugins, J>['guard'];
-  readonly requestContext: Server<R, Schemes, Auth, RequestContext, Plugins, J>['requestContext'];
-  readonly router: Server<R, Schemes, Auth, RequestContext, Plugins, J>['router'];
-  readonly jobs: Server<R, Schemes, Auth, RequestContext, Plugins, J>['jobs'];
-  readonly api: Server<R, Schemes, Auth, RequestContext, Plugins, J>['api'];
-  constructor(contract: ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, options?: ServerOptions);
+declare class KizunaServer<C extends Contract> implements Server<C> {
+  readonly guard: Server<C>['guard'];
+  readonly requestContext: Server<C>['requestContext'];
+  readonly router: Server<C>['router'];
+  readonly jobs: Server<C>['jobs'];
+  readonly api: Server<C>['api'];
+  constructor(contract: C, options?: ServerOptions);
 }
 //#endregion
 export { FastifyApi, FastifyHandlerContext, FastifyOptions, FastifyPreHandler, JobsRouter, KizunaPluginOptions, KizunaServer, RouteHandler, Router, Server, fastifyKizuna };

package/dist/index.d.mts

@@ -1,7 +1,6 @@
-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 { ApiWithRouter, ContractJobsRouter, ContractRouter, ErrorFormatter, GUARDS_META, JOBS_META, REQUEST_CONTEXT_META, RouteDefinition, RouteHandler as RouteHandler$1, Routes, SCHEMES_META, Server as Server$1, ServerOptions } from "@ts-kizuna/core/adapter";
 import { FastifyInstance, FastifyPluginAsync, FastifyReply, FastifyRequest } from "fastify";
-import { z } from "zod";
-import { Contract, CredentialOf, GuardSuccess, JobHandlers, JobsArg, RequestContextHeaderValues, RequestContextSchema, SecurityScheme, TagOptions } from "@ts-kizuna/core";
+import { Contract, RoutesOf } from "@ts-kizuna/core";
 
 //#region src/server.d.ts
 type FastifyApi<R extends Routes = Routes> = ApiWithRouter<R> & {
@@ -33,18 +32,12 @@ type RouteHandler<R extends RouteDefinition> = RouteHandler$1<R, FastifyHandlerC
  * 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> = C extends Contract<infer R, infer _Tags, infer _Codes, infer Schemes, infer Auth, infer RequestContext, infer Plugins, infer J> ? HandlersFromAuth<R, FastifyHandlerContext & RequestContextValues<RequestContext> & PluginArgs<Plugins> & JobsArg<J>, Schemes, Auth> : C extends Routes ? Router$1<C, FastifyHandlerContext> : never;
+type Router<C> = ContractRouter<C, FastifyHandlerContext>;
 /**
  * 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> = GroupOrRoutes extends string ? Router<Source>[Extract<GroupOrRoutes, keyof Router<Source>>] : Router<GroupOrRoutes>;
+type JobsRouter<C> = ContractJobsRouter<C>;
 declare module 'fastify' {
   interface FastifyRequest {
     kizunaRoute?: RouteDefinition;
@@ -66,32 +59,6 @@ interface FastifyOptions {
    */
   formatError?: ErrorFormatter<FastifyRequest>;
 }
-/**
- * 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> = { [Name in keyof Schemes]: (args: FastifyHandlerContext & 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>> = { [Name in keyof Schemes]: GuardRun<FastifyHandlerContext> };
-/**
- * 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>> = { [Name in keyof RequestContext]: (args: FastifyHandlerContext & {
-  params: Record<string, string>;
-  headers: RequestContextHeaderValues<RequestContext[Name]>;
-}) => z.output<RequestContext[Name]['context']> | Promise<z.output<RequestContext[Name]['context']>> };
 interface KizunaPluginOptions extends FastifyOptions {
   /**
    * The API object built by `server.api`.
@@ -106,95 +73,19 @@ interface KizunaPluginOptions extends FastifyOptions {
  * await api.mount(app);
  */
 declare const fastifyKizuna: (app: FastifyInstance, options: KizunaPluginOptions) => Promise<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, 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>>[Name]): GuardRun<FastifyHandlerContext>;
-  /**
-   * 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>[Name]): RequestContextRun<FastifyHandlerContext>;
-  /**
-   * 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>>, string> | Routes>(group: GroupOrRoutes, router: GroupRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, GroupOrRoutes>): GroupRouter<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, GroupOrRoutes>;
-    (router: Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>): Router<ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>>;
-  };
-  /**
-   * 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>>;
-  } & (string extends keyof Schemes ? {
-    guards?: undefined;
-  } : {
-    guards: NoInfer<GuardsForSchemes<Schemes>>;
-  }) & (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<FastifyHandlerContext> }>;
-  }) & (string extends keyof Plugins ? {
-    plugins?: undefined;
-  } : {
-    plugins: PluginImplementations<Plugins, FastifyHandlerContext>;
-  })): FastifyApi<R>;
-}
+interface Server<C extends Contract> extends Server$1<C, FastifyHandlerContext, FastifyApi<RoutesOf<C>>> {}
 /**
  * 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, J extends Jobs = Jobs> implements Server<R, Schemes, Auth, RequestContext, Plugins, J> {
-  readonly guard: Server<R, Schemes, Auth, RequestContext, Plugins, J>['guard'];
-  readonly requestContext: Server<R, Schemes, Auth, RequestContext, Plugins, J>['requestContext'];
-  readonly router: Server<R, Schemes, Auth, RequestContext, Plugins, J>['router'];
-  readonly jobs: Server<R, Schemes, Auth, RequestContext, Plugins, J>['jobs'];
-  readonly api: Server<R, Schemes, Auth, RequestContext, Plugins, J>['api'];
-  constructor(contract: ServerContract<R, Schemes, Auth, RequestContext, Plugins, J>, options?: ServerOptions);
+declare class KizunaServer<C extends Contract> implements Server<C> {
+  readonly guard: Server<C>['guard'];
+  readonly requestContext: Server<C>['requestContext'];
+  readonly router: Server<C>['router'];
+  readonly jobs: Server<C>['jobs'];
+  readonly api: Server<C>['api'];
+  constructor(contract: C, options?: ServerOptions);
 }
 //#endregion
 export { FastifyApi, FastifyHandlerContext, FastifyOptions, FastifyPreHandler, JobsRouter, KizunaPluginOptions, KizunaServer, RouteHandler, Router, Server, fastifyKizuna };

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import fastifyPlugin from "fastify-plugin";
 import { Readable } from "node:stream";
-import { GUARDS_META, JOBS_META, REQUEST_CONTEXT_META, ROUTER_META, SCHEMES_META, assembleApi, createAdapter, jobRouter, jobRoutes, jobRunnerFrom, pluginExportsOf, pluginRouterOf, pluginRoutesOf, renderJsonResult, warnUnsupportedJobOptions } from "@ts-kizuna/core/adapter";
+import { GUARDS_META, JOBS_META, REQUEST_CONTEXT_META, ROUTER_META, SCHEMES_META, createAdapter, createServerSurface, jobRouter, jobRoutes, jobRunnerFrom, pluginExportsOf, pluginRouterOf, pluginRoutesOf, renderJsonResult } from "@ts-kizuna/core/adapter";
 //#region src/server.ts
 /**
 * Write a web `Response` to a Fastify reply. Plugins answer in web terms to stay
@@ -103,21 +103,15 @@ const fastifyKizuna = fastifyPlugin(async (app, options) => {
 		for (const [routeKey, route] of Object.entries(routes)) mountRoute(routeKey, route, routes, router);
 	}
 }, { name: "@ts-kizuna/fastify" });
-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 });
+/**
+* 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.
+*/
+var KizunaServer = class {
+	constructor(contract, options) {
+		Object.assign(this, createServerSurface(contract, options, (assembled) => {
+			const api = assembled;
 			const plugin = fastifyPlugin(async (app, pluginOptions) => {
 				await fastifyKizuna(app, {
 					...pluginOptions,
@@ -130,32 +124,7 @@ const createServerSurface = (contract, options) => {
 					await app.register(plugin, 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-kizuna/fastify",
-  "version": "1.49.7",
+  "version": "1.51.0",
   "description": "Fastify adapter for ts-kizuna",
   "keywords": [
     "ts-kizuna",
@@ -60,14 +60,14 @@
   "peerDependencies": {
     "fastify": "^5.0.0",
     "zod": "^4.0.0",
-    "@ts-kizuna/core": "1.49.7"
+    "@ts-kizuna/core": "1.51.0"
   },
   "devDependencies": {
     "fastify": "^5.0.0",
     "tsdown": "^0.21.0",
-    "typescript": "^5.6.3",
+    "typescript": "^6.0.3",
     "zod": "^4.0.0",
-    "@ts-kizuna/core": "1.49.7"
+    "@ts-kizuna/core": "1.51.0"
   },
   "scripts": {
     "build": "tsdown src/index.ts --format esm,cjs --dts --clean --external @ts-kizuna/core --external fastify --external fastify-plugin --external zod",