After rearranging things, I've finally discovered a more effective solution that suits my needs.

"next-auth": "5.0.0-beta.5",
"next-i18n-router": "^5.2.0",

Simply utilize the NextAuth middleware configuration:

middleware.ts

import NextAuth from 'next-auth'
import { authConfig } from './auth.config'

export default NextAuth(authConfig).auth

export const config = {
  matcher: '/((?!api|static|.*\\..*|_next).*)'
}

Then combine authorized handler and i18nRouter in the auth.config file:

auth.config.ts

import { i18nRouter } from 'next-i18n-router'
import type { NextAuthConfig } from 'next-auth'
import { i18nConfig } from '@/locale/config'

const getLocaleFromPath = (pathname: string) => {
  const localeFromPathRegex = new RegExp(`^/(${i18nConfig.locales.join('|')})?`)
  const localeFromPath = pathname.match(localeFromPathRegex)?.[1]
  return { locale: localeFromPath, path: localeFromPath ? `/${localeFromPath}` : '' }
}

const checkCurrentRoute = (pathname: string, locale?: string) => {
  const checkPathnameRegex = (pattern: string | RegExp) => {
    const rootRegex = new RegExp(pattern)
    return Boolean(pathname.match(rootRegex))
  }

  return {
    root: checkPathnameRegex(`^/(${locale})?$`),
    dashboard: checkPathnameRegex(`^(/${locale})?/dashboard.*`),
    login: checkPathnameRegex(`^(/${locale})?/login.*`)
  }
}

export const authConfig = {
  pages: {
    signIn: '/login'
  },
  callbacks: {
    authorized({ auth, request }) {
      const { nextUrl } = request

      const locale = getLocaleFromPath(nextUrl.pathname)
      const dashboardUrl = new URL(`${locale.path}/dashboard`, nextUrl)

      const { root: isOnRoot, dashboard: isOnDashboard, login: isOnLogin } = checkCurrentRoute(nextUrl.pathname, locale.locale)

      const isLoggedIn = !!auth?.user

      if (isOnRoot || (isLoggedIn && !isOnDashboard)) {
        // If on root or logged in but not on dashboard, redirect to dashboard
        return Response.redirect(dashboardUrl)
      }

      if ((isOnLogin && !isLoggedIn) || (isOnDashboard && isLoggedIn)) {
        // Not logged in but on login OR logged in and on dashboard => allow access
        return i18nRouter(request, i18nConfig)
      }

      // Not logged in and not on login or dashboard => redirect to login page
      return false
    }
  },

  providers: []
} satisfies NextAuthConfig

@/locale/config.ts

export const i18nConfig = {
  locales: ['en', 'es'],
  defaultLocale: 'en'
}

This approach has proven successful for me. By manually extracting the locale from the pathname, I can reuse it in redirections. If no unauthorized redirection is necessary, simply return the i18nRouter so i18n remains enabled.

For additional configuration details, I followed this guide: NextAuth tutorial

My approach:

middleware.js

export function middleware(request) {
  let locales = ['en', 'fr'];
  let defaultLocale = 'en';
  // Checking for supported locale in the pathname
  const { pathname } = request.nextUrl;
  const isPathAllowed = ['/img', 'img', '/api'].some((allowedPath) =>
    pathname.startsWith(`${allowedPath}`),
  );
  if (isPathAllowed) return;
  const pathnameHasLocale = locales.some(
    (locale) => pathname.startsWith(`/${locale}/`) || pathname === `/${locale}`,
  );

  if (pathnameHasLocale) return;

  // Redirecting if there is no locale
  const locale = defaultLocale;
  request.nextUrl.pathname = `/${locale}${pathname}`;
  // Example: incoming request is /products
  // The new URL will be /en/products
  return Response.redirect(request.nextUrl);
}

export const config = {
  matcher: [
    // Skip all internal paths (_next)
    '/((?!_next).*)',
    // Optional: only run on root (/) URL
    // '/'
  ],
};

en.json

{
  "Index": {
    "title": "en title",
    "description": "en description"
    }
}

fr.json

{
  "Index": {
    "title": "french title",
    "description": "french description"
    }
}

messages.js

import en from './en.json';
import fr from './fr.json';

export const getSelectedLanguage = (lang) => {
  switch (lang) {
    case 'en':
      return en;
    case 'fr':
      return fr;
    default:
      return null;
  }
};

layout.js

'use client';

import '@/app/globals.css';
import { SessionProvider } from 'next-auth/react';
import { NextIntlClientProvider } from 'next-intl';
import { getSelectedLanguage } from '@/internationalization/messages/messages';

export default function RootLayout({ children, params: { lang } }) {
  const messages = getSelectedLanguage(lang);

  return (
    <html lang={lang}>
      <body>
        <NextIntlClientProvider locale={lang} messages={messages}>
          <SessionProvider>{children}</SessionProvider>
        </NextIntlClientProvider>
      </body>
    </html>
  );
}

page.jsx

'use client';

import Link from 'next/link';
import { useLocale, useTranslations } from 'next-intl';

const HomePage = () => {
  const t = useTranslations('Index');
  const locale = useLocale();

  return (
    <>
      <main>
          <div className="container">
            <h1>{t('title')}</h1>
          </div>
      </main>
   </>
  );
}