@monocloud/auth-nextjs 0.1.5 → 0.1.7

package/dist/index.cjs

@@ -1,10 +1,10 @@
-const require_chunk = require('./chunk-CbDLau6x.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('./chunk-C0xms8kb.cjs');
 let _monocloud_auth_node_core = require("@monocloud/auth-node-core");
 let next_server_js = require("next/server.js");
 let _monocloud_auth_node_core_internal = require("@monocloud/auth-node-core/internal");
 let _monocloud_auth_node_core_utils = require("@monocloud/auth-node-core/utils");
 let cookie = require("cookie");
-let node_http = require("node:http");
 
 //#region src/requests/monocloud-app-router-request.ts
 var MonoCloudAppRouterRequest = class {
@@ -220,6 +220,12 @@ var MonoCloudCookieRequest = class {
 const isMonoCloudRequest = (req) => req instanceof MonoCloudAppRouterRequest || req instanceof MonoCloudPageRouterRequest || req instanceof MonoCloudCookieRequest;
 const isMonoCloudResponse = (res) => res instanceof MonoCloudAppRouterResponse || res instanceof MonoCloudPageRouterResponse || res instanceof MonoCloudCookieResponse;
 const isAppRouter = (req) => req instanceof Request || req.headers instanceof Headers || typeof req.bodyUsed === "boolean";
+const isNodeRequest = (req) => {
+	return !!(req && typeof req === "object" && "headers" in req && !("bodyUsed" in req) && typeof req.on === "function");
+};
+const isNodeResponse = (res) => {
+	return !!(res && typeof res === "object" && "setHeader" in res && typeof res.setHeader === "function" && "end" in res && typeof res.end === "function");
+};
 const getNextRequest = (req) => {
 	if (req instanceof next_server_js.NextRequest) return req;
 	return new next_server_js.NextRequest(req.url, {
@@ -253,7 +259,7 @@ const getMonoCloudCookieReqRes = (req, resOrCtx) => {
 		request = new MonoCloudAppRouterRequest(getNextRequest(req));
 		response = resOrCtx instanceof Response ? new MonoCloudAppRouterResponse(getNextResponse(resOrCtx)) : new MonoCloudCookieResponse();
 	} else {
-		if (!(req instanceof node_http.IncomingMessage) || !(resOrCtx instanceof node_http.ServerResponse)) throw new _monocloud_auth_node_core.MonoCloudValidationError("Invalid pages router request and response");
+		if (!isNodeRequest(req) || !isNodeResponse(resOrCtx)) throw new _monocloud_auth_node_core.MonoCloudValidationError("Invalid pages router request and response");
 		request = new MonoCloudPageRouterRequest(req);
 		response = new MonoCloudPageRouterResponse(resOrCtx);
 	}
@@ -280,35 +286,32 @@ const mergeResponse = (responses) => {
 //#endregion
 //#region src/monocloud-next-client.ts
 /**
-* The MonoCloud Next.js Client.
+* `MonoCloudNextClient` is the core SDK entry point for integrating MonoCloud authentication into a Next.js application.
 *
-* @example Using Environment Variables (Recommended)
+* It provides:
+* - Authentication middleware
+* - Route protection helpers
+* - Session and token access
+* - Redirect utilities
+* - Server-side enforcement helpers
 *
-* 1. Add following variables to your `.env`.
+* ## 1. Add environment variables
 *
-* ```bash
+* ```bash:.env.local
 * MONOCLOUD_AUTH_TENANT_DOMAIN=<tenant-domain>
 * MONOCLOUD_AUTH_CLIENT_ID=<client-id>
 * MONOCLOUD_AUTH_CLIENT_SECRET=<client-secret>
-* MONOCLOUD_AUTH_SCOPES=openid profile email # Default
+* MONOCLOUD_AUTH_SCOPES=openid profile email
 * MONOCLOUD_AUTH_APP_URL=http://localhost:3000
 * MONOCLOUD_AUTH_COOKIE_SECRET=<cookie-secret>
 * ```
 *
-* 2. Instantiate the client in a shared file (e.g., lib/monocloud.ts)
-*
-* ```typescript
-* import { MonoCloudNextClient } from '@monocloud/auth-nextjs';
-*
-* export const monoCloud = new MonoCloudNextClient();
-* ```
-*
-* 3. Add MonoCloud middleware/proxy
+* ## 2. Register middleware
 *
-* ```typescript
-* import { monoCloud } from "@/lib/monocloud";
+* ```typescript:src/proxy.ts
+* import { authMiddleware } from "@monocloud/auth-nextjs";
 *
-* export default monoCloud.authMiddleware();
+* export default authMiddleware();
 *
 * export const config = {
 *   matcher: [
@@ -317,218 +320,115 @@ const mergeResponse = (responses) => {
 * };
 * ```
 *
-* @example Using Constructor Options
+* ## Advanced usage
 *
-* ⚠️ Security Note: Never commit your credentials to version control. Load them from environment variables.
+* ### Create a shared client instance
+*
+* By default, the SDK exposes function exports (for example, `authMiddleware()`, `getSession()`, `getTokens()`) that internally use a shared singleton `MonoCloudNextClient`.
+*
+* Create your own `MonoCloudNextClient` instance when you need multiple configurations, dependency injection, or explicit control over initialization.
+*
+* ```ts:src/monocloud.ts
+* import { MonoCloudNextClient } from "@monocloud/auth-nextjs";
+*
+* export const monoCloud = new MonoCloudNextClient();
+* ```
 *
-* 1. Instantiate the client in a shared file (e.g., lib/monocloud.ts)
+* ### Using instance methods
 *
-* ```typescript
-* import { MonoCloudNextClient } from '@monocloud/auth-nextjs';
+* Once you create a client instance, call methods directly on it instead of using the default function exports.
+*
+* ```ts:src/app/page.tsx
+* import { monoCloud } from "@/monocloud";
+*
+* export default async function Page() {
+*   const session = await monoCloud.getSession();
+*
+*   if (!session) {
+*     return <>Not signed in</>;
+*   }
+*
+*   return <>Hello {session.user.name}</>;
+* }
+* ```
+*
+* #### Using constructor options
+*
+* When configuration is provided through both constructor options and environment variables, the values passed to the constructor take precedence. Environment variables are used only for options that are not explicitly supplied.
+*
+* ```ts:src/monocloud.ts
+* import { MonoCloudNextClient } from "@monocloud/auth-nextjs";
 *
 * export const monoCloud = new MonoCloudNextClient({
-*  tenantDomain: '<tenant-domain>',
-*  clientId: '<client-id>',
-*  clientSecret: '<client-secret>',
-*  scopes: 'openid profile email', // Default
-*  appUrl: 'http://localhost:3000',
-*  cookieSecret: '<cookie-secret>'
+*   tenantDomain: "<tenant-domain>",
+*   clientId: "<client-id>",
+*   clientSecret: "<client-secret>",
+*   appUrl: "http://localhost:3000",
+*   cookieSecret: "<cookie-secret>",
+*   defaultAuthParams: {
+*     scopes: "openid profile email",
+*   },
 * });
 * ```
-* 2. Add MonoCloud middleware/proxy
 *
-* ```typescript
-* import { monoCloud } from "@/lib/monocloud";
+* ### Modifying default routes
 *
-* export default monoCloud.authMiddleware();
+* If you customize any of the default auth route paths:
 *
-* export const config = {
-*   matcher: [
-*     "/((?!_next/static|_next/image|favicon.ico|sitemap.xml|robots.txt).*)",
-*   ],
-* };
+* - Also set the corresponding `NEXT_PUBLIC_` environment variables so client-side helpers
+*   (for example `<SignIn />`, `<SignOut />`, and `useAuth()`) can discover the correct URLs.
+* - Update the **Application URLs** in your MonoCloud Dashboard to match the new paths.
+*
+* Example:
+*
+* ```bash:.env.local
+* MONOCLOUD_AUTH_CALLBACK_URL=/api/custom_callback
+* NEXT_PUBLIC_MONOCLOUD_AUTH_CALLBACK_URL=/api/custom_callback
 * ```
 *
-* <details>
-* <summary>All Environment Variables</summary>
-*  <h4>Core Configuration (Required)</h4>
-*
-*  <ul>
-*    <li><strong>MONOCLOUD_AUTH_CLIENT_ID : </strong>Unique identifier for your application/client.</li>
-*    <li><strong>MONOCLOUD_AUTH_CLIENT_SECRET : </strong>Application/client secret.</li>
-*    <li><strong>MONOCLOUD_AUTH_TENANT_DOMAIN : </strong>The domain of your MonoCloud tenant (e.g., https://your-tenant.us.monocloud.com).</li>
-*    <li><strong>MONOCLOUD_AUTH_APP_URL : </strong>The base URL where your application is hosted.</li>
-*    <li><strong>MONOCLOUD_AUTH_COOKIE_SECRET : </strong>A long, random string used to encrypt and sign session cookies.</li>
-*  </ul>
-*
-*  <h4>Authentication &amp; Security</h4>
-*
-*  <ul>
-*    <li><strong>MONOCLOUD_AUTH_SCOPES : </strong>A space-separated list of OIDC scopes to request (e.g., openid profile email).</li>
-*    <li><strong>MONOCLOUD_AUTH_RESOURCE : </strong>The default resource/audience identifier for access tokens.</li>
-*    <li><strong>MONOCLOUD_AUTH_USE_PAR : </strong>Enables Pushed Authorization Requests.</li>
-*    <li><strong>MONOCLOUD_AUTH_CLOCK_SKEW : </strong>The allowed clock drift in seconds when validating token timestamps.</li>
-*    <li><strong>MONOCLOUD_AUTH_FEDERATED_SIGNOUT : </strong>If true, signs the user out of MonoCloud (SSO sign-out) when they sign out of the app.</li>
-*    <li><strong>MONOCLOUD_AUTH_RESPONSE_TIMEOUT : </strong>The maximum time in milliseconds to wait for a response.</li>
-*    <li><strong>MONOCLOUD_AUTH_ALLOW_QUERY_PARAM_OVERRIDES : </strong>Allows dynamic overrides of auth parameters via URL query strings.</li>
-*    <li><strong>MONOCLOUD_AUTH_POST_LOGOUT_REDIRECT_URI : </strong>The URL users are sent to after a successful logout.</li>
-*    <li><strong>MONOCLOUD_AUTH_USER_INFO : </strong>Determines if user profile data from the UserInfo endpoint should be fetched after authorization code exchange.</li>
-*    <li><strong>MONOCLOUD_AUTH_REFETCH_USER_INFO : </strong>If true, re-fetches user information on every request to userinfo endpoint or when calling getTokens()</li>
-*    <li><strong>MONOCLOUD_AUTH_ID_TOKEN_SIGNING_ALG : </strong>The expected algorithm for signing ID tokens (e.g., RS256).</li>
-*    <li><strong>MONOCLOUD_AUTH_FILTERED_ID_TOKEN_CLAIMS : </strong>A space-separated list of claims to exclude from the session object.</li>
-*  </ul>
-*
-*  <h4>Routes</h4>
-*
-*   <aside>
-*     <strong>⚠️ Important: Modifying Default Routes</strong>
-*     <p>If you choose to customize any of the default route paths, you must adhere to the following requirements:</p>
-*     <ul>
-*       <li>
-*         <strong>Client-Side Synchronization:</strong> You must also define a corresponding <code>NEXT_PUBLIC_</code> version of the environment variable (e.g., <code>NEXT_PUBLIC_MONOCLOUD_AUTH_CALLBACK_URL</code>). This ensures that client-side components like <code>&lt;SignIn /&gt;</code>, <code>&lt;SignOut /&gt;</code>, and the <code>useAuth()</code> hook can correctly identify your custom endpoints.
-*       </li>
-*       <li>
-*         <strong>Dashboard Configuration:</strong> Changing these URLs will alter the endpoints required by MonoCloud. You must update the <strong>Application URLs</strong> section in your MonoCloud Dashboard to match these new paths.
-*       </li>
-*     </ul>
-*     <p><em>Example:</em></p>
-*     <code>
-*       MONOCLOUD_AUTH_CALLBACK_URL=/api/custom_callback<br />
-*       NEXT_PUBLIC_MONOCLOUD_AUTH_CALLBACK_URL=/api/custom_callback
-*     </code>
-*     <p>In this case, the Redirect URI in your dashboard should be set to: <code>http://localhost:3000/api/custom_callback</code> (assuming local development).</p>
-*   </aside>
-*
-*  <ul>
-*    <li><strong>MONOCLOUD_AUTH_CALLBACK_URL : </strong>The application path where MonoCloud sends the user after authentication.</li>
-*    <li><strong>MONOCLOUD_AUTH_SIGNIN_URL : </strong>The internal route path to trigger the sign-in.</li>
-*    <li><strong>MONOCLOUD_AUTH_SIGNOUT_URL : </strong>The internal route path to trigger the sign-out.</li>
-*    <li><strong>MONOCLOUD_AUTH_USER_INFO_URL : </strong>The route that exposes the current user's profile from userinfo endpoint.</li>
-*  </ul>
-*
-*  <h4>Session Cookie Settings</h4>
-*
-*  <ul>
-*    <li><strong>MONOCLOUD_AUTH_SESSION_COOKIE_NAME : </strong>The name of the cookie used to store the user session.</li>
-*    <li><strong>MONOCLOUD_AUTH_SESSION_COOKIE_PATH : </strong>The scope path for the session cookie.</li>
-*    <li><strong>MONOCLOUD_AUTH_SESSION_COOKIE_DOMAIN : </strong>The domain scope for the session cookie.</li>
-*    <li><strong>MONOCLOUD_AUTH_SESSION_COOKIE_HTTP_ONLY : </strong>Prevents client-side scripts from accessing the session cookie.</li>
-*    <li><strong>MONOCLOUD_AUTH_SESSION_COOKIE_SECURE : </strong>Ensures the session cookie is only sent over HTTPS.</li>
-*    <li><strong>MONOCLOUD_AUTH_SESSION_COOKIE_SAME_SITE : </strong>The SameSite policy for the session cookie (Lax, Strict, or None).</li>
-*    <li><strong>MONOCLOUD_AUTH_SESSION_COOKIE_PERSISTENT : </strong>If true, the session survives browser restarts.</li>
-*    <li><strong>MONOCLOUD_AUTH_SESSION_SLIDING : </strong>If true, the session will be a sliding session instead of absolute.</li>
-*    <li><strong>MONOCLOUD_AUTH_SESSION_DURATION : </strong>The session lifetime in seconds.</li>
-*    <li><strong>MONOCLOUD_AUTH_SESSION_MAX_DURATION : </strong>The absolute maximum lifetime of a session in seconds.</li>
-*  </ul>
-*
-*  <h4>State Cookie Settings</h4>
-*
-*  <ul>
-*    <li><strong>MONOCLOUD_AUTH_STATE_COOKIE_NAME : </strong>The name of the cookie used to store OpenID state/nonce.</li>
-*    <li><strong>MONOCLOUD_AUTH_STATE_COOKIE_PATH : </strong>The scope path for the state cookie.</li>
-*    <li><strong>MONOCLOUD_AUTH_STATE_COOKIE_DOMAIN : </strong>The domain scope for the state cookie.</li>
-*    <li><strong>MONOCLOUD_AUTH_STATE_COOKIE_SECURE : </strong>Ensures the state cookie is only sent over HTTPS</li>
-*    <li><strong>MONOCLOUD_AUTH_STATE_COOKIE_SAME_SITE : </strong>The SameSite policy for the state cookie.</li>
-*    <li><strong>MONOCLOUD_AUTH_STATE_COOKIE_PERSISTENT : </strong>Whether the state cookie is persistent.</li>
-*  </ul>
-*
-*  <h4>Caching</h4>
-*
-*  <ul>
-*    <li><strong>MONOCLOUD_AUTH_JWKS_CACHE_DURATION : </strong>Duration in seconds to cache the JSON Web Key Set.</li>
-*    <li><strong>MONOCLOUD_AUTH_METADATA_CACHE_DURATION : </strong>Duration in seconds to cache the OpenID discovery metadata.</li>
-*  </ul>
-* </details>
+* When routes are overridden, the Redirect URI configured in the dashboard
+* must reflect the new path. For example, during local development:
 *
+* `http://localhost:3000/api/custom_callback`
 *
+* @category Classes
 */
 var MonoCloudNextClient = class {
 	/**
-	* The underlying OIDC client instance used for low-level OpenID Connect operations.
+	* This exposes the framework-agnostic MonoCloud client used internally by the Next.js SDK.
+	* Use it if you need access to lower-level functionality not directly exposed by MonoCloudNextClient.
+	*
+	* @returns Returns the underlying **Node client** instance.
+	*/
+	get coreClient() {
+		return this._coreClient;
+	}
+	/**
+	* This is intended for advanced scenarios requiring direct control over the authorization or token flow.
 	*
-	* @example
-	* // Manually revoke an access token
-	* await client.oidcClient.revokeToken(accessToken, 'access_token');
+	* @returns Returns the underlying **OIDC client** used for OpenID Connect operations.
 	*/
 	get oidcClient() {
 		return this.coreClient.oidcClient;
 	}
 	/**
-	* @param options Configuration options including domain, client ID, and secret.
+	* Creates a new client instance.
+	*
+	* @param options Optional configuration for initializing the MonoCloud client. If not provided, settings are automatically resolved from environment variables.
 	*/
 	constructor(options) {
 		const opt = {
 			...options ?? {},
-			userAgent: (options === null || options === void 0 ? void 0 : options.userAgent) ?? `@monocloud/auth-nextjs@0.1.5`,
+			userAgent: (options === null || options === void 0 ? void 0 : options.userAgent) ?? `@monocloud/auth-nextjs@0.1.7`,
 			debugger: (options === null || options === void 0 ? void 0 : options.debugger) ?? "@monocloud:auth-nextjs"
 		};
 		this.registerPublicEnvVariables();
-		this.coreClient = new _monocloud_auth_node_core.MonoCloudCoreClient(opt);
+		this._coreClient = new _monocloud_auth_node_core.MonoCloudCoreClient(opt);
 	}
 	/**
-	* Creates a **Next.js API route handler** (for both Pages Router and App Router)
-	* that processes all MonoCloud authentication endpoints
-	* (`/signin`, `/callback`, `/userinfo`, `/signout`).
-	*
-	* @param options Authentication configuration routes.
-	*
-	* **Note:** If you are already using `authMiddleware()`, you typically do **not**
-	* need this API route handler. This function is intended for applications where
-	* middleware cannot be used—such as statically generated (SSG) deployments that still
-	* require server-side authentication flows.
-	*
-	* @example App Router
-	*
-	* ```typescript
-	* // app/api/auth/[...monocloud]/route.ts
-	*
-	* import { monoCloud } from "@/lib/monocloud";
-	*
-	* export const GET = monoCloud.monoCloudAuth();
-	*```
-	*
-	* @example App Router with Response
-	*
-	* ```typescript
-	* import { monoCloud } from "@/lib/monocloud";
-	* import { NextRequest, NextResponse } from "next/server";
-	*
-	* export const GET = (req: NextRequest) => {
-	*   const authHandler = monoCloud.monoCloudAuth();
-	*
-	*   const res = new NextResponse();
-	*
-	*   res.cookies.set("last_auth_requested", `${Date.now()}`);
-	*
-	*   return authHandler(req, res);
-	* };
-	* ```
-	*
-	* @example Pages Router
-	*
-	* ```typescript
-	* // pages/api/auth/[...monocloud].ts
-	*
-	* import { monoCloud } from "@/lib/monocloud";
-	*
-	* export default monoCloud.monoCloudAuth();
-	*```
-	*
-	* @example Page Router with Response
-	*
-	* ```typescript
-	* import { monoCloud } from "@/lib/monocloud";
-	* import { NextApiRequest, NextApiResponse } from "next";
-	*
-	* export default function handler(req: NextApiRequest, res: NextApiResponse) {
-	*   const authHandler = monoCloud.monoCloudAuth();
-	*
-	*   res.setHeader("last_auth_requested", `${Date.now()}`);
-	*
-	*   return authHandler(req, res);
-	* }
-	* ```
-	*
+	* @see {@link monoCloudAuth} for full docs and examples.
+	* @param options Optional configuration for the auth handler.
+	* @returns Returns a Next.js-compatible handler for App Router route handlers or Pages Router API routes.
 	*/
 	monoCloudAuth(options) {
 		return (req, resOrCtx) => {
@@ -596,10 +496,10 @@ var MonoCloudNextClient = class {
 			if (!session) {
 				var _options$authParams10, _options$authParams11, _options$authParams12, _options$authParams13, _options$authParams14, _options$authParams15, _options$authParams16, _options$authParams17, _options$authParams18;
 				if (options === null || options === void 0 ? void 0 : options.onAccessDenied) {
-					const customProps$1 = await options.onAccessDenied({ ...context });
+					const customProps = await options.onAccessDenied({ ...context });
 					return {
-						...customProps$1 ?? {},
-						props: { ...(customProps$1 === null || customProps$1 === void 0 ? void 0 : customProps$1.props) ?? {} }
+						...customProps ?? {},
+						props: { ...(customProps === null || customProps === void 0 ? void 0 : customProps.props) ?? {} }
 					};
 				}
 				const { routes, appUrl } = this.getOptions();
@@ -621,13 +521,13 @@ var MonoCloudNextClient = class {
 			}
 			if ((options === null || options === void 0 ? void 0 : options.groups) && !(0, _monocloud_auth_node_core_utils.isUserInGroup)(session.user, options.groups, options.groupsClaim ?? process.env.MONOCLOUD_AUTH_GROUPS_CLAIM, options.matchAll)) {
 				var _options$onGroupAcces;
-				const customProps$1 = await ((_options$onGroupAcces = options.onGroupAccessDenied) === null || _options$onGroupAcces === void 0 ? void 0 : _options$onGroupAcces.call(options, {
+				const customProps = await ((_options$onGroupAcces = options.onGroupAccessDenied) === null || _options$onGroupAcces === void 0 ? void 0 : _options$onGroupAcces.call(options, {
 					...context,
 					user: session.user
 				})) ?? { props: { groupAccessDenied: true } };
 				return {
-					...customProps$1,
-					props: { ...customProps$1.props ?? {} }
+					...customProps,
+					props: { ...customProps.props ?? {} }
 				};
 			}
 			const customProps = (options === null || options === void 0 ? void 0 : options.getServerSideProps) ? await options.getServerSideProps(context) : {};
@@ -800,7 +700,7 @@ var MonoCloudNextClient = class {
 			({request, response} = getMonoCloudCookieReqRes(args[0], void 0));
 			options = args[1];
 		}
-		else if (args.length === 2 && args[0] instanceof node_http.IncomingMessage && args[1] instanceof node_http.ServerResponse) ({request, response} = getMonoCloudCookieReqRes(args[0], args[1]));
+		else if (args.length === 2 && isNodeRequest(args[0]) && isNodeResponse(args[1])) ({request, response} = getMonoCloudCookieReqRes(args[0], args[1]));
 		else {
 			({request, response} = getMonoCloudCookieReqRes(args[0], args[1]));
 			options = args[2];
@@ -820,52 +720,9 @@ var MonoCloudNextClient = class {
 		return await this.coreClient.isAuthenticated(request, response);
 	}
 	/**
-	* Redirects the user to the sign-in flow if they are not authenticated.
-	*
-	* **This helper is App Router only and is designed for server environments (server components, route handlers, and server actions).**
-	*
-	* @param options Options to customize the sign-in.
-	*
-	* @returns
-	*
-	* @example React Server Component
-	*
-	* ```tsx
-	* import { monoCloud } from "@/lib/monocloud";
-	*
-	* export default async function Home() {
-	*   await monoCloud.protect();
-	*
-	*   return <>You are signed in.</>;
-	* }
-	* ```
-	*
-	* @example API Handler
-	*
-	* ```typescript
-	* import { NextResponse } from "next/server";
-	* import { monoCloud } from "@/lib/monocloud";
-	*
-	* export const GET = async () => {
-	*   await monoCloud.protect();
-	*
-	*   return NextResponse.json({ secret: "ssshhhh!!!" });
-	* };
-	* ```
-	*
-	* @example Server Action
-	*
-	* ```typescript
-	* "use server";
-	*
-	* import { monoCloud } from "@/lib/monocloud";
-	*
-	* export async function getMessage() {
-	*   await monoCloud.protect();
-	*
-	*   return { secret: "sssshhhhh!!!" };
-	* }
-	* ```
+	* @see {@link protect} for full docs and examples.
+	* @param options Optional configuration for redirect behavior (for example, return URL or sign-in parameters).
+	* @returns Resolves if the user is authenticated; otherwise triggers a redirect.
 	*/
 	async protect(options) {
 		var _options$authParams19, _options$authParams20, _options$authParams21, _options$authParams22, _options$authParams23, _options$authParams24, _options$authParams25, _options$authParams26, _options$authParams27;
@@ -874,7 +731,7 @@ var MonoCloudNextClient = class {
 		try {
 			const session = await this.getSession();
 			if (session && !(options === null || options === void 0 ? void 0 : options.groups)) return;
-			if (session && options && options.groups && (0, _monocloud_auth_node_core_utils.isUserInGroup)(session.user, options.groups, options.groupsClaim ?? process.env.MONOCLOUD_AUTH_GROUPS_CLAIM, options.matchAll)) return;
+			if (session && (options === null || options === void 0 ? void 0 : options.groups) && (0, _monocloud_auth_node_core_utils.isUserInGroup)(session.user, options.groups, options.groupsClaim ?? process.env.MONOCLOUD_AUTH_GROUPS_CLAIM, options.matchAll)) return;
 			const { headers } = await import("next/headers");
 			path = (await headers()).get("x-monocloud-path") ?? "/";
 		} catch {
@@ -913,7 +770,7 @@ var MonoCloudNextClient = class {
 				groups = args[1];
 				options = args[2];
 			}
-			if (args[0] instanceof node_http.IncomingMessage && args[1] instanceof node_http.ServerResponse) {
+			if (isNodeRequest(args[0]) && isNodeResponse(args[1])) {
 				({request, response} = getMonoCloudCookieReqRes(args[0], args[1]));
 				groups = args[2];
 			}
@@ -939,66 +796,9 @@ var MonoCloudNextClient = class {
 		return await this.coreClient.isUserInGroup(request, response, groups, (options === null || options === void 0 ? void 0 : options.groupsClaim) ?? process.env.MONOCLOUD_AUTH_GROUPS_CLAIM, options === null || options === void 0 ? void 0 : options.matchAll);
 	}
 	/**
-	* Redirects the user to the sign-in flow.
-	*
-	* **This helper is App Router only and is designed for server environments (server components, route handlers, and server actions).**
-	*
-	* @param options Options to customize the sign-in.
-	*
-	* @returns
-	*
-	* @example React Server Component
-	*
-	* ```tsx
-	* import { monoCloud } from "@/lib/monocloud";
-	*
-	* export default async function Home() {
-	*   const allowed = await monoCloud.isUserInGroup(["admin"]);
-	*
-	*   if (!allowed) {
-	*     await monoCloud.redirectToSignIn({ returnUrl: "/home" });
-	*   }
-	*
-	*   return <>You are signed in.</>;
-	* }
-	* ```
-	*
-	* @example Server Action
-	*
-	* ```typescript
-	* "use server";
-	*
-	* import { monoCloud } from "@/lib/monocloud";
-	*
-	* export async function protectedAction() {
-	*   const session = await monoCloud.getSession();
-	*
-	*   if (!session) {
-	*     await monoCloud.redirectToSignIn();
-	*   }
-	*
-	*   return { data: "Sensitive Data" };
-	* }
-	* ```
-	*
-	* @example API Handler
-	*
-	* ```typescript
-	* import { NextResponse } from "next/server";
-	* import { monoCloud } from "@/lib/monocloud";
-	*
-	* export const GET = async () => {
-	*   const session = await monoCloud.getSession();
-	*
-	*   if (!session) {
-	*     await monoCloud.redirectToSignIn({
-	*       returnUrl: "/dashboard",
-	*     });
-	*   }
-	*
-	*   return NextResponse.json({ data: "Protected content" });
-	* };
-	* ```
+	* @see {@link redirectToSignIn} for full docs and examples.
+	* @param options Optional configuration for the redirect, such as `returnUrl` or additional sign-in parameters.
+	* @returns Never resolves. Triggers a redirect to the sign-in flow.
 	*/
 	async redirectToSignIn(options) {
 		const { routes, appUrl } = this.coreClient.getOptions();
@@ -1023,65 +823,9 @@ var MonoCloudNextClient = class {
 		redirect(signInRoute.toString());
 	}
 	/**
-	* Redirects the user to the sign-out flow.
-	*
-	* **This helper is App Router only and is designed for server environments (server components, route handlers, and server actions).**
-	*
-	* @param options Options to customize the sign out.
-	*
-	* @returns
-	*
-	* @example React Server Component
-	*
-	* ```tsx
-	* import { monoCloud } from "@/lib/monocloud";
-	*
-	* export default async function Page() {
-	*   const session = await monoCloud.getSession();
-	*
-	*   // Example: Force sign-out if a specific condition is met (e.g., account suspended)
-	*   if (session?.user.isSuspended) {
-	*     await monoCloud.redirectToSignOut();
-	*   }
-	*
-	*   return <>Welcome User</>;
-	* }
-	* ```
-	*
-	* @example Server Action
-	*
-	* ```typescript
-	* "use server";
-	*
-	* import { monoCloud } from "@/lib/monocloud";
-	*
-	* export async function signOutAction() {
-	*   const session = await monoCloud.getSession();
-	*
-	*   if (session) {
-	*     await monoCloud.redirectToSignOut();
-	*   }
-	* }
-	* ```
-	*
-	* @example API Handler
-	*
-	* ```typescript
-	* import { monoCloud } from "@/lib/monocloud";
-	* import { NextResponse } from "next/server";
-	*
-	* export const GET = async () => {
-	*   const session = await monoCloud.getSession();
-	*
-	*   if (session) {
-	*     await monoCloud.redirectToSignOut({
-	*       postLogoutRedirectUri: "/goodbye",
-	*     });
-	*   }
-	*
-	*   return NextResponse.json({ status: "already_signed_out" });
-	* };
-	* ```
+	* @see {@link redirectToSignOut} for full docs and examples.
+	* @param options Optional configuration for the redirect, such as `postLogoutRedirectUri` or additional sign-out parameters.
+	* @returns Never resolves. Triggers a redirect to the sign-out flow.
 	*/
 	async redirectToSignOut(options) {
 		var _options$postLogoutRe;
@@ -1109,6 +853,276 @@ var MonoCloudNextClient = class {
 	}
 };
 
+//#endregion
+//#region src/initialize.ts
+let instance;
+/**
+* Retrieves the singleton instance of the MonoCloudNextClient.
+* Initializes it lazily on the first call.
+*/
+const getInstance = () => {
+	instance ??= new MonoCloudNextClient();
+	return instance;
+};
+/**
+* Creates a Next.js catch-all auth route handler (Pages Router and App Router) for the built-in routes (`/signin`, `/callback`, `/userinfo`, `/signout`).
+*
+* Mount this handler on a catch-all route (e.g. `/api/auth/[...monocloud]`).
+*
+* > If you already use `authMiddleware()`, you typically don’t need this handler. Use `monoCloudAuth()` when middleware cannot be used or when auth routes need customization.
+*
+* @example App Router
+* ```tsx:src/app/api/auth/[...monocloud]/route.ts tab="App Router" tab-group="monoCloudAuth"
+* import { monoCloudAuth } from "@monocloud/auth-nextjs";
+*
+* export const GET = monoCloudAuth();
+*```
+*
+* @example App Router (Response)
+* ```tsx:src/app/api/auth/[...monocloud]/route.ts tab="App Router (Response)" tab-group="monoCloudAuth"
+* import { monoCloudAuth } from "@monocloud/auth-nextjs";
+* import { NextRequest, NextResponse } from "next/server";
+*
+* export const GET = (req: NextRequest) => {
+*   const authHandler = monoCloudAuth();
+*
+*   const res = new NextResponse();
+*
+*   res.cookies.set("last_auth_requested", `${Date.now()}`);
+*
+*   return authHandler(req, res);
+* };
+* ```
+*
+* @example Pages Router
+* ```tsx:src/pages/api/auth/[...monocloud].ts tab="Pages Router" tab-group="monoCloudAuth"
+* import { monoCloudAuth } from "@monocloud/auth-nextjs";
+*
+* export default monoCloudAuth();
+*```
+*
+* @example Pages Router (Response)
+* ```tsx:src/pages/api/auth/[...monocloud].ts tab="Pages Router (Response)" tab-group="monoCloudAuth"
+* import { monoCloudAuth } from "@monocloud/auth-nextjs";
+* import { NextApiRequest, NextApiResponse } from "next";
+*
+* export default function handler(req: NextApiRequest, res: NextApiResponse) {
+*   const authHandler = monoCloudAuth();
+*
+*   res.setHeader("last_auth_requested", `${Date.now()}`);
+*
+*   return authHandler(req, res);
+* }
+* ```
+*
+* @param options Optional configuration for the auth handler.
+* @returns Returns a Next.js-compatible handler for App Router route handlers or Pages Router API routes.
+*
+* @category Functions
+*/
+function monoCloudAuth(options) {
+	return getInstance().monoCloudAuth(options);
+}
+function authMiddleware(...args) {
+	return getInstance().authMiddleware(...args);
+}
+function getSession(...args) {
+	return getInstance().getSession(...args);
+}
+function getTokens(...args) {
+	return getInstance().getTokens(...args);
+}
+function isAuthenticated(...args) {
+	return getInstance().isAuthenticated(...args);
+}
+/**
+* Ensures the current user is authenticated. If not, redirects to the sign-in flow.
+*
+* > **App Router only.** Intended for Server Components, Route Handlers, and Server Actions.
+*
+* @example Server Component
+* ```tsx:src/app/page.tsx tab="Server Component" tab-group="protect"
+* import { protect } from "@monocloud/auth-nextjs";
+*
+* export default async function Home() {
+*   await protect();
+*
+*   return <>You are signed in.</>;
+* }
+* ```
+*
+* @example Server Action
+* ```tsx:src/action.ts tab="Server Action" tab-group="protect"
+* "use server";
+*
+* import { protect } from "@monocloud/auth-nextjs";
+*
+* export async function getMessage() {
+*   await protect();
+*
+*   return { secret: "sssshhhhh!!!" };
+* }
+* ```
+*
+* @example API Handler
+* ```tsx:src/app/api/protected/route.ts tab="API Handler" tab-group="protect"
+* import { protect } from "@monocloud/auth-nextjs";
+* import { NextResponse } from "next/server";
+*
+* export const GET = async () => {
+*   await protect();
+*
+*   return NextResponse.json({ secret: "ssshhhh!!!" });
+* };
+* ```
+*
+* @param options Optional configuration for redirect behavior (for example, return URL or sign-in parameters).
+* @returns Resolves if the user is authenticated; otherwise triggers a redirect.
+*
+* @category Functions
+*/
+function protect(options) {
+	return getInstance().protect(options);
+}
+function protectApi(handler, options) {
+	return getInstance().protectApi(handler, options);
+}
+function protectPage(...args) {
+	return getInstance().protectPage(...args);
+}
+function isUserInGroup(...args) {
+	return getInstance().isUserInGroup(...args);
+}
+/**
+* Redirects the user to the sign-in flow.
+*
+* > **App Router only**. Intended for use in Server Components, Route Handlers, and Server Actions.
+*
+* This helper performs a server-side redirect to the configured sign-in route. Execution does not continue after the redirect is triggered.
+*
+* @example Server Component
+* ```tsx:src/app/page.tsx tab="Server Component" tab-group="redirect-to-sign-in"
+* import { isUserInGroup, redirectToSignIn } from "@monocloud/auth-nextjs";
+*
+* export default async function Home() {
+*   const allowed = await isUserInGroup(["admin"]);
+*
+*   if (!allowed) {
+*     await redirectToSignIn({ returnUrl: "/home" });
+*   }
+*
+*   return <>You are signed in.</>;
+* }
+* ```
+*
+* @example Server Action
+* ```tsx:src/action.ts tab="Server Action" tab-group="redirect-to-sign-in"
+* "use server";
+*
+* import { getSession, redirectToSignIn } from "@monocloud/auth-nextjs";
+*
+* export async function protectedAction() {
+*   const session = await getSession();
+*
+*   if (!session) {
+*     await redirectToSignIn();
+*   }
+*
+*   return { data: "Sensitive Data" };
+* }
+* ```
+*
+* @example API Handler
+* ```tsx:src/app/api/protected/route.ts tab="API Handler" tab-group="redirect-to-sign-in"
+* import { getSession, redirectToSignIn } from "@monocloud/auth-nextjs";
+* import { NextResponse } from "next/server";
+*
+* export const GET = async () => {
+*   const session = await getSession();
+*
+*   if (!session) {
+*     await redirectToSignIn({
+*       returnUrl: "/dashboard",
+*     });
+*   }
+*
+*   return NextResponse.json({ data: "Protected content" });
+* };
+* ```
+*
+* @param options Optional configuration for the redirect, such as `returnUrl` or additional sign-in parameters.
+* @returns Never resolves. Triggers a redirect to the sign-in flow.
+*
+* @category Functions
+*/
+function redirectToSignIn(options) {
+	return getInstance().redirectToSignIn(options);
+}
+/**
+* Redirects the user to the sign-out flow.
+*
+* > **App Router only**. Intended for use in Server Components, Route Handlers, and Server Actions.
+*
+* This helper performs a server-side redirect to the configured sign-out route. Execution does not continue after the redirect is triggered.
+*
+* @example Server Component
+* ```tsx:src/app/page.tsx tab="Server Component" tab-group="redirect-to-sign-out"
+* import { getSession, redirectToSignOut } from "@monocloud/auth-nextjs";
+*
+* export default async function Page() {
+*   const session = await getSession();
+*
+*   // Example: Force sign-out if a specific condition is met (e.g., account suspended)
+*   if (session?.user.isSuspended) {
+*     await redirectToSignOut();
+*   }
+*
+*   return <>Welcome User</>;
+* }
+* ```
+*
+* @example Server Action
+* ```tsx:src/action.ts tab="Server Action" tab-group="redirect-to-sign-out"
+* "use server";
+*
+* import { getSession, redirectToSignOut } from "@monocloud/auth-nextjs";
+*
+* export async function signOutAction() {
+*   const session = await getSession();
+*
+*   if (session) {
+*     await redirectToSignOut();
+*   }
+* }
+* ```
+*
+* @example API Handler
+* ```tsx:src/app/api/signout/route.ts tab="API Handler" tab-group="redirect-to-sign-out"
+* import { getSession, redirectToSignOut } from "@monocloud/auth-nextjs";
+* import { NextResponse } from "next/server";
+*
+* export const GET = async () => {
+*   const session = await getSession();
+*
+*   if (session) {
+*     await redirectToSignOut({
+*       postLogoutRedirectUri: "/goodbye",
+*     });
+*   }
+*
+*   return NextResponse.json({ status: "already_signed_out" });
+* };
+* ```
+*
+* @param options Optional configuration for the redirect, such as `postLogoutRedirectUri` or additional sign-out parameters.
+* @returns Never resolves. Triggers a redirect to the sign-out flow.
+*
+* @category Functions
+*/
+function redirectToSignOut(options) {
+	return getInstance().redirectToSignOut(options);
+}
+
 //#endregion
 Object.defineProperty(exports, 'MonoCloudAuthBaseError', {
   enumerable: true,
@@ -1141,4 +1155,15 @@ Object.defineProperty(exports, 'MonoCloudValidationError', {
     return _monocloud_auth_node_core.MonoCloudValidationError;
   }
 });
+exports.authMiddleware = authMiddleware;
+exports.getSession = getSession;
+exports.getTokens = getTokens;
+exports.isAuthenticated = isAuthenticated;
+exports.isUserInGroup = isUserInGroup;
+exports.monoCloudAuth = monoCloudAuth;
+exports.protect = protect;
+exports.protectApi = protectApi;
+exports.protectPage = protectPage;
+exports.redirectToSignIn = redirectToSignIn;
+exports.redirectToSignOut = redirectToSignOut;
 //# sourceMappingURL=index.cjs.map