@taserjs/router 0.1.2 → 0.1.4

package/dist/cjs/middleware/cors.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"cors.cjs","names":[],"sources":["../../../src/middleware/cors.ts"],"sourcesContent":["import { cors as honoCors } from \"hono/cors\";\n\nimport { wrapHonoMiddleware } from \"./wrap-hono.js\";\n\nconst wrapped = wrapHonoMiddleware(honoCors);\n\nexport function cors(...args: Parameters<typeof honoCors>) {\n  return wrapped(...args);\n}\n\nexport type CorsOptions = NonNullable<Parameters<typeof honoCors>[0]>;\n"],"mappings":";;;;AAIA,IAAM,UAAU,kBAAA,mBAAmB,UAAA,IAAQ;AAE3C,SAAgB,KAAK,GAAG,MAAmC;CACzD,OAAO,QAAQ,GAAG,IAAI;AACxB"}
+{"version":3,"file":"cors.cjs","names":[],"sources":["../../../src/middleware/cors.ts"],"sourcesContent":["import { cors as honoCors } from \"hono/cors\";\n\nimport { defineMiddleware } from \"../define/middleware.js\";\nimport { honoMw } from \"./hono-mw.js\";\n\nexport function cors(...args: Parameters<typeof honoCors>) {\n  return defineMiddleware(honoMw(honoCors(...args)));\n}\n\nexport type CorsOptions = NonNullable<Parameters<typeof honoCors>[0]>;\n"],"mappings":";;;;;AAKA,SAAgB,KAAK,GAAG,MAAmC;CACzD,OAAO,mBAAA,iBAAiB,gBAAA,QAAA,GAAA,UAAA,KAAA,CAAgB,GAAG,IAAI,CAAC,CAAC;AACnD"}

package/dist/cjs/middleware/cors.d.cts

@@ -1,3 +1,3 @@
 import { cors as honoCors } from 'hono/cors';
-export declare function cors(...args: Parameters<typeof honoCors>): import('../types/units.js').MiddlewareUnit<import('../types/units.js').MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
+export declare function cors(...args: Parameters<typeof honoCors>): import('../types/units.js').DefineMiddlewareResult<unknown, unknown, unknown, {}, Response, unknown, unknown, unknown, {}, null, {}>;
 export type CorsOptions = NonNullable<Parameters<typeof honoCors>[0]>;

package/dist/cjs/middleware/csrf.cjs

@@ -1,10 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_wrap_hono = require("./wrap-hono.cjs");
+const require_middleware = require("../define/middleware.cjs");
+const require_hono_mw = require("./hono-mw.cjs");
 let hono_csrf = require("hono/csrf");
 //#region src/middleware/csrf.ts
-var wrapped = require_wrap_hono.wrapHonoMiddleware(hono_csrf.csrf);
 function csrf(...args) {
-	return wrapped(...args);
+	return require_middleware.defineMiddleware(require_hono_mw.honoMw((0, hono_csrf.csrf)(...args)));
 }
 //#endregion
 exports.csrf = csrf;

package/dist/cjs/middleware/csrf.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"csrf.cjs","names":[],"sources":["../../../src/middleware/csrf.ts"],"sourcesContent":["import { csrf as honoCsrf } from \"hono/csrf\";\n\nimport { wrapHonoMiddleware } from \"./wrap-hono.js\";\n\nconst wrapped = wrapHonoMiddleware(honoCsrf);\n\nexport function csrf(...args: Parameters<typeof honoCsrf>) {\n  return wrapped(...args);\n}\n\nexport type CsrfOptions = NonNullable<Parameters<typeof honoCsrf>[0]>;\n"],"mappings":";;;;AAIA,IAAM,UAAU,kBAAA,mBAAmB,UAAA,IAAQ;AAE3C,SAAgB,KAAK,GAAG,MAAmC;CACzD,OAAO,QAAQ,GAAG,IAAI;AACxB"}
+{"version":3,"file":"csrf.cjs","names":[],"sources":["../../../src/middleware/csrf.ts"],"sourcesContent":["import { csrf as honoCsrf } from \"hono/csrf\";\n\nimport { defineMiddleware } from \"../define/middleware.js\";\nimport { honoMw } from \"./hono-mw.js\";\n\nexport function csrf(...args: Parameters<typeof honoCsrf>) {\n  return defineMiddleware(honoMw(honoCsrf(...args)));\n}\n\nexport type CsrfOptions = NonNullable<Parameters<typeof honoCsrf>[0]>;\n"],"mappings":";;;;;AAKA,SAAgB,KAAK,GAAG,MAAmC;CACzD,OAAO,mBAAA,iBAAiB,gBAAA,QAAA,GAAA,UAAA,KAAA,CAAgB,GAAG,IAAI,CAAC,CAAC;AACnD"}

package/dist/cjs/middleware/csrf.d.cts

@@ -1,3 +1,3 @@
 import { csrf as honoCsrf } from 'hono/csrf';
-export declare function csrf(...args: Parameters<typeof honoCsrf>): import('../types/units.js').MiddlewareUnit<import('../types/units.js').MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
+export declare function csrf(...args: Parameters<typeof honoCsrf>): import('../types/units.js').DefineMiddlewareResult<unknown, unknown, unknown, {}, Response, unknown, unknown, unknown, {}, null, {}>;
 export type CsrfOptions = NonNullable<Parameters<typeof honoCsrf>[0]>;

package/dist/cjs/middleware/etag.cjs

@@ -1,10 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_wrap_hono = require("./wrap-hono.cjs");
+const require_middleware = require("../define/middleware.cjs");
+const require_hono_mw = require("./hono-mw.cjs");
 let hono_etag = require("hono/etag");
 //#region src/middleware/etag.ts
-var wrapped = require_wrap_hono.wrapHonoMiddleware(hono_etag.etag);
 function etag(...args) {
-	return wrapped(...args);
+	return require_middleware.defineMiddleware(require_hono_mw.honoMw((0, hono_etag.etag)(...args)));
 }
 //#endregion
 exports.etag = etag;

package/dist/cjs/middleware/etag.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"etag.cjs","names":[],"sources":["../../../src/middleware/etag.ts"],"sourcesContent":["import { etag as honoEtag } from \"hono/etag\";\n\nimport { wrapHonoMiddleware } from \"./wrap-hono.js\";\n\nconst wrapped = wrapHonoMiddleware(honoEtag);\n\nexport function etag(...args: Parameters<typeof honoEtag>) {\n  return wrapped(...args);\n}\n\nexport type EtagOptions = NonNullable<Parameters<typeof honoEtag>[0]>;\n"],"mappings":";;;;AAIA,IAAM,UAAU,kBAAA,mBAAmB,UAAA,IAAQ;AAE3C,SAAgB,KAAK,GAAG,MAAmC;CACzD,OAAO,QAAQ,GAAG,IAAI;AACxB"}
+{"version":3,"file":"etag.cjs","names":[],"sources":["../../../src/middleware/etag.ts"],"sourcesContent":["import { etag as honoEtag } from \"hono/etag\";\n\nimport { defineMiddleware } from \"../define/middleware.js\";\nimport { honoMw } from \"./hono-mw.js\";\n\nexport function etag(...args: Parameters<typeof honoEtag>) {\n  return defineMiddleware(honoMw(honoEtag(...args)));\n}\n\nexport type EtagOptions = NonNullable<Parameters<typeof honoEtag>[0]>;\n"],"mappings":";;;;;AAKA,SAAgB,KAAK,GAAG,MAAmC;CACzD,OAAO,mBAAA,iBAAiB,gBAAA,QAAA,GAAA,UAAA,KAAA,CAAgB,GAAG,IAAI,CAAC,CAAC;AACnD"}

