diff --git a/docs/processors/markdown.md b/docs/processors/markdown.md
index b1e2877ec..8a70d18b7 100644
--- a/docs/processors/markdown.md
+++ b/docs/processors/markdown.md
@@ -183,6 +183,8 @@ Comment bodies are passed through unmodified, so the plugin supports any [config
 
 This example enables the `alert` global variable, disables the `no-alert` rule, and configures the `quotes` rule to prefer single quotes:
 
+<!-- eslint-skip -->
+
 ````markdown
 <!-- global alert -->
 <!-- eslint-disable no-alert -->
@@ -195,6 +197,8 @@ alert('Hello, world!');
 
 Each code block in a file is linted separately, so configuration comments apply only to the code block that immediately follows.
 
+<!-- eslint-skip -->
+
 ````markdown
 Assuming `no-alert` is enabled in `eslint.config.js`, the first code block will have no error from `no-alert`:
 
diff --git a/src/processor.js b/src/processor.js
index 38e9ef56b..e46f1a9c3 100644
--- a/src/processor.js
+++ b/src/processor.js
@@ -17,6 +17,8 @@ import { fromMarkdown } from "mdast-util-from-markdown";
  * @import { LintMessage, RuleTextEdit, SourceRange } from "@eslint/core";
  * @import { Node, Parent, Code, Html } from "mdast";
  * @import { Block, RangeMap } from "./types.js";
+ * @typedef { Block['comments'][number] } Comment
+ * @typedef {{ comment: Comment, startLine: number, endLine: number, jsOffset: number }} CommentMapping
  */
 
 //-----------------------------------------------------------------------------
@@ -30,6 +32,8 @@ const UNSATISFIABLE_RULES = new Set([
 const SUPPORTS_AUTOFIX = true;
 
 const BOM = "\uFEFF";
+const unusedDirectiveMessagePattern =
+	/^Unused eslint-(?:disable|enable) directive/u;
 
 /**
  * @type {Map<string, Block[]>}
@@ -138,7 +142,7 @@ function getIndentText(text, node) {
  * delta at the beginning of each line.
  * @param {string} text The text of the file.
  * @param {Code} node A Markdown code block AST node.
- * @param {string[]} comments List of configuration comment strings that will be
+ * @param {Comment[]} comments List of configuration comment objects that will be
  *     inserted at the beginning of the code block.
  * @returns {RangeMap[]} A list of offset-based adjustments, where lookups are
  *     done based on the `js` key, which represents the range in the linted JS,
@@ -176,7 +180,7 @@ function getBlockRangeMap(text, node, comments) {
 	 * of the linted JS and start the JS offset lookup keys at this index.
 	 */
 	const commentLength = comments.reduce(
-		(len, comment) => len + comment.length + 1,
+		(len, comment) => len + comment.text.length + 1,
 		0,
 	);
 
@@ -237,6 +241,67 @@ function getBlockRangeMap(text, node, comments) {
 	return rangeMap;
 }
 
+/**
+ * Determines whether a message reports an unused directive.
+ * @param {LintMessage} message The message to check.
+ * @returns {boolean} True if the message reports an unused directive.
+ */
+function isUnusedDirectiveMessage(message) {
+	return (
+		message.ruleId === null &&
+		unusedDirectiveMessagePattern.test(message.message)
+	);
+}
+
+/**
+ * Adjusts an unused directive message in an inserted JS comment.
+ * @param {LintMessage} message The message to adjust.
+ * @param {CommentMapping[]} commentMappings Precomputed comment line ranges and offsets.
+ * @returns {LintMessage} The adjusted message, if it can be mapped.
+ */
+function adjustCommentMessage(message, commentMappings) {
+	const mapping = commentMappings.find(
+		m => message.line >= m.startLine && message.line < m.endLine,
+	);
+
+	if (!mapping) {
+		return message;
+	}
+
+	const { comment: foundComment, jsOffset } = mapping;
+	const { start, end } = foundComment.position;
+	const { fix, ...messageWithoutFix } = message;
+
+	const adjustedMessage = /** @type {LintMessage} */ ({
+		...messageWithoutFix,
+		line: start.line,
+		column: start.column,
+	});
+
+	if (fix) {
+		const isFullRemoval =
+			fix.range[0] <= jsOffset &&
+			fix.range[1] >= jsOffset + foundComment.text.length;
+
+		if (isFullRemoval) {
+			adjustedMessage.fix = {
+				range: [start.offset, end.offset],
+				text: fix.text,
+			};
+		} else {
+			// '4' is the length of '<!--' and '2' is the length of '/*'.
+			const offsetDelta = start.offset + 4 - (jsOffset + 2);
+
+			adjustedMessage.fix = {
+				range: [fix.range[0] + offsetDelta, fix.range[1] + offsetDelta],
+				text: fix.text,
+			};
+		}
+	}
+
+	return adjustedMessage;
+}
+
 const codeBlockFileNameRegex = /filename=(?<quote>["'])(?<filename>.*?)\1/u;
 
 /**
@@ -278,7 +343,7 @@ function preprocess(sourceText, filename) {
 	 * block immediately follows such a sequence, insert the comments at the
 	 * top of the code block. Any non-ESLint comment or other node type breaks
 	 * and empties the sequence.
-	 * @type {string[]}
+	 * @type {Comment[]}
 	 */
 	let htmlComments = [];
 
@@ -294,16 +359,19 @@ function preprocess(sourceText, filename) {
 		 */
 		code(node) {
 			if (node.lang) {
-				/** @type {string[]} */
+				/** @type {Comment[]} */
 				const comments = [];
 
 				for (const comment of htmlComments) {
-					if (comment.trim() === "eslint-skip") {
+					if (comment.text.trim() === "eslint-skip") {
 						htmlComments = [];
 						return;
 					}
 
-					comments.push(`/*${comment}*/`);
+					comments.push({
+						text: `/*${comment.text}*/`,
+						position: comment.position,
+					});
 				}
 
 				htmlComments = [];
@@ -326,7 +394,7 @@ function preprocess(sourceText, filename) {
 			const comment = getComment(node.value);
 
 			if (comment) {
-				htmlComments.push(comment);
+				htmlComments.push({ text: comment, position: node.position });
 			} else {
 				htmlComments = [];
 			}
@@ -345,7 +413,9 @@ function preprocess(sourceText, filename) {
 
 		return {
 			filename: fileNameFromMeta(block) ?? `${index}.${fileExtension}`,
-			text: [...block.comments, block.value, ""].join("\n"),
+			text: [...block.comments.map(c => c.text), block.value, ""].join(
+				"\n",
+			),
 		};
 	});
 }
@@ -386,10 +456,24 @@ function adjustFix(block, fix) {
  * @returns {(message: LintMessage) => LintMessage | null} A function that adjusts messages in a code block.
  */
 function adjustBlock(block) {
-	const leadingCommentLines = block.comments.reduce(
-		(count, comment) => count + comment.split("\n").length,
-		0,
-	);
+	/** @type {CommentMapping[]} */
+	const commentMappings = [];
+	let currentLine = 1;
+	let jsOffset = 0;
+
+	for (const comment of block.comments) {
+		const commentLines = comment.text.split("\n").length;
+		commentMappings.push({
+			comment,
+			startLine: currentLine,
+			endLine: currentLine + commentLines,
+			jsOffset,
+		});
+		currentLine += commentLines;
+		jsOffset += comment.text.length + 1;
+	}
+
+	const leadingCommentLines = currentLine - 1;
 
 	const blockStart = block.position.start.line;
 
@@ -410,7 +494,9 @@ function adjustBlock(block) {
 		const lineInCode = message.line - leadingCommentLines;
 
 		if (lineInCode < 1 || lineInCode >= block.rangeMap.length) {
-			return null;
+			return isUnusedDirectiveMessage(message)
+				? adjustCommentMessage(message, commentMappings)
+				: null;
 		}
 
 		/** @type {Pick<LintMessage, "line" | "column" | "endLine" | "suggestions">} */
diff --git a/src/types.ts b/src/types.ts
index e5c12c5f0..ff69819a2 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -39,6 +39,7 @@ import type {
 	Yaml,
 } from "mdast";
 import type { InlineMath, Math } from "mdast-util-math";
+import type { Position } from "unist";
 import type {
 	LanguageContext,
 	LanguageOptions,
@@ -66,7 +67,7 @@ export interface RangeMap {
 
 export interface BlockBase {
 	baseIndentText: string;
-	comments: string[];
+	comments: { text: string; position: Position }[];
 	rangeMap: RangeMap[];
 }
 
diff --git a/tests/fixtures/eslint.config.js b/tests/fixtures/eslint.config.js
index cbe969781..5b85a3aa0 100644
--- a/tests/fixtures/eslint.config.js
+++ b/tests/fixtures/eslint.config.js
@@ -9,6 +9,9 @@ export default [
 		languageOptions: {
 			globals: globals.browser,
 		},
+		linterOptions: {
+			reportUnusedDisableDirectives: "off",
+		},
 		rules: {
 			"eol-last": "error",
 			"no-console": "error",
diff --git a/tests/plugin.test.js b/tests/plugin.test.js
index f76f96bef..907799930 100644
--- a/tests/plugin.test.js
+++ b/tests/plugin.test.js
@@ -454,6 +454,277 @@ describe("LegacyESLint", () => {
 				);
 				assert.strictEqual(results[0].messages[0].line, 5);
 			});
+
+			describe("unused disable directives", () => {
+				let unusedDisableESLint;
+
+				beforeEach(() => {
+					unusedDisableESLint = initLegacyESLint("eslintrc.json", {
+						reportUnusedDisableDirectives: "error",
+					});
+				});
+
+				it("reports unused disable directives", async () => {
+					const code = [
+						"<!-- eslint-disable no-console -->",
+						"",
+						"```js",
+						"var answer = 42;",
+						"```",
+					].join("\n");
+
+					const results = await unusedDisableESLint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results.length, 1);
+					assert.strictEqual(results[0].messages.length, 1);
+					assert.strictEqual(
+						results[0].messages[0].message,
+						"Unused eslint-disable directive (no problems were reported from 'no-console').",
+					);
+					assert.strictEqual(results[0].messages[0].line, 1);
+					assert.strictEqual(results[0].messages[0].column, 1);
+					assert.deepStrictEqual(results[0].messages[0].fix, {
+						range: [0, 34],
+						text: " ",
+					});
+				});
+
+				it("reports unused disable directives correctly among multiple comments", async () => {
+					const code = [
+						"# Title",
+						"",
+						"<!-- eslint-disable quotes -->",
+						"<!-- eslint-disable no-console -->",
+						"",
+						"```js",
+						"var message = 'single quotes';",
+						"```",
+					].join("\n");
+
+					const results = await unusedDisableESLint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results.length, 1);
+					assert.strictEqual(results[0].messages.length, 1);
+					assert.strictEqual(
+						results[0].messages[0].message,
+						"Unused eslint-disable directive (no problems were reported from 'no-console').",
+					);
+					assert.strictEqual(results[0].messages[0].line, 4);
+					assert.strictEqual(results[0].messages[0].column, 1);
+				});
+
+				it("reports unused disable-next-line directives", async () => {
+					const code = [
+						"<!-- eslint-disable-next-line no-console -->",
+						"",
+						"```js",
+						"var answer = 42;",
+						"```",
+					].join("\n");
+
+					const results = await unusedDisableESLint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results.length, 1);
+					assert.strictEqual(results[0].messages.length, 1);
+					assert.strictEqual(
+						results[0].messages[0].message,
+						"Unused eslint-disable directive (no problems were reported from 'no-console').",
+					);
+					assert.strictEqual(results[0].messages[0].line, 1);
+					assert.strictEqual(results[0].messages[0].column, 1);
+				});
+
+				it("reports unused disable directives when paired with eslint-enable", async () => {
+					const code = [
+						"<!-- eslint-disable no-console -->",
+						"<!-- eslint-enable no-console -->",
+						"",
+						"```js",
+						"var answer = 42;",
+						"```",
+					].join("\n");
+
+					const results = await unusedDisableESLint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results.length, 1);
+					assert.strictEqual(results[0].messages.length, 1);
+					assert.strictEqual(
+						results[0].messages[0].message,
+						"Unused eslint-disable directive (no problems were reported from 'no-console').",
+					);
+					assert.strictEqual(results[0].messages[0].line, 1);
+					assert.strictEqual(results[0].messages[0].column, 1);
+				});
+
+				it("reports unused disable directives spanning multiple lines", async () => {
+					const code = [
+						"<!--",
+						"eslint-disable",
+						"no-console",
+						"-->",
+						"",
+						"```js",
+						"var answer = 42;",
+						"```",
+					].join("\n");
+
+					const results = await unusedDisableESLint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results.length, 1);
+					assert.strictEqual(results[0].messages.length, 1);
+					assert.strictEqual(
+						results[0].messages[0].message,
+						"Unused eslint-disable directive (no problems were reported from 'no-console').",
+					);
+					assert.strictEqual(results[0].messages[0].line, 1);
+					assert.strictEqual(results[0].messages[0].column, 1);
+				});
+			});
+
+			describe("autofixing unused disable directives", () => {
+				let fixUnusedEslint;
+
+				beforeEach(() => {
+					fixUnusedEslint = initLegacyESLint("eslintrc.json", {
+						fix: true,
+						reportUnusedDisableDirectives: "error",
+					});
+				});
+
+				it("removes the entire HTML comment when all rules are unused", async () => {
+					const code = [
+						"<!-- eslint-disable no-console -->",
+						"",
+						"```js",
+						"var answer = 42;",
+						"```",
+					].join("\n");
+
+					const expected = [
+						" ",
+						"",
+						"```js",
+						"var answer = 42;",
+						"```",
+					].join("\n");
+
+					const results = await fixUnusedEslint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results[0].output, expected);
+				});
+
+				it("partially removes unused rules from the end of an HTML comment", async () => {
+					const code = [
+						"<!-- eslint-disable no-undef, no-console -->",
+						"",
+						"```js",
+						"var answer = missingVariable;",
+						"```",
+					].join("\n");
+
+					const expected = [
+						"<!-- eslint-disable no-undef -->",
+						"",
+						"```js",
+						"var answer = missingVariable;",
+						"```",
+					].join("\n");
+
+					const results = await fixUnusedEslint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results[0].output, expected);
+				});
+
+				it("partially removes unused rules from the beginning of an HTML comment", async () => {
+					const code = [
+						"<!-- eslint-disable no-console, no-undef -->",
+						"",
+						"```js",
+						"var answer = missingVariable;",
+						"```",
+					].join("\n");
+
+					const expected = [
+						"<!-- eslint-disable no-undef -->",
+						"",
+						"```js",
+						"var answer = missingVariable;",
+						"```",
+					].join("\n");
+
+					const results = await fixUnusedEslint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results[0].output, expected);
+				});
+
+				it("partially removes unused rules from the middle of an HTML comment", async () => {
+					const code = [
+						"<!-- eslint-disable no-console, no-alert, no-undef -->",
+						"",
+						"```js",
+						"console.log(missingVariable);",
+						"```",
+					].join("\n");
+
+					const expected = [
+						"<!-- eslint-disable no-console, no-undef -->",
+						"",
+						"```js",
+						"console.log(missingVariable);",
+						"```",
+					].join("\n");
+
+					const results = await fixUnusedEslint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results[0].output, expected);
+				});
+
+				it("removes unused rules from a multiline HTML comment", async () => {
+					const code = [
+						"<!--",
+						"eslint-disable no-console, no-alert, no-undef",
+						"-->",
+						"",
+						"```js",
+						"console.log(missingVariable);",
+						"```",
+					].join("\n");
+
+					const expected = [
+						"<!--",
+						"eslint-disable no-console, no-undef",
+						"-->",
+						"",
+						"```js",
+						"console.log(missingVariable);",
+						"```",
+					].join("\n");
+
+					const results = await fixUnusedEslint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results[0].output, expected);
+				});
+			});
 		});
 
 		describe("should fix code", () => {
@@ -1569,6 +1840,285 @@ describe("FlatESLint", () => {
 				);
 				assert.strictEqual(results[0].messages[0].line, 5);
 			});
+
+			describe("unused disable directives", () => {
+				let unusedDisableESLint;
+
+				beforeEach(() => {
+					unusedDisableESLint = initFlatESLint("eslint.config.js", {
+						overrideConfig: {
+							linterOptions: {
+								reportUnusedDisableDirectives: "error",
+							},
+						},
+					});
+				});
+
+				it("reports unused disable directives", async () => {
+					const code = [
+						"<!-- eslint-disable no-console -->",
+						"",
+						"```js",
+						"const answer = 42;",
+						"```",
+					].join("\n");
+
+					const results = await unusedDisableESLint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results.length, 1);
+					assert.strictEqual(results[0].messages.length, 1);
+					assert.strictEqual(
+						results[0].messages[0].message,
+						"Unused eslint-disable directive (no problems were reported from 'no-console').",
+					);
+					assert.strictEqual(results[0].messages[0].line, 1);
+					assert.strictEqual(results[0].messages[0].column, 1);
+					assert.deepStrictEqual(results[0].messages[0].fix, {
+						range: [0, 34],
+						text: " ",
+					});
+				});
+
+				it("reports unused disable directives correctly among multiple comments", async () => {
+					const code = [
+						"# Title",
+						"",
+						"<!-- eslint-disable quotes -->",
+						"<!-- eslint-disable no-console -->",
+						"",
+						"```js",
+						"const message = 'single quotes';",
+						"```",
+					].join("\n");
+
+					const results = await unusedDisableESLint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results.length, 1);
+					assert.strictEqual(results[0].messages.length, 1);
+					assert.strictEqual(
+						results[0].messages[0].message,
+						"Unused eslint-disable directive (no problems were reported from 'no-console').",
+					);
+					assert.strictEqual(results[0].messages[0].line, 4);
+					assert.strictEqual(results[0].messages[0].column, 1);
+				});
+
+				it("reports unused disable-next-line directives", async () => {
+					const code = [
+						"<!-- eslint-disable-next-line no-console -->",
+						"",
+						"```js",
+						"const answer = 42;",
+						"```",
+					].join("\n");
+
+					const results = await unusedDisableESLint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results.length, 1);
+					assert.strictEqual(results[0].messages.length, 1);
+					assert.strictEqual(
+						results[0].messages[0].message,
+						"Unused eslint-disable directive (no problems were reported from 'no-console').",
+					);
+					assert.strictEqual(results[0].messages[0].line, 1);
+					assert.strictEqual(results[0].messages[0].column, 1);
+				});
+
+				it("reports unused disable directives when paired with eslint-enable", async () => {
+					const code = [
+						"<!-- eslint-disable no-console -->",
+						"<!-- eslint-enable no-console -->",
+						"",
+						"```js",
+						"const answer = 42;",
+						"```",
+					].join("\n");
+
+					const results = await unusedDisableESLint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results.length, 1);
+					assert.strictEqual(results[0].messages.length, 1);
+					assert.strictEqual(
+						results[0].messages[0].message,
+						"Unused eslint-disable directive (no problems were reported from 'no-console').",
+					);
+					assert.strictEqual(results[0].messages[0].line, 1);
+					assert.strictEqual(results[0].messages[0].column, 1);
+				});
+
+				it("reports unused disable directives spanning multiple lines", async () => {
+					const code = [
+						"<!--",
+						"eslint-disable",
+						"no-console",
+						"-->",
+						"",
+						"```js",
+						"const answer = 42;",
+						"```",
+					].join("\n");
+
+					const results = await unusedDisableESLint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results.length, 1);
+					assert.strictEqual(results[0].messages.length, 1);
+					assert.strictEqual(
+						results[0].messages[0].message,
+						"Unused eslint-disable directive (no problems were reported from 'no-console').",
+					);
+					assert.strictEqual(results[0].messages[0].line, 1);
+					assert.strictEqual(results[0].messages[0].column, 1);
+				});
+			});
+
+			describe("autofixing unused disable directives", () => {
+				let fixUnusedEslint;
+
+				beforeEach(() => {
+					fixUnusedEslint = initFlatESLint("eslint.config.js", {
+						fix: true,
+						overrideConfig: {
+							linterOptions: {
+								reportUnusedDisableDirectives: "error",
+							},
+						},
+					});
+				});
+
+				it("removes the entire HTML comment when all rules are unused", async () => {
+					const code = [
+						"<!-- eslint-disable no-console -->",
+						"",
+						"```js",
+						"const answer = 42;",
+						"```",
+					].join("\n");
+
+					const expected = [
+						" ",
+						"",
+						"```js",
+						"const answer = 42;",
+						"```",
+					].join("\n");
+
+					const results = await fixUnusedEslint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results[0].output, expected);
+				});
+
+				it("partially removes unused rules from the end of an HTML comment", async () => {
+					const code = [
+						"<!-- eslint-disable no-undef, no-console -->",
+						"",
+						"```js",
+						"const answer = missingVariable;",
+						"```",
+					].join("\n");
+
+					const expected = [
+						"<!-- eslint-disable no-undef -->",
+						"",
+						"```js",
+						"const answer = missingVariable;",
+						"```",
+					].join("\n");
+
+					const results = await fixUnusedEslint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results[0].output, expected);
+				});
+
+				it("partially removes unused rules from the beginning of an HTML comment", async () => {
+					const code = [
+						"<!-- eslint-disable no-console, no-undef -->",
+						"",
+						"```js",
+						"const answer = missingVariable;",
+						"```",
+					].join("\n");
+
+					const expected = [
+						"<!-- eslint-disable no-undef -->",
+						"",
+						"```js",
+						"const answer = missingVariable;",
+						"```",
+					].join("\n");
+
+					const results = await fixUnusedEslint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results[0].output, expected);
+				});
+
+				it("partially removes unused rules from the middle of an HTML comment", async () => {
+					const code = [
+						"<!-- eslint-disable no-console, no-alert, no-undef -->",
+						"",
+						"```js",
+						"console.log(missingVariable);",
+						"```",
+					].join("\n");
+
+					const expected = [
+						"<!-- eslint-disable no-console, no-undef -->",
+						"",
+						"```js",
+						"console.log(missingVariable);",
+						"```",
+					].join("\n");
+
+					const results = await fixUnusedEslint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results[0].output, expected);
+				});
+
+				it("removes unused rules from a multiline HTML comment", async () => {
+					const code = [
+						"<!--",
+						"eslint-disable no-console, no-alert, no-undef",
+						"-->",
+						"",
+						"```js",
+						"console.log(missingVariable);",
+						"```",
+					].join("\n");
+
+					const expected = [
+						"<!--",
+						"eslint-disable no-console, no-undef",
+						"-->",
+						"",
+						"```js",
+						"console.log(missingVariable);",
+						"```",
+					].join("\n");
+
+					const results = await fixUnusedEslint.lintText(code, {
+						filePath: "test.md",
+					});
+
+					assert.strictEqual(results[0].output, expected);
+				});
+			});
 		});
 
 		describe("should fix code", () => {
diff --git a/tests/types/types.test.ts b/tests/types/types.test.ts
index a0a55d11e..e07910686 100644
--- a/tests/types/types.test.ts
+++ b/tests/types/types.test.ts
@@ -58,7 +58,15 @@ const validBlock: Block = {
 
 	// `BlockBase` properties
 	baseIndentText: "  ",
-	comments: ["// A comment"],
+	comments: [
+		{
+			text: "eslint-disable",
+			position: {
+				start: { line: 1, column: 1, offset: 0 },
+				end: { line: 1, column: 15, offset: 14 },
+			},
+		},
+	],
 	rangeMap: [{ indent: 2, js: 0, md: 4 }],
 };
 
@@ -72,7 +80,9 @@ validBlock.data satisfies CodeData | undefined;
 
 // Verify `Block` has `BlockBase` properties
 validBlock.baseIndentText satisfies string;
-validBlock.comments satisfies string[];
+validBlock.comments satisfies { text: string; position: Position }[];
+validBlock.comments[0].text satisfies string;
+validBlock.comments[0].position satisfies Position;
 validBlock.rangeMap satisfies RangeMap[];
 
 // Verify `RangeMap` structure