@clerk/ui 1.30.8-canary.v20260824165645 → 1.30.8

package/dist/ClerkUI.js

@@ -22,8 +22,8 @@ import { isVersionAtLeast, parseVersion } from "@clerk/shared/versionCheck";
 * @public
 */
 var ClerkUI = class ClerkUI {
-	static version = "1.30.8-canary.v20260824165645";
-	version = "1.30.8-canary.v20260824165645";
+	static version = "1.30.8";
+	version = "1.30.8";
 	#componentRenderer;
 	/**
 	* Creates a new `ClerkUI` instance and mounts the internal component renderer.

package/dist/hooks/useProtectCheckRunner.js

@@ -1,8 +1,10 @@
+import { useEnvironment } from "../contexts/EnvironmentContext.js";
 import { useCardState } from "../elements/contexts/index.js";
 import { handleError } from "../utils/errorHandler.js";
 import { ClerkRuntimeError, isClerkAPIResponseError } from "@clerk/shared/error";
 import React from "react";
 import { ERROR_CODES } from "@clerk/shared/internal/clerk-js/constants";
+import { useClerk } from "@clerk/shared/react";
 import { flushSync } from "react-dom";
 
 //#region src/hooks/useProtectCheckRunner.ts
@@ -15,8 +17,6 @@ import { flushSync } from "react-dom";
 * being decided with the clerk_go team; this cap is the defensive floor until that lands.
 */
 const MAX_EXPIRED_RELOADS = 2;
-/** Upper bound on how long we wait for the challenge SDK to settle before failing loud. */
-const PROTECT_CHECK_SCRIPT_TIMEOUT_MS = 6e4;
 /**
 * Shared driver for the `<SignInProtectCheck />` and `<SignUpProtectCheck />` cards. Both run the
 * exact same lifecycle — load + execute the Protect SDK, submit the proof token, continue the flow
@@ -27,6 +27,9 @@ const PROTECT_CHECK_SCRIPT_TIMEOUT_MS = 6e4;
 */
 function useProtectCheckRunner(params) {
 	const card = useCardState();
+	const loaderTimeoutMs = useClerk().__internal_protectChallengeLoadTimeoutMs;
+	const instanceTimeoutMs = useEnvironment().protectConfig?.challenge_load_timeout_ms;
+	const loadTimeoutMs = loaderTimeoutMs ?? instanceTimeoutMs;
 	const reportError = (err) => {
 		try {
 			handleError(err, [], card.setError);
@@ -105,18 +108,13 @@ function useProtectCheckRunner(params) {
 		isRunningRef.current = true;
 		setIsRunning(true);
 		const runChallenge = async () => {
-			let timeoutId;
 			try {
 				const { executeProtectCheck } = await import("@clerk/shared/internal/clerk-js/protectCheck");
-				const proofToken = await Promise.race([executeProtectCheck(protectCheck, container, {
+				const proofToken = await executeProtectCheck(protectCheck, container, {
 					signal: abortController.signal,
-					setWidgetVisible
-				}), new Promise((_, reject) => {
-					timeoutId = setTimeout(() => {
-						abortController.abort();
-						reject(new ClerkRuntimeError("Protect verification timed out", { code: ERROR_CODES.PROTECT_CHECK_TIMED_OUT }));
-					}, PROTECT_CHECK_SCRIPT_TIMEOUT_MS);
-				})]);
+					setWidgetVisible,
+					loadTimeoutMs
+				});
 				if (cancelled) return;
 				let updatedResource;
 				try {
@@ -137,7 +135,6 @@ function useProtectCheckRunner(params) {
 				if (cancelled) return;
 				reportError(err);
 			} finally {
-				if (timeoutId) clearTimeout(timeoutId);
 				if (!cancelled) {
 					isRunningRef.current = false;
 					setIsRunning(false);

package/dist/hooks/useProtectCheckRunner.js.map

@@ -1 +1 @@
-{"version":3,"file":"useProtectCheckRunner.js","names":[],"sources":["../../src/hooks/useProtectCheckRunner.ts"],"sourcesContent":["import { ClerkRuntimeError, isClerkAPIResponseError } from '@clerk/shared/error';\nimport { ERROR_CODES } from '@clerk/shared/internal/clerk-js/constants';\nimport type { ProtectCheckResource } from '@clerk/shared/types';\nimport React from 'react';\nimport { flushSync } from 'react-dom';\n\nimport { useCardState } from '@/ui/elements/contexts';\nimport { handleError } from '@/ui/utils/errorHandler';\n\n/**\n * A plain GET reload does not re-mint a protect_check challenge server-side, so an expired\n * challenge would otherwise reload → still expired → reload again, forever. Cap the attempts\n * and surface an error instead of spinning silently.\n *\n * NOTE: who re-mints an expired challenge on read (FAPI vs. re-running the gated step) is still\n * being decided with the clerk_go team; this cap is the defensive floor until that lands.\n */\nconst MAX_EXPIRED_RELOADS = 2;\n\n/** Upper bound on how long we wait for the challenge SDK to settle before failing loud. */\nconst PROTECT_CHECK_SCRIPT_TIMEOUT_MS = 60_000;\n\nexport interface ProtectCheckRunnerParams<TResource> {\n  /**\n   * Reads the current protect_check off the resource. Called fresh on each effect run because\n   * `fromJSON` mints a new object on every resource update — we key the effect on the token, not\n   * this reference, so an unrelated refresh doesn't restart the challenge under the user.\n   */\n  getProtectCheck: () => ProtectCheckResource | null | undefined;\n  /** Returns the live resource, used to route after a reload (which mutates it in place). */\n  getResource: () => TResource;\n  /** Reloads the underlying resource (GET) to pick up fresh server state. */\n  reload: () => Promise<unknown>;\n  /** Submits the proof token; resolves to the updated resource. */\n  submitProtectCheck: (params: { proofToken: string }) => Promise<TResource>;\n  /**\n   * Continues the flow once the gate clears (or a chained challenge / already-resolved is\n   * detected). Receives the resource to route on (the `submitProtectCheck` result, or the live\n   * resource after a reload) and must finalize (`setActive`) the `complete` case itself.\n   * `isCancelled` lets the continuation bail if the component unmounted mid-await.\n   */\n  onResolved: (resource: TResource, isCancelled: () => boolean) => Promise<unknown>;\n}\n\nexport interface ProtectCheckRunner {\n  containerRef: React.MutableRefObject<HTMLDivElement | null>;\n  isRunning: boolean;\n  /**\n   * Whether the challenge script has signalled (via the `setWidgetVisible` init callback) that\n   * it is showing a widget in the container. While true, the widget owns the progress UI —\n   * callers should hide their own spinner and give the container layout space.\n   */\n  isWidgetVisible: boolean;\n  /** Whether the card is currently showing a (recoverable) error. */\n  hasError: boolean;\n  /** Clears the error and re-runs the challenge from scratch. */\n  retry: () => void;\n}\n\n/**\n * Shared driver for the `<SignInProtectCheck />` and `<SignUpProtectCheck />` cards. Both run the\n * exact same lifecycle — load + execute the Protect SDK, submit the proof token, continue the flow\n * — so the abort/cancel/expiry/timeout/no-RHC handling lives here once instead of being duplicated\n * (and drifting) across the two components.\n *\n * Must be called from within a `CardStateProvider`.\n */\nexport function useProtectCheckRunner<TResource>(params: ProtectCheckRunnerParams<TResource>): ProtectCheckRunner {\n  const card = useCardState();\n\n  // `handleError` re-throws what it does not recognise, and this runner awaits caller code that\n  // raises plain errors (a transient fetch failure, an OAuth continuation that did not complete).\n  const reportError = (err: any) => {\n    try {\n      handleError(err, [], card.setError);\n    } catch {\n      card.setError('Unable to complete action at this time. If the problem persists please contact support.');\n    }\n  };\n\n  const containerRef = React.useRef<HTMLDivElement | null>(null);\n  const isRunningRef = React.useRef(false);\n  const reloadCountRef = React.useRef(0);\n  const [isRunning, setIsRunning] = React.useState(false);\n  const [isWidgetVisible, setIsWidgetVisibleState] = React.useState(false);\n  const [retryNonce, setRetryNonce] = React.useState(0);\n\n  // Tracks real unmount, distinct from the per-run `cancelled` flag below. Clearing `protectCheck`\n  // (e.g. an expired-challenge reload that advances the flow) flips the token dependency and\n  // re-runs/cancels the main effect — but that re-run is exactly our cue to route, so the routing\n  // must key on actual unmount, not on the effect's cancel flag.\n  const mountedRef = React.useRef(true);\n  React.useEffect(() => {\n    mountedRef.current = true;\n    return () => {\n      mountedRef.current = false;\n    };\n  }, []);\n\n  // Keep the latest callbacks without re-running the effect when the caller re-renders.\n  const paramsRef = React.useRef(params);\n  paramsRef.current = params;\n\n  const token = params.getProtectCheck()?.token;\n\n  React.useEffect(() => {\n    const { getProtectCheck, getResource, reload, submitProtectCheck, onResolved } = paramsRef.current;\n    const protectCheck = getProtectCheck();\n    if (!protectCheck || isRunningRef.current) {\n      return;\n    }\n\n    const abortController = new AbortController();\n    let cancelled = false;\n    // Routing after the gate clears must survive the effect re-run that\n    // clearing `protectCheck` triggers — that re-run is our cue to route, not a\n    // reason to bail. So the onResolved paths below key on REAL unmount, not the\n    // effect's per-run `cancelled` flag (which the re-run's cleanup sets). Same\n    // rationale the expired-reload path already relies on above.\n    const isUnmounted = () => !mountedRef.current;\n\n    const cleanup = () => {\n      cancelled = true;\n      abortController.abort();\n      // Reset the guard so the next mount / token change / retry can re-run; this is what makes\n      // chained challenges work correctly across re-renders.\n      isRunningRef.current = false;\n    };\n\n    const failWith = (code: string, message: string) => {\n      isRunningRef.current = false;\n      setIsRunning(false);\n      handleError(new ClerkRuntimeError(message, { code }), [], card.setError);\n    };\n\n    // The script owns the widget-visibility decision: it receives this callback in its init\n    // payload (as `setWidgetVisible`) and calls it right before revealing UI in the container,\n    // and again with `false` once its widget is done. flushSync so the returned promise only\n    // resolves after the change is committed to the DOM — the caller's spinner is genuinely\n    // gone when the script reveals its widget, with no frame of overlap (same guarantee\n    // BaseRouter relies on flushSync for). Scoped to THIS run: the abort contract is\n    // best-effort, so a zombie script from a timed-out, retried, or superseded run can still\n    // call it late — those signals must not flip visibility under the active run.\n    const setWidgetVisible = (visible: boolean): Promise<void> => {\n      if (cancelled || abortController.signal.aborted || !mountedRef.current) {\n        return Promise.resolve();\n      }\n      flushSync(() => setIsWidgetVisibleState(visible));\n      return Promise.resolve();\n    };\n\n    // Fail closed in no-RHC builds (chrome extension / clerk.no-rhc.js): the gate requires a\n    // remote `import(sdk_url)` we must not perform there. This guard MUST live in the component\n    // layer — `executeProtectCheck` is in `@clerk/shared`, compiled once with the flag hard-coded\n    // `false`, so a guard there would never trip.\n    if (__BUILD_DISABLE_RHC__) {\n      failWith(\n        ERROR_CODES.PROTECT_CHECK_UNSUPPORTED_ENVIRONMENT,\n        'Protect verification is not supported in this environment',\n      );\n      return;\n    }\n\n    // Expired challenge: reload once to pick up a fresh challenge if the server minted one, but\n    // cap the attempts (see MAX_EXPIRED_RELOADS) so a server that returns the same expired\n    // challenge on read can't spin us forever.\n    if (protectCheck.expiresAt !== undefined && protectCheck.expiresAt < Date.now()) {\n      if (reloadCountRef.current >= MAX_EXPIRED_RELOADS) {\n        failWith(ERROR_CODES.PROTECT_CHECK_TIMED_OUT, 'Protect verification expired');\n        return;\n      }\n      reloadCountRef.current += 1;\n      isRunningRef.current = true;\n      setIsRunning(true);\n      void (async () => {\n        try {\n          await reload();\n          if (!mountedRef.current) {\n            return;\n          }\n          const refreshed = getProtectCheck();\n          const stillExpired = !!refreshed && refreshed.expiresAt !== undefined && refreshed.expiresAt < Date.now();\n          if (stillExpired) {\n            // The server didn't re-mint on read. Don't sit on a spinner — fail loud so the user\n            // gets a retry instead of an indefinite wait.\n            failWith(ERROR_CODES.PROTECT_CHECK_TIMED_OUT, 'Protect verification expired');\n          } else if (!refreshed) {\n            // The reload cleared the gate or completed the flow. Route on the refreshed live\n            // resource so the flow continues (and a completed sign-in still gets `setActive`)\n            // instead of the route guard bouncing the user back to flow start. Keyed on mount (not\n            // `cancelled`): clearing protectCheck re-runs/cancels this effect, and that re-run is\n            // our signal to route — it must not abort the routing.\n            await onResolved(getResource(), () => !mountedRef.current);\n          }\n          // Otherwise the server re-minted a fresh, non-expired challenge whose new token\n          // re-triggers this effect (keyed on the token), which then runs it.\n        } catch (err: any) {\n          if (mountedRef.current) {\n            reportError(err);\n          }\n        } finally {\n          if (mountedRef.current) {\n            isRunningRef.current = false;\n            setIsRunning(false);\n          }\n        }\n      })();\n      return cleanup;\n    }\n\n    const container = containerRef.current;\n    if (!container) {\n      return;\n    }\n\n    // This run owns the container outright: drop anything a previous run left behind (a solved or\n    // errored widget) so the spinner covers the load phase and a re-rendering SDK can't stack a\n    // second widget under a stale one. Reset visibility in the same breath — the container is\n    // empty by construction here, and waiting on the observer callback would leave the state\n    // stale for a scheduling-dependent window (especially on the MutationObserver fallback).\n    while (container.firstChild) {\n      container.removeChild(container.firstChild);\n    }\n    setIsWidgetVisibleState(false);\n\n    isRunningRef.current = true;\n    setIsRunning(true);\n\n    const runChallenge = async () => {\n      let timeoutId: ReturnType<typeof setTimeout> | undefined;\n      try {\n        // Load the Protect SDK loader lazily, gated on the same compile-time flag as the\n        // fail-closed guard above. In no-RHC builds `__BUILD_DISABLE_RHC__` is `true`, so this\n        // branch (and the dynamic `import()` below it) is dead-code-eliminated — the loader and\n        // its remote `import(sdk_url)` are tree-shaken out of those bundles entirely rather than\n        // merely shipped-but-unused.\n        if (__BUILD_DISABLE_RHC__) {\n          return;\n        }\n        const { executeProtectCheck } = await import('@clerk/shared/internal/clerk-js/protectCheck');\n        const proofToken = await Promise.race([\n          executeProtectCheck(protectCheck, container, { signal: abortController.signal, setWidgetVisible }),\n          new Promise<never>((_, reject) => {\n            timeoutId = setTimeout(() => {\n              // Stop the (possibly hung) SDK and surface a retryable timeout error.\n              abortController.abort();\n              reject(\n                new ClerkRuntimeError('Protect verification timed out', {\n                  code: ERROR_CODES.PROTECT_CHECK_TIMED_OUT,\n                }),\n              );\n            }, PROTECT_CHECK_SCRIPT_TIMEOUT_MS);\n          }),\n        ]);\n        if (cancelled) {\n          return;\n        }\n\n        let updatedResource: TResource;\n        try {\n          updatedResource = await submitProtectCheck({ proofToken });\n        } catch (err) {\n          if (cancelled) {\n            return;\n          }\n          // `protect_check_already_resolved` is retry-safe: the server's state has already moved\n          // past this gate. Reload to clear the stale local protectCheck, then continue routing on\n          // the refreshed live resource.\n          if (isClerkAPIResponseError(err) && err.errors?.[0]?.code === ERROR_CODES.PROTECT_CHECK_ALREADY_RESOLVED) {\n            await reload();\n            if (isUnmounted()) {\n              return;\n            }\n            await onResolved(getResource(), isUnmounted);\n            return;\n          }\n          throw err;\n        }\n        if (isUnmounted()) {\n          return;\n        }\n        await onResolved(updatedResource, isUnmounted);\n      } catch (err: any) {\n        if (cancelled) {\n          return;\n        }\n        reportError(err);\n      } finally {\n        if (timeoutId) {\n          clearTimeout(timeoutId);\n        }\n        if (!cancelled) {\n          isRunningRef.current = false;\n          setIsRunning(false);\n        }\n      }\n    };\n\n    void runChallenge();\n    return cleanup;\n    // Keyed on the challenge token (a primitive) rather than the protectCheck object: an unrelated\n    // resource refresh keeps the same token and must NOT restart the challenge, while a genuine\n    // chained challenge carries a new token and re-runs. `retryNonce` re-runs on manual retry.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [token, retryNonce]);\n\n  const retry = React.useCallback(() => {\n    card.setError('');\n    reloadCountRef.current = 0;\n    isRunningRef.current = false;\n    setRetryNonce(n => n + 1);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  return { containerRef, isRunning, isWidgetVisible, hasError: !!card.error, retry };\n}\n"],"mappings":"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"}
+{"version":3,"file":"useProtectCheckRunner.js","names":[],"sources":["../../src/hooks/useProtectCheckRunner.ts"],"sourcesContent":["import { ClerkRuntimeError, isClerkAPIResponseError } from '@clerk/shared/error';\nimport { ERROR_CODES } from '@clerk/shared/internal/clerk-js/constants';\nimport { useClerk } from '@clerk/shared/react';\nimport type { ProtectCheckResource } from '@clerk/shared/types';\nimport React from 'react';\nimport { flushSync } from 'react-dom';\n\nimport { useEnvironment } from '@/ui/contexts/EnvironmentContext';\nimport { useCardState } from '@/ui/elements/contexts';\nimport { handleError } from '@/ui/utils/errorHandler';\n\n/**\n * A plain GET reload does not re-mint a protect_check challenge server-side, so an expired\n * challenge would otherwise reload → still expired → reload again, forever. Cap the attempts\n * and surface an error instead of spinning silently.\n *\n * NOTE: who re-mints an expired challenge on read (FAPI vs. re-running the gated step) is still\n * being decided with the clerk_go team; this cap is the defensive floor until that lands.\n */\nconst MAX_EXPIRED_RELOADS = 2;\n\nexport interface ProtectCheckRunnerParams<TResource> {\n  /**\n   * Reads the current protect_check off the resource. Called fresh on each effect run because\n   * `fromJSON` mints a new object on every resource update — we key the effect on the token, not\n   * this reference, so an unrelated refresh doesn't restart the challenge under the user.\n   */\n  getProtectCheck: () => ProtectCheckResource | null | undefined;\n  /** Returns the live resource, used to route after a reload (which mutates it in place). */\n  getResource: () => TResource;\n  /** Reloads the underlying resource (GET) to pick up fresh server state. */\n  reload: () => Promise<unknown>;\n  /** Submits the proof token; resolves to the updated resource. */\n  submitProtectCheck: (params: { proofToken: string }) => Promise<TResource>;\n  /**\n   * Continues the flow once the gate clears (or a chained challenge / already-resolved is\n   * detected). Receives the resource to route on (the `submitProtectCheck` result, or the live\n   * resource after a reload) and must finalize (`setActive`) the `complete` case itself.\n   * `isCancelled` lets the continuation bail if the component unmounted mid-await.\n   */\n  onResolved: (resource: TResource, isCancelled: () => boolean) => Promise<unknown>;\n}\n\nexport interface ProtectCheckRunner {\n  containerRef: React.MutableRefObject<HTMLDivElement | null>;\n  isRunning: boolean;\n  /**\n   * Whether the challenge script has signalled (via the `setWidgetVisible` init callback) that\n   * it is showing a widget in the container. While true, the widget owns the progress UI —\n   * callers should hide their own spinner and give the container layout space.\n   */\n  isWidgetVisible: boolean;\n  /** Whether the card is currently showing a (recoverable) error. */\n  hasError: boolean;\n  /** Clears the error and re-runs the challenge from scratch. */\n  retry: () => void;\n}\n\n/**\n * Shared driver for the `<SignInProtectCheck />` and `<SignUpProtectCheck />` cards. Both run the\n * exact same lifecycle — load + execute the Protect SDK, submit the proof token, continue the flow\n * — so the abort/cancel/expiry/timeout/no-RHC handling lives here once instead of being duplicated\n * (and drifting) across the two components.\n *\n * Must be called from within a `CardStateProvider`.\n */\nexport function useProtectCheckRunner<TResource>(params: ProtectCheckRunnerParams<TResource>): ProtectCheckRunner {\n  const card = useCardState();\n\n  // Override for the module-LOAD bound only (see `executeProtectCheck`), resolved loader first\n  // and instance second: a loader being rolled out gradually can carry its own value without\n  // changing anything for browsers still on the loader it replaces. Undefined at both levels\n  // leaves the SDK default in force. Read here rather than inside the effect so the effect keeps\n  // depending on primitives.\n  // Older clerk-js versions omit this getter; undefined preserves the instance/default fallback.\n  const loaderTimeoutMs = useClerk().__internal_protectChallengeLoadTimeoutMs;\n  const instanceTimeoutMs = useEnvironment().protectConfig?.challenge_load_timeout_ms;\n  const loadTimeoutMs = loaderTimeoutMs ?? instanceTimeoutMs;\n\n  // `handleError` re-throws what it does not recognise, and this runner awaits caller code that\n  // raises plain errors (a transient fetch failure, an OAuth continuation that did not complete).\n  const reportError = (err: any) => {\n    try {\n      handleError(err, [], card.setError);\n    } catch {\n      card.setError('Unable to complete action at this time. If the problem persists please contact support.');\n    }\n  };\n\n  const containerRef = React.useRef<HTMLDivElement | null>(null);\n  const isRunningRef = React.useRef(false);\n  const reloadCountRef = React.useRef(0);\n  const [isRunning, setIsRunning] = React.useState(false);\n  const [isWidgetVisible, setIsWidgetVisibleState] = React.useState(false);\n  const [retryNonce, setRetryNonce] = React.useState(0);\n\n  // Tracks real unmount, distinct from the per-run `cancelled` flag below. Clearing `protectCheck`\n  // (e.g. an expired-challenge reload that advances the flow) flips the token dependency and\n  // re-runs/cancels the main effect — but that re-run is exactly our cue to route, so the routing\n  // must key on actual unmount, not on the effect's cancel flag.\n  const mountedRef = React.useRef(true);\n  React.useEffect(() => {\n    mountedRef.current = true;\n    return () => {\n      mountedRef.current = false;\n    };\n  }, []);\n\n  // Keep the latest callbacks without re-running the effect when the caller re-renders.\n  const paramsRef = React.useRef(params);\n  paramsRef.current = params;\n\n  const token = params.getProtectCheck()?.token;\n\n  React.useEffect(() => {\n    const { getProtectCheck, getResource, reload, submitProtectCheck, onResolved } = paramsRef.current;\n    const protectCheck = getProtectCheck();\n    if (!protectCheck || isRunningRef.current) {\n      return;\n    }\n\n    const abortController = new AbortController();\n    let cancelled = false;\n    // Routing after the gate clears must survive the effect re-run that\n    // clearing `protectCheck` triggers — that re-run is our cue to route, not a\n    // reason to bail. So the onResolved paths below key on REAL unmount, not the\n    // effect's per-run `cancelled` flag (which the re-run's cleanup sets). Same\n    // rationale the expired-reload path already relies on above.\n    const isUnmounted = () => !mountedRef.current;\n\n    const cleanup = () => {\n      cancelled = true;\n      abortController.abort();\n      // Reset the guard so the next mount / token change / retry can re-run; this is what makes\n      // chained challenges work correctly across re-renders.\n      isRunningRef.current = false;\n    };\n\n    const failWith = (code: string, message: string) => {\n      isRunningRef.current = false;\n      setIsRunning(false);\n      handleError(new ClerkRuntimeError(message, { code }), [], card.setError);\n    };\n\n    // The script owns the widget-visibility decision: it receives this callback in its init\n    // payload (as `setWidgetVisible`) and calls it right before revealing UI in the container,\n    // and again with `false` once its widget is done. flushSync so the returned promise only\n    // resolves after the change is committed to the DOM — the caller's spinner is genuinely\n    // gone when the script reveals its widget, with no frame of overlap (same guarantee\n    // BaseRouter relies on flushSync for). Scoped to THIS run: the abort contract is\n    // best-effort, so a zombie script from a timed-out, retried, or superseded run can still\n    // call it late — those signals must not flip visibility under the active run.\n    const setWidgetVisible = (visible: boolean): Promise<void> => {\n      if (cancelled || abortController.signal.aborted || !mountedRef.current) {\n        return Promise.resolve();\n      }\n      flushSync(() => setIsWidgetVisibleState(visible));\n      return Promise.resolve();\n    };\n\n    // Fail closed in no-RHC builds (chrome extension / clerk.no-rhc.js): the gate requires a\n    // remote `import(sdk_url)` we must not perform there. This guard MUST live in the component\n    // layer — `executeProtectCheck` is in `@clerk/shared`, compiled once with the flag hard-coded\n    // `false`, so a guard there would never trip.\n    if (__BUILD_DISABLE_RHC__) {\n      failWith(\n        ERROR_CODES.PROTECT_CHECK_UNSUPPORTED_ENVIRONMENT,\n        'Protect verification is not supported in this environment',\n      );\n      return;\n    }\n\n    // Expired challenge: reload once to pick up a fresh challenge if the server minted one, but\n    // cap the attempts (see MAX_EXPIRED_RELOADS) so a server that returns the same expired\n    // challenge on read can't spin us forever.\n    if (protectCheck.expiresAt !== undefined && protectCheck.expiresAt < Date.now()) {\n      if (reloadCountRef.current >= MAX_EXPIRED_RELOADS) {\n        failWith(ERROR_CODES.PROTECT_CHECK_TIMED_OUT, 'Protect verification expired');\n        return;\n      }\n      reloadCountRef.current += 1;\n      isRunningRef.current = true;\n      setIsRunning(true);\n      void (async () => {\n        try {\n          await reload();\n          if (!mountedRef.current) {\n            return;\n          }\n          const refreshed = getProtectCheck();\n          const stillExpired = !!refreshed && refreshed.expiresAt !== undefined && refreshed.expiresAt < Date.now();\n          if (stillExpired) {\n            // The server didn't re-mint on read. Don't sit on a spinner — fail loud so the user\n            // gets a retry instead of an indefinite wait.\n            failWith(ERROR_CODES.PROTECT_CHECK_TIMED_OUT, 'Protect verification expired');\n          } else if (!refreshed) {\n            // The reload cleared the gate or completed the flow. Route on the refreshed live\n            // resource so the flow continues (and a completed sign-in still gets `setActive`)\n            // instead of the route guard bouncing the user back to flow start. Keyed on mount (not\n            // `cancelled`): clearing protectCheck re-runs/cancels this effect, and that re-run is\n            // our signal to route — it must not abort the routing.\n            await onResolved(getResource(), () => !mountedRef.current);\n          }\n          // Otherwise the server re-minted a fresh, non-expired challenge whose new token\n          // re-triggers this effect (keyed on the token), which then runs it.\n        } catch (err: any) {\n          if (mountedRef.current) {\n            reportError(err);\n          }\n        } finally {\n          if (mountedRef.current) {\n            isRunningRef.current = false;\n            setIsRunning(false);\n          }\n        }\n      })();\n      return cleanup;\n    }\n\n    const container = containerRef.current;\n    if (!container) {\n      return;\n    }\n\n    // This run owns the container outright: drop anything a previous run left behind (a solved or\n    // errored widget) so the spinner covers the load phase and a re-rendering SDK can't stack a\n    // second widget under a stale one. Reset visibility in the same breath — the container is\n    // empty by construction here, and waiting on the observer callback would leave the state\n    // stale for a scheduling-dependent window (especially on the MutationObserver fallback).\n    while (container.firstChild) {\n      container.removeChild(container.firstChild);\n    }\n    setIsWidgetVisibleState(false);\n\n    isRunningRef.current = true;\n    setIsRunning(true);\n\n    const runChallenge = async () => {\n      try {\n        // Load the Protect SDK loader lazily, gated on the same compile-time flag as the\n        // fail-closed guard above. In no-RHC builds `__BUILD_DISABLE_RHC__` is `true`, so this\n        // branch (and the dynamic `import()` below it) is dead-code-eliminated — the loader and\n        // its remote `import(sdk_url)` are tree-shaken out of those bundles entirely rather than\n        // merely shipped-but-unused.\n        if (__BUILD_DISABLE_RHC__) {\n          return;\n        }\n        const { executeProtectCheck } = await import('@clerk/shared/internal/clerk-js/protectCheck');\n        // Deliberately unraced. `executeProtectCheck` bounds LOADING the challenge module and\n        // nothing after it: once control passes to the challenge, the challenge owns its own\n        // deadline. We cannot know an honest duration for it — the challenge type is chosen\n        // server-side, per decision, long after this bundle shipped, and its work may be waiting\n        // on a person or moving a server-chosen number of bytes over a link we know nothing\n        // about. The wall that used to be here aborted valid challenges and reported them to the\n        // user as a timeout, and since a re-run restarts the work from the beginning, retrying\n        // could never win on any connection slow enough to trip it in the first place.\n        const proofToken = await executeProtectCheck(protectCheck, container, {\n          signal: abortController.signal,\n          setWidgetVisible,\n          loadTimeoutMs,\n        });\n        if (cancelled) {\n          return;\n        }\n\n        let updatedResource: TResource;\n        try {\n          updatedResource = await submitProtectCheck({ proofToken });\n        } catch (err) {\n          if (cancelled) {\n            return;\n          }\n          // `protect_check_already_resolved` is retry-safe: the server's state has already moved\n          // past this gate. Reload to clear the stale local protectCheck, then continue routing on\n          // the refreshed live resource.\n          if (isClerkAPIResponseError(err) && err.errors?.[0]?.code === ERROR_CODES.PROTECT_CHECK_ALREADY_RESOLVED) {\n            await reload();\n            if (isUnmounted()) {\n              return;\n            }\n            await onResolved(getResource(), isUnmounted);\n            return;\n          }\n          throw err;\n        }\n        if (isUnmounted()) {\n          return;\n        }\n        await onResolved(updatedResource, isUnmounted);\n      } catch (err: any) {\n        if (cancelled) {\n          return;\n        }\n        reportError(err);\n      } finally {\n        if (!cancelled) {\n          isRunningRef.current = false;\n          setIsRunning(false);\n        }\n      }\n    };\n\n    void runChallenge();\n    return cleanup;\n    // Keyed on the challenge token (a primitive) rather than the protectCheck object: an unrelated\n    // resource refresh keeps the same token and must NOT restart the challenge, while a genuine\n    // chained challenge carries a new token and re-runs. `retryNonce` re-runs on manual retry.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [token, retryNonce]);\n\n  const retry = React.useCallback(() => {\n    card.setError('');\n    reloadCountRef.current = 0;\n    isRunningRef.current = false;\n    setRetryNonce(n => n + 1);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  return { containerRef, isRunning, isWidgetVisible, hasError: !!card.error, retry };\n}\n"],"mappings":"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"}

package/dist/index.js

@@ -17,7 +17,7 @@ import { ClerkUI } from "./ClerkUI.js";
 */
 const ui = {
 	__brand: UI_BRAND,
-	version: "1.30.8-canary.v20260824165645",
+	version: "1.30.8",
 	ClerkUI
 };
 

package/dist/no-rhc/ClerkUI.js

@@ -22,8 +22,8 @@ import { isVersionAtLeast, parseVersion } from "@clerk/shared/versionCheck";
 * @public
 */
 var ClerkUI = class ClerkUI {
-	static version = "1.30.8-canary.v20260824165645";
-	version = "1.30.8-canary.v20260824165645";
+	static version = "1.30.8";
+	version = "1.30.8";
 	#componentRenderer;
 	/**
 	* Creates a new `ClerkUI` instance and mounts the internal component renderer.

package/dist/no-rhc/hooks/useProtectCheckRunner.js

@@ -1,8 +1,10 @@
+import { useEnvironment } from "../contexts/EnvironmentContext.js";
 import { useCardState } from "../elements/contexts/index.js";
 import { handleError } from "../utils/errorHandler.js";
 import { ClerkRuntimeError, isClerkAPIResponseError } from "@clerk/shared/error";
 import React from "react";
 import { ERROR_CODES } from "@clerk/shared/internal/clerk-js/constants";
+import { useClerk } from "@clerk/shared/react";
 import { flushSync } from "react-dom";
 
 //#region src/hooks/useProtectCheckRunner.ts
@@ -16,6 +18,8 @@ import { flushSync } from "react-dom";
 */
 function useProtectCheckRunner(params) {
 	const card = useCardState();
+	useClerk().__internal_protectChallengeLoadTimeoutMs;
+	useEnvironment().protectConfig?.challenge_load_timeout_ms;
 	const containerRef = React.useRef(null);
 	const isRunningRef = React.useRef(false);
 	const reloadCountRef = React.useRef(0);

package/dist/no-rhc/hooks/useProtectCheckRunner.js.map

@@ -1 +1 @@
-{"version":3,"file":"useProtectCheckRunner.js","names":[],"sources":["../../../src/hooks/useProtectCheckRunner.ts"],"sourcesContent":["import { ClerkRuntimeError, isClerkAPIResponseError } from '@clerk/shared/error';\nimport { ERROR_CODES } from '@clerk/shared/internal/clerk-js/constants';\nimport type { ProtectCheckResource } from '@clerk/shared/types';\nimport React from 'react';\nimport { flushSync } from 'react-dom';\n\nimport { useCardState } from '@/ui/elements/contexts';\nimport { handleError } from '@/ui/utils/errorHandler';\n\n/**\n * A plain GET reload does not re-mint a protect_check challenge server-side, so an expired\n * challenge would otherwise reload → still expired → reload again, forever. Cap the attempts\n * and surface an error instead of spinning silently.\n *\n * NOTE: who re-mints an expired challenge on read (FAPI vs. re-running the gated step) is still\n * being decided with the clerk_go team; this cap is the defensive floor until that lands.\n */\nconst MAX_EXPIRED_RELOADS = 2;\n\n/** Upper bound on how long we wait for the challenge SDK to settle before failing loud. */\nconst PROTECT_CHECK_SCRIPT_TIMEOUT_MS = 60_000;\n\nexport interface ProtectCheckRunnerParams<TResource> {\n  /**\n   * Reads the current protect_check off the resource. Called fresh on each effect run because\n   * `fromJSON` mints a new object on every resource update — we key the effect on the token, not\n   * this reference, so an unrelated refresh doesn't restart the challenge under the user.\n   */\n  getProtectCheck: () => ProtectCheckResource | null | undefined;\n  /** Returns the live resource, used to route after a reload (which mutates it in place). */\n  getResource: () => TResource;\n  /** Reloads the underlying resource (GET) to pick up fresh server state. */\n  reload: () => Promise<unknown>;\n  /** Submits the proof token; resolves to the updated resource. */\n  submitProtectCheck: (params: { proofToken: string }) => Promise<TResource>;\n  /**\n   * Continues the flow once the gate clears (or a chained challenge / already-resolved is\n   * detected). Receives the resource to route on (the `submitProtectCheck` result, or the live\n   * resource after a reload) and must finalize (`setActive`) the `complete` case itself.\n   * `isCancelled` lets the continuation bail if the component unmounted mid-await.\n   */\n  onResolved: (resource: TResource, isCancelled: () => boolean) => Promise<unknown>;\n}\n\nexport interface ProtectCheckRunner {\n  containerRef: React.MutableRefObject<HTMLDivElement | null>;\n  isRunning: boolean;\n  /**\n   * Whether the challenge script has signalled (via the `setWidgetVisible` init callback) that\n   * it is showing a widget in the container. While true, the widget owns the progress UI —\n   * callers should hide their own spinner and give the container layout space.\n   */\n  isWidgetVisible: boolean;\n  /** Whether the card is currently showing a (recoverable) error. */\n  hasError: boolean;\n  /** Clears the error and re-runs the challenge from scratch. */\n  retry: () => void;\n}\n\n/**\n * Shared driver for the `<SignInProtectCheck />` and `<SignUpProtectCheck />` cards. Both run the\n * exact same lifecycle — load + execute the Protect SDK, submit the proof token, continue the flow\n * — so the abort/cancel/expiry/timeout/no-RHC handling lives here once instead of being duplicated\n * (and drifting) across the two components.\n *\n * Must be called from within a `CardStateProvider`.\n */\nexport function useProtectCheckRunner<TResource>(params: ProtectCheckRunnerParams<TResource>): ProtectCheckRunner {\n  const card = useCardState();\n\n  // `handleError` re-throws what it does not recognise, and this runner awaits caller code that\n  // raises plain errors (a transient fetch failure, an OAuth continuation that did not complete).\n  const reportError = (err: any) => {\n    try {\n      handleError(err, [], card.setError);\n    } catch {\n      card.setError('Unable to complete action at this time. If the problem persists please contact support.');\n    }\n  };\n\n  const containerRef = React.useRef<HTMLDivElement | null>(null);\n  const isRunningRef = React.useRef(false);\n  const reloadCountRef = React.useRef(0);\n  const [isRunning, setIsRunning] = React.useState(false);\n  const [isWidgetVisible, setIsWidgetVisibleState] = React.useState(false);\n  const [retryNonce, setRetryNonce] = React.useState(0);\n\n  // Tracks real unmount, distinct from the per-run `cancelled` flag below. Clearing `protectCheck`\n  // (e.g. an expired-challenge reload that advances the flow) flips the token dependency and\n  // re-runs/cancels the main effect — but that re-run is exactly our cue to route, so the routing\n  // must key on actual unmount, not on the effect's cancel flag.\n  const mountedRef = React.useRef(true);\n  React.useEffect(() => {\n    mountedRef.current = true;\n    return () => {\n      mountedRef.current = false;\n    };\n  }, []);\n\n  // Keep the latest callbacks without re-running the effect when the caller re-renders.\n  const paramsRef = React.useRef(params);\n  paramsRef.current = params;\n\n  const token = params.getProtectCheck()?.token;\n\n  React.useEffect(() => {\n    const { getProtectCheck, getResource, reload, submitProtectCheck, onResolved } = paramsRef.current;\n    const protectCheck = getProtectCheck();\n    if (!protectCheck || isRunningRef.current) {\n      return;\n    }\n\n    const abortController = new AbortController();\n    let cancelled = false;\n    // Routing after the gate clears must survive the effect re-run that\n    // clearing `protectCheck` triggers — that re-run is our cue to route, not a\n    // reason to bail. So the onResolved paths below key on REAL unmount, not the\n    // effect's per-run `cancelled` flag (which the re-run's cleanup sets). Same\n    // rationale the expired-reload path already relies on above.\n    const isUnmounted = () => !mountedRef.current;\n\n    const cleanup = () => {\n      cancelled = true;\n      abortController.abort();\n      // Reset the guard so the next mount / token change / retry can re-run; this is what makes\n      // chained challenges work correctly across re-renders.\n      isRunningRef.current = false;\n    };\n\n    const failWith = (code: string, message: string) => {\n      isRunningRef.current = false;\n      setIsRunning(false);\n      handleError(new ClerkRuntimeError(message, { code }), [], card.setError);\n    };\n\n    // The script owns the widget-visibility decision: it receives this callback in its init\n    // payload (as `setWidgetVisible`) and calls it right before revealing UI in the container,\n    // and again with `false` once its widget is done. flushSync so the returned promise only\n    // resolves after the change is committed to the DOM — the caller's spinner is genuinely\n    // gone when the script reveals its widget, with no frame of overlap (same guarantee\n    // BaseRouter relies on flushSync for). Scoped to THIS run: the abort contract is\n    // best-effort, so a zombie script from a timed-out, retried, or superseded run can still\n    // call it late — those signals must not flip visibility under the active run.\n    const setWidgetVisible = (visible: boolean): Promise<void> => {\n      if (cancelled || abortController.signal.aborted || !mountedRef.current) {\n        return Promise.resolve();\n      }\n      flushSync(() => setIsWidgetVisibleState(visible));\n      return Promise.resolve();\n    };\n\n    // Fail closed in no-RHC builds (chrome extension / clerk.no-rhc.js): the gate requires a\n    // remote `import(sdk_url)` we must not perform there. This guard MUST live in the component\n    // layer — `executeProtectCheck` is in `@clerk/shared`, compiled once with the flag hard-coded\n    // `false`, so a guard there would never trip.\n    if (__BUILD_DISABLE_RHC__) {\n      failWith(\n        ERROR_CODES.PROTECT_CHECK_UNSUPPORTED_ENVIRONMENT,\n        'Protect verification is not supported in this environment',\n      );\n      return;\n    }\n\n    // Expired challenge: reload once to pick up a fresh challenge if the server minted one, but\n    // cap the attempts (see MAX_EXPIRED_RELOADS) so a server that returns the same expired\n    // challenge on read can't spin us forever.\n    if (protectCheck.expiresAt !== undefined && protectCheck.expiresAt < Date.now()) {\n      if (reloadCountRef.current >= MAX_EXPIRED_RELOADS) {\n        failWith(ERROR_CODES.PROTECT_CHECK_TIMED_OUT, 'Protect verification expired');\n        return;\n      }\n      reloadCountRef.current += 1;\n      isRunningRef.current = true;\n      setIsRunning(true);\n      void (async () => {\n        try {\n          await reload();\n          if (!mountedRef.current) {\n            return;\n          }\n          const refreshed = getProtectCheck();\n          const stillExpired = !!refreshed && refreshed.expiresAt !== undefined && refreshed.expiresAt < Date.now();\n          if (stillExpired) {\n            // The server didn't re-mint on read. Don't sit on a spinner — fail loud so the user\n            // gets a retry instead of an indefinite wait.\n            failWith(ERROR_CODES.PROTECT_CHECK_TIMED_OUT, 'Protect verification expired');\n          } else if (!refreshed) {\n            // The reload cleared the gate or completed the flow. Route on the refreshed live\n            // resource so the flow continues (and a completed sign-in still gets `setActive`)\n            // instead of the route guard bouncing the user back to flow start. Keyed on mount (not\n            // `cancelled`): clearing protectCheck re-runs/cancels this effect, and that re-run is\n            // our signal to route — it must not abort the routing.\n            await onResolved(getResource(), () => !mountedRef.current);\n          }\n          // Otherwise the server re-minted a fresh, non-expired challenge whose new token\n          // re-triggers this effect (keyed on the token), which then runs it.\n        } catch (err: any) {\n          if (mountedRef.current) {\n            reportError(err);\n          }\n        } finally {\n          if (mountedRef.current) {\n            isRunningRef.current = false;\n            setIsRunning(false);\n          }\n        }\n      })();\n      return cleanup;\n    }\n\n    const container = containerRef.current;\n    if (!container) {\n      return;\n    }\n\n    // This run owns the container outright: drop anything a previous run left behind (a solved or\n    // errored widget) so the spinner covers the load phase and a re-rendering SDK can't stack a\n    // second widget under a stale one. Reset visibility in the same breath — the container is\n    // empty by construction here, and waiting on the observer callback would leave the state\n    // stale for a scheduling-dependent window (especially on the MutationObserver fallback).\n    while (container.firstChild) {\n      container.removeChild(container.firstChild);\n    }\n    setIsWidgetVisibleState(false);\n\n    isRunningRef.current = true;\n    setIsRunning(true);\n\n    const runChallenge = async () => {\n      let timeoutId: ReturnType<typeof setTimeout> | undefined;\n      try {\n        // Load the Protect SDK loader lazily, gated on the same compile-time flag as the\n        // fail-closed guard above. In no-RHC builds `__BUILD_DISABLE_RHC__` is `true`, so this\n        // branch (and the dynamic `import()` below it) is dead-code-eliminated — the loader and\n        // its remote `import(sdk_url)` are tree-shaken out of those bundles entirely rather than\n        // merely shipped-but-unused.\n        if (__BUILD_DISABLE_RHC__) {\n          return;\n        }\n        const { executeProtectCheck } = await import('@clerk/shared/internal/clerk-js/protectCheck');\n        const proofToken = await Promise.race([\n          executeProtectCheck(protectCheck, container, { signal: abortController.signal, setWidgetVisible }),\n          new Promise<never>((_, reject) => {\n            timeoutId = setTimeout(() => {\n              // Stop the (possibly hung) SDK and surface a retryable timeout error.\n              abortController.abort();\n              reject(\n                new ClerkRuntimeError('Protect verification timed out', {\n                  code: ERROR_CODES.PROTECT_CHECK_TIMED_OUT,\n                }),\n              );\n            }, PROTECT_CHECK_SCRIPT_TIMEOUT_MS);\n          }),\n        ]);\n        if (cancelled) {\n          return;\n        }\n\n        let updatedResource: TResource;\n        try {\n          updatedResource = await submitProtectCheck({ proofToken });\n        } catch (err) {\n          if (cancelled) {\n            return;\n          }\n          // `protect_check_already_resolved` is retry-safe: the server's state has already moved\n          // past this gate. Reload to clear the stale local protectCheck, then continue routing on\n          // the refreshed live resource.\n          if (isClerkAPIResponseError(err) && err.errors?.[0]?.code === ERROR_CODES.PROTECT_CHECK_ALREADY_RESOLVED) {\n            await reload();\n            if (isUnmounted()) {\n              return;\n            }\n            await onResolved(getResource(), isUnmounted);\n            return;\n          }\n          throw err;\n        }\n        if (isUnmounted()) {\n          return;\n        }\n        await onResolved(updatedResource, isUnmounted);\n      } catch (err: any) {\n        if (cancelled) {\n          return;\n        }\n        reportError(err);\n      } finally {\n        if (timeoutId) {\n          clearTimeout(timeoutId);\n        }\n        if (!cancelled) {\n          isRunningRef.current = false;\n          setIsRunning(false);\n        }\n      }\n    };\n\n    void runChallenge();\n    return cleanup;\n    // Keyed on the challenge token (a primitive) rather than the protectCheck object: an unrelated\n    // resource refresh keeps the same token and must NOT restart the challenge, while a genuine\n    // chained challenge carries a new token and re-runs. `retryNonce` re-runs on manual retry.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [token, retryNonce]);\n\n  const retry = React.useCallback(() => {\n    card.setError('');\n    reloadCountRef.current = 0;\n    isRunningRef.current = false;\n    setRetryNonce(n => n + 1);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  return { containerRef, isRunning, isWidgetVisible, hasError: !!card.error, retry };\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAmEA,SAAgB,sBAAiC,QAAiE;CAChH,MAAM,OAAO,aAAa;CAY1B,MAAM,eAAe,MAAM,OAA8B,IAAI;CAC7D,MAAM,eAAe,MAAM,OAAO,KAAK;CACvC,MAAM,iBAAiB,MAAM,OAAO,CAAC;CACrC,MAAM,CAAC,WAAW,gBAAgB,MAAM,SAAS,KAAK;CACtD,MAAM,CAAC,iBAAiB,2BAA2B,MAAM,SAAS,KAAK;CACvE,MAAM,CAAC,YAAY,iBAAiB,MAAM,SAAS,CAAC;CAMpD,MAAM,aAAa,MAAM,OAAO,IAAI;CACpC,MAAM,gBAAgB;EACpB,WAAW,UAAU;EACrB,aAAa;GACX,WAAW,UAAU;EACvB;CACF,GAAG,CAAC,CAAC;CAGL,MAAM,YAAY,MAAM,OAAO,MAAM;CACrC,UAAU,UAAU;CAEpB,MAAM,QAAQ,OAAO,gBAAgB,CAAC,EAAE;CAExC,MAAM,gBAAgB;EACpB,MAAM,EAAE,iBAAiB,aAAa,QAAQ,oBAAoB,eAAe,UAAU;EAE3F,IAAI,CADiB,gBACL,KAAK,aAAa,SAChC;EAGsB,IAAI,gBAAgB;EAiB5C,MAAM,YAAY,MAAc,YAAoB;GAClD,aAAa,UAAU;GACvB,aAAa,KAAK;GAClB,YAAY,IAAI,kBAAkB,SAAS,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,QAAQ;EACzE;EAuBE,SACE,YAAY,uCACZ,2DACF;CAiJJ,GAAG,CAAC,OAAO,UAAU,CAAC;CAEtB,MAAM,QAAQ,MAAM,kBAAkB;EACpC,KAAK,SAAS,EAAE;EAChB,eAAe,UAAU;EACzB,aAAa,UAAU;EACvB,eAAc,MAAK,IAAI,CAAC;CAE1B,GAAG,CAAC,CAAC;CAEL,OAAO;EAAE;EAAc;EAAW;EAAiB,UAAU,CAAC,CAAC,KAAK;EAAO;CAAM;AACnF"}
+{"version":3,"file":"useProtectCheckRunner.js","names":[],"sources":["../../../src/hooks/useProtectCheckRunner.ts"],"sourcesContent":["import { ClerkRuntimeError, isClerkAPIResponseError } from '@clerk/shared/error';\nimport { ERROR_CODES } from '@clerk/shared/internal/clerk-js/constants';\nimport { useClerk } from '@clerk/shared/react';\nimport type { ProtectCheckResource } from '@clerk/shared/types';\nimport React from 'react';\nimport { flushSync } from 'react-dom';\n\nimport { useEnvironment } from '@/ui/contexts/EnvironmentContext';\nimport { useCardState } from '@/ui/elements/contexts';\nimport { handleError } from '@/ui/utils/errorHandler';\n\n/**\n * A plain GET reload does not re-mint a protect_check challenge server-side, so an expired\n * challenge would otherwise reload → still expired → reload again, forever. Cap the attempts\n * and surface an error instead of spinning silently.\n *\n * NOTE: who re-mints an expired challenge on read (FAPI vs. re-running the gated step) is still\n * being decided with the clerk_go team; this cap is the defensive floor until that lands.\n */\nconst MAX_EXPIRED_RELOADS = 2;\n\nexport interface ProtectCheckRunnerParams<TResource> {\n  /**\n   * Reads the current protect_check off the resource. Called fresh on each effect run because\n   * `fromJSON` mints a new object on every resource update — we key the effect on the token, not\n   * this reference, so an unrelated refresh doesn't restart the challenge under the user.\n   */\n  getProtectCheck: () => ProtectCheckResource | null | undefined;\n  /** Returns the live resource, used to route after a reload (which mutates it in place). */\n  getResource: () => TResource;\n  /** Reloads the underlying resource (GET) to pick up fresh server state. */\n  reload: () => Promise<unknown>;\n  /** Submits the proof token; resolves to the updated resource. */\n  submitProtectCheck: (params: { proofToken: string }) => Promise<TResource>;\n  /**\n   * Continues the flow once the gate clears (or a chained challenge / already-resolved is\n   * detected). Receives the resource to route on (the `submitProtectCheck` result, or the live\n   * resource after a reload) and must finalize (`setActive`) the `complete` case itself.\n   * `isCancelled` lets the continuation bail if the component unmounted mid-await.\n   */\n  onResolved: (resource: TResource, isCancelled: () => boolean) => Promise<unknown>;\n}\n\nexport interface ProtectCheckRunner {\n  containerRef: React.MutableRefObject<HTMLDivElement | null>;\n  isRunning: boolean;\n  /**\n   * Whether the challenge script has signalled (via the `setWidgetVisible` init callback) that\n   * it is showing a widget in the container. While true, the widget owns the progress UI —\n   * callers should hide their own spinner and give the container layout space.\n   */\n  isWidgetVisible: boolean;\n  /** Whether the card is currently showing a (recoverable) error. */\n  hasError: boolean;\n  /** Clears the error and re-runs the challenge from scratch. */\n  retry: () => void;\n}\n\n/**\n * Shared driver for the `<SignInProtectCheck />` and `<SignUpProtectCheck />` cards. Both run the\n * exact same lifecycle — load + execute the Protect SDK, submit the proof token, continue the flow\n * — so the abort/cancel/expiry/timeout/no-RHC handling lives here once instead of being duplicated\n * (and drifting) across the two components.\n *\n * Must be called from within a `CardStateProvider`.\n */\nexport function useProtectCheckRunner<TResource>(params: ProtectCheckRunnerParams<TResource>): ProtectCheckRunner {\n  const card = useCardState();\n\n  // Override for the module-LOAD bound only (see `executeProtectCheck`), resolved loader first\n  // and instance second: a loader being rolled out gradually can carry its own value without\n  // changing anything for browsers still on the loader it replaces. Undefined at both levels\n  // leaves the SDK default in force. Read here rather than inside the effect so the effect keeps\n  // depending on primitives.\n  // Older clerk-js versions omit this getter; undefined preserves the instance/default fallback.\n  const loaderTimeoutMs = useClerk().__internal_protectChallengeLoadTimeoutMs;\n  const instanceTimeoutMs = useEnvironment().protectConfig?.challenge_load_timeout_ms;\n  const loadTimeoutMs = loaderTimeoutMs ?? instanceTimeoutMs;\n\n  // `handleError` re-throws what it does not recognise, and this runner awaits caller code that\n  // raises plain errors (a transient fetch failure, an OAuth continuation that did not complete).\n  const reportError = (err: any) => {\n    try {\n      handleError(err, [], card.setError);\n    } catch {\n      card.setError('Unable to complete action at this time. If the problem persists please contact support.');\n    }\n  };\n\n  const containerRef = React.useRef<HTMLDivElement | null>(null);\n  const isRunningRef = React.useRef(false);\n  const reloadCountRef = React.useRef(0);\n  const [isRunning, setIsRunning] = React.useState(false);\n  const [isWidgetVisible, setIsWidgetVisibleState] = React.useState(false);\n  const [retryNonce, setRetryNonce] = React.useState(0);\n\n  // Tracks real unmount, distinct from the per-run `cancelled` flag below. Clearing `protectCheck`\n  // (e.g. an expired-challenge reload that advances the flow) flips the token dependency and\n  // re-runs/cancels the main effect — but that re-run is exactly our cue to route, so the routing\n  // must key on actual unmount, not on the effect's cancel flag.\n  const mountedRef = React.useRef(true);\n  React.useEffect(() => {\n    mountedRef.current = true;\n    return () => {\n      mountedRef.current = false;\n    };\n  }, []);\n\n  // Keep the latest callbacks without re-running the effect when the caller re-renders.\n  const paramsRef = React.useRef(params);\n  paramsRef.current = params;\n\n  const token = params.getProtectCheck()?.token;\n\n  React.useEffect(() => {\n    const { getProtectCheck, getResource, reload, submitProtectCheck, onResolved } = paramsRef.current;\n    const protectCheck = getProtectCheck();\n    if (!protectCheck || isRunningRef.current) {\n      return;\n    }\n\n    const abortController = new AbortController();\n    let cancelled = false;\n    // Routing after the gate clears must survive the effect re-run that\n    // clearing `protectCheck` triggers — that re-run is our cue to route, not a\n    // reason to bail. So the onResolved paths below key on REAL unmount, not the\n    // effect's per-run `cancelled` flag (which the re-run's cleanup sets). Same\n    // rationale the expired-reload path already relies on above.\n    const isUnmounted = () => !mountedRef.current;\n\n    const cleanup = () => {\n      cancelled = true;\n      abortController.abort();\n      // Reset the guard so the next mount / token change / retry can re-run; this is what makes\n      // chained challenges work correctly across re-renders.\n      isRunningRef.current = false;\n    };\n\n    const failWith = (code: string, message: string) => {\n      isRunningRef.current = false;\n      setIsRunning(false);\n      handleError(new ClerkRuntimeError(message, { code }), [], card.setError);\n    };\n\n    // The script owns the widget-visibility decision: it receives this callback in its init\n    // payload (as `setWidgetVisible`) and calls it right before revealing UI in the container,\n    // and again with `false` once its widget is done. flushSync so the returned promise only\n    // resolves after the change is committed to the DOM — the caller's spinner is genuinely\n    // gone when the script reveals its widget, with no frame of overlap (same guarantee\n    // BaseRouter relies on flushSync for). Scoped to THIS run: the abort contract is\n    // best-effort, so a zombie script from a timed-out, retried, or superseded run can still\n    // call it late — those signals must not flip visibility under the active run.\n    const setWidgetVisible = (visible: boolean): Promise<void> => {\n      if (cancelled || abortController.signal.aborted || !mountedRef.current) {\n        return Promise.resolve();\n      }\n      flushSync(() => setIsWidgetVisibleState(visible));\n      return Promise.resolve();\n    };\n\n    // Fail closed in no-RHC builds (chrome extension / clerk.no-rhc.js): the gate requires a\n    // remote `import(sdk_url)` we must not perform there. This guard MUST live in the component\n    // layer — `executeProtectCheck` is in `@clerk/shared`, compiled once with the flag hard-coded\n    // `false`, so a guard there would never trip.\n    if (__BUILD_DISABLE_RHC__) {\n      failWith(\n        ERROR_CODES.PROTECT_CHECK_UNSUPPORTED_ENVIRONMENT,\n        'Protect verification is not supported in this environment',\n      );\n      return;\n    }\n\n    // Expired challenge: reload once to pick up a fresh challenge if the server minted one, but\n    // cap the attempts (see MAX_EXPIRED_RELOADS) so a server that returns the same expired\n    // challenge on read can't spin us forever.\n    if (protectCheck.expiresAt !== undefined && protectCheck.expiresAt < Date.now()) {\n      if (reloadCountRef.current >= MAX_EXPIRED_RELOADS) {\n        failWith(ERROR_CODES.PROTECT_CHECK_TIMED_OUT, 'Protect verification expired');\n        return;\n      }\n      reloadCountRef.current += 1;\n      isRunningRef.current = true;\n      setIsRunning(true);\n      void (async () => {\n        try {\n          await reload();\n          if (!mountedRef.current) {\n            return;\n          }\n          const refreshed = getProtectCheck();\n          const stillExpired = !!refreshed && refreshed.expiresAt !== undefined && refreshed.expiresAt < Date.now();\n          if (stillExpired) {\n            // The server didn't re-mint on read. Don't sit on a spinner — fail loud so the user\n            // gets a retry instead of an indefinite wait.\n            failWith(ERROR_CODES.PROTECT_CHECK_TIMED_OUT, 'Protect verification expired');\n          } else if (!refreshed) {\n            // The reload cleared the gate or completed the flow. Route on the refreshed live\n            // resource so the flow continues (and a completed sign-in still gets `setActive`)\n            // instead of the route guard bouncing the user back to flow start. Keyed on mount (not\n            // `cancelled`): clearing protectCheck re-runs/cancels this effect, and that re-run is\n            // our signal to route — it must not abort the routing.\n            await onResolved(getResource(), () => !mountedRef.current);\n          }\n          // Otherwise the server re-minted a fresh, non-expired challenge whose new token\n          // re-triggers this effect (keyed on the token), which then runs it.\n        } catch (err: any) {\n          if (mountedRef.current) {\n            reportError(err);\n          }\n        } finally {\n          if (mountedRef.current) {\n            isRunningRef.current = false;\n            setIsRunning(false);\n          }\n        }\n      })();\n      return cleanup;\n    }\n\n    const container = containerRef.current;\n    if (!container) {\n      return;\n    }\n\n    // This run owns the container outright: drop anything a previous run left behind (a solved or\n    // errored widget) so the spinner covers the load phase and a re-rendering SDK can't stack a\n    // second widget under a stale one. Reset visibility in the same breath — the container is\n    // empty by construction here, and waiting on the observer callback would leave the state\n    // stale for a scheduling-dependent window (especially on the MutationObserver fallback).\n    while (container.firstChild) {\n      container.removeChild(container.firstChild);\n    }\n    setIsWidgetVisibleState(false);\n\n    isRunningRef.current = true;\n    setIsRunning(true);\n\n    const runChallenge = async () => {\n      try {\n        // Load the Protect SDK loader lazily, gated on the same compile-time flag as the\n        // fail-closed guard above. In no-RHC builds `__BUILD_DISABLE_RHC__` is `true`, so this\n        // branch (and the dynamic `import()` below it) is dead-code-eliminated — the loader and\n        // its remote `import(sdk_url)` are tree-shaken out of those bundles entirely rather than\n        // merely shipped-but-unused.\n        if (__BUILD_DISABLE_RHC__) {\n          return;\n        }\n        const { executeProtectCheck } = await import('@clerk/shared/internal/clerk-js/protectCheck');\n        // Deliberately unraced. `executeProtectCheck` bounds LOADING the challenge module and\n        // nothing after it: once control passes to the challenge, the challenge owns its own\n        // deadline. We cannot know an honest duration for it — the challenge type is chosen\n        // server-side, per decision, long after this bundle shipped, and its work may be waiting\n        // on a person or moving a server-chosen number of bytes over a link we know nothing\n        // about. The wall that used to be here aborted valid challenges and reported them to the\n        // user as a timeout, and since a re-run restarts the work from the beginning, retrying\n        // could never win on any connection slow enough to trip it in the first place.\n        const proofToken = await executeProtectCheck(protectCheck, container, {\n          signal: abortController.signal,\n          setWidgetVisible,\n          loadTimeoutMs,\n        });\n        if (cancelled) {\n          return;\n        }\n\n        let updatedResource: TResource;\n        try {\n          updatedResource = await submitProtectCheck({ proofToken });\n        } catch (err) {\n          if (cancelled) {\n            return;\n          }\n          // `protect_check_already_resolved` is retry-safe: the server's state has already moved\n          // past this gate. Reload to clear the stale local protectCheck, then continue routing on\n          // the refreshed live resource.\n          if (isClerkAPIResponseError(err) && err.errors?.[0]?.code === ERROR_CODES.PROTECT_CHECK_ALREADY_RESOLVED) {\n            await reload();\n            if (isUnmounted()) {\n              return;\n            }\n            await onResolved(getResource(), isUnmounted);\n            return;\n          }\n          throw err;\n        }\n        if (isUnmounted()) {\n          return;\n        }\n        await onResolved(updatedResource, isUnmounted);\n      } catch (err: any) {\n        if (cancelled) {\n          return;\n        }\n        reportError(err);\n      } finally {\n        if (!cancelled) {\n          isRunningRef.current = false;\n          setIsRunning(false);\n        }\n      }\n    };\n\n    void runChallenge();\n    return cleanup;\n    // Keyed on the challenge token (a primitive) rather than the protectCheck object: an unrelated\n    // resource refresh keeps the same token and must NOT restart the challenge, while a genuine\n    // chained challenge carries a new token and re-runs. `retryNonce` re-runs on manual retry.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [token, retryNonce]);\n\n  const retry = React.useCallback(() => {\n    card.setError('');\n    reloadCountRef.current = 0;\n    isRunningRef.current = false;\n    setRetryNonce(n => n + 1);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  return { containerRef, isRunning, isWidgetVisible, hasError: !!card.error, retry };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkEA,SAAgB,sBAAiC,QAAiE;CAChH,MAAM,OAAO,aAAa;CAQF,SAAS,CAAC,CAAC;CACT,eAAe,CAAC,CAAC,eAAe;CAa1D,MAAM,eAAe,MAAM,OAA8B,IAAI;CAC7D,MAAM,eAAe,MAAM,OAAO,KAAK;CACvC,MAAM,iBAAiB,MAAM,OAAO,CAAC;CACrC,MAAM,CAAC,WAAW,gBAAgB,MAAM,SAAS,KAAK;CACtD,MAAM,CAAC,iBAAiB,2BAA2B,MAAM,SAAS,KAAK;CACvE,MAAM,CAAC,YAAY,iBAAiB,MAAM,SAAS,CAAC;CAMpD,MAAM,aAAa,MAAM,OAAO,IAAI;CACpC,MAAM,gBAAgB;EACpB,WAAW,UAAU;EACrB,aAAa;GACX,WAAW,UAAU;EACvB;CACF,GAAG,CAAC,CAAC;CAGL,MAAM,YAAY,MAAM,OAAO,MAAM;CACrC,UAAU,UAAU;CAEpB,MAAM,QAAQ,OAAO,gBAAgB,CAAC,EAAE;CAExC,MAAM,gBAAgB;EACpB,MAAM,EAAE,iBAAiB,aAAa,QAAQ,oBAAoB,eAAe,UAAU;EAE3F,IAAI,CADiB,gBACL,KAAK,aAAa,SAChC;EAGsB,IAAI,gBAAgB;EAiB5C,MAAM,YAAY,MAAc,YAAoB;GAClD,aAAa,UAAU;GACvB,aAAa,KAAK;GAClB,YAAY,IAAI,kBAAkB,SAAS,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,QAAQ;EACzE;EAuBE,SACE,YAAY,uCACZ,2DACF;CA4IJ,GAAG,CAAC,OAAO,UAAU,CAAC;CAEtB,MAAM,QAAQ,MAAM,kBAAkB;EACpC,KAAK,SAAS,EAAE;EAChB,eAAe,UAAU;EACzB,aAAa,UAAU;EACvB,eAAc,MAAK,IAAI,CAAC;CAE1B,GAAG,CAAC,CAAC;CAEL,OAAO;EAAE;EAAc;EAAW;EAAiB,UAAU,CAAC,CAAC,KAAK;EAAO;CAAM;AACnF"}

package/dist/no-rhc/index.js

@@ -17,7 +17,7 @@ import { ClerkUI } from "./ClerkUI.js";
 */
 const ui = {
 	__brand: UI_BRAND,
-	version: "1.30.8-canary.v20260824165645",
+	version: "1.30.8",
 	ClerkUI
 };
 

package/dist/server.js

@@ -22,7 +22,7 @@ import { ClerkUI } from "./ClerkUI.js";
 */
 const ui = {
 	__brand: UI_BRAND,
-	version: "1.30.8-canary.v20260824165645",
+	version: "1.30.8",
 	ClerkUI
 };