@payez/next-mvp 4.5.7 → 4.7.9

package/src/lib/device-id.ts

@@ -0,0 +1,67 @@
+/**
+ * Per-browser device identity — card 240566 (QAPert flag 2 on the 9c7a815 review).
+ *
+ * BEFORE: /api/auth/admin-login forwarded ONE hardcoded device-id cookie —
+ * `payez-PayEz-6c8201c35c1b44c9b2e823b36b95a718` — for every caller on the
+ * PUBLIC /sign-in password path. To the IDP's rate limiter and device
+ * fingerprinting, every portal user was literally the same device. Two
+ * consequences, both measured-by-inspection rather than hypothetical:
+ *   1. SHARED-FATE LOCKOUT — one attacker's failed attempts consume the
+ *      throttle budget for every legitimate user at once.
+ *   2. Per-device risk signals are meaningless: "new device" and "trusted
+ *      device" cannot distinguish anybody from anybody.
+ *
+ * The id is a routing/telemetry key, NOT a credential — the IDP must never
+ * grant anything on the strength of it, and nothing here assumes otherwise.
+ * It is client-supplied and therefore client-forgeable; that is inherent to
+ * device-id throttling and is why it supplements, never replaces, the
+ * identifier- and IP-scoped limits on the IDP side.
+ *
+ * Shape is fixed by what the IDP already accepts from
+ * createLoginHandler: `payez-PayEz-<32 lowercase hex>`.
+ */
+
+export const DEVICE_ID_HEADER = 'X-Device-Id';
+export const DEVICE_ID_PATTERN = /^payez-PayEz-[0-9a-f]{32}$/;
+const STORAGE_KEY = 'payez.device-id';
+
+/** True for a well-formed device id. Used on BOTH sides of the wire. */
+export function isValidDeviceId(value: string | null | undefined): value is string {
+  return typeof value === 'string' && DEVICE_ID_PATTERN.test(value);
+}
+
+function mint(): string {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  const hex = Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('');
+  return `payez-PayEz-${hex}`;
+}
+
+/**
+ * The stable per-browser device id, minted once and persisted.
+ *
+ * Browser-only. Persistence is best-effort: private windows, disabled site
+ * data and storage-quota failures all throw on access, so every read and
+ * write is guarded. A browser that cannot persist still gets a VALID id for
+ * this call — it simply looks like a new device each time, which is the
+ * honest answer for a client that refuses to be remembered, and is still
+ * strictly better than every user sharing one identity.
+ */
+export function getDeviceId(): string {
+  if (typeof window === 'undefined') return mint();
+
+  try {
+    const existing = window.localStorage.getItem(STORAGE_KEY);
+    if (isValidDeviceId(existing)) return existing;
+  } catch {
+    return mint();
+  }
+
+  const minted = mint();
+  try {
+    window.localStorage.setItem(STORAGE_KEY, minted);
+  } catch {
+    /* not persistable — the minted id is still returned and used for this call */
+  }
+  return minted;
+}

package/src/lib/lock-window.ts