package/dist/cjs/middleware/etag.d.cts

@@ -1,3 +1,3 @@
 import { etag as honoEtag } from 'hono/etag';
-export declare function etag(...args: Parameters<typeof honoEtag>): import('../types/units.js').MiddlewareUnit<import('../types/units.js').MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
+export declare function etag(...args: Parameters<typeof honoEtag>): import('../types/units.js').DefineMiddlewareResult<unknown, unknown, unknown, {}, Response, unknown, unknown, unknown, {}, null, {}>;
 export type EtagOptions = NonNullable<Parameters<typeof honoEtag>[0]>;

package/dist/cjs/middleware/hono-mw.cjs

@@ -0,0 +1,23 @@
+let _taserjs_router_core = require("@taserjs/router-core");
+//#region src/middleware/hono-mw.ts
+/**
+* Adapts a standard Web / Hono-compatible middleware function `(c, next) => ...`
+* into a Taser-compatible middleware handler function `(ctx, next) => Promise<Response>`.
+*
+* @example
+* ```ts
+* import { honoMw } from "@taserjs/router";
+* import { cors } from "hono/cors";
+*
+* const app = t.get("/hello").use(honoMw(cors()));
+* // or
+* const customCors = defineMiddleware(honoMw(cors()));
+* ```
+*/
+function honoMw(middleware) {
+	return (0, _taserjs_router_core.createTaserCompatHandler)(middleware);
+}
+//#endregion
+exports.honoMw = honoMw;
+
+//# sourceMappingURL=hono-mw.cjs.map

package/dist/cjs/middleware/hono-mw.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hono-mw.cjs","names":[],"sources":["../../../src/middleware/hono-mw.ts"],"sourcesContent":["import { createTaserCompatHandler } from \"@taserjs/router-core\";\nimport type { MiddlewareHandler } from \"hono\";\n\n/**\n * Adapts a standard Web / Hono-compatible middleware function `(c, next) => ...`\n * into a Taser-compatible middleware handler function `(ctx, next) => Promise<Response>`.\n *\n * @example\n * ```ts\n * import { honoMw } from \"@taserjs/router\";\n * import { cors } from \"hono/cors\";\n *\n * const app = t.get(\"/hello\").use(honoMw(cors()));\n * // or\n * const customCors = defineMiddleware(honoMw(cors()));\n * ```\n */\nexport function honoMw(\n  middleware: MiddlewareHandler,\n): (ctx: unknown, next: any) => Promise<Response> {\n  return createTaserCompatHandler(middleware) as (ctx: unknown, next: any) => Promise<Response>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAiBA,SAAgB,OACd,YACgD;CAChD,QAAA,GAAA,qBAAA,yBAAA,CAAgC,UAAU;AAC5C"}

package/dist/cjs/middleware/hono-mw.d.cts

@@ -0,0 +1,16 @@
+import { MiddlewareHandler } from 'hono';
+/**
+ * Adapts a standard Web / Hono-compatible middleware function `(c, next) => ...`
+ * into a Taser-compatible middleware handler function `(ctx, next) => Promise<Response>`.
+ *
+ * @example
+ * ```ts
+ * import { honoMw } from "@taserjs/router";
+ * import { cors } from "hono/cors";
+ *
+ * const app = t.get("/hello").use(honoMw(cors()));
+ * // or
+ * const customCors = defineMiddleware(honoMw(cors()));
+ * ```
+ */
+export declare function honoMw(middleware: MiddlewareHandler): (ctx: unknown, next: any) => Promise<Response>;

