@cldmv/eslint-plugin-jsonv 1.0.11 → 1.0.12

package/README.md

@@ -6,6 +6,22 @@
 
 ESLint plugin for validating `.jsonv` files using the [@cldmv/jsonv](https://github.com/CLDMV/jsonv) parser.
 
+## ✨ What's New
+
+### Latest: v1.0.12 (September 2026)
+
+- **A real ESLint AST for `.jsonv` files** — the `jsonv/jsonv` language now builds a positioned AST from `@cldmv/jsonv`'s `parseToAst()` instead of an empty `Program`. Rules can select objects, arrays, properties, literals, references and templates; reports land on the node they target instead of `1:0`; and inline `eslint-disable` / `eslint-enable` / `eslint-disable-next-line` comments now work. Requires `@cldmv/jsonv` 1.1.0 or later (#26).
+- [View full v1.0.12 Changelog](https://github.com/CLDMV/jsonv-eslint-plugin-jsonv/blob/master/docs/changelog/v1/v1.0.12.md)
+
+### Recent Releases
+
+- **v1.0.11** (September 2026) — language options are validated, parse errors report at their real position, and the plugin gained a vitest suite with a CI coverage badge (#16, #17, #18, #23, #24) ([Changelog](https://github.com/CLDMV/jsonv-eslint-plugin-jsonv/blob/master/docs/changelog/v1/v1.0.11.md))
+- **v1.0.10** (September 2026) — the README links back to the jsonv repo (#15) ([Changelog](https://github.com/CLDMV/jsonv-eslint-plugin-jsonv/blob/master/docs/changelog/v1/v1.0.10.md))
+- **v1.0.9** (September 2026) — corrected package name, badge row and license badges (#12) ([Changelog](https://github.com/CLDMV/jsonv-eslint-plugin-jsonv/blob/master/docs/changelog/v1/v1.0.9.md))
+- **v1.0.8** (September 2026) — Node CI matrix updated for vitest 5 (max Node 26, min Node 22.12.0) (#10) ([Changelog](https://github.com/CLDMV/jsonv-eslint-plugin-jsonv/blob/master/docs/changelog/v1/v1.0.8.md))
+
+📚 **For complete version history, see [docs/changelog/](https://github.com/CLDMV/jsonv-eslint-plugin-jsonv/tree/master/docs/changelog/) and the [GitHub Releases](https://github.com/CLDMV/jsonv-eslint-plugin-jsonv/releases).**
+
 ## Features
 
 - **Syntax Validation**: Validates jsonv syntax using the actual jsonv parser
@@ -75,6 +91,39 @@ The parser supports the following options:
 }
 ```
 
+### Inline Configuration
+
+The usual ESLint comments work inside `.jsonv` files: `// eslint-disable`, `/* eslint-disable <rule> */`, `/* eslint-enable */`, `// eslint-disable-line`, `// eslint-disable-next-line`, and `/* eslint <rule>: "off" */` rule configuration.
+
+### Writing Rules
+
+The `jsonv/jsonv` language exposes the document as an AST built from `@cldmv/jsonv`'s `parseToAst()`. Every node has a `loc` (1-based lines and columns) and a `range`, so reports on a node land on that node, and rules can use node types and selectors:
+
+| Node type | Children | Notes |
+|---|---|---|
+| `Program` | `body` | The document; `body` is the root value. `comments` and `tokens` hang off it. |
+| `ObjectExpression` | `properties` | `{ ... }` |
+| `Property` | `key`, `value` | `key` is a `Literal` (quoted or numeric key) or an `Identifier` (unquoted key). |
+| `ArrayExpression` | `elements` | `[ ... ]` |
+| `Literal` | — | Strings, numbers, BigInt (`bigint` holds the digits), booleans, `null`, `Infinity`, `NaN`; `raw` is the source text. |
+| `Identifier` | — | An unquoted key, or an internal reference such as `backup: port`. |
+| `MemberExpression` | `object`, `property` | A dotted internal reference such as `server.port`. |
+| `TemplateLiteral` | `quasis`, `expressions` | A backtick string with `${...}` interpolation (a plain backtick string is a `Literal`). |
+| `TemplateElement` | — | A literal segment of a template. |
+
+```javascript
+// Report every string value containing "TODO", on the string itself
+create(context) {
+  return {
+    "Property > Literal.value"(node) {
+      if (typeof node.value === "string" && node.value.includes("TODO")) {
+        context.report({ node, message: "Unexpected TODO." });
+      }
+    }
+  };
+}
+```
+
 ## Supported Features
 
 ### ES2011 (JSON5 Base)

package/dist/index.d.mts

@@ -1,4 +1,34 @@
-export default plugin;
+/**
+ * @fileoverview ESLint plugin for @cldmv/jsonv files
+ * @module eslint-plugin-jsonv
+ * @public
+ *
+ * @description
+ * Custom ESLint plugin for validating .jsonv files using the @cldmv/jsonv parser.
+ * Provides language definition, parser, and recommended rules for jsonv files.
+ *
+ * Features:
+ * - Validates jsonv syntax using the actual jsonv parser
+ * - Reports parse errors with accurate source locations
+ * - Supports all ES2011-2025 features (JSON5, binary/octal literals, BigInt, numeric separators, etc.)
+ * - Detects internal reference errors (circular refs, undefined refs)
+ * - Configurable year-based feature detection
+ * - Exposes a positioned AST (objects, arrays, properties, literals, references, templates),
+ *   comments and tokens, so rules can select nodes and inline `eslint-disable` comments work
+ *
+ * @example
+ * // In eslint.config.mjs
+ * import jsonv from 'eslint-plugin-jsonv';
+ *
+ * export default [
+ *   {
+ *     files: ["**\/*.jsonv"],
+ *     plugins: { jsonv },
+ *     language: "jsonv/jsonv",
+ *     extends: ["jsonv/recommended"]
+ *   }
+ * ];
+ */
 /**
  * ESLint plugin export
  *
@@ -6,4 +36,5 @@ export default plugin;
  * @type {Object}
  */
 declare const plugin: Object;
+export default plugin;
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../index.mjs"],"names":[],"mappings":";AAsRA;;;;;GAKG;AACH,sBAFU,MAAM,CAkBd"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../index.mjs"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAigBH;;;;;GAKG;AACH,QAAA,MAAM,MAAM,EAFF,MAkBT,CAAC;eAEa,MAAM"}

package/dist/index.mjs

@@ -13,6 +13,8 @@
  * - Supports all ES2011-2025 features (JSON5, binary/octal literals, BigInt, numeric separators, etc.)
  * - Detects internal reference errors (circular refs, undefined refs)
  * - Configurable year-based feature detection
+ * - Exposes a positioned AST (objects, arrays, properties, literals, references, templates),
+ *   comments and tokens, so rules can select nodes and inline `eslint-disable` comments work
  *
  * @example
  * // In eslint.config.mjs
@@ -28,8 +30,8 @@
  * ];
  */
 
-// Use proper package import - package is copied to node_modules during build
-import { JsonvSyntaxError, parseWithOptions } from "@cldmv/jsonv/parser";
+import { JsonvReferenceError, JsonvSyntaxError, parseToAst, parseWithOptions } from "@cldmv/jsonv/parser";
+import { ConfigCommentParser, Directive, TextSourceCodeBase, VisitNodeStep } from "@eslint/plugin-kit";
 
 import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
@@ -77,6 +79,321 @@ const SUPPORTED_LANGUAGE_OPTIONS = new Set(["year", "strictBigInt"]);
  */
 const VALID_YEARS = new Set([2011, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025]);
 
+/**
+ * Child keys of every node type in the AST `jsonvLanguage#parse` produces, in source order
+ * where that is defined. The node types and their shapes come from @cldmv/jsonv's own AST
+ * (`@cldmv/jsonv/parser`'s `Program`/`Expression` types); the plugin only re-positions them.
+ *
+ * - `Program` — the document; `body` is the single root value.
+ * - `ObjectExpression` — `{ ... }`, with `properties` (`Property` nodes).
+ * - `Property` — `key: value`; `key` is a `Literal` (quoted or numeric key) or an `Identifier` (unquoted key).
+ * - `ArrayExpression` — `[ ... ]`, with `elements`.
+ * - `Literal` — string, number, BigInt, boolean, null, `Infinity`, `NaN` (`raw` holds the source text).
+ * - `Identifier` — an unquoted key, or an internal reference such as `backup: port`.
+ * - `MemberExpression` — a dotted internal reference such as `server.port`.
+ * - `TemplateLiteral` / `TemplateElement` — backtick strings and their `${...}` interpolations.
+ *
+ * @public
+ * @type {Readonly<Record<string, ReadonlyArray<string>>>}
+ */
+const VISITOR_KEYS = Object.freeze({
+	Program: Object.freeze(["body"]),
+	ObjectExpression: Object.freeze(["properties"]),
+	Property: Object.freeze(["key", "value"]),
+	ArrayExpression: Object.freeze(["elements"]),
+	Literal: Object.freeze([]),
+	Identifier: Object.freeze([]),
+	MemberExpression: Object.freeze(["object", "property"]),
+	TemplateLiteral: Object.freeze(["quasis", "expressions"]),
+	TemplateElement: Object.freeze([])
+});
+
+/**
+ * Line terminators, matching how @cldmv/jsonv advances its line counter (`\r\n` as one
+ * break, plus lone `\r`, `\n`, U+2028 and U+2029), so `sourceCode.lines` and
+ * `getLocFromIndex()` agree with the node positions.
+ *
+ * @public
+ * @type {RegExp}
+ */
+const LINE_ENDING_PATTERN = /\r\n|[\r\n\u2028\u2029]/u;
+
+/**
+ * Matches the comment bodies ESLint treats as inline configuration (same pattern as @eslint/json).
+ *
+ * @public
+ * @type {RegExp}
+ */
+const INLINE_CONFIG = /^\s*eslint(?:-enable|-disable(?:(?:-next)?-line)?)?(?:\s|$)/u;
+
+/**
+ * Shared parser for `eslint-*` directive comments.
+ *
+ * @public
+ * @type {ConfigCommentParser}
+ */
+const commentParser = new ConfigCommentParser();
+
+/**
+ * Tests whether a value is a positioned @cldmv/jsonv AST node.
+ * @public
+ * @param {unknown} value - Any property value of a node.
+ * @returns {boolean} `true` for an object with a string `type` and a `loc`.
+ * @example
+ * isJsonvNode({ type: "Literal", loc: { start: {}, end: {} } }); // true
+ */
+function isJsonvNode(value) {
+	return value !== null && typeof value === "object" && typeof value.type === "string" && typeof value.loc === "object";
+}
+
+/**
+ * Returns the child keys to visit for a node: its entry in {@link VISITOR_KEYS}, or — for a
+ * node type @cldmv/jsonv may add later — every key holding a node or an array of nodes.
+ * @public
+ * @param {Object} node - An AST node.
+ * @returns {ReadonlyArray<string>} Child property names.
+ * @example
+ * getChildKeys({ type: "Property", key, value }); // ["key", "value"]
+ */
+function getChildKeys(node) {
+	return (
+		VISITOR_KEYS[node.type] ??
+		Object.keys(node).filter((key) => {
+			const value = node[key];
+			return Array.isArray(value) ? value.some(isJsonvNode) : isJsonvNode(value);
+		})
+	);
+}
+
+/**
+ * Converts a @cldmv/jsonv `loc` (1-based lines, 0-based columns, 0-based `offset`s) into the
+ * ESLint `loc`/`range` pair for this language. The language declares `lineStart: 1` and
+ * `columnStart: 1`, so columns are shifted to 1-based; `range` comes from the offsets.
+ * @public
+ * @param {{start: {line: number, column: number, offset: number}, end: {line: number, column: number, offset: number}}} loc - A jsonv location.
+ * @returns {{loc: {start: {line: number, column: number}, end: {line: number, column: number}}, range: [number, number]}} The ESLint location and range.
+ * @example
+ * toEslintPosition({ start: { line: 1, column: 0, offset: 0 }, end: { line: 1, column: 3, offset: 3 } });
+ * // { loc: { start: { line: 1, column: 1 }, end: { line: 1, column: 4 } }, range: [0, 3] }
+ */
+function toEslintPosition(loc) {
+	return {
+		loc: {
+			start: { line: loc.start.line, column: loc.start.column + 1 },
+			end: { line: loc.end.line, column: loc.end.column + 1 }
+		},
+		range: [loc.start.offset, loc.end.offset]
+	};
+}
+
+/**
+ * Copies a jsonv comment or token with ESLint positions (a 1-based `loc` and a `range`).
+ * Tokens are never walked for children: some token types share a name with a node type
+ * (`Identifier`, `TemplateLiteral`) but carry no child nodes.
+ * @public
+ * @param {Object} element - A jsonv comment or token.
+ * @returns {Object} The converted copy.
+ * @example
+ * convertLeaf(parseToAst("// note\n1").comments[0]);
+ */
+function convertLeaf(element) {
+	return { ...element, ...toEslintPosition(element.loc) };
+}
+
+/**
+ * Deep-copies a jsonv AST node with ESLint positions: every node gets a 1-based `loc` and a
+ * `range`, and child nodes are converted recursively.
+ * @public
+ * @param {Object} node - A jsonv AST node.
+ * @returns {Object} The converted copy.
+ * @example
+ * convertNode(parseToAst("{ a: 1 }").program.body);
+ */
+function convertNode(node) {
+	const converted = convertLeaf(node);
+	for (const key of getChildKeys(node)) {
+		const child = node[key];
+		converted[key] = Array.isArray(child) ? child.map(convertNode) : convertNode(child);
+	}
+	return converted;
+}
+
+/**
+ * Builds the ESLint AST for a document from @cldmv/jsonv's `parseToAst()` result: the
+ * `Program` root (whose `body` is the root value) with positioned `comments` and `tokens`.
+ * @public
+ * @param {{program: Object, comments: Object[], tokens: Object[]}} astResult - The `parseToAst()` result.
+ * @returns {Object} The `Program` node.
+ * @example
+ * buildProgram(parseToAst("// note\n{ a: 1 }"));
+ */
+function buildProgram({ program, comments, tokens }) {
+	return {
+		...convertNode(program),
+		comments: comments.map(convertLeaf),
+		tokens: tokens.map(convertLeaf)
+	};
+}
+
+/**
+ * SourceCode for a parsed `.jsonv` file, modelled on @eslint/json's `JSONSourceCode`:
+ * positions, lines and text helpers come from `TextSourceCodeBase`; this class adds AST
+ * traversal, parent lookup and inline configuration (`eslint-disable*` / `eslint-enable`
+ * directives and `/* eslint rule: ... *\/` config comments).
+ *
+ * @public
+ */
+class JsonvSourceCode extends TextSourceCodeBase {
+	/**
+	 * Cached traversal steps.
+	 * @type {VisitNodeStep[]|undefined}
+	 */
+	#steps;
+
+	/**
+	 * Parent of every non-root node.
+	 * @type {WeakMap<Object, Object>}
+	 */
+	#parents = new WeakMap();
+
+	/**
+	 * Cached inline configuration comments.
+	 * @type {Object[]|undefined}
+	 */
+	#inlineConfigComments;
+
+	/**
+	 * Creates a SourceCode object.
+	 * @param {Object} options - Options.
+	 * @param {string} options.text - The source text.
+	 * @param {Object} options.ast - The `Program` node built by `jsonvLanguage#parse`.
+	 */
+	constructor({ text, ast }) {
+		super({ text, ast, lineEndingPattern: LINE_ENDING_PATTERN });
+		/** @type {Object[]} Comments in source order. */
+		this.comments = ast.comments;
+		/** @type {Object[]} Tokens in source order, excluding comments. */
+		this.tokens = ast.tokens;
+		/** @type {boolean} Whether the text starts with a byte order mark. */
+		this.hasBOM = text.charCodeAt(0) === 0xfeff;
+	}
+
+	/**
+	 * Returns the source text split into lines (a fresh copy of `lines`).
+	 * @public
+	 * @returns {string[]} The lines.
+	 */
+	getLines() {
+		return [...this.lines];
+	}
+
+	/**
+	 * Walks the AST once, recording enter/exit steps and each node's parent.
+	 * @returns {VisitNodeStep[]} The traversal steps.
+	 */
+	#ensureTraversal() {
+		if (!this.#steps) {
+			const steps = [];
+			const visit = (node, parent) => {
+				if (parent) this.#parents.set(node, parent);
+				steps.push(new VisitNodeStep({ target: node, phase: 1, args: [node, parent] }));
+				for (const key of getChildKeys(node)) {
+					const child = node[key];
+					for (const item of Array.isArray(child) ? child : [child]) visit(item, node);
+				}
+				steps.push(new VisitNodeStep({ target: node, phase: 2, args: [node, parent] }));
+			};
+			visit(this.ast, undefined);
+			this.#steps = steps;
+		}
+		return this.#steps;
+	}
+
+	/**
+	 * Returns the enter/exit visit steps for every node, depth first in source order.
+	 * @public
+	 * @returns {Iterator<VisitNodeStep>} The traversal steps.
+	 */
+	traverse() {
+		return this.#ensureTraversal().values();
+	}
+
+	/**
+	 * Returns the parent of a node, or `undefined` for the `Program` root.
+	 * @public
+	 * @param {Object} node - An AST node.
+	 * @returns {Object|undefined} The parent node.
+	 */
+	getParent(node) {
+		this.#ensureTraversal();
+		return this.#parents.get(node);
+	}
+
+	/**
+	 * Returns the comments that hold inline configuration (`eslint`, `eslint-enable`,
+	 * `eslint-disable`, `eslint-disable-line`, `eslint-disable-next-line`).
+	 * @public
+	 * @returns {Object[]} The inline configuration comments.
+	 */
+	getInlineConfigNodes() {
+		if (!this.#inlineConfigComments) {
+			this.#inlineConfigComments = this.comments.filter((comment) => INLINE_CONFIG.test(comment.value));
+		}
+		return this.#inlineConfigComments;
+	}
+
+	/**
+	 * Returns the `eslint-disable*` / `eslint-enable` directives, plus problems for malformed
+	 * ones (an `eslint-disable-line` spanning several lines).
+	 * @public
+	 * @returns {{problems: Object[], directives: Directive[]}} Directives and problems.
+	 */
+	getDisableDirectives() {
+		const problems = [];
+		const directives = [];
+
+		for (const comment of this.getInlineConfigNodes()) {
+			const { label, value, justification } = commentParser.parseDirective(comment.value);
+
+			if (label === "eslint-disable-line" && comment.loc.start.line !== comment.loc.end.line) {
+				problems.push({ ruleId: null, message: `${label} comment should not span multiple lines.`, loc: comment.loc });
+				continue;
+			}
+
+			if (label !== "eslint") {
+				directives.push(new Directive({ type: label.slice("eslint-".length), node: comment, value, justification }));
+			}
+		}
+
+		return { problems, directives };
+	}
+
+	/**
+	 * Returns the rule configurations from `/* eslint rule: ... *\/` comments, plus problems for
+	 * ones that fail to parse.
+	 * @public
+	 * @returns {{problems: Object[], configs: Array<{config: {rules: Object}, loc: Object}>}} Configs and problems.
+	 */
+	applyInlineConfig() {
+		const problems = [];
+		const configs = [];
+
+		for (const comment of this.getInlineConfigNodes()) {
+			const { label, value } = commentParser.parseDirective(comment.value);
+			if (label !== "eslint") continue;
+
+			const parseResult = commentParser.parseJSONLikeConfig(value);
+			if (parseResult.ok) {
+				configs.push({ config: { rules: parseResult.config }, loc: comment.loc });
+			} else {
+				problems.push({ ruleId: null, message: parseResult.error.message, loc: comment.loc });
+			}
+		}
+
+		return { problems, configs };
+	}
+}
+
 /**
  * Language definition for jsonv files
  *
@@ -88,13 +405,21 @@ const jsonvLanguage = {
 	fileType: "text",
 	/** Line numbering starts at 1 */
 	lineStart: 1,
-	/** Column numbering starts at 1 */
+	/** Column numbering starts at 1 (node `loc` columns are 1-based) */
 	columnStart: 1,
 	/** Property name for node types */
 	nodeTypeKey: "type",
+	/** Child keys of each AST node type, used for selector matching */
+	visitorKeys: VISITOR_KEYS,
 
 	/**
-	 * Parse jsonv source code - ESLint 9 Language API
+	 * Parse jsonv source code - ESLint Language API.
+	 *
+	 * The file is first parsed and evaluated with `parseWithOptions` — that is what reports
+	 * syntax errors, year-gated features, `strictBigInt` violations and unresolved/circular
+	 * internal references, each with its source position. A file that passes is then parsed
+	 * with `parseToAst` to build the positioned AST, comments and tokens ESLint traverses.
+	 *
 	 * @param {Object} file - File object with body property containing source text
 	 * @param {Object} context - Context with languageOptions
 	 * @returns {Object} Parse result {ok, ast, jsonvValue} or {ok: false, errors}
@@ -102,46 +427,37 @@ const jsonvLanguage = {
 	parse(file, context) {
 		const text = file.body;
 		const options = context.languageOptions || {};
+		const parseOptions = {
+			year: options.year || 2025,
+			strictBigInt: options.strictBigInt !== undefined ? options.strictBigInt : false,
+			mode: "jsonv"
+		};
 
 		try {
-			// Parse with all features enabled (ES2025) and strict mode off by default
-			const result = parseWithOptions(text, {
-				year: options.year || 2025,
-				strictBigInt: options.strictBigInt !== undefined ? options.strictBigInt : false,
-				mode: "jsonv",
-				preserveComments: true,
-				tolerant: false
-			});
-
-			// Return parse result with minimal ESTree-compatible AST
+			const jsonvValue = parseWithOptions(text, { ...parseOptions, tolerant: false });
+			const ast = buildProgram(parseToAst(text, parseOptions));
+
 			return {
 				ok: true,
-				ast: {
-					type: "Program",
-					body: [],
-					sourceType: "module",
-					comments: [],
-					tokens: []
-				},
-				// Store the parsed jsonv value for potential use by rules
-				jsonvValue: result
+				ast,
+				// The evaluated document (references resolved) for callers of parse()
+				jsonvValue
 			};
 		} catch (error) {
-			// @cldmv/jsonv (>=1.0.10) throws a `JsonvSyntaxError` — or its `LexerError` subclass, which
-			// extends it — for every parser-level and lexer-level failure, carrying the real
-			// `line`/`column`/`loc` of the failure. Its `column` is 0-based (matching the column
-			// embedded in its own messages), while this language's `columnStart: 1` means ESLint
-			// expects 1-based columns, so the reported column is `error.column + 1`.
+			// @cldmv/jsonv (>=1.1.0) throws a `JsonvSyntaxError` (or its `LexerError` subclass) for
+			// every parser-level and lexer-level failure, and a `JsonvReferenceError` for an
+			// unresolved or circular internal reference; both carry the real `line`/`column`/`loc`.
+			// Their `column` is 0-based (matching the column embedded in jsonv's messages), while
+			// this language's `columnStart: 1` means ESLint expects 1-based columns, hence `+ 1`.
 			//
-			// Unresolved-reference errors (jsonv#32, in progress) are still a plain `Error` with no
-			// position — fall back to line 1, column 1 for anything that isn't a `JsonvSyntaxError`.
-			const hasPosition = error instanceof JsonvSyntaxError;
+			// Anything else (e.g. a RangeError from exhausting the call stack on pathologically deep
+			// nesting) has no position — fall back to line 1, column 1.
+			const hasPosition = error instanceof JsonvSyntaxError || error instanceof JsonvReferenceError;
 
 			const errorInfo = hasPosition
 				? { message: error.message, line: error.line, column: error.column + 1, endLine: error.loc.end.line, endColumn: error.loc.end.column + 1 }
 				: { message: error.message, line: 1, column: 1 };
 
-			// Return error result
 			return {
 				ok: false,
 				errors: [errorInfo]
@@ -150,67 +466,16 @@ const jsonvLanguage = {
 	},
 
 	/**
-	 * Create source code object
-	 * Required by ESLint 9 language API
+	 * Create the SourceCode object ESLint hands to rules
 	 *
 	 * @public
 	 * @param {Object} file - The file object
-	 * @param {Object} parseResult - The result from parse()
-	 * @param {Object} context - Context object
-	 * @returns {Object} SourceCode object
+	 * @param {Object} parseResult - The successful result from parse()
+	 * @returns {JsonvSourceCode} SourceCode object
 	 */
-	createSourceCode(file, parseResult, context) {
+	createSourceCode(file, parseResult) {
 		const text = typeof file.body === "string" ? file.body : String(file.body || "");
-		const ast = parseResult.ast;
-
-		return {
-			text,
-			ast,
-			lines: text.split(/\r\n|[\r\n\u2028\u2029]/g),
-			hasBOM: text.charCodeAt(0) === 0xfeff,
-
-			// Required methods
-			getLoc(node) {
-				return node.loc || { start: { line: 1, column: 0 }, end: { line: 1, column: 0 } };
-			},
-
-			getRange(node) {
-				return node.range || [0, 0];
-			},
-
-			traverse() {
-				// ESLint expects: { kind: 1 (VISIT), target: node, phase: 1|2, args: [] }
-				// kind: 1 = STEP_KIND_VISIT
-				// phase: 1 = enter, 2 = exit
-				return [
-					{
-						kind: 1,
-						target: ast,
-						phase: 1,
-						args: [ast]
-					},
-					{
-						kind: 1,
-						target: ast,
-						phase: 2,
-						args: [ast]
-					}
-				].values();
-			},
-
-			// Optional helper methods
-			getText(node, beforeCount, afterCount) {
-				if (node && node.range) {
-					const [start, end] = node.range;
-					return text.slice(Math.max(0, start - (beforeCount || 0)), Math.min(text.length, end + (afterCount || 0)));
-				}
-				return text;
-			},
-
-			getLines() {
-				return text.split(/\r\n|[\r\n\u2028\u2029]/g);
-			}
-		};
+		return new JsonvSourceCode({ text, ast: parseResult.ast });
 	},
 
 	/**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cldmv/eslint-plugin-jsonv",
-	"version": "1.0.11",
+	"version": "1.0.12",
 	"description": "ESLint plugin for @cldmv/jsonv files",
 	"type": "module",
 	"main": "./dist/index.mjs",
@@ -29,14 +29,14 @@
 		"README.md"
 	],
 	"peerDependencies": {
-		"@cldmv/jsonv": "^1.0.10"
+		"@cldmv/jsonv": "^1.1.0"
 	},
 	"devDependencies": {
-		"@cldmv/jsonv": "^1.0.10",
+		"@cldmv/jsonv": "^1.1.0",
 		"@cldmv/vitest-runner": "^1.4.3",
 		"@vitest/coverage-v8": "^5.0.2",
 		"eslint": "^10.11.0",
-		"typescript": "^5.9.3",
+		"typescript": "^7.0.2",
 		"vitest": "^5.0.2"
 	},
 	"keywords": [
@@ -81,5 +81,8 @@
 	"homepage": "https://github.com/CLDMV/jsonv-eslint-plugin-jsonv/#readme",
 	"engines": {
 		"node": ">=18.0.0"
+	},
+	"dependencies": {
+		"@eslint/plugin-kit": "^0.7.3"
 	}
 }