@@ -0,0 +1,49 @@
+/**
+ * PAY-1608: a 2FA lock's window, stated as the IdP enforces it. Never a hard-coded "15 minutes".
+ *
+ * Core answers every 2FA lock with 429 code "locked" plus Retry-After: MfaController.SecondFactorLocked sends the
+ * full lockout (900), and VerifyTotp sends what is LEFT of the lock. The portal used to hard-code "locked for 15
+ * minutes" in three places (verify-code-copy.ts, twofa-rejection.ts, and the next-mvp BFF), which was true only
+ * while every lock was exactly 15 minutes and the user had just tripped it.
+ *
+ * The window arrives in one of two ways:
+ *   - Door A (verify-code): next-mvp >= 4.5.2 relays it in the BFF body as `retryAfterSeconds` (a number).
+ *   - Door B (admin-login): this route reads the IdP's Retry-After header itself.
+ * With no window, the sentence states NO number rather than a guessed one.
+ *
+ * Dependency-free on purpose: the verify-code page (client) and the admin-login route (server) both use it, and
+ * the chain gate executes it directly.
+ */
+
+/** A positive whole number of seconds from the BFF body, or undefined. Anything else - a string, 0, NaN - is dropped. */
+export function lockSecondsFromBody(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.ceil(value) : undefined;
+}
+
+/** A Retry-After header as whole seconds. ONE implementation: the package's lib/retry-after (the portal copy was the same rule). */
+export { parseRetryAfterSeconds } from './retry-after';
+
+/**
+ * The window in words, rounded UP so the user is never told a shorter wait than the IdP enforces:
+ * 900 -> "15 minutes", 61 -> "2 minutes", 60 -> "1 minute", 45 -> "45 seconds", 7200 -> "2 hours".
+ */
+export function formatLockWindow(seconds: number | undefined): string | undefined {
+  if (typeof seconds !== 'number' || !Number.isFinite(seconds) || seconds <= 0) return undefined;
+  const plural = (n: number, unit: string) => `${n} ${unit}${n === 1 ? '' : 's'}`;
+  if (seconds < 60) return plural(Math.ceil(seconds), 'second');
+  const minutes = Math.ceil(seconds / 60);
+  if (minutes < 120) return plural(minutes, 'minute');
+  return plural(Math.ceil(minutes / 60), 'hour');
+}
+
+/** The sentence for a lock whose window was NOT sent. It says even a correct code is refused, and states no number. */
+export const LOCKED_NO_WINDOW =
+  'Too many incorrect codes. Verification is locked for now - even a correct code is refused until the lock ends. Wait before entering another code.';
+
+/** The locked sentence: the IdP's real window when it sent one, otherwise LOCKED_NO_WINDOW. */
+export function lockedSentence(seconds?: number): string {
+  const window = formatLockWindow(seconds);
+  return window
+    ? `Too many incorrect codes. Verification is locked for ${window} - wait before entering another code.`
+    : LOCKED_NO_WINDOW;
+}

package/src/lib/login-error-message.ts

@@ -0,0 +1,41 @@
+/**
+ * PAY-2319 (4.7.2): what the login page SAYS for an `?error=` / `?oauth_error=` code, as pure functions so a test can
+ * execute them (the page is a client component and effects do not run in a static render).
+ *
+ * 4.7.1 mapped these codes in an effect that called setLoginError, but the page never RENDERED loginError (it only fed the
+ * loading gate), so no sentence was ever shown (NightHawk's walk, 73801, W1). Now that the text is displayed, a raw code from
+ * the URL must NOT be echoed: `/account-auth/login?error=<anything an attacker types>` would otherwise print attacker-chosen
+ * text on the login page (content spoofing / phishing). Known codes get their sentence; anything else gets one generic
+ * sentence; nothing from the URL is ever shown verbatim.
+ */
+
+export const GENERIC_LOGIN_ERROR = 'We could not sign you in. Please try again.';
+
+const KNOWN: Record<string, string> = {
+  TwoFactorTimeout: 'Your verification step timed out before the code was confirmed. Please sign in again.',
+  AUTHORIZE_RESUME_REFUSED: 'That sign-in request could not be continued. Please sign in again.',
+  ServiceUnavailable: 'Authentication service is temporarily unavailable. Please try again in a few minutes.',
+  CredentialsSignin: 'Invalid email or password. Please try again.',
+};
+
+/**
+ * The sentence for `?error=<code>`, or null when nothing should be shown.
+ * SessionExpired is a normal event (not an error) and shows nothing; an absent/empty code shows nothing.
+ */
+export function friendlyLoginError(code: string | null | undefined): string | null {
+  if (typeof code !== 'string' || code === '') return null;
+  if (code === 'SessionExpired') return null;
+  if (Object.prototype.hasOwnProperty.call(KNOWN, code)) return KNOWN[code];
+  // The old raw-JSON parse failures the middleware/proxy could bounce here:
+  if (code.startsWith('Unexpected token') || code.includes('not valid JSON')) {
+    return 'An authentication error occurred. Please try signing in again.';
+  }
+  return GENERIC_LOGIN_ERROR;
+}
+
+/** `?oauth_error=<provider>`: only a plain provider-like slug is echoed (capitalised); anything else is the generic sentence. */
+export function oauthFailureMessage(provider: string | null | undefined): string | null {
+  if (typeof provider !== 'string' || provider === '') return null;
+  if (!/^[a-z][a-z0-9_-]{0,31}$/i.test(provider)) return GENERIC_LOGIN_ERROR;
+  return `${provider.charAt(0).toUpperCase()}${provider.slice(1)} sign-in did not complete. Please try again.`;
+}

package/src/lib/twofa-rejection.ts

