@cldmv/eslint-plugin-jsonv 1.0.10 → 1.0.12

package/LICENSE

@@ -1,210 +1,202 @@
-Apache License
-Version 2.0, January 2004
-http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License.
-
-   Subject to the terms and conditions of this License, each Contributor
-   hereby grants to You a perpetual, worldwide, non-exclusive, no-charge,
-   royalty-free, irrevocable copyright license to reproduce, prepare
-   Derivative Works of, publicly display, publicly perform, sublicense,
-   and distribute the Work and such Derivative Works in Source or Object
-   form.
-
-3. Grant of Patent License.
-
-   Subject to the terms and conditions of this License, each Contributor
-   hereby grants to You a perpetual, worldwide, non-exclusive, no-charge,
-   royalty-free, irrevocable (except as stated in this section) patent
-   license to make, have made, use, offer to sell, sell, import, and
-   otherwise transfer the Work, where such license applies only to those
-   patent claims licensable by such Contributor that are necessarily
-   infringed by their Contribution(s) alone or by combination of their
-   Contribution(s) with the Work to which such Contribution(s) was
-   submitted. If You institute patent litigation against any entity
-   (including a cross-claim or counterclaim in a lawsuit) alleging that
-   the Work or a Contribution incorporated within the Work constitutes
-   direct or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate as of
-   the date such litigation is filed.
-
-4. Redistribution.
-
-   You may reproduce and distribute copies of the Work or Derivative
-   Works thereof in any medium, with or without modifications, and in
-   Source or Object form, provided that You meet the following conditions:
-
-   (a) You must give any other recipients of the Work or Derivative Works
-   a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-   stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works that
-   You distribute, all copyright, patent, trademark, and attribution
-   notices from the Source form of the Work, excluding those notices
-   that do not pertain to any part of the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-   distribution, then any Derivative Works that You distribute must
-   include a readable copy of the attribution notices contained
-   within such NOTICE file, excluding those notices that do not
-   pertain to any part of the Derivative Works, in at least one
-   of the following places: within a NOTICE text file distributed
-   as part of the Derivative Works; within the Source form or
-   documentation, if provided along with the Derivative Works; or,
-   within a display generated by the Derivative Works, if and
-   wherever such third-party notices normally appear. The contents
-   of the NOTICE file are for informational purposes only and
-   do not modify the License. You may add Your own attribution
-   notices within Derivative Works that You distribute, alongside
-   or as an addendum to the NOTICE text from the Work, provided
-   that such additional attribution notices cannot be construed
-   as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions.
-
-   Unless You explicitly state otherwise, any Contribution intentionally
-   submitted for inclusion in the Work by You to the Licensor shall be
-   under the terms and conditions of this License, without any additional
-   terms or conditions. Notwithstanding the above, nothing herein shall
-   supersede or modify the terms of any separate license agreement you
-   may have executed with Licensor regarding such Contributions.
-
-6. Trademarks.
-
-   This License does not grant permission to use the trade names,
-   trademarks, service marks, or product names of the Licensor, except
-   as required for describing the origin of the Work and reproducing
-   the content of the NOTICE file.
-
-7. Disclaimer of Warranty.
-
-   Unless required by applicable law or agreed to in writing, Licensor
-   provides the Work (and each Contributor provides its Contributions)
-   on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
-   either express or implied, including, without limitation, any
-   warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY,
-   or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for
-   determining the appropriateness of using or redistributing the Work
-   and assume any risks associated with Your exercise of permissions
-   under this License.
-
-8. Limitation of Liability.
-
-   In no event and under no legal theory, whether in tort (including
-   negligence), contract, or otherwise, unless required by applicable
-   law (such as deliberate and grossly negligent acts) or agreed to in
-   writing, shall any Contributor be liable to You for damages, including
-   any direct, indirect, special, incidental, or consequential damages
-   of any character arising as a result of this License or out of the
-   use or inability to use the Work (including but not limited to damages
-   for loss of goodwill, work stoppage, computer failure or malfunction,
-   or any and all other commercial damages or losses), even if such
-   Contributor has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability.
-
-   While redistributing the Work or Derivative Works thereof, You may choose
-   to offer, and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this License.
-   However, in accepting such obligations, You may act only on Your own behalf
-   and on Your sole responsibility, not on behalf of any other Contributor,
-   and only if You agree to indemnify, defend, and hold each Contributor
-   harmless for any liability incurred by, or claims asserted against, such
-   Contributor by reason of your accepting any such warranty or additional
-   liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-To apply the Apache License to your work, attach the following boilerplate
-notice, with the fields enclosed by brackets "[]" replaced with your own
-identifying information. (Don't include the brackets!) The text should be
-enclosed in the appropriate comment syntax for the file format. We also
-recommend that a file or class name and description of purpose be included
-on the same "printed page" as the copyright notice for easier
-identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

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":";AAuNA;;;;;GAKG;AACH,sBAFU,MAAM,CAqBd"}
+{"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,369 @@
  * ];
  */
 
-// Use proper package import - package is copied to node_modules during build
-import { 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";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/**
+ * Reads this package's own `name` and `version` from its `package.json`.
+ *
+ * `scripts/build.mjs` copies this file verbatim into `dist/index.mjs` — one directory
+ * deeper than the source file — so `package.json` sits alongside the source copy but
+ * one level up from the built copy. Check the co-located path first and fall back to
+ * the parent directory so this resolves correctly from either location.
+ *
+ * @public
+ * @returns {{name: string, version: string}} The package's `name` and `version`.
+ * @example
+ * const { name, version } = readPackageMeta();
+ */
+function readPackageMeta() {
+	const here = dirname(fileURLToPath(import.meta.url));
+	const localPath = join(here, "package.json");
+	const pkgPath = existsSync(localPath) ? localPath : join(here, "..", "package.json");
+	const require = createRequire(import.meta.url);
+	const { name, version } = require(pkgPath);
+	return { name, version };
+}
+
+/**
+ * Language options `jsonvLanguage#parse` reads from `context.languageOptions` and
+ * forwards to `@cldmv/jsonv`'s `parseWithOptions`. Any other key is rejected by
+ * `validateLanguageOptions` since it would silently do nothing.
+ *
+ * @public
+ * @type {Set<string>}
+ */
+const SUPPORTED_LANGUAGE_OPTIONS = new Set(["year", "strictBigInt"]);
+
+/**
+ * Valid `year` language option values, matching @cldmv/jsonv's `ParseOptions["year"]`
+ * union (see `@cldmv/jsonv/parser`'s `ParseOptions` type).
+ *
+ * @public
+ * @type {Set<number>}
+ */
+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
@@ -42,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}
@@ -56,157 +427,114 @@ 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) {
-			// Return error result
+			// @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`.
+			//
+			// 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 {
 				ok: false,
-				errors: [
-					{
-						message: error.message,
-						line: error.line || 1,
-						column: error.column || 1
-					}
-				]
+				errors: [errorInfo]
 			};
 		}
 	},
 
 	/**
-	 * 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 });
 	},
 
 	/**
 	 * Validate language options
-	 * Required by ESLint 9 language API
+	 * Required by ESLint 9 language API. ESLint calls this with the languageOptions
+	 * already merged with `defaultLanguageOptions` below, so `languageOptions` here
+	 * reflects the effective options that will reach `parse()`.
 	 *
 	 * @public
-	 * @param {Object} languageOptions - The language options to validate
+	 * @param {Object} languageOptions - The (already-merged) language options to validate
 	 * @returns {void}
+	 * @throws {TypeError} When an unsupported key is present, or a supported key holds an invalid value
 	 */