package/dist/cjs/middleware/jwk.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_middleware = require("../define/middleware.cjs");
-const require_wrap_hono = require("./wrap-hono.cjs");
+const require_hono_mw = require("./hono-mw.cjs");
 let hono_jwk = require("hono/jwk");
 //#region src/middleware/jwk.ts
 function assertJwksScheme(jwksUri, allowInsecure) {
@@ -18,7 +18,11 @@ function jwk(options, init) {
 	const jwksUri = options.jwks_uri;
 	if (typeof jwksUri === "string") assertJwksScheme(jwksUri, options.allowInsecure ?? false);
 	const { allowInsecure: _allowInsecure, ...honoOptions } = options;
-	return require_middleware.defineMiddleware({ handler: require_wrap_hono.extractJwtPayload((0, hono_jwk.jwk)(honoOptions, init?.headers !== void 0 ? { headers: init.headers } : void 0)) });
+	const mw = require_hono_mw.honoMw((0, hono_jwk.jwk)(honoOptions, init?.headers !== void 0 ? { headers: init.headers } : void 0));
+	return require_middleware.defineMiddleware((ctx, next) => mw(ctx, async () => {
+		const payload = ctx.var.jwtPayload;
+		return next({ jwtPayload: payload });
+	}));
 }
 //#endregion
 exports.jwk = jwk;

package/dist/cjs/middleware/jwk.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"jwk.cjs","names":[],"sources":["../../../src/middleware/jwk.ts"],"sourcesContent":["import type { MiddlewareHandler } from \"hono\";\nimport { jwk as honoJwk } from \"hono/jwk\";\n\nimport { defineMiddleware } from \"../define/middleware.js\";\nimport type { JwtMiddlewareUnit, JwtPayloadState } from \"./jwt.js\";\nimport { extractJwtPayload } from \"./wrap-hono.js\";\n\nexport type JwkOptions = Parameters<typeof honoJwk>[0];\n\nexport type JwkRequestInit = Pick<RequestInit, \"headers\">;\n\nexport type JwkMiddlewareOptions = JwkOptions & {\n  /** Allow `http://` JWKS URLs (local dev). Default false — requires `https://`. */\n  allowInsecure?: boolean;\n};\n\nfunction assertJwksScheme(jwksUri: string, allowInsecure: boolean): void {\n  const scheme = new URL(jwksUri).protocol.replace(\":\", \"\");\n  if (scheme === \"https\") {\n    return;\n  }\n  if (scheme === \"http\" && allowInsecure) {\n    return;\n  }\n  throw new Error(`JWKS URL must use https:// (or http:// with allowInsecure: true): \"${jwksUri}\"`);\n}\n\n/**\n * JWK auth middleware. Invalid or missing tokens return **401** (Hono).\n * Successfully decoded payload is placed in `ctx.state.jwtPayload`.\n * Static `jwks_uri` must use HTTPS unless `allowInsecure: true`.\n */\nexport function jwk<TPayload = Record<string, unknown>>(\n  options: JwkMiddlewareOptions,\n  init?: JwkRequestInit,\n): JwtMiddlewareUnit<TPayload> {\n  const jwksUri = options.jwks_uri;\n  if (typeof jwksUri === \"string\") {\n    assertJwksScheme(jwksUri, options.allowInsecure ?? false);\n  }\n\n  const { allowInsecure: _allowInsecure, ...honoOptions } = options;\n  const safeInit = init?.headers !== undefined ? { headers: init.headers } : undefined;\n  const honoMw: MiddlewareHandler = honoJwk(honoOptions, safeInit);\n\n  return defineMiddleware<JwtPayloadState<TPayload>>({\n    handler: extractJwtPayload<TPayload>(honoMw),\n  });\n}\n"],"mappings":";;;;;AAgBA,SAAS,iBAAiB,SAAiB,eAA8B;CACvE,MAAM,SAAS,IAAI,IAAI,OAAO,CAAC,CAAC,SAAS,QAAQ,KAAK,EAAE;CACxD,IAAI,WAAW,SACb;CAEF,IAAI,WAAW,UAAU,eACvB;CAEF,MAAM,IAAI,MAAM,sEAAsE,QAAQ,EAAE;AAClG;;;;;;AAOA,SAAgB,IACd,SACA,MAC6B;CAC7B,MAAM,UAAU,QAAQ;CACxB,IAAI,OAAO,YAAY,UACrB,iBAAiB,SAAS,QAAQ,iBAAiB,KAAK;CAG1D,MAAM,EAAE,eAAe,gBAAgB,GAAG,gBAAgB;CAI1D,OAAO,mBAAA,iBAA4C,EACjD,SAAS,kBAAA,mBAAA,GAAA,SAAA,IAAA,CAH+B,aADzB,MAAM,YAAY,KAAA,IAAY,EAAE,SAAS,KAAK,QAAQ,IAAI,KAAA,CAIpC,CAAM,EAC7C,CAAC;AACH"}
+{"version":3,"file":"jwk.cjs","names":[],"sources":["../../../src/middleware/jwk.ts"],"sourcesContent":["import { jwk as honoJwk } from \"hono/jwk\";\n\nimport { defineMiddleware } from \"../define/middleware.js\";\nimport { honoMw } from \"./hono-mw.js\";\nimport type { JwtMiddlewareUnit, JwtPayloadState } from \"./jwt.js\";\n\nexport type JwkOptions = Parameters<typeof honoJwk>[0];\n\nexport type JwkRequestInit = Pick<RequestInit, \"headers\">;\n\nexport type JwkMiddlewareOptions = JwkOptions & {\n  /** Allow `http://` JWKS URLs (local dev). Default false — requires `https://`. */\n  allowInsecure?: boolean;\n};\n\nfunction assertJwksScheme(jwksUri: string, allowInsecure: boolean): void {\n  const scheme = new URL(jwksUri).protocol.replace(\":\", \"\");\n  if (scheme === \"https\") {\n    return;\n  }\n  if (scheme === \"http\" && allowInsecure) {\n    return;\n  }\n  throw new Error(`JWKS URL must use https:// (or http:// with allowInsecure: true): \"${jwksUri}\"`);\n}\n\n/**\n * JWK auth middleware. Invalid or missing tokens return **401** (Hono).\n * Successfully decoded payload is placed in `ctx.state.jwtPayload`.\n * Static `jwks_uri` must use HTTPS unless `allowInsecure: true`.\n */\nexport function jwk<TPayload = Record<string, unknown>>(\n  options: JwkMiddlewareOptions,\n  init?: JwkRequestInit,\n): JwtMiddlewareUnit<TPayload> {\n  const jwksUri = options.jwks_uri;\n  if (typeof jwksUri === \"string\") {\n    assertJwksScheme(jwksUri, options.allowInsecure ?? false);\n  }\n\n  const { allowInsecure: _allowInsecure, ...honoOptions } = options;\n  const safeInit = init?.headers !== undefined ? { headers: init.headers } : undefined;\n  const mw = honoMw(honoJwk(honoOptions, safeInit));\n\n  return defineMiddleware<JwtPayloadState<TPayload>>((ctx, next) =>\n    mw(ctx, async () => {\n      const payload = (ctx as unknown as { var: { jwtPayload?: unknown } }).var.jwtPayload;\n      return next({ jwtPayload: payload as TPayload });\n    }),\n  );\n}\n"],"mappings":";;;;;AAeA,SAAS,iBAAiB,SAAiB,eAA8B;CACvE,MAAM,SAAS,IAAI,IAAI,OAAO,CAAC,CAAC,SAAS,QAAQ,KAAK,EAAE;CACxD,IAAI,WAAW,SACb;CAEF,IAAI,WAAW,UAAU,eACvB;CAEF,MAAM,IAAI,MAAM,sEAAsE,QAAQ,EAAE;AAClG;;;;;;AAOA,SAAgB,IACd,SACA,MAC6B;CAC7B,MAAM,UAAU,QAAQ;CACxB,IAAI,OAAO,YAAY,UACrB,iBAAiB,SAAS,QAAQ,iBAAiB,KAAK;CAG1D,MAAM,EAAE,eAAe,gBAAgB,GAAG,gBAAgB;CAE1D,MAAM,KAAK,gBAAA,QAAA,GAAA,SAAA,IAAA,CAAe,aADT,MAAM,YAAY,KAAA,IAAY,EAAE,SAAS,KAAK,QAAQ,IAAI,KAAA,CAC5B,CAAC;CAEhD,OAAO,mBAAA,kBAA6C,KAAK,SACvD,GAAG,KAAK,YAAY;EAClB,MAAM,UAAW,IAAqD,IAAI;EAC1E,OAAO,KAAK,EAAE,YAAY,QAAoB,CAAC;CACjD,CAAC,CACH;AACF"}

package/dist/cjs/middleware/jwt.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_middleware = require("../define/middleware.cjs");
-const require_wrap_hono = require("./wrap-hono.cjs");
+const require_hono_mw = require("./hono-mw.cjs");
 let hono_jwt = require("hono/jwt");
 //#region src/middleware/jwt.ts
 /**
@@ -8,7 +8,11 @@ let hono_jwt = require("hono/jwt");
 * Successfully decoded payload is placed in `ctx.state.jwtPayload`.
 */
 function jwt(options) {
-	return require_middleware.defineMiddleware({ handler: require_wrap_hono.extractJwtPayload((0, hono_jwt.jwt)(options)) });
+	const mw = require_hono_mw.honoMw((0, hono_jwt.jwt)(options));
+	return require_middleware.defineMiddleware((ctx, next) => mw(ctx, async () => {
+		const payload = ctx.var.jwtPayload;
+		return next({ jwtPayload: payload });
+	}));
 }
 //#endregion
 exports.jwt = jwt;

package/dist/cjs/middleware/jwt.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"jwt.cjs","names":[],"sources":["../../../src/middleware/jwt.ts"],"sourcesContent":["import type { MiddlewareHandler } from \"hono\";\nimport { jwt as honoJwt } from \"hono/jwt\";\n\nimport { defineMiddleware } from \"../define/middleware.js\";\nimport type { MiddlewareReturnFromParts, MiddlewareUnit } from \"../types/units.js\";\nimport { extractJwtPayload } from \"./wrap-hono.js\";\n\nexport type JwtPayloadState<TPayload> = {\n  jwtPayload: TPayload;\n};\n\nexport type JwtMiddlewareUnit<TPayload> = MiddlewareUnit<\n  MiddlewareReturnFromParts<unknown, unknown, unknown, JwtPayloadState<TPayload>>\n>;\n\nexport type JwtOptions = Parameters<typeof honoJwt>[0];\n\n/**\n * JWT auth middleware. Invalid or missing tokens return **401** (Hono).\n * Successfully decoded payload is placed in `ctx.state.jwtPayload`.\n */\nexport function jwt<TPayload = Record<string, unknown>>(\n  options: JwtOptions,\n): JwtMiddlewareUnit<TPayload> {\n  const honoMw: MiddlewareHandler = honoJwt(options);\n  return defineMiddleware<JwtPayloadState<TPayload>>({\n    handler: extractJwtPayload<TPayload>(honoMw),\n  });\n}\n"],"mappings":";;;;;;;;;AAqBA,SAAgB,IACd,SAC6B;CAE7B,OAAO,mBAAA,iBAA4C,EACjD,SAAS,kBAAA,mBAAA,GAAA,SAAA,IAAA,CAF+B,OAEH,CAAM,EAC7C,CAAC;AACH"}
+{"version":3,"file":"jwt.cjs","names":[],"sources":["../../../src/middleware/jwt.ts"],"sourcesContent":["import { jwt as honoJwt } from \"hono/jwt\";\n\nimport { defineMiddleware } from \"../define/middleware.js\";\nimport type { MiddlewareReturnFromParts, MiddlewareUnit } from \"../types/units.js\";\nimport { honoMw } from \"./hono-mw.js\";\n\nexport type JwtPayloadState<TPayload> = {\n  jwtPayload: TPayload;\n};\n\nexport type JwtMiddlewareUnit<TPayload> = MiddlewareUnit<\n  MiddlewareReturnFromParts<unknown, unknown, unknown, JwtPayloadState<TPayload>>\n>;\n\nexport type JwtOptions = Parameters<typeof honoJwt>[0];\n\n/**\n * JWT auth middleware. Invalid or missing tokens return **401** (Hono).\n * Successfully decoded payload is placed in `ctx.state.jwtPayload`.\n */\nexport function jwt<TPayload = Record<string, unknown>>(\n  options: JwtOptions,\n): JwtMiddlewareUnit<TPayload> {\n  const mw = honoMw(honoJwt(options));\n  return defineMiddleware<JwtPayloadState<TPayload>>((ctx, next) =>\n    mw(ctx, async () => {\n      const payload = (ctx as unknown as { var: { jwtPayload?: unknown } }).var.jwtPayload;\n      return next({ jwtPayload: payload as TPayload });\n    }),\n  );\n}\n"],"mappings":";;;;;;;;;AAoBA,SAAgB,IACd,SAC6B;CAC7B,MAAM,KAAK,gBAAA,QAAA,GAAA,SAAA,IAAA,CAAe,OAAO,CAAC;CAClC,OAAO,mBAAA,kBAA6C,KAAK,SACvD,GAAG,KAAK,YAAY;EAClB,MAAM,UAAW,IAAqD,IAAI;EAC1E,OAAO,KAAK,EAAE,YAAY,QAAoB,CAAC;CACjD,CAAC,CACH;AACF"}