@@ -0,0 +1,91 @@
+/**
+ * Door B (/api/auth/admin-login) twofa verify: what to tell the user when every lane refused.
+ *
+ * Classification is by the MOST BLOCKING outcome across lanes (268121 ruling), in this order:
+ *   429 from the IdP, or any lane answering code `locked`  -> 429 lockout (PAY-903)
+ *   any 5xx, or a lane answering code server_error / service_unavailable (PAY-1589) -> 502 "our side, not your code"
+ *   otherwise                                              -> 400 wrong / expired code
+ *
+ * PAY-903: MfaController.VerifyTotp returns 400 {message, code:"locked"} for a 15-minute lockout
+ * (MfaTotpService ErrorCode "locked"). Status-only classification read that as "wrong code, try again" -
+ * coaching a locked-out user to spend attempts. The body is inspected for EVERY lane, because with lane
+ * order [totp, email] the last response is the email lane's and never carries the TOTP lockout.
+ * Disclosing the lockout here is safe: this step is post-password (the caller already proved the account).
+ *
+ * PAY-1608: the lockout states the LOCKED LANE's own Retry-After (Core sends one on every 2FA lock; VerifyTotp sends
+ * what is LEFT of it). It used to hard-code 15 minutes / 900 s. With no usable header, no number is stated and
+ * `retryAfter` is omitted rather than invented.
+ */
+import { lockedSentence, parseRetryAfterSeconds } from './lock-window';
+
+export interface TwofaLaneResult {
+  status: number;
+  body: string;
+  /** PAY-2284: which lane this answer came from, so a fault in the TOTP/SMS lane can offer the email lane (never offered when the EMAIL lane is the one that faulted). */
+  lane?: 'totp' | 'sms' | 'email';
+  /** PAY-1608: this lane's Retry-After header, as received. */
+  retryAfter?: string | null;
+}
+
+export interface TwofaRejection {
+  status: 400 | 429 | 502;
+  error: string;
+  retryAfter?: number;
+  /**
+   * PAY-2284: true when the authenticator (or text) lane failed on OUR side and the emailed-code lane has not faulted. The sign-in
+   * card then shows a real "Email me a code instead" action. Before this, the copy said "use another sign-in method" and the screen
+   * offered none, and a TOTP holder - for whom the door sends NOTHING at sign-in - was stuck (Jon, 12 Oct, dev-93 key version 57).
+   */
+  offerEmailCode?: true;
+}
+
+/** Every code the IdP body carries: flat {code}, envelope {error:{code}}, or {error:{details:{code}}}. */
+function laneCodes(body: string): string[] {
+  try {
+    const j = JSON.parse(body) as Record<string, unknown> | null;
+    if (!j || typeof j !== 'object') return [];
+    const err = (j.error && typeof j.error === 'object' ? j.error : null) as Record<string, unknown> | null;
+    const details = (err?.details && typeof err.details === 'object' ? err.details : null) as Record<string, unknown> | null;
+    return [j.code, err?.code, details?.code].filter((c): c is string => typeof c === 'string').map((c) => c.toLowerCase());
+  } catch {
+    return [];
+  }
+}
+
+export function classifyTwofaRejection(lanes: TwofaLaneResult[], retryAfterHeader?: string | null): TwofaRejection {
+  const lockedLane = lanes.find((l) => laneCodes(l.body).includes('locked'));
+  if (lockedLane) {
+    const secs = parseRetryAfterSeconds(lockedLane.retryAfter);
+    return { status: 429, error: lockedSentence(secs), ...(secs ? { retryAfter: secs } : {}) };
+  }
+  if (lanes.some((l) => l.status === 429)) {
+    const parsed = retryAfterHeader ? parseInt(retryAfterHeader, 10) : NaN;
+    return {
+      status: 429,
+      error: 'Too many attempts. Your code is still valid - wait before trying again.',
+      retryAfter: Number.isFinite(parsed) && parsed > 0 ? parsed : 60,
+    };
+  }
+  // PAY-1589: an IdP-side fault that arrives as 400 + code (TOTP secret cannot be decrypted -> server_error;
+  // replay store down -> service_unavailable). It is not the user's code and does not count toward the lockout,
+  // so calling it "not right" sends them round a loop that cannot succeed. Email may still work, so say so.
+  const faulted = (l: TwofaLaneResult) => laneCodes(l.body).some((c) => c === 'server_error' || c === 'service_unavailable');
+  if (lanes.some(faulted)) {
+    const emailLaneFaulted = lanes.some((l) => l.lane === 'email' && (faulted(l) || l.status >= 500));
+    const offer = !emailLaneFaulted && lanes.some((l) => faulted(l) && (l.lane === 'totp' || l.lane === 'sms'));
+    return {
+      status: 502,
+      error: offer
+        ? 'We could not check your code just now - this is a problem on our side, not with your code. You can have us email you a code instead.'
+        : 'We could not check your code just now - this is a problem on our side, not with your code. Try again shortly.',
+      ...(offer ? { offerEmailCode: true as const } : {}),
+    };
+  }
+  if (lanes.some((l) => l.status >= 500)) {
+    return {
+      status: 502,
+      error: 'We could not check your code just now - this is a problem on our side, not with your code. Try again shortly.',
+    };
+  }
+  return { status: 400, error: 'That code is not right or has expired. Try again.' };
+}

