Add oxlint rule: no-thrown-unawaited-redirect

Adds a custom oxlint JS plugin (trigger/no-thrown-unawaited-redirect) that
flags `throw <asyncRedirectHelper>(...)` on ThrowStatement. These helpers
return a Promise, so throwing them un-awaited throws a pending Promise and
Remix renders the error boundary instead of redirecting. The rule provides an
autofix that inserts `await`. Plain synchronous `throw redirect(...)` is not
flagged.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EZ8nrziWFcXhqGewJgo4ei

Author: claude

.oxlintrc.json

@@ -1,6 +1,7 @@
 {
   "$schema": "./node_modules/oxlint/configuration_schema.json",
   "plugins": ["typescript", "import", "react"],
+  "jsPlugins": ["./oxlint-plugins/no-thrown-unawaited-redirect.js"],
   "ignorePatterns": [
     "**/dist/**",
     "**/build/**",
@@ -31,6 +32,7 @@
     "import/no-duplicates": "error",
     "import/namespace": "off",
     "react-hooks/exhaustive-deps": "off",
-    "react-hooks/rules-of-hooks": "off"
+    "react-hooks/rules-of-hooks": "off",
+    "trigger/no-thrown-unawaited-redirect": "error"
   }
 }

oxlint-plugins/no-thrown-unawaited-redirect.js

@@ -0,0 +1,86 @@
+/**
+ * oxlint custom rule: no-thrown-unawaited-redirect
+ *
+ * Catches `throw someRedirectHelper(...)` where the helper is an *async* function
+ * that returns a Promise<Response> (e.g. `redirectWithErrorMessage`). Throwing the
+ * un-awaited call throws a *pending Promise* instead of a Response, so Remix renders
+ * the route's error boundary instead of performing the redirect.
+ *
+ * Correct forms are:
+ *   - `throw await redirectWithErrorMessage(...)`
+ *   - `return redirectWithErrorMessage(...)`
+ *
+ * Note: the plain synchronous `redirect(...)` from `remix-typedjson` returns a
+ * `Response` directly, so `throw redirect(...)` is the intended Remix control-flow
+ * pattern and is intentionally NOT flagged.
+ */
+
+// Async redirect helpers that return a Promise. Extend this list as new async
+// redirect helpers are added.
+const ASYNC_REDIRECT_HELPERS = new Set([
+  "redirectWithSuccessMessage",
+  "redirectWithErrorMessage",
+  "redirectBackWithErrorMessage",
+  "redirectBackWithSuccessMessage",
+  "redirectWithImpersonation",
+]);
+
+/** @type {import("eslint").Rule.RuleModule} */
+const noThrownUnawaitedRedirect = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow throwing an un-awaited async redirect helper (throws a pending Promise instead of a Response).",
+    },
+    fixable: "code",
+    messages: {
+      unawaited:
+        'Throwing an un-awaited "{{name}}()" throws a pending Promise (Remix renders the error boundary instead of redirecting). Use "throw await {{name}}()" or "return {{name}}()".',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      ThrowStatement(node) {
+        const argument = node.argument;
+
+        // Already awaited (`throw await helper()`) -> fine.
+        if (!argument || argument.type === "AwaitExpression") {
+          return;
+        }
+
+        // Only care about direct calls: `throw helper(...)`.
+        if (argument.type !== "CallExpression") {
+          return;
+        }
+
+        const callee = argument.callee;
+        if (callee.type !== "Identifier" || !ASYNC_REDIRECT_HELPERS.has(callee.name)) {
+          return;
+        }
+
+        context.report({
+          node: argument,
+          messageId: "unawaited",
+          data: { name: callee.name },
+          fix(fixer) {
+            return fixer.insertTextBefore(argument, "await ");
+          },
+        });
+      },
+    };
+  },
+};
+
+/** @type {import("eslint").ESLint.Plugin} */
+const plugin = {
+  meta: {
+    name: "trigger",
+  },
+  rules: {
+    "no-thrown-unawaited-redirect": noThrownUnawaitedRedirect,
+  },
+};
+
+export default plugin;