package/dist/cjs/middleware/secure-headers.cjs

@@ -1,10 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_wrap_hono = require("./wrap-hono.cjs");
+const require_middleware = require("../define/middleware.cjs");
+const require_hono_mw = require("./hono-mw.cjs");
 let hono_secure_headers = require("hono/secure-headers");
 //#region src/middleware/secure-headers.ts
-var wrapped = require_wrap_hono.wrapHonoMiddleware(hono_secure_headers.secureHeaders);
 function secureHeaders(...args) {
-	return wrapped(...args);
+	return require_middleware.defineMiddleware(require_hono_mw.honoMw((0, hono_secure_headers.secureHeaders)(...args)));
 }
 //#endregion
 exports.secureHeaders = secureHeaders;

package/dist/cjs/middleware/secure-headers.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"secure-headers.cjs","names":[],"sources":["../../../src/middleware/secure-headers.ts"],"sourcesContent":["import { secureHeaders as honoSecureHeaders } from \"hono/secure-headers\";\n\nimport { wrapHonoMiddleware } from \"./wrap-hono.js\";\n\nconst wrapped = wrapHonoMiddleware(honoSecureHeaders);\n\nexport function secureHeaders(...args: Parameters<typeof honoSecureHeaders>) {\n  return wrapped(...args);\n}\n\nexport type SecureHeadersOptions = NonNullable<Parameters<typeof honoSecureHeaders>[0]>;\n"],"mappings":";;;;AAIA,IAAM,UAAU,kBAAA,mBAAmB,oBAAA,aAAiB;AAEpD,SAAgB,cAAc,GAAG,MAA4C;CAC3E,OAAO,QAAQ,GAAG,IAAI;AACxB"}
+{"version":3,"file":"secure-headers.cjs","names":[],"sources":["../../../src/middleware/secure-headers.ts"],"sourcesContent":["import { secureHeaders as honoSecureHeaders } from \"hono/secure-headers\";\n\nimport { defineMiddleware } from \"../define/middleware.js\";\nimport { honoMw } from \"./hono-mw.js\";\n\nexport function secureHeaders(...args: Parameters<typeof honoSecureHeaders>) {\n  return defineMiddleware(honoMw(honoSecureHeaders(...args)));\n}\n\nexport type SecureHeadersOptions = NonNullable<Parameters<typeof honoSecureHeaders>[0]>;\n"],"mappings":";;;;;AAKA,SAAgB,cAAc,GAAG,MAA4C;CAC3E,OAAO,mBAAA,iBAAiB,gBAAA,QAAA,GAAA,oBAAA,cAAA,CAAyB,GAAG,IAAI,CAAC,CAAC;AAC5D"}

package/dist/cjs/middleware/secure-headers.d.cts

@@ -1,3 +1,3 @@
 import { secureHeaders as honoSecureHeaders } from 'hono/secure-headers';
-export declare function secureHeaders(...args: Parameters<typeof honoSecureHeaders>): import('../types/units.js').MiddlewareUnit<import('../types/units.js').MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
+export declare function secureHeaders(...args: Parameters<typeof honoSecureHeaders>): import('../types/units.js').DefineMiddlewareResult<unknown, unknown, unknown, {}, Response, unknown, unknown, unknown, {}, null, {}>;
 export type SecureHeadersOptions = NonNullable<Parameters<typeof honoSecureHeaders>[0]>;

package/dist/cjs/middleware/timing.cjs

@@ -1,10 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_wrap_hono = require("./wrap-hono.cjs");
+const require_middleware = require("../define/middleware.cjs");
+const require_hono_mw = require("./hono-mw.cjs");
 let hono_timing = require("hono/timing");
 //#region src/middleware/timing.ts
-var wrapped = require_wrap_hono.wrapHonoMiddleware(hono_timing.timing);
 function timing(...args) {
-	return wrapped(...args);
+	return require_middleware.defineMiddleware(require_hono_mw.honoMw((0, hono_timing.timing)(...args)));
 }
 //#endregion
 exports.timing = timing;

package/dist/cjs/middleware/timing.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"timing.cjs","names":[],"sources":["../../../src/middleware/timing.ts"],"sourcesContent":["import { timing as honoTiming } from \"hono/timing\";\n\nimport { wrapHonoMiddleware } from \"./wrap-hono.js\";\n\nconst wrapped = wrapHonoMiddleware(honoTiming);\n\nexport function timing(...args: Parameters<typeof honoTiming>) {\n  return wrapped(...args);\n}\n\nexport type TimingOptions = NonNullable<Parameters<typeof honoTiming>[0]>;\n"],"mappings":";;;;AAIA,IAAM,UAAU,kBAAA,mBAAmB,YAAA,MAAU;AAE7C,SAAgB,OAAO,GAAG,MAAqC;CAC7D,OAAO,QAAQ,GAAG,IAAI;AACxB"}
+{"version":3,"file":"timing.cjs","names":[],"sources":["../../../src/middleware/timing.ts"],"sourcesContent":["import { timing as honoTiming } from \"hono/timing\";\n\nimport { defineMiddleware } from \"../define/middleware.js\";\nimport { honoMw } from \"./hono-mw.js\";\n\nexport function timing(...args: Parameters<typeof honoTiming>) {\n  return defineMiddleware(honoMw(honoTiming(...args)));\n}\n\nexport type TimingOptions = NonNullable<Parameters<typeof honoTiming>[0]>;\n"],"mappings":";;;;;AAKA,SAAgB,OAAO,GAAG,MAAqC;CAC7D,OAAO,mBAAA,iBAAiB,gBAAA,QAAA,GAAA,YAAA,OAAA,CAAkB,GAAG,IAAI,CAAC,CAAC;AACrD"}

package/dist/cjs/middleware/timing.d.cts

@@ -1,3 +1,3 @@
 import { timing as honoTiming } from 'hono/timing';