-	validateLanguageOptions(___languageOptions) {
-		// No validation needed - all options are optional
-		// year, strictBigInt, mode, preserveComments, tolerant
-	},
+	validateLanguageOptions(languageOptions) {
+		const options = languageOptions ?? {};
 
-	/**
-	 * Validate language options
-	 * Required by ESLint 9 language API
-	 *
-	 * @public
-	 * @param {Object} languageOptions - The language options to validate
-	 * @returns {void}
-	 */
-	validateLanguageOptions(___languageOptions) {
-		// No validation needed - all options are optional
-		// year, strictBigInt, mode, preserveComments, tolerant
+		for (const key of Object.keys(options)) {
+			if (!SUPPORTED_LANGUAGE_OPTIONS.has(key)) {
+				throw new TypeError(`Unknown language option "${key}". Supported options are: ${[...SUPPORTED_LANGUAGE_OPTIONS].join(", ")}.`);
+			}
+		}
+
+		if (options.year !== undefined && !VALID_YEARS.has(options.year)) {
+			throw new TypeError(
+				`Invalid "year" language option: ${JSON.stringify(options.year)}. Supported years are: ${[...VALID_YEARS].join(", ")}.`
+			);
+		}
+
+		if (options.strictBigInt !== undefined && typeof options.strictBigInt !== "boolean") {
+			throw new TypeError(`Invalid "strictBigInt" language option: expected a boolean, got ${typeof options.strictBigInt}.`);
+		}
 	},
 
-	/**	 * Default parser options
+	/**
+	 * Default language options
+	 * Required by ESLint 9 language API to supply defaults when a config specifies
+	 * none — ESLint deep-merges this with the config's `languageOptions` before
+	 * calling `validateLanguageOptions` and `parse()`.
 	 *
 	 * @public
 	 * @type {Object}
 	 */
-	defaultParserOptions: {
+	defaultLanguageOptions: {
 		year: 2025,
-		strictBigInt: false,
-		mode: "jsonv"
+		strictBigInt: false
 	}
 };
 
 /**
  * Recommended configuration for jsonv files
  *
+ * `languageOptions.parser` is intentionally omitted: that field is only read by
+ * ESLint's built-in "js" language (for its legacy custom-parser support) — a custom
+ * `language` such as `jsonv/jsonv` never consults it, so setting it here was inert.
+ *
  * @public
  * @type {Object}
  */
 const recommendedConfig = {
-	languageOptions: {
-		parser: jsonvLanguage
-	},
 	rules: {
 		// Add custom jsonv rules here in the future
 		// For now, parsing validation is enough
@@ -220,10 +548,7 @@ const recommendedConfig = {
  * @type {Object}
  */
 const plugin = {
-	meta: {
-		name: "eslint-plugin-jsonv",
-		version: "0.1.0"
-	},
+	meta: readPackageMeta(),
 	languages: {
 		jsonv: jsonvLanguage
 	},

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cldmv/eslint-plugin-jsonv",
-	"version": "1.0.10",
+	"version": "1.0.12",
 	"description": "ESLint plugin for @cldmv/jsonv files",
 	"type": "module",
 	"main": "./dist/index.mjs",
@@ -13,8 +13,13 @@
 	},
 	"scripts": {
 		"build": "npm run build:js && npm run build:types",
+		"build:ci": "npm run lint --if-present && npm run format:check --if-present && npm run build",
 		"build:js": "node scripts/build.mjs",
-		"build:types": "tsc -p .configs/tsconfig.types.json"
+		"build:types": "tsc -p .configs/tsconfig.types.json",
+		"test": "node tests/run-vitest.mjs",
+		"test:watch": "vitest --config .configs/vitest.config.mjs",
+		"coverage": "node tests/run-vitest.mjs --coverage-quiet",
+		"ci:coverage": "npm run coverage"
 	},
 	"publishConfig": {
 		"access": "public"
@@ -24,11 +29,15 @@
 		"README.md"
 	],
 	"peerDependencies": {
-		"@cldmv/jsonv": "^1.0.2"
+		"@cldmv/jsonv": "^1.1.0"
 	},
 	"devDependencies": {
-		"@cldmv/jsonv": "^1.0.2",
-		"typescript": "^5.9.3"
+		"@cldmv/jsonv": "^1.1.0",
+		"@cldmv/vitest-runner": "^1.4.3",
+		"@vitest/coverage-v8": "^5.0.2",
+		"eslint": "^10.11.0",
+		"typescript": "^7.0.2",
+		"vitest": "^5.0.2"
 	},
 	"keywords": [
 		"eslint",
@@ -72,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"
 	}
 }