package/src/middleware/create-middleware.ts

@@ -158,6 +158,18 @@ export interface MvpMiddlewareOptions {
    * is signed out for not implementing the check).
    */
   revocationFailMode?: 'closed' | 'open';
+
+  /**
+   * PAY-2302 cut 1c (BAPert 73585): this app has NO revocation source - for example a development environment
+   * provisioned without a vibe client id / HMAC key - and says so EXPLICITLY. Under it a viability answer of
+   * `revocationStatus: 'not_configured'` is viable, and a loud warning is logged once at startup.
+   *
+   * It relaxes ONLY 'not_configured'. 'unknown' (a revocation read that FAILED) and 'revoked' stay closed whatever
+   * `revocationFailMode` says, and the default (option absent) is unchanged: 'not_configured' fails closed, because
+   * for an app that HAS a vibe client it means a misconfiguration (BAPert 66356). Do not use this to paper over a
+   * misconfigured production app; remove it when the environment has a vibe client + HMAC key.
+   */
+  noRevocationSource?: boolean;
 }
 
 // =============================================================================
@@ -195,8 +207,13 @@ const defaultLogger: MiddlewareLogger = {
 const LOGIN_PAGE = '/account-auth/login';
 const VERIFY_CODE_PAGE = '/account-auth/verify-code';
 
+// PAY-2315 (4.7.1): /login is a public alias of the login page. It used to take the 'public: allow' arm and never reached the
+// 'already_authenticated' redirect, so a signed-in user was shown the sign-in form. It is the login page for every arm now.
+// (safe-callback refuses /login as a destination, so this cannot redirect to itself.)
+const LOGIN_ALIAS = '/login';
+
 function isLoginPage(pathname: string): boolean {
-  return pathname === LOGIN_PAGE;
+  return pathname === LOGIN_PAGE || pathname === LOGIN_ALIAS;
 }
 
 /**
@@ -542,6 +559,15 @@ export function createMvpMiddleware(options: MvpMiddlewareOptions = {}) {
   const rbacExemptPaths = options.rbacExemptPaths || [];
   // PAY-1882 step 4: default 'closed' (Jon's option A / BAPert 66316).
   const revocationFailMode = options.revocationFailMode || 'closed';
+  // PAY-2302 cut 1c: strictly `=== true`, so a truthy string in a config file cannot switch revocation off.
+  const noRevocationSource = options.noRevocationSource === true;
+  if (noRevocationSource) {
+    log.warn(
+      '[next-mvp] noRevocationSource is ON: sessions of this app CANNOT be revoked server-side (no vibe client / HMAC key). ' +
+      "revocationStatus 'not_configured' is treated as viable; 'unknown' and 'revoked' still sign the user out. " +
+      'Remove this option once the environment has a vibe client id and HMAC key.'
+    );
+  }
   const sessionResetRoute =
     options.sessionResetRoute === true ? DEFAULT_SESSION_RESET_ROUTE
     : typeof options.sessionResetRoute === 'string' && options.sessionResetRoute ? options.sessionResetRoute
@@ -604,7 +630,8 @@ export function createMvpMiddleware(options: MvpMiddlewareOptions = {}) {
       request,
       viabilityEndpoint,
       log,
-      revocationFailMode
+      revocationFailMode,
+      noRevocationSource
     );
 
     // --- Stale session (cookie exists but session doesn't): OBSERVE ONLY, DO NOT DECIDE ---
@@ -687,11 +714,14 @@ export function createMvpMiddleware(options: MvpMiddlewareOptions = {}) {
 export function decideForceInvalid(
   data: { revocationStatus?: unknown; forceInvalid?: unknown; revoked?: unknown },
   revocationFailMode: 'closed' | 'open',
+  noRevocationSource: boolean = false,
 ): boolean {
   const status = data.revocationStatus;
   if (typeof status === 'string') {
     if (status === 'revoked') return true;
     if (status === 'active') return false;
+    // PAY-2302 cut 1c: an app that declared it has no revocation source. ONLY the exact 'not_configured' string.
+    if (status === 'not_configured' && noRevocationSource === true) return false;
     // S1 (NightHawk 66409): ANY other string - 'unknown', 'not_configured', a
     // typo like 'Revoked', 'error', or '' - is treated as 'unknown' (fail mode
     // applies), NEVER as 'active'. Returning false here would let the first
@@ -720,7 +750,8 @@ async function checkViability(
   request: NextRequest,
   endpoint: string,
   log: MiddlewareLogger,
-  revocationFailMode: 'closed' | 'open'
+  revocationFailMode: 'closed' | 'open',
+  noRevocationSource: boolean = false
 ): Promise<{
   sessionStatus: SessionStatus;
   sessionPointer: SessionPointer;
@@ -798,7 +829,7 @@ async function checkViability(
       // revocations status, decide from it + failMode and ignore the folded
       // booleans for unknown/not_configured. The booleans are read ONLY when
       // revocationStatus is ABSENT (idealresume.online's older boolean route).
-      sessionStatus.forceInvalid = decideForceInvalid(data, revocationFailMode);
+      sessionStatus.forceInvalid = decideForceInvalid(data, revocationFailMode, noRevocationSource);
       // PAY-2216: a STALE session - the cookie resolved to a token, but no store holds the session - used to set
       // pointer.exists=false, so makeAuthDecision took no_session (login, cookie NOT cleared) and its stale_session
       // arm (clearCookies) was unreachable: a dead cookie lingered and re-ran viability on every request.

package/src/pages/login/page.tsx

@@ -29,6 +29,7 @@ import { Suspense } from 'react';
 import ReservedStatusBox from '../../components/reserved/ReservedStatusBox';
 import ReservedRecoveryWarning from '../../components/reserved/ReservedRecoveryWarning';
 import { useBranding, useColors, useLayout } from '../../theme/useTheme';
+import { friendlyLoginError, oauthFailureMessage } from '../../lib/login-error-message';
 
 function LoginForm({ altAuthSlot }: { altAuthSlot?: React.ReactNode }) {
   const searchParams = useSearchParams();
@@ -117,46 +118,20 @@ function LoginForm({ altAuthSlot }: { altAuthSlot?: React.ReactNode }) {
   // Atomic state management - only ONE can be true at a time
   const [isSubmitting, setIsSubmitting] = useState(false);
   const [loginSuccess, setLoginSuccess] = useState(false);
-  const [loginError, setLoginError] = useState<string | null>(null);
+  // undefined = the user has not acted yet (show what the URL says); null/string = an explicit state set by a handler below.
+  const [loginError, setLoginError] = useState<string | null | undefined>(undefined);
   const [loading, setLoading] = useState(false);
   const [showRecoveryOptions, setShowRecoveryOptions] = useState(false);
 
   // Force show form after timeout if stuck in loading
   const [forceShowForm, setForceShowForm] = useState(false);
 
-  // Surface OAuth failures the Better Auth mount bounced back here.
+  // PAY-2319 (4.7.2): what the URL says, derived at render (no effect) so it is shown on the FIRST paint and in a static render.
+  // 4.7.1 mapped these in effects that only set loginError, which was never rendered. Unknown codes are NOT echoed (see lib/login-error-message).
+  const urlMessage = oauthFailureMessage(oauthError) ?? friendlyLoginError(urlError);
+  const shownError: string | null = loginError !== undefined ? loginError : urlMessage;
   useEffect(() => {
-    if (oauthError) {
-      const name = oauthError.charAt(0).toUpperCase() + oauthError.slice(1);
-      setLoginError(`${name} sign-in did not complete. Please try again.`);
-    }
-  }, [oauthError]);
-
-  // Handle URL errors with user-friendly messages
-  useEffect(() => {
-    if (urlError) {
-      let friendlyError: string | null = urlError;
-
-      if (urlError === 'SessionExpired') {
-        // Session expiration is normal - don't show as error
-        console.log('[LOGIN] SessionExpired detected - normal behavior');
-        friendlyError = null;
-      } else if (urlError === 'TwoFactorTimeout') {
-        // PAY-884: the sign-in expired while the verification code was outstanding. Unlike
-        // SessionExpired this is NOT silent - the user was mid-2FA and must know why they are here.
-        friendlyError = 'Your verification step timed out before the code was confirmed. Please sign in again.';
-      } else if (urlError === 'ServiceUnavailable') {
-        friendlyError = 'Authentication service is temporarily unavailable. Please try again in a few minutes.';
-      } else if (urlError.startsWith("Unexpected token")) {
-        friendlyError = 'An authentication error occurred. Please try signing in again.';
-      } else if (urlError.includes('not valid JSON')) {
-        friendlyError = 'An authentication error occurred. Please try signing in again.';
-      } else if (urlError === 'CredentialsSignin') {
-        friendlyError = 'Invalid email or password. Please try again.';
-      }
-
-      setLoginError(friendlyError);
-    }
+    if (urlError === 'SessionExpired') console.log('[LOGIN] SessionExpired detected - normal behavior');
   }, [urlError]);
 
   // Timeout to prevent infinite loading states
@@ -186,7 +161,7 @@ function LoginForm({ altAuthSlot }: { altAuthSlot?: React.ReactNode }) {
   // package never configures emailAndPassword. See the note at the render site.
 
   // Show loading spinner for initial loads
-  if (!forceShowForm && !loginError && (loading || (status === 'loading' && !session))) {
+  if (!forceShowForm && !shownError && (loading || (status === 'loading' && !session))) {
     return (
       <div className={`flex flex-col items-center justify-center min-h-screen ${colors.background}`}>
         <svg className="animate-spin h-6 w-6" style={{ color: buttonColor }} viewBox="0 0 24 24" fill="none">
@@ -246,6 +221,17 @@ function LoginForm({ altAuthSlot }: { altAuthSlot?: React.ReactNode }) {
             </p>
           </div>
 
+          {/* PAY-2319 (4.7.2): the error sentence. 4.7.1 set loginError but never rendered it. */}
+          {shownError && (
+            <div
+              role="alert"
+              data-testid="login-error"
+              className="mb-6 rounded-lg border border-red-200 bg-red-50 px-4 py-3 text-sm text-red-700"
+            >
+              {shownError}
+            </div>
+          )}
+
           {/* Social sign-in — rendered ONLY from the IDP client config's
               enabled providers (see the /api/auth/settings discovery above).
               Above the form, divider idiom per the package's ModeAwareLoginPage. */}