-export declare function timing(...args: Parameters<typeof honoTiming>): import('../types/units.js').MiddlewareUnit<import('../types/units.js').MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
+export declare function timing(...args: Parameters<typeof honoTiming>): import('../types/units.js').DefineMiddlewareResult<unknown, unknown, unknown, {}, Response, unknown, unknown, unknown, {}, null, {}>;
 export type TimingOptions = NonNullable<Parameters<typeof honoTiming>[0]>;

package/dist/cjs/types/index.d.cts

@@ -3,13 +3,13 @@ import { RouterRegister } from '../register.js';
 import { MergeMiddlewareField, MergeMiddlewareInputField, MergePart, RequestShape, Simplify, UnionToIntersection, UnitRuntimeContext } from './type-utils.js';
 import { ReturnsMap, ValidHandlerReply } from './returns.js';
 import { Schema } from './schema.js';
-import { AppContext, ExtractState, HandlerContext, HandlerUnit, InlineMiddlewareOptions, Method, MiddlewareDefinition, MiddlewareReturnFromParts, MiddlewareUnit, ValidatorParts } from './units.js';
+import { AppContext, ExtractState, Method, MiddlewareDefinition, MiddlewareReturnFromParts, MiddlewareUnit, NextFn, ValidatorParts } from './units.js';
 export type { Awaitable } from '@taserjs/router-core';
 export type { SchemaRequestShape, InferInput, InferOutput, Schema, StandardSchemaV1, } from './schema.js';
 export type { RouterRegister } from '../register.js';
 export type { MergeMiddlewareField, MergeMiddlewareInputField, MergePart, RequestShape, Simplify, UnitRuntimeContext, UnwrapPart, } from './type-utils.js';
 export type { EmptyReturns, EnforceHandlerReply, HandlerReply, HasReturns, MergeReturns, ReplyFor, ReturnsMap, StatusCode, ValidHandlerReply, } from './returns.js';
-export type { AppContext, ExtractState, HandlerContext, HandlerUnit, HttpMethod, InlineMiddlewareOptions, IsUnknown, Method, MiddlewareDefinition, MiddlewareNext, MiddlewareReturnFromParts, MiddlewareUnit, NextFn, NextResult, StandaloneMiddlewareContext, StateBrand, ValidatorParts, } from './units.js';
+export type { AppContext, ExtractState, HttpMethod, IsUnknown, Method, MiddlewareDefinition, MiddlewareNext, MiddlewareReturnFromParts, MiddlewareUnit, MiddlewareUnitBuilder, NextFn, NextResult, StandaloneMiddlewareContext, StateBrand, ValidatorParts, } from './units.js';
 export type RoutePath = RouterRegister extends {
     RoutePath: infer P;
 } ? P : never;
@@ -169,17 +169,13 @@ export type MiddlewareBuilder<Layout extends LayoutId, Acc extends readonly unkn
             actualState: MiddlewareChainField<Layout, Acc, "state">;
         }
     ]): MiddlewareBuilder<Layout, readonly [...Acc, TAcc], TAppContext>;
-    use<TQuery = unknown, TParams = unknown, TBody = unknown, TReturns extends ReturnsMap = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown, R = unknown>(options: InlineMiddlewareOptions<MiddlewareChainContext<Layout, Acc, TQuery, TParams, TBody, TAppContext>, TQuery, TParams, TBody, TReturns, TQueryIn, TParamsIn, TBodyIn, R>): MiddlewareBuilder<Layout, readonly [
-        ...Acc,
-        MiddlewareReturnFromParts<TQuery, TParams, TBody, ExtractState<R>, TQueryIn, TParamsIn, TBodyIn>
-    ], TAppContext>;
+    use<R = unknown>(fn: (ctx: MiddlewareChainContext<Layout, Acc, unknown, unknown, unknown, TAppContext>, next: NextFn) => Awaitable<R>): MiddlewareBuilder<Layout, readonly [...Acc, MiddlewareReturnFromParts<unknown, unknown, unknown, ExtractState<R>>], TAppContext>;
 };
 export type RouteExport<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], TReturns extends ReturnsMap = {}, TOutput = Response> = Acc & {
     readonly path: Path;
     readonly method: TMethod | "ANY" | "ALL";
     readonly methods?: readonly Method[];
     readonly middlewares: readonly MiddlewareDefinition[];
-    readonly handlerMiddlewares: readonly MiddlewareDefinition[];
     readonly returns?: TReturns;
     readonly bodyMode?: "json" | "form" | "urlencoded";
     handler: (ctx: unknown) => Awaitable<Response>;
@@ -191,9 +187,6 @@ export type RouteExport<Path extends RoutePath, TMethod extends Method, Acc exte
     query?: Schema<unknown>;
     params?: Schema<unknown>;
     body?: Schema<unknown>;
-    handlerQuery?: Schema<unknown>;
-    handlerParams?: Schema<unknown>;
-    handlerBody?: Schema<unknown>;
 };
 type RouteHandleResult<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], Validators extends ValidatorParts, TReturns extends ReturnsMap = {}, TOutput = Response, TAppContext extends Record<string, unknown> = AppContext> = Omit<RouteExport<Path, TMethod, Acc, TReturns, TOutput>, "$Infer"> & {
     readonly $Infer: {
@@ -231,17 +224,13 @@ export type RouteBuilderBase<Path extends RoutePath, TMethod extends Method, Acc
             actualState: RouteResolvedField<Path, TMethod, Acc, "state">;
         }
     ]): RouteBuilder<Path, TMethod, readonly [...Acc, TAcc], Validators, Omit<TReturns, keyof UReturns> & UReturns, TAppContext>;
-    use<TQuery = unknown, TParams = unknown, TBody = unknown, UReturns extends ReturnsMap = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown, R = unknown>(options: InlineMiddlewareOptions<RouteChainContext<Path, TMethod, Acc, TQuery, TParams, TBody, TAppContext>, TQuery, TParams, TBody, UReturns, TQueryIn, TParamsIn, TBodyIn, R>): RouteBuilder<Path, TMethod, readonly [
-        ...Acc,
-        MiddlewareReturnFromParts<TQuery, TParams, TBody, ExtractState<R>, TQueryIn, TParamsIn, TBodyIn>
-    ], Validators, Omit<TReturns, keyof UReturns> & UReturns, TAppContext>;
+    use<R = unknown>(fn: (ctx: RouteChainContext<Path, TMethod, Acc, unknown, unknown, unknown, TAppContext>, next: NextFn) => Awaitable<R>): RouteBuilder<Path, TMethod, readonly [...Acc, MiddlewareReturnFromParts<unknown, unknown, unknown, ExtractState<R>>], Validators, TReturns, TAppContext>;
     handler<R extends Response = Response>(fn: (ctx: TMethod extends "GET" | "DELETE" | "HEAD" | "OPTIONS" ? RouteHandleContextWithoutBody<Path, TMethod, Acc, Validators, TAppContext> : RouteHandleContext<Path, TMethod, Acc, Validators, TAppContext>) => Awaitable<R>, ..._assert: [R] extends [ValidHandlerReply<R, TReturns>] ? [] : [
         {
             expected: ValidHandlerReply<R, TReturns>;
             actual: R;
         }
     ]): RouteHandleResult<Path, TMethod, Acc, Validators, TReturns, R, TAppContext>;
