diff --git a/docs/package.json b/docs/package.json
index cb11570a689..5f9030f4e59 100644
--- a/docs/package.json
+++ b/docs/package.json
@@ -24,6 +24,7 @@
     },
     "devDependencies": {
         "@11ty/eleventy": "^2.0.1",
+        "@11ty/eleventy-fetch": "^4.0.0",
         "@11ty/eleventy-img": "^3.1.1",
         "@11ty/eleventy-navigation": "^0.3.5",
         "@11ty/eleventy-plugin-rss": "^1.1.1",
diff --git a/docs/src/_data/eslintNextVersion.js b/docs/src/_data/eslintNextVersion.js
new file mode 100644
index 00000000000..d3742364c54
--- /dev/null
+++ b/docs/src/_data/eslintNextVersion.js
@@ -0,0 +1,32 @@
+/**
+ * @fileoverview
+ * @author Nicholas C. Zakas
+ */
+
+//-----------------------------------------------------------------------------
+// Requirements
+//-----------------------------------------------------------------------------
+
+const eleventyFetch  = require("@11ty/eleventy-fetch");
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+module.exports = async function() {
+
+    // if we're on the next branch, we can just read the package.json file
+    if (process.env.BRANCH === "next") {
+        return require("../../package.json").version;
+    }
+
+    // otherwise, we need to fetch the latest version from the GitHub API
+    const url = "https://raw.githubusercontent.com/eslint/eslint/next/docs/package.json";
+
+    const response = await eleventyFetch(url, {
+        duration: "1d",
+        type: "json"
+    });
+
+    return response.version;
+}
diff --git a/docs/src/_includes/components/nav-version-switcher.html b/docs/src/_includes/components/nav-version-switcher.html
index a01e5ddf30c..b070e90a954 100644
--- a/docs/src/_includes/components/nav-version-switcher.html
+++ b/docs/src/_includes/components/nav-version-switcher.html
@@ -14,7 +14,7 @@
         <select name="version selector" id="nav-version-select" aria-describedby="nav-version-infobox" class="c-custom-select switcher__select auto-switcher">
             <option value="HEAD" data-url="/docs/head/" {% if HEAD %}selected{% endif %}>HEAD</option>
             {% if config.showNextVersion == true %}
-                <option value="NEXT" data-url="/docs/next/" {% if GIT_BRANCH == "next" %}selected{% endif %}>NEXT</option>
+                <option value="{{ eslintNextVersion }}" data-url="/docs/next/" {% if GIT_BRANCH == "next" %}selected{% endif %}>v{{ eslintNextVersion }}</option>
             {% endif %}
             <option value="{{ eslintVersion }}" data-url="/docs/latest/" {% if GIT_BRANCH == "latest" %}selected{% endif %}>v{{ eslintVersion }}</option>
             {% for version in versions.items %}
diff --git a/docs/src/_includes/components/version-switcher.html b/docs/src/_includes/components/version-switcher.html
index b19e0fd3b4e..96418804bb0 100644
--- a/docs/src/_includes/components/version-switcher.html
+++ b/docs/src/_includes/components/version-switcher.html
@@ -14,7 +14,7 @@
         <select name="version selector" id="version-select" aria-describedby="version-infobox" class="c-custom-select switcher__select auto-switcher">
             <option value="HEAD" data-url="/docs/head/"  {% if HEAD %}selected{% endif %}>HEAD</option>
             {% if config.showNextVersion == true %}
-              <option value="NEXT" data-url="/docs/next/" {% if GIT_BRANCH=="next" %}selected{% endif %}>NEXT</option>
+              <option value="{{ eslintNextVersion }}" data-url="/docs/next/" {% if GIT_BRANCH=="next" %}selected{% endif %}>v{{ eslintNextVersion }}</option>
             {% endif %}
             <option value="{{ eslintVersion }}" data-url="/docs/latest/"  {% if GIT_BRANCH == "latest" %}selected{% endif %}>v{{ eslintVersion }}</option>
             {% for version in versions.items %}
diff --git a/docs/src/_includes/partials/versions-list.html b/docs/src/_includes/partials/versions-list.html
index 7f07e4fa495..2b859eb9c77 100644
--- a/docs/src/_includes/partials/versions-list.html
+++ b/docs/src/_includes/partials/versions-list.html
@@ -1,7 +1,7 @@
 <ul class="versions-list">
     <li><a href="/docs/head/" {% if HEAD %} data-current="true" {% endif %}>HEAD</a></li>
     {% if config.showNextVersion == true %}
-      <li><a href="/docs/next/" {% if GIT_BRANCH == "next" %} data-current="true" {% endif %}>NEXT</a></li>
+      <li><a href="/docs/next/" {% if GIT_BRANCH == "next" %} data-current="true" {% endif %}>v{{ eslintNextVersion }}</a></li>
     {% endif %}
     <li><a href="/docs/latest/" {% if GIT_BRANCH == "latest" %} data-current="true" {% endif %}>v{{ eslintVersion }}</a></li>
     {%- for version in versions.items -%}
diff --git a/lib/linter/linter.js b/lib/linter/linter.js
index 2ece33c8284..7cdcbec21c6 100644
--- a/lib/linter/linter.js
+++ b/lib/linter/linter.js
@@ -43,7 +43,7 @@ const
 const { getRuleFromConfig } = require("../config/flat-config-helpers");
 const { FlatConfigArray } = require("../config/flat-config-array");
 const { RuleValidator } = require("../config/rule-validator");
-const { assertIsRuleOptions, assertIsRuleSeverity } = require("../config/flat-config-schema");
+const { assertIsRuleSeverity } = require("../config/flat-config-schema");
 const { normalizeSeverityToString } = require("../shared/severity");
 const debug = require("debug")("eslint:linter");
 const MAX_AUTOFIX_PASSES = 10;
@@ -326,10 +326,11 @@ function createDisableDirectives(options) {
  * @param {SourceCode} sourceCode The SourceCode object to get comments from.
  * @param {function(string): {create: Function}} ruleMapper A map from rule IDs to defined rules
  * @param {string|null} warnInlineConfig If a string then it should warn directive comments as disabled. The string value is the config name what the setting came from.
+ * @param {ConfigData} config Provided config.
  * @returns {{configuredRules: Object, enabledGlobals: {value:string,comment:Token}[], exportedVariables: Object, problems: LintMessage[], disableDirectives: DisableDirective[]}}
  * A collection of the directive comments that were found, along with any problems that occurred when parsing
  */
-function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig) {
+function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config) {
     const configuredRules = {};
     const enabledGlobals = Object.create(null);
     const exportedVariables = {};
@@ -438,8 +439,50 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig) {
                             return;
                         }
 
+                        let ruleOptions = Array.isArray(ruleValue) ? ruleValue : [ruleValue];
+
+                        /*
+                         * If the rule was already configured, inline rule configuration that
+                         * only has severity should retain options from the config and just override the severity.
+                         *
+                         * Example:
+                         *
+                         *   {
+                         *       rules: {
+                         *           curly: ["error", "multi"]
+                         *       }
+                         *   }
+                         *
+                         *   /* eslint curly: ["warn"] * /
+                         *
+                         *   Results in:
+                         *
+                         *   curly: ["warn", "multi"]
+                         */
+                        if (
+
+                            /*
+                             * If inline config for the rule has only severity
+                             */
+                            ruleOptions.length === 1 &&
+
+                            /*
+                             * And the rule was already configured
+                             */
+                            config.rules && Object.hasOwn(config.rules, name)
+                        ) {
+
+                            /*
+                             * Then use severity from the inline config and options from the provided config
+                             */
+                            ruleOptions = [
+                                ruleOptions[0], // severity from the inline config
+                                ...Array.isArray(config.rules[name]) ? config.rules[name].slice(1) : [] // options from the provided config
+                            ];
+                        }
+
                         try {
-                            validator.validateRuleOptions(rule, name, ruleValue);
+                            validator.validateRuleOptions(rule, name, ruleOptions);
                         } catch (err) {
 
                             /*
@@ -460,7 +503,7 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig) {
                             return;
                         }
 
-                        configuredRules[name] = ruleValue;
+                        configuredRules[name] = ruleOptions;
                     });
                 } else {
                     problems.push(parseResult.error);
@@ -1322,7 +1365,7 @@ class Linter {
 
         const sourceCode = slots.lastSourceCode;
         const commentDirectives = options.allowInlineConfig
-            ? getDirectiveComments(sourceCode, ruleId => getRule(slots, ruleId), options.warnInlineConfig)
+            ? getDirectiveComments(sourceCode, ruleId => getRule(slots, ruleId), options.warnInlineConfig, config)
             : { configuredRules: {}, enabledGlobals: {}, exportedVariables: {}, problems: [], disableDirectives: [] };
 
         // augment global scope with declared global variables
@@ -1332,56 +1375,8 @@ class Linter {
             { exportedVariables: commentDirectives.exportedVariables, enabledGlobals: commentDirectives.enabledGlobals }
         );
 
-        /*
-         * Now we determine the final configurations for rules.
-         * First, let all inline rule configurations override those from the config.
-         * Then, check for a special case: if a rule is configured in both places,
-         * inline rule configuration that only has severity should retain options from
-         * the config and just override the severity.
-         *
-         * Example:
-         *
-         *   {
-         *       rules: {
-         *           curly: ["error", "multi"]
-         *       }
-         *   }
-         *
-         *   /* eslint curly: ["warn"] * /
-         *
-         *   Results in:
-         *
-         *   curly: ["warn", "multi"]
-         */
         const configuredRules = Object.assign({}, config.rules, commentDirectives.configuredRules);
 
-        if (config.rules) {
-            for (const [ruleId, ruleInlineConfig] of Object.entries(commentDirectives.configuredRules)) {
-                if (
-
-                    /*
-                     * If inline config for the rule has only severity
-                     */
-                    (!Array.isArray(ruleInlineConfig) || ruleInlineConfig.length === 1) &&
-
-                    /*
-                     * And provided config for the rule has options
-                     */
-                    Object.hasOwn(config.rules, ruleId) &&
-                    (Array.isArray(config.rules[ruleId]) && config.rules[ruleId].length > 1)
-                ) {
-
-                    /*
-                     * Then use severity from the inline config and options from the provided config
-                     */
-                    configuredRules[ruleId] = [
-                        Array.isArray(ruleInlineConfig) ? ruleInlineConfig[0] : ruleInlineConfig, // severity from the inline config
-                        ...config.rules[ruleId].slice(1) // options from the provided config
-                    ];
-                }
-            }
-        }
-
         let lintingProblems;
 
         try {
@@ -1713,17 +1708,67 @@ class Linter {
 
                         try {
 
-                            const ruleOptions = Array.isArray(ruleValue) ? ruleValue : [ruleValue];
+                            let ruleOptions = Array.isArray(ruleValue) ? ruleValue : [ruleValue];
 
-                            assertIsRuleOptions(ruleId, ruleValue);
                             assertIsRuleSeverity(ruleId, ruleOptions[0]);
 
-                            ruleValidator.validate({
-                                plugins: config.plugins,
-                                rules: {
-                                    [ruleId]: ruleOptions
+                            /*
+                             * If the rule was already configured, inline rule configuration that
+                             * only has severity should retain options from the config and just override the severity.
+                             *
+                             * Example:
+                             *
+                             *   {
+                             *       rules: {
+                             *           curly: ["error", "multi"]
+                             *       }
+                             *   }
+                             *
+                             *   /* eslint curly: ["warn"] * /
+                             *
+                             *   Results in:
+                             *
+                             *   curly: ["warn", "multi"]
+                             */
+
+                            let shouldValidateOptions = true;
+
+                            if (
+
+                                /*
+                                 * If inline config for the rule has only severity
+                                 */
+                                ruleOptions.length === 1 &&
+
+                                /*
+                                 * And the rule was already configured
+                                 */
+                                config.rules && Object.hasOwn(config.rules, ruleId)
+                            ) {
+
+                                /*
+                                 * Then use severity from the inline config and options from the provided config
+                                 */
+                                ruleOptions = [
+                                    ruleOptions[0], // severity from the inline config
+                                    ...config.rules[ruleId].slice(1) // options from the provided config
+                                ];
+
+                                // if the rule was enabled, the options have already been validated
+                                if (config.rules[ruleId][0] > 0) {
+                                    shouldValidateOptions = false;
                                 }
-                            });
+                            }
+
+                            if (shouldValidateOptions) {
+                                ruleValidator.validate({
+                                    plugins: config.plugins,
+                                    rules: {
+                                        [ruleId]: ruleOptions
+                                    }
+                                });
+                            }
+
                             mergedInlineConfig.rules[ruleId] = ruleOptions;
                         } catch (err) {
 
@@ -1763,58 +1808,8 @@ class Linter {
             )
             : { problems: [], disableDirectives: [] };
 
-        /*
-         * Now we determine the final configurations for rules.
-         * First, let all inline rule configurations override those from the config.
-         * Then, check for a special case: if a rule is configured in both places,
-         * inline rule configuration that only has severity should retain options from
-         * the config and just override the severity.
-         *
-         * Example:
-         *
-         *   {
-         *       rules: {
-         *           curly: ["error", "multi"]
-         *       }
-         *   }
-         *
-         *   /* eslint curly: ["warn"] * /
-         *
-         *   Results in:
-         *
-         *   curly: ["warn", "multi"]
-         *
-         * At this point, all rule configurations are normalized to arrays.
-         */
         const configuredRules = Object.assign({}, config.rules, mergedInlineConfig.rules);
 
-        if (config.rules) {
-            for (const [ruleId, ruleInlineConfig] of Object.entries(mergedInlineConfig.rules)) {
-                if (
-
-                    /*
-                     * If inline config for the rule has only severity
-                     */
-                    ruleInlineConfig.length === 1 &&
-
-                    /*
-                     * And provided config for the rule has options
-                     */
-                    Object.hasOwn(config.rules, ruleId) &&
-                    config.rules[ruleId].length > 1
-                ) {
-
-                    /*
-                     * Then use severity from the inline config and options from the provided config
-                     */
-                    configuredRules[ruleId] = [
-                        ruleInlineConfig[0], // severity from the inline config
-                        ...config.rules[ruleId].slice(1) // options from the provided config
-                    ];
-                }
-            }
-        }
-
         let lintingProblems;
 
         sourceCode.finalize();
diff --git a/package.json b/package.json
index f1947fda1c3..b48913a9de1 100644
--- a/package.json
+++ b/package.json
@@ -122,7 +122,7 @@
     "eslint-plugin-jsdoc": "^46.9.0",
     "eslint-plugin-n": "^16.6.0",
     "eslint-plugin-unicorn": "^49.0.0",
-    "eslint-release": "^3.2.0",
+    "eslint-release": "^3.2.2",
     "eslump": "^3.0.0",
     "esprima": "^4.0.1",
     "fast-glob": "^3.2.11",
diff --git a/tests/lib/linter/linter.js b/tests/lib/linter/linter.js
index 8cd20c1b6fb..9ead00af1a9 100644
--- a/tests/lib/linter/linter.js
+++ b/tests/lib/linter/linter.js
@@ -1461,20 +1461,42 @@ describe("Linter", () => {
         describe("when the rule was already configured", () => {
 
             beforeEach(() => {
-                linter.defineRule("my-rule", {
-                    meta: {
-                        schema: [{
-                            type: "string"
-                        }]
-                    },
-                    create(context) {
-                        const message = context.options[0] ?? "option not provided";
+                linter.defineRules({
+                    "my-rule": {
+                        meta: {
+                            schema: [{
+                                type: "string"
+                            }]
+                        },
+                        create(context) {
+                            const message = context.options[0] ?? "option not provided";
 
-                        return {
-                            Program(node) {
-                                context.report({ node, message });
+                            return {
+                                Program(node) {
+                                    context.report({ node, message });
+                                }
+                            };
+                        }
+                    },
+                    "requires-option": {
+                        meta: {
+                            schema: {
+                                type: "array",
+                                items: [{
+                                    type: "string"
+                                }],
+                                minItems: 1
                             }
-                        };
+                        },
+                        create(context) {
+                            const message = context.options[0];
+
+                            return {
+                                Identifier(node) {
+                                    context.report({ node, message });
+                                }
+                            };
+                        }
                     }
                 });
             });
@@ -1540,6 +1562,27 @@ describe("Linter", () => {
                     assert.strictEqual(suppressedMessages.length, 0);
                 });
             });
+
+            it("should validate and use originally configured options when /*eslint*/ comment enables rule that was set to 'off' in the configuration", () => {
+                const code = "/*eslint my-rule: ['warn'], requires-option: 'warn' */ foo;";
+                const config = {
+                    rules: {
+                        "my-rule": ["off", true], // invalid options for this rule
+                        "requires-option": ["off", "Don't use identifier"] // valid options for this rule
+                    }
+                };
+                const messages = linter.verify(code, config);
+                const suppressedMessages = linter.getSuppressedMessages();
+
+                assert.strictEqual(messages.length, 2);
+                assert.strictEqual(messages[0].ruleId, "my-rule");
+                assert.strictEqual(messages[0].severity, 2);
+                assert.strictEqual(messages[0].message, "Configuration for rule \"my-rule\" is invalid:\n\tValue true should be string.\n");
+                assert.strictEqual(messages[1].ruleId, "requires-option");
+                assert.strictEqual(messages[1].severity, 1);
+                assert.strictEqual(messages[1].message, "Don't use identifier");
+                assert.strictEqual(suppressedMessages.length, 0);
+            });
         });
     });
 
@@ -10730,6 +10773,26 @@ describe("Linter with FlatConfigArray", () => {
                                             }
                                         };
                                     }
+                                },
+                                "requires-option": {
+                                    meta: {
+                                        schema: {
+                                            type: "array",
+                                            items: [{
+                                                type: "string"
+                                            }],
+                                            minItems: 1
+                                        }
+                                    },
+                                    create(context) {
+                                        const message = context.options[0];
+
+                                        return {
+                                            Identifier(node) {
+                                                context.report({ node, message });
+                                            }
+                                        };
+                                    }
                                 }
                             }
                         };
@@ -10798,6 +10861,30 @@ describe("Linter with FlatConfigArray", () => {
                                 assert.strictEqual(suppressedMessages.length, 0);
                             });
                         });
+
+                        it("should validate and use originally configured options when /*eslint*/ comment enables rule that was set to 'off' in the configuration", () => {
+                            const code = "/*eslint test/my-rule: ['warn'], test/requires-option: 'warn' */ foo;";
+                            const config = {
+                                plugins: {
+                                    test: plugin
+                                },
+                                rules: {
+                                    "test/my-rule": ["off", true], // invalid options for this rule
+                                    "test/requires-option": ["off", "Don't use identifier"] // valid options for this rule
+                                }
+                            };
+                            const messages = linter.verify(code, config);
+                            const suppressedMessages = linter.getSuppressedMessages();
+
+                            assert.strictEqual(messages.length, 2);
+                            assert.strictEqual(messages[0].ruleId, "test/my-rule");
+                            assert.strictEqual(messages[0].severity, 2);
+                            assert.strictEqual(messages[0].message, "Inline configuration for rule \"test/my-rule\" is invalid:\n\tValue true should be string.\n");
+                            assert.strictEqual(messages[1].ruleId, "test/requires-option");
+                            assert.strictEqual(messages[1].severity, 1);
+                            assert.strictEqual(messages[1].message, "Don't use identifier");
+                            assert.strictEqual(suppressedMessages.length, 0);
+                        });
                     });
                 });