package/src/routes/auth/credential-login-email-code.ts

@@ -0,0 +1,6 @@
+/**
+ * PAY-2302 cut 1: ask the IdP to email a code when the authenticator lane failed on our side.
+ * The handler lives in api-handlers/auth/credential-login-email-code.ts (moved from VibeID-Customer-Portal src/app/api/auth/admin-login/email-code/route.ts). A consuming app's route file
+ * re-exports POST and writes `export const runtime = 'nodejs'` literally.
+ */
+export { POST } from '../../api-handlers/auth/credential-login-email-code';

package/src/routes/auth/credential-login.ts

@@ -0,0 +1,6 @@
+/**
+ * PAY-2302 cut 1: password sign-in route (IdP ExternalAuth/login, session written via lib/session-store, 2FA-outstanding handling).
+ * The handler lives in api-handlers/auth/credential-login.ts (moved from VibeID-Customer-Portal src/app/api/auth/admin-login/route.ts). A consuming app's route file
+ * re-exports POST and writes `export const runtime = 'nodejs'` literally.
+ */
+export { POST } from '../../api-handlers/auth/credential-login';

package/src/routes/oauth/resume.ts

@@ -0,0 +1,11 @@
+/**
+ * PAY-2302 cut 2: post-2FA OAuth authorize resume route. The handler lives in api-handlers/oauth/resume.ts
+ * (moved from VibeID-Customer-Portal src/app/api/oauth/resume/route.ts). A consuming app's route file re-exports GET
+ * and writes `export const runtime = 'nodejs'` literally.
+ *
+ * 4.7.3: `createOAuthResumeHandler({ refusalLocation })` and `DEFAULT_REFUSAL_LOCATION` are re-exported HERE because a consumer can only
+ * import what `package.json` `exports` lists, and this route module is the entry. An app whose sign-in page is not
+ * /account-auth/login (the portal uses /sign-in) writes `export const GET = createOAuthResumeHandler({ refusalLocation: '/sign-in?error=AUTHORIZE_RESUME_REFUSED' });`.
+ */
+export { GET, createOAuthResumeHandler, DEFAULT_REFUSAL_LOCATION } from '../../api-handlers/oauth/resume';
+export type { OAuthResumeOptions, OAuthResumeDeps } from '../../api-handlers/oauth/resume';