-    handler<HandlerAcc extends readonly unknown[] = readonly [], HandlerValidators extends ValidatorParts = ValidatorParts, HReturns extends ReturnsMap = {}, HOutput = Response>(unit: HandlerUnit<HandlerAcc, HandlerValidators, HReturns, HOutput>): RouteHandleResult<Path, TMethod, readonly [...Acc, ...HandlerAcc], Validators, Omit<TReturns, keyof HReturns> & HReturns, HOutput, TAppContext>;
 };
 export type RouteBuilder<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[] = readonly [], Validators extends ValidatorParts = {}, TReturns extends ReturnsMap = {}, TAppContext extends Record<string, unknown> = AppContext> = RouteBuilderBase<Path, TMethod, Acc, Validators, TReturns, TAppContext> & (TMethod extends "GET" | "DELETE" | "HEAD" | "OPTIONS" ? {} : {
     body<TBody, TBodyIn = unknown>(schema: Schema<TBody, TBodyIn>): RouteBuilder<Path, TMethod, Acc, Omit<Validators, "body" | "bodyIn"> & {
@@ -253,32 +242,6 @@ export type RouteBuilder<Path extends RoutePath, TMethod extends Method, Acc ext
         bodyIn: TBodyIn;
     }, TReturns, TAppContext>;
 });
-export type HandlerBuilder<Acc extends readonly unknown[] = readonly [], Validators extends ValidatorParts = {}, TReturns extends ReturnsMap = {}, TAppContext extends Record<string, unknown> = AppContext> = {
-    returns<const M extends ReturnsMap>(map: M): HandlerBuilder<Acc, Validators, Omit<TReturns, keyof M> & M, TAppContext>;
-    use<TAcc, UReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequiredState = unknown>(unit: MiddlewareUnit<TAcc, UReturns, TRequiredLayouts, TRequiredState>, ..._assert: [IsStateSatisfied<MergeMiddlewareField<Acc, "state">, TRequiredState>] extends [
-        true
-    ] ? [] : [
-        {
-            error: "Middleware cannot be attached to this handler";
-            requiredState: TRequiredState;
-            actualState: MergeMiddlewareField<Acc, "state">;
-        }
-    ]): HandlerBuilder<readonly [...Acc, TAcc], Validators, Omit<TReturns, keyof UReturns> & UReturns, TAppContext>;
-    use<TQuery = unknown, TParams = unknown, TBody = unknown, UReturns extends ReturnsMap = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown, R = unknown>(options: InlineMiddlewareOptions<HandlerContext<Acc, {
-        query: TQuery;
-        params: TParams;
-        body: TBody;
-    }, TAppContext>, TQuery, TParams, TBody, UReturns, TQueryIn, TParamsIn, TBodyIn, R>): HandlerBuilder<readonly [
-        ...Acc,
-        MiddlewareReturnFromParts<TQuery, TParams, TBody, ExtractState<R>, TQueryIn, TParamsIn, TBodyIn>
-    ], Validators, Omit<TReturns, keyof UReturns> & UReturns, TAppContext>;
-    handler<R extends Response = Response>(fn: (ctx: HandlerContext<Acc, Validators, TAppContext>) => Awaitable<R>, ..._assert: [R] extends [ValidHandlerReply<R, TReturns>] ? [] : [
-        {
-            expected: ValidHandlerReply<R, TReturns>;
-            actual: R;
-        }
-    ]): HandlerUnit<Acc, Validators, TReturns, R>;
-};
 export type RouteDefinition<Path extends RoutePath = RoutePath, TMethod extends Method = Method, Acc extends readonly unknown[] = readonly unknown[], Validators extends ValidatorParts = ValidatorParts, TReturns extends ReturnsMap = ReturnsMap, TOutput = Response, TAppContext extends Record<string, unknown> = AppContext> = RouteHandleResult<Path, TMethod, Acc, Validators, TReturns, TOutput, TAppContext>;
 export type InferRouteContext<R> = R extends {
     $Infer: {

package/dist/cjs/types/units.d.cts

@@ -1,5 +1,5 @@
 import { Awaitable, MiddlewareDefinition as CoreMiddlewareDefinition, TaserCookieJar, TaserHeaders } from '@taserjs/router-core';
-import { MergeMiddlewareField, MergePart, RequestShape, Simplify, UnitRuntimeContext, UnwrapPart } from './type-utils.js';
+import { RequestShape, Simplify, UnitRuntimeContext, UnwrapPart } from './type-utils.js';
 import { ReturnsMap } from './returns.js';
 import { Schema } from './schema.js';
 export type { HttpMethod, Method } from './type-utils.js';
@@ -50,43 +50,18 @@ export type StandaloneMiddlewareContext<TQuery = unknown, TParams = unknown, TBo
     headers: TaserHeaders;
     cookies: TaserCookieJar;
 }>;
-export type HandlerContext<Acc extends readonly unknown[], Validators extends ValidatorParts, TAppContext extends Record<string, unknown> = AppContext> = Simplify<TAppContext & UnitRuntimeContext & {
-    query: Simplify<MergePart<Validators extends {
-        query?: infer Q;
-    } ? Q : unknown, MergeMiddlewareField<Acc, "query">>>;
-    params: Simplify<MergePart<Validators extends {
-        params?: infer P;
-    } ? P : unknown, MergeMiddlewareField<Acc, "params">>>;
-    body: Simplify<MergePart<Validators extends {
-        body?: infer B;
-    } ? B : unknown, MergeMiddlewareField<Acc, "body">>>;
-    state: Simplify<MergeMiddlewareField<Acc, "state">>;
-    headers: TaserHeaders;
-    cookies: TaserCookieJar;
-}>;
 export type MiddlewareUnit<TAcc = unknown, TReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequiredState = unknown> = MiddlewareDefinition & {
     readonly __middlewareAcc: TAcc;
     readonly __returns?: TReturns;
     readonly __requiredLayouts?: TRequiredLayouts;
     readonly __requiredState?: TRequiredState;
 };
-export type HandlerUnit<_Acc extends readonly unknown[], _Validators extends ValidatorParts, TReturns extends ReturnsMap = {}, TOutput = Response> = {
-    readonly __returns?: TReturns;
-    readonly $Infer: {
-        Output: TOutput;
-    };
-    middlewares: readonly MiddlewareDefinition[];
-    handler: (ctx: unknown) => Awaitable<Response>;
-    returns?: ReturnsMap;
-    query?: Schema<unknown>;
-    params?: Schema<unknown>;
-    body?: Schema<unknown>;
-};
-export type InlineMiddlewareOptions<Ctx = unknown, TQuery = unknown, TParams = unknown, TBody = unknown, TReturns extends ReturnsMap = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown, R = unknown> = {
-    query?: Schema<TQuery, TQueryIn>;
-    params?: Schema<TParams, TParamsIn>;
-    body?: Schema<TBody, TBodyIn>;
-    returns?: TReturns;
-    handler: (ctx: Ctx, next: NextFn) => Awaitable<R>;
+export type MiddlewareUnitBuilder<TQuery = unknown, TParams = unknown, TBody = unknown, TReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequiredState = {}, TAppContext extends Record<string, unknown> = AppContext, TInheritedState = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown> = {
+    query<Q, QIn = unknown>(schema: Schema<Q, QIn>): MiddlewareUnitBuilder<Q, TParams, TBody, TReturns, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, QIn, TParamsIn, TBodyIn>;
+    params<P, PIn = unknown>(schema: Schema<P, PIn>): MiddlewareUnitBuilder<TQuery, P, TBody, TReturns, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, TQueryIn, PIn, TBodyIn>;
+    body<B, BIn = unknown>(schema: Schema<B, BIn>): MiddlewareUnitBuilder<TQuery, TParams, B, TReturns, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, TQueryIn, TParamsIn, BIn>;
+    body<Mode extends "json" | "form" | "urlencoded", B, BIn = unknown>(mode: Mode, schema: Schema<B, BIn>): MiddlewareUnitBuilder<TQuery, TParams, B, TReturns, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, TQueryIn, TParamsIn, BIn>;
+    returns<const M extends ReturnsMap>(map: M): MiddlewareUnitBuilder<TQuery, TParams, TBody, Omit<TReturns, keyof M> & M, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, TQueryIn, TParamsIn, TBodyIn>;
+    requires<Requires extends Record<string, unknown>>(): MiddlewareUnitBuilder<TQuery, TParams, TBody, TReturns, TRequiredLayouts, TRequiredState & Requires, TAppContext, TInheritedState, TQueryIn, TParamsIn, TBodyIn>;
+    handler<TState = unknown, R = unknown>(fn: (ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext, TInheritedState & TRequiredState>, next: NextFn<NoInfer<TState>>) => Awaitable<R>): DefineMiddlewareResult<TQuery, TParams, TBody, TState, R, TQueryIn, TParamsIn, TBodyIn, TReturns, TRequiredLayouts, TRequiredState>;
 };
-export declare function isHandlerUnit(value: unknown): value is HandlerUnit<readonly unknown[], ValidatorParts>;

package/dist/esm/builder/constants.d.ts

@@ -1,8 +1,3 @@
 /** Input schema keys validated by middleware and route handlers. Headers/cookies are parsed only. */
 export declare const SCHEMA_KEYS: readonly ["query", "params", "body"];
 export type SchemaKey = (typeof SCHEMA_KEYS)[number];
-export declare const HANDLER_SCHEMA_KEY_MAP: {
-    readonly query: "handlerQuery";
-    readonly params: "handlerParams";
-    readonly body: "handlerBody";
-};

package/dist/esm/builder/constants.js

@@ -5,12 +5,7 @@ var SCHEMA_KEYS = [
 	"params",
 	"body"
 ];
-var HANDLER_SCHEMA_KEY_MAP = {
-	query: "handlerQuery",
-	params: "handlerParams",
-	body: "handlerBody"
-};
 //#endregion
-export { HANDLER_SCHEMA_KEY_MAP, SCHEMA_KEYS };
+export { SCHEMA_KEYS };
 
 //# sourceMappingURL=constants.js.map

package/dist/esm/builder/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","names":[],"sources":["../../../src/builder/constants.ts"],"sourcesContent":["/** Input schema keys validated by middleware and route handlers. Headers/cookies are parsed only. */\nexport const SCHEMA_KEYS = [\"query\", \"params\", \"body\"] as const;\n\nexport type SchemaKey = (typeof SCHEMA_KEYS)[number];\n\nexport const HANDLER_SCHEMA_KEY_MAP = {\n  query: \"handlerQuery\",\n  params: \"handlerParams\",\n  body: \"handlerBody\",\n} as const satisfies Record<SchemaKey, string>;\n"],"mappings":";;AACA,IAAa,cAAc;CAAC;CAAS;CAAU;AAAM;AAIrD,IAAa,yBAAyB;CACpC,OAAO;CACP,QAAQ;CACR,MAAM;AACR"}
+{"version":3,"file":"constants.js","names":[],"sources":["../../../src/builder/constants.ts"],"sourcesContent":["/** Input schema keys validated by middleware and route handlers. Headers/cookies are parsed only. */\nexport const SCHEMA_KEYS = [\"query\", \"params\", \"body\"] as const;\n\nexport type SchemaKey = (typeof SCHEMA_KEYS)[number];\n"],"mappings":";;AACA,IAAa,cAAc;CAAC;CAAS;CAAU;AAAM"}

package/dist/esm/builder/middleware-unit.d.ts

@@ -0,0 +1,18 @@
+import { BodyMode } from '@taserjs/router-core';
+import { ReturnsMap } from '../types/returns.js';
+import { Schema } from '../types/schema.js';
+export declare function createMiddlewareUnitBuilder(requiredLayouts?: string | readonly string[]): {
+    query(schema: Schema<unknown>): /*elided*/ any;
+    params(schema: Schema<unknown>): /*elided*/ any;
+    body(modeOrSchema: BodyMode | Schema<unknown>, schema?: Schema<unknown>): /*elided*/ any;
+    returns(map: ReturnsMap): /*elided*/ any;
+    requires(): /*elided*/ any;
+    handler(fn: (ctx: any, next: any) => any): {
+        __middlewareAcc: unknown;
+        __requiredLayouts?: string | readonly string[];
+        returns?: ReturnsMap;
+        __returns?: ReturnsMap;
+        bodyMode?: BodyMode;
+        handler: (ctx: any, next: any) => any;
+    };
+};

package/dist/esm/builder/middleware-unit.js

@@ -0,0 +1,55 @@
+import { pickDefinedSchemas } from "../define/validators.js";
+//#region src/builder/middleware-unit.ts
+function createMiddlewareUnitBuilder(requiredLayouts) {
+	const validators = {};
+	let bodyMode;
+	let returnsMap;
+	const builder = {
+		query(schema) {
+			validators.query = schema;
+			return builder;
+		},
+		params(schema) {
+			validators.params = schema;
+			return builder;
+		},
+		body(modeOrSchema, schema) {
+			if (typeof modeOrSchema === "string") {
+				bodyMode = modeOrSchema;
+				if (schema !== void 0) validators.body = schema;
+			} else {
+				bodyMode = "json";
+				validators.body = modeOrSchema;
+			}
+			return builder;
+		},
+		returns(map) {
+			returnsMap = {
+				...returnsMap,
+				...map
+			};
+			return builder;
+		},
+		requires() {
+			return builder;
+		},
+		handler(fn) {
+			return {
+				handler: fn,
+				...pickDefinedSchemas(validators),
+				...bodyMode ? { bodyMode } : {},
+				...returnsMap ? {
+					returns: returnsMap,
+					__returns: returnsMap
+				} : {},
+				...requiredLayouts !== void 0 ? { __requiredLayouts: requiredLayouts } : {},
+				__middlewareAcc: void 0
+			};
+		}
+	};
+	return builder;
+}
+//#endregion
+export { createMiddlewareUnitBuilder };
+
+//# sourceMappingURL=middleware-unit.js.map

package/dist/esm/builder/middleware-unit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware-unit.js","names":[],"sources":["../../../src/builder/middleware-unit.ts"],"sourcesContent":["import type { BodyMode } from \"@taserjs/router-core\";\n\nimport type { ReturnsMap } from \"../types/returns.js\";\nimport type { Schema } from \"../types/schema.js\";\nimport { pickDefinedSchemas, type SchemaValidators } from \"../define/validators.js\";\n\nexport function createMiddlewareUnitBuilder(requiredLayouts?: string | readonly string[]) {\n  const validators: SchemaValidators = {};\n  let bodyMode: BodyMode | undefined;\n  let returnsMap: ReturnsMap | undefined;\n\n  const builder = {\n    query(schema: Schema<unknown>) {\n      validators.query = schema;\n      return builder;\n    },\n    params(schema: Schema<unknown>) {\n      validators.params = schema;\n      return builder;\n    },\n    body(modeOrSchema: BodyMode | Schema<unknown>, schema?: Schema<unknown>) {\n      if (typeof modeOrSchema === \"string\") {\n        bodyMode = modeOrSchema as BodyMode;\n        if (schema !== undefined) {\n          validators.body = schema;\n        }\n      } else {\n        bodyMode = \"json\";\n        validators.body = modeOrSchema;\n      }\n      return builder;\n    },\n    returns(map: ReturnsMap) {\n      returnsMap = { ...returnsMap, ...map };\n      return builder;\n    },\n    requires() {\n      return builder;\n    },\n    handler(fn: (ctx: any, next: any) => any) {\n      const schemas = pickDefinedSchemas(validators);\n      const unit = {\n        handler: fn,\n        ...schemas,\n        ...(bodyMode ? { bodyMode } : {}),\n        ...(returnsMap ? { returns: returnsMap, __returns: returnsMap } : {}),\n        ...(requiredLayouts !== undefined ? { __requiredLayouts: requiredLayouts } : {}),\n        __middlewareAcc: undefined as unknown,\n      };\n      return unit;\n    },\n  };\n\n  return builder;\n}\n"],"mappings":";;AAMA,SAAgB,4BAA4B,iBAA8C;CACxF,MAAM,aAA+B,CAAC;CACtC,IAAI;CACJ,IAAI;CAEJ,MAAM,UAAU;EACd,MAAM,QAAyB;GAC7B,WAAW,QAAQ;GACnB,OAAO;EACT;EACA,OAAO,QAAyB;GAC9B,WAAW,SAAS;GACpB,OAAO;EACT;EACA,KAAK,cAA0C,QAA0B;GACvE,IAAI,OAAO,iBAAiB,UAAU;IACpC,WAAW;IACX,IAAI,WAAW,KAAA,GACb,WAAW,OAAO;GAEtB,OAAO;IACL,WAAW;IACX,WAAW,OAAO;GACpB;GACA,OAAO;EACT;EACA,QAAQ,KAAiB;GACvB,aAAa;IAAE,GAAG;IAAY,GAAG;GAAI;GACrC,OAAO;EACT;EACA,WAAW;GACT,OAAO;EACT;EACA,QAAQ,IAAkC;GAUxC,OAAO;IAPL,SAAS;IACT,GAHc,mBAAmB,UAG9B;IACH,GAAI,WAAW,EAAE,SAAS,IAAI,CAAC;IAC/B,GAAI,aAAa;KAAE,SAAS;KAAY,WAAW;IAAW,IAAI,CAAC;IACnE,GAAI,oBAAoB,KAAA,IAAY,EAAE,mBAAmB,gBAAgB,IAAI,CAAC;IAC9E,iBAAiB,KAAA;GAEZ;EACT;CACF;CAEA,OAAO;AACT"}

package/dist/esm/builder/middleware.js

@@ -5,7 +5,8 @@ function createMiddleware(layout) {
 		layout,
 		middlewares: entries,
 		use(definition) {
-			entries.push(definition);
+			if (typeof definition === "function") entries.push({ handler: definition });
+			else entries.push(definition);
 			return chain;
 		}
 	};

package/dist/esm/builder/middleware.js.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.js","names":[],"sources":["../../../src/builder/middleware.ts"],"sourcesContent":["import type { LayoutId, MiddlewareBuilder } from \"../types/index.js\";\nimport type { MiddlewareDefinition } from \"../types/units.js\";\n\nexport function createMiddleware<const Layout extends LayoutId>(\n  layout: Layout,\n): MiddlewareBuilder<Layout, readonly []> {\n  const entries: MiddlewareDefinition[] = [];\n\n  const chain = {\n    layout,\n    middlewares: entries,\n    use(definition: MiddlewareDefinition) {\n      entries.push(definition);\n      return chain;\n    },\n  };\n\n  return chain as unknown as MiddlewareBuilder<Layout, readonly []>;\n}\n"],"mappings":";AAGA,SAAgB,iBACd,QACwC;CACxC,MAAM,UAAkC,CAAC;CAEzC,MAAM,QAAQ;EACZ;EACA,aAAa;EACb,IAAI,YAAkC;GACpC,QAAQ,KAAK,UAAU;GACvB,OAAO;EACT;CACF;CAEA,OAAO;AACT"}
+{"version":3,"file":"middleware.js","names":[],"sources":["../../../src/builder/middleware.ts"],"sourcesContent":["import type { LayoutId, MiddlewareBuilder } from \"../types/index.js\";\nimport type { MiddlewareDefinition } from \"../types/units.js\";\n\nexport function createMiddleware<const Layout extends LayoutId>(\n  layout: Layout,\n): MiddlewareBuilder<Layout, readonly []> {\n  const entries: MiddlewareDefinition[] = [];\n\n  const chain = {\n    layout,\n    middlewares: entries,\n    use(definition: MiddlewareDefinition | ((ctx: any, next: any) => any)) {\n      if (typeof definition === \"function\") {\n        entries.push({ handler: definition as any });\n      } else {\n        entries.push(definition);\n      }\n      return chain;\n    },\n  };\n\n  return chain as unknown as MiddlewareBuilder<Layout, readonly []>;\n}\n"],"mappings":";AAGA,SAAgB,iBACd,QACwC;CACxC,MAAM,UAAkC,CAAC;CAEzC,MAAM,QAAQ;EACZ;EACA,aAAa;EACb,IAAI,YAAmE;GACrE,IAAI,OAAO,eAAe,YACxB,QAAQ,KAAK,EAAE,SAAS,WAAkB,CAAC;QAE3C,QAAQ,KAAK,UAAU;GAEzB,OAAO;EACT;CACF;CAEA,OAAO;AACT"}

package/dist/esm/builder/route.js

@@ -1,5 +1,3 @@
-import { isHandlerUnit } from "../types/units.js";
-import { HANDLER_SCHEMA_KEY_MAP } from "./constants.js";
 import { pickDefinedSchemas } from "../define/validators.js";
 import { collectReturnsFromDefinitions, hasInputSchemas, mergeReturnsMaps, withAuto422 } from "@taserjs/router-utils";
 //#region src/builder/route.ts
@@ -10,7 +8,7 @@ function toUtilsMap(map) {
 	return out;
 }
 function buildEffectiveReturns(args) {
-	const with422 = withAuto422(mergeReturnsMaps(toUtilsMap(args.middlewareReturns), toUtilsMap(args.routeReturns), toUtilsMap(args.handlerMiddlewareReturns), toUtilsMap(args.handlerReturns)), hasInputSchemas(args.schemas));
+	const with422 = withAuto422(mergeReturnsMaps(toUtilsMap(args.middlewareReturns), toUtilsMap(args.routeReturns)), hasInputSchemas(args.schemas));
 	return Object.keys(with422).length > 0 ? with422 : void 0;
 }
 function buildRouteBase(path, method, methods, middlewares) {
@@ -56,38 +54,25 @@ function createRouteBuilder(path, method, methods) {
 			return builder;
 		},
 		use(definition) {
-			middlewares.push(definition);
+			if (typeof definition === "function") middlewares.push({ handler: definition });
+			else middlewares.push(definition);
 			return builder;
 		},
-		handler(fnOrUnit) {
+		handler(fn) {
 			const routeSchemas = pickDefinedSchemas(validators);
 			const base = buildRouteBase(path, method, methods, middlewares);
-			const unit = isHandlerUnit(fnOrUnit) ? fnOrUnit : {
-				handler: fnOrUnit,
-				middlewares: [],
-				returns: void 0
-			};
-			const handlerSchemas = isHandlerUnit(fnOrUnit) ? pickDefinedSchemas(fnOrUnit, HANDLER_SCHEMA_KEY_MAP) : {};
 			const returns = buildEffectiveReturns({
 				middlewareReturns: collectReturnsFromDefinitions(middlewares),
 				routeReturns,
-				handlerMiddlewareReturns: collectReturnsFromDefinitions(unit.middlewares),
-				handlerReturns: unit.returns,
 				schemas: {
 					...validators,
-					handlerQuery: unit.query,
-					handlerParams: unit.params,
-					handlerBody: unit.body,
-					middlewares,
-					handlerMiddlewares: unit.middlewares
+					middlewares
 				}
 			});
 			return {
 				...base,
-				handlerMiddlewares: [...unit.middlewares],
-				handler: unit.handler,
+				handler: fn,
 				...routeSchemas,
-				...handlerSchemas,
 				...bodyMode ? { bodyMode } : {},
 				...returns ? { returns } : {}
 			};