mdrefine 0.2.0-rc.2 → 0.2.0

package/CONTRIBUTING.md

@@ -1,18 +1,191 @@
 # Contributing
 
-Human and agent-authored issues and pull requests are welcome. Read the
-[contribution guide](https://viell-dev.github.io/slop-markdown-tools/contributing.html)
-for defect reports, development, verification, and PR policy. This project is
-entirely agent-authored and agent-maintained, as described in
-[README.md](README.md); no person reads or reviews its code. Write issue and PR
-descriptions for a reader who has not seen the code.
-
-Changes to document rendering need a minimal synthetic regression example.
-Remove private vault content and credentials from all reports. Report security
-vulnerabilities through the channel in [SECURITY.md](SECURITY.md).
-
-For issue and PR triage, follow the
-[label policy](docs/contributing.md#issue-and-pull-request-labels) and the
-[exact label catalog](https://github.com/viell-dev/slop-markdown-tools/blob/main/.github/labels.json).
-Reassess labels whenever an item is answered, closed, reopened, or otherwise
-updated.
+Issues and pull requests from people and from agents are welcome. The project is
+maintained by AI agents, as the [README](README.md#status) says, and its owner
+follows it through issue and pull request descriptions rather than code, so
+write them for a reader who has not seen the code. Agents maintaining the
+repository also follow [AGENTS.md](AGENTS.md). Everyone follows the [code of
+conduct](CODE_OF_CONDUCT.md).
+
+## Report a defect
+
+Search the open and closed
+[issues](https://github.com/viell-dev/slop-markdown-tools/issues) first, then
+open one with the bug form's details:
+
+- the mdrefine version, the Node.js version, the operating system, and the exact
+  command;
+- the dialect in effect, and the configuration, with any plugins;
+- a minimal Markdown input, synthetic or public;
+- the actual output or diagnostics, with the `--json` report when you have one;
+- the expected output, and how the rendering differs.
+
+A screenshot can show a rendering difference, but only the Markdown source
+reproduces it. Remove private content from every example. Agents should open an
+issue only when their operator has authorized publishing it. Report
+vulnerabilities privately, as [SECURITY.md](SECURITY.md) describes.
+
+## Set up
+
+Development needs Node.js 22.22.2 or newer, or 24.15.0 or newer (24 is
+preferred), and npm 10 or newer.
+
+```sh
+git clone https://github.com/viell-dev/slop-markdown-tools.git
+cd slop-markdown-tools
+npm ci
+npm run build
+node dist/cli/main.js --help
+```
+
+In a checkout, `node dist/cli/main.js` takes the place of `npx mdtools`. A built
+checkout can also be installed into another project as a local dependency.
+
+## Checks
+
+```sh
+npm run check
+npm run test:package
+```
+
+`check` runs the TypeScript checks, ESLint, Prettier on everything but Markdown,
+the tool's own lint and format check of the Markdown, the documentation site's
+build, and both test suites. `test:package` packs the package, installs it into
+a temporary project with npm and again with pnpm, whose strict layout lets a
+package use only the dependencies it declares, and runs the installed command,
+the library through `import` and `require()`, a shipped example, and TypeScript
+consumers of the published types. npm fetches the pinned pnpm into the
+repository's cache, and both installations can need access to the npm registry.
+
+The configuration's JSON Schema is `src/config/resolve.ts`'s `configSchema`.
+`npm run schema` writes it to `config.schema.json`, which the package ships and
+the site serves; a test fails when the two differ.
+
+GitHub Actions runs `check` and a dependency audit on Linux with Node.js 24, the
+build and tests on Linux with Node.js 22.12.0, the lowest version the package
+supports, on Windows with Node.js 24, and on Linux with Node.js 26, and
+`test:package` on all four. `main` requires the first three. The Node.js 26 job
+is not required, so that a defect only the newest Node.js shows does not block
+unrelated merges; its failures get an issue. Windows covers file paths, access
+control lists, junctions, and the installed command; macOS is not a routine
+target.
+
+## Dependencies
+
+Every dependency is pinned to an exact version, and the lockfile is committed.
+For the runtime dependencies this is deliberate: a formatter's output should
+depend only on its own version, and an update of the parser can change it, so a
+dependency update reaches users only in a release of mdrefine whose tests passed
+with it. `@types/node` stays on the major version of the lowest supported
+Node.js version, 22, so that the type check rejects interfaces that Node.js 22
+does not have; the CI job on 22.12.0 catches those that later 22.x releases
+added.
+
+Dependabot proposes updates weekly, the development dependencies as one group,
+and only versions published at least seven days earlier, which leaves time for a
+broken or compromised release to be found. Security updates are not delayed.
+
+## Tests
+
+| Command                    | Runs                                  |
+| -------------------------- | ------------------------------------- |
+| `npm test`                 | The build, then both suites           |
+| `npm run test:unit`        | The unit suite; needs no build        |
+| `npm run test:integration` | The build, then the integration suite |
+
+The suites run one after the other, because the processes that integration tests
+start would make the time limits of a few unit tests unreliable.
+
+`tests/unit/` imports from `src/` and touches neither files nor other processes.
+A defect in how a rule reads or rewrites Markdown belongs here, as the smallest
+synthetic document that shows it, usually checked together with the contracts of
+every formatting change: formatting the output again changes nothing, the parsed
+meaning is unchanged, and disabling the rule leaves the source as written. Rules
+are tested in `rules.test.ts`, list rules in `lists.test.ts`, code fences,
+thematic breaks, and blank space in `blocks.test.ts`, problem rules in
+`references.test.ts`, `structure.test.ts`, and `content.test.ts`, wrapping in
+`wrap.test.ts` and `callout-wrap.test.ts`, links in `links.test.ts`, dollar math
+in `math.test.ts` against the renderers' output recorded in `math-renderers.ts`,
+the engine, configuration, and plugins in `engine.test.ts`, and the diff that
+`format` prints in `diff.test.ts`.
+
+`tests/integration/` runs the built CLI as a child process in temporary
+workspaces, and runs `examples/` and `benchmarks/` as they are, without the
+machine's user and system Git settings, which would change what Git ignores. A
+defect in what the tool selects, prints, writes, or how it exits belongs here:
+`cli.test.ts` for commands and options, `selection.test.ts` for which files a
+run selects, compared with Git's own decisions, `workflows.test.ts` for whole
+tasks, `node.test.ts` for `mdrefine/node`, and `examples.test.ts` and
+`docs.test.ts` for the examples and documentation. `support.ts` holds the
+helpers: `fixture()` writes a temporary workspace, `run()` starts the CLI,
+`restrict()` and `denyRead()` take away read permission on Unix and on Windows,
+`denyWrite()` takes away write permission on Windows, `windowsTool()` runs a
+program of Windows such as `icacls.exe`, and `linkDirectory()` links a
+directory, as a junction on Windows. Tests that need Unix permission modes are
+skipped on Windows and for the root user, and one that links a file needs
+`canSymlink`.
+
+A test marked `it.fails` reproduces a confirmed defect that is not fixed yet and
+names its issue; remove the marker with the fix. A few unit tests guard against
+algorithms whose cost grows faster than their input; add one with the fix for
+such a defect.
+
+## Benchmarks
+
+`npm run benchmark` times the tool on generated documents; it takes a few
+minutes, is not part of `check`, and never fails on a slow result. Run it before
+and after a change that could affect speed, on the same idle machine, and
+compare as the [benchmarks
+page](https://viell-dev.github.io/slop-markdown-tools/benchmarks.html#run-it-and-compare)
+explains. The reference results on that page come from the Benchmark workflow on
+a GitHub-hosted runner, which runs for pull requests that change `benchmarks/`
+and on request (`gh workflow run benchmark.yml --ref <branch>`); replace them
+only from such a run.
+
+## Documentation
+
+The site's source is `docs/`, built by VitePress. The tool formats and lints the
+repository's own Markdown at 80 columns; Prettier formats everything else and
+leaves Markdown alone. The fixtures in `tests/fixtures/` and the documents of
+`examples/workspaces/` and `examples/plugin/notes/` are left unformatted on
+purpose.
+
+```sh
+npm run format:docs        # format the Markdown
+npm run format:docs:check  # lint it and check its format without writing
+npm run format             # both formatters
+npm run docs:dev           # preview the site while editing
+npm run docs:build && npm run docs:preview
+```
+
+The preview's address includes the `/slop-markdown-tools/` base path. The site
+build fails on a link to a page that does not exist, and the tool's lint fails
+on a heading fragment that does not. The integration tests compare the examples
+page, the rule index, and the benchmark page with the code, so update them with
+the behavior they describe. CI builds the site for every pull request. The site
+describes the newest stable release: the Pages workflow deploys it from that
+release's tag after the Release workflow publishes it, as
+[RELEASING.md](RELEASING.md) describes. GitHub Pages must use GitHub Actions as
+its source.
+
+## Pull requests
+
+Every change to `main` goes through a pull request with passing CI, and is
+merged with a merge commit; `main` requires three of the CI checks and resolved
+review threads, but no approval from a second account. Contributions are made
+under the MIT license. Keep discussion respectful and about reproducible
+behavior; harassment and disclosure of private data are not acceptable.
+
+- Describe the problem, the resulting behavior, and the decisions made and why,
+  for a reader who will not read the diff. Link the issue.
+- A change to formatting needs tests of the expected output, of formatting
+  twice, and of preserved meaning; a defect that changes rendering needs a
+  minimal regression example.
+- Update every document, example, and test that describes what you changed, in
+  the same pull request, and add the change to the `Unreleased` section of
+  [CHANGELOG.md](CHANGELOG.md).
+- A change to the command line, the configuration, the JSON report, or the
+  library that is not a defect fix waits for the next minor release; see the
+  [versioning
+  policy](https://viell-dev.github.io/slop-markdown-tools/versions.html).
+- Keep changes scoped, and state remaining limits.

package/README.md

@@ -1,173 +1,119 @@
-# mdrefine — Markdown Tools
-
-Configurable linting and formatting for CommonMark, GitHub Markdown, Forgejo
-(Codeberg), Gitea, and Obsidian. Separate `lint` and `format` commands share
-syntax, style settings, and an extensible rule engine.
-
-[npm package](https://www.npmjs.com/package/mdrefine) ·
-[GitHub releases](https://github.com/viell-dev/slop-markdown-tools/releases)
-
-## Maintenance
-
-This project is entirely agent-authored and agent-maintained. AI agents wrote
-the code, tests, documentation, CI, and release tooling, and agents implement,
-verify, and merge every change. It is **not human-maintained**; do not assume
-that a person has reviewed generated changes. The repository owner does not
-write, read, or review code, does not know the codebase or API, and does not use
-the tool directly. They guide the project lightly, from what they can see: the
-public documentation, issue and PR descriptions, and Markdown documents that
-agents have processed with the tool. They assign agents to tasks; the assigned
-agents make the architectural and design decisions and keep every part of the
-repository consistent with the rest. Human and agent-authored issues and pull
-requests are welcome. Reproducible examples, automated checks, and regression
-tests guide maintenance.
-
-The project is currently an early prerelease. Report document corruption or
-changed rendering with a minimal input, the configuration, actual output, and
-expected output. Remove private content before posting examples. Agents using
-the tool should report reproducible defects when their operator has authorized
-publishing an issue.
-
-## Documentation
-
-Read the
-[quick start](https://viell-dev.github.io/slop-markdown-tools/quick-start.html)
-or browse the
-[documentation site](https://viell-dev.github.io/slop-markdown-tools/). It
-covers CLI workflows, configuration and rules, Obsidian vaults, plugins, and
-current limitations. The Markdown source lives in `docs/`. Working
-[examples](https://viell-dev.github.io/slop-markdown-tools/examples.html) live
-in `examples/` and ship with the package: starting configurations, workspaces
-before and after formatting, a plugin, and library scripts.
-
-## Getting started
-
-The CLI requires Node.js 22.12 or newer. The npm package is `mdrefine`; the
-executable is `mdtools`. To install the release candidate in your document
-workspace:
-
-```sh
-npm install --save-dev --save-exact mdrefine@0.2.0-rc.2
-npx --no-install mdtools --help
+# mdrefine
+
+Lint and format Markdown for GitHub, Forgejo, Gitea, Obsidian, or any CommonMark
+renderer, with one configuration for both.
+
+[![npm](https://img.shields.io/npm/v/mdrefine)](https://www.npmjs.com/package/mdrefine)
+[![CI](https://github.com/viell-dev/slop-markdown-tools/actions/workflows/ci.yml/badge.svg)](https://github.com/viell-dev/slop-markdown-tools/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/npm/l/mdrefine)](LICENSE)
+
+mdrefine is meant to replace a general-purpose linter and formatter, such as
+markdownlint and Prettier, for Markdown. It does not cover all of their checks
+yet; [the
+comparison](https://viell-dev.github.io/slop-markdown-tools/integrations.html#coming-from-prettier-or-markdownlint)
+shows which have a rule.
+
+- **One configuration for lint and format.** Style rules report in `lint` and
+  fix in `format`; problem rules report what has no single correct repair.
+- **Changes only what its rules target.** Everything else stays byte for byte as
+  written, and an edit that would change a document's parsed meaning is refused.
+- **Dialect-aware.** CommonMark, GitHub, Forgejo and Codeberg, Gitea, and
+  Obsidian: tables, math, wikilinks, and callouts are read as each renderer
+  reads them.
+- **Checks local links** and their heading and block fragments, with each
+  renderer's anchors.
+- **Extensible.** Plugins add rules, presets, and syntax, and a library runs the
+  same engine without the command line.
+
+## Example
+
+```markdown
+Weather Station collects *temperature*, *humidity*, and *pressure* readings from a sensor board.
+
+> [!note]
+> Use matching firmware and page versions, or the page shows __no data__.
+
+| Sensor | Unit |
+|---|---|
+| Temperature | °C |
 ```
 
-See the
-[release procedure](https://viell-dev.github.io/slop-markdown-tools/releases.html)
-for registry availability, preparation, and authentication requirements.
-
-Inspect your documents from the workspace where you installed the package:
-
-```sh
-npx --no-install mdtools lint --root /path/to/documents --json
-npx --no-install mdtools format --root /path/to/documents --diff
-npx --no-install mdtools format --root /path/to/documents --write
-npx --no-install mdtools format --root /path/to/documents --check
-```
+`npx mdtools format --write` with the `recommended` and `github` presets turns
+it into:
 
-`lint` never writes documents. `format` previews a diff by default for file
-inputs and writes only with `--write`. For stdin, `format -` returns formatted
-Markdown on stdout. Diagnostics use stderr unless `--json` requests a structured
-report. `--no-install` prevents fetching a different package if the local
-executable is missing.
+```markdown
+Weather Station collects _temperature_, _humidity_, and _pressure_ readings from
+a sensor board.
 
-Without a configuration file, the commands apply the `recommended` preset and
-assume GitHub Markdown, or the Obsidian dialect for documents inside an Obsidian
-vault. Version 0.2.0-rc.1 and earlier assumed CommonMark, in which formatting
-reflows tables and joins the lines of a note. The quick start shows how to
-choose a profile for GitHub, Forgejo, Gitea, Obsidian, or plain CommonMark.
+> [!NOTE]
+> Use matching firmware and page versions, or the page shows **no data**.
 
-## Build from source
-
-For development, use Node.js 22.22.2+ or 24.15.0+ and npm 10 or newer; Node.js
-24 LTS is preferred.
-
-```sh
-git clone https://github.com/viell-dev/slop-markdown-tools.git
-cd slop-markdown-tools
-npm ci
-npm run build
-node dist/cli/main.js --help
+| Sensor      | Unit |
+| ----------- | ---- |
+| Temperature | °C   |
 ```
 
-From the checkout, use `node dist/cli/main.js` in place of
-`npx --no-install mdtools` in the examples above. You can also install the built
-checkout as a local dependency.
-
-## Contributions and verification
-
-All changes to `main` require a pull request and passing CI, including
-prerelease maintenance. Published npm versions and release tags are immutable;
-corrections get a new version. See [CONTRIBUTING.md](CONTRIBUTING.md) and
-[SECURITY.md](SECURITY.md) for contribution and vulnerability reporting.
+## Install
 
-Issues and PRs from people and agents are welcome. For defects, include the
-version, command, configuration, minimal Markdown input, actual output, and
-expected rendering. A screenshot can help explain a visible defect, but the
-Markdown source is needed to reproduce it. For agents, include the JSON
-diagnostic output when available. Automatic issue reporting is not built into
-the tool.
+mdrefine needs Node.js 22.12 or newer. The package is `mdrefine`, and its
+command is `mdtools`:
 
 ```sh
-npm run check
-npm run test:package
+npm install --save-dev --save-exact mdrefine@0.2.0
+npx mdtools lint
+npx mdtools format --diff
+npx mdtools format --write
+npx mdtools format --check
 ```
 
-The project uses Markdown Tools to lint and format its own Markdown at the
-default 80-column width. `npm run format:docs` formats Markdown;
-`npm run format:docs:check` checks it without writing. Prettier formats
-implementation and configuration files and excludes Markdown. `npm run format`
-runs both formatters. Markdown fixtures under `tests/fixtures/` and the example
-documents under `examples/workspaces/` and `examples/plugin/notes/` are excluded
-from documentation passes, because they are deliberately unformatted.
-
-`npm-run-all2` coordinates scripts, running independent checks in parallel and
-building the CLI before documentation checks and tests.
-
-`check` runs strict TypeScript checks, ESLint, Prettier for non-Markdown files,
-Markdown Tools for documentation, the VitePress site build, and both test
-suites. Unit tests in `tests/unit/` call the library's source; integration tests
-in `tests/integration/` run the built CLI on real files and check the examples
-and documentation against the tool. `npm run test:unit` and
-`npm run test:integration` run one suite; see
-[testing](https://viell-dev.github.io/slop-markdown-tools/testing.html). GitHub
-Actions runs full checks on Linux with Node.js 24, plus build and test coverage
-on Linux with Node.js 22 and Windows with Node.js 24. All three jobs verify the
-installed package. Changes to formatting need tests for expected output,
-idempotence, and preserved semantics; defects should add a regression example.
-Keep fixes scoped and describe remaining limitations in the PR.
-
-Agent contributors should read
-[AGENTS.md](https://github.com/viell-dev/slop-markdown-tools/blob/main/AGENTS.md)
-for maintenance-specific instructions, including what an assigned agent decides
-and the limits of that authority. `test:package` packs and installs a temporary
-consumer project, then exercises the installed CLI and library; it can require
-access to the npm registry.
-
-## Benchmarks
+`lint` reports and never writes. `format` shows a diff, writes with `--write`,
+and with `--check` fails when a document would change.
 
-```sh
-npm run benchmark
-```
-
-The benchmark times parsing, linting, and formatting of synthetic documents
-through the library and the CLI, with Prettier on the same files for comparison.
-It takes a few minutes and is not part of `check`.
-[Benchmarks](https://viell-dev.github.io/slop-markdown-tools/benchmarks.html)
-explains what each number means and whether it is good.
+## Configure
 
-## Documentation website
+`mdtools.config.jsonc` at the root of the documents:
 
-```sh
-npm run docs:dev
-npm run docs:build
-npm run docs:preview
+```jsonc
+{
+  "extends": ["recommended", "github"],
+}
 ```
 
-VitePress renders `docs/`; Markdown Tools formats its Markdown sources. The
-Pages workflow builds from `main` and deploys the generated artifact. No
-publishing branch or committed build output is needed. See the
-[documentation workflow](https://viell-dev.github.io/slop-markdown-tools/contributing.html#write-and-preview-documentation).
+`recommended` wraps prose at 80 columns; writes emphasis as `_text_`, strong
+text as `**text**`, list items as `- item` and `1. item`, headings with `#`,
+code fences with backticks, and thematic breaks as `---`; aligns tables; removes
+trailing spaces and repeated blank lines; ends files with a line break; and
+checks links. It also warns about references without a definition, unused
+definitions, empty links, skipped heading levels, images without alternative
+text, and table rows with the wrong number of cells. Use `forgejo`, `codeberg`,
+`gitea`, or `obsidian` in place of `github` for documents rendered there.
 
-## License
+## Documentation
 
-[MIT](LICENSE).
+The [documentation](https://viell-dev.github.io/slop-markdown-tools/) starts
+with [getting
+started](https://viell-dev.github.io/slop-markdown-tools/quick-start.html) and
+covers the [rules](https://viell-dev.github.io/slop-markdown-tools/rules.html),
+configuration, the command line, Obsidian vaults, CI and editors, the library
+and plugins, and [what is not covered
+yet](https://viell-dev.github.io/slop-markdown-tools/design.html#limits). The
+package ships working
+[examples](https://viell-dev.github.io/slop-markdown-tools/examples.html) and
+the [changelog](CHANGELOG.md).
+
+## Status
+
+mdrefine follows a [pre-1.0 versioning
+policy](https://viell-dev.github.io/slop-markdown-tools/versions.html): a minor
+release may change behavior and says how, and a patch release only fixes
+defects. It is written and maintained by AI agents, and no person reviews the
+code. Changes are accepted on their tests, CI on Linux and Windows, and a
+semantic check that refuses any formatting edit that would change a document's
+parsed meaning.
+
+## Contributing, security, and license
+
+[CONTRIBUTING.md](CONTRIBUTING.md) explains how to report a defect and how to
+make a change, and [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) what is expected of
+everyone who takes part. Report vulnerabilities as [SECURITY.md](SECURITY.md)
+describes. mdrefine is released under the [MIT license](LICENSE).

package/SECURITY.md

@@ -1,17 +1,19 @@
 # Security policy
 
-Report suspected vulnerabilities through
-[GitHub private vulnerability reporting](https://github.com/viell-dev/slop-markdown-tools/security/advisories/new).
-Include the affected version, configuration, and a minimal synthetic example. Do
-not disclose exploitable details or private documents in a public issue.
+Report a suspected vulnerability through [GitHub's private vulnerability
+reporting](https://github.com/viell-dev/slop-markdown-tools/security/advisories/new),
+with the affected version, the configuration, and a minimal synthetic example.
+Do not put exploitable details or private documents in a public issue.
 
-This project is authored and maintained by agents, without a guaranteed response
-time. Reports are handled by an agent assigned by the repository owner; no
-person reads the code. Security fixes target the latest prerelease until a
-stable release exists; older prereleases do not receive separate backports.
+Reports are handled by an AI agent that the repository owner assigns, without a
+guaranteed response time. Fixes go into the newest release line; older versions
+and prereleases do not receive backports.
 
-JavaScript configuration and plugins execute with the caller's permissions. Only
-load trusted code. JSON configuration is data, but its plugin entries can still
-load executable code. Link validation does not fetch external URLs. Document
-rendering defects without a security impact belong in ordinary issues; remove
-private content before posting.
+JavaScript configuration files and plugins run with the permissions of whoever
+runs the tool, so load only code you trust. A JSON configuration is data, but
+its `plugins` entries still load code. In a Git repository, the command line
+runs Git (`git config` and `git ls-files`) to read the ignore rules that Git
+applies. It turns off the file system monitor, which a repository's own
+configuration could otherwise name as a program to run, and on Windows it runs
+Git only from an absolute folder of `PATH`. Link checks never fetch URLs. A
+rendering defect without a security impact belongs in an ordinary issue.

package/config.schema.json

@@ -0,0 +1,91 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "mdtools configuration",
+  "description": "Configuration of the mdtools command of mdrefine: https://viell-dev.github.io/slop-markdown-tools/configuration.html",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "$schema": {
+      "description": "The JSON Schema for editors; the tool ignores it.",
+      "type": "string"
+    },
+    "resolve": {
+      "description": "Files that links may lead to, which are never linted or formatted.",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "gitIgnored": {
+          "description": "Files that .gitignore files exclude are link targets. Default: false.",
+          "type": "boolean"
+        },
+        "nestedRepositories": {
+          "description": "Files of nested Git repositories are link targets. Default: false.",
+          "type": "boolean"
+        }
+      }
+    },
+    "extends": {
+      "description": "Presets to start from, in order: a preset name or a list of them. Without it, the configuration starts from recommended.",
+      "anyOf": [{ "type": "string" }, { "type": "array", "items": { "type": "string" } }]
+    },
+    "dialect": { "$ref": "#/definitions/dialect" },
+    "rules": { "$ref": "#/definitions/rules" },
+    "ignore": {
+      "description": "Path patterns of documents that are never linted or formatted, matched with their letter case. They stay link targets.",
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "plugins": {
+      "description": "Plugins to load: files relative to this file, or package names.",
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "overrides": {
+      "description": "Settings for the documents that match one of the patterns in files.",
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["files"],
+        "additionalProperties": false,
+        "properties": {
+          "files": {
+            "description": "Path patterns, matched with their letter case against paths relative to the workspace root.",
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1
+          },
+          "dialect": { "$ref": "#/definitions/dialect" },
+          "rules": { "$ref": "#/definitions/rules" }
+        }
+      }
+    }
+  },
+  "definitions": {
+    "dialect": {
+      "description": "The renderer whose syntax documents are read in. When nothing names one, github is assumed, or obsidian inside a vault.",
+      "enum": ["commonmark", "github", "forgejo", "codeberg", "gitea", "obsidian"]
+    },
+    "severity": { "enum": ["off", "warn", "error"] },
+    "rules": {
+      "description": "Rule IDs and their settings: a severity, or a list of a severity and the rule's options, as in [\"warn\", { \"width\": 100 }].",
+      "type": "object",
+      "additionalProperties": {
+        "anyOf": [
+          { "$ref": "#/definitions/severity" },
+          {
+            "type": "array",
+            "items": [{ "$ref": "#/definitions/severity" }],
+            "minItems": 1,
+            "maxItems": 1
+          },
+          {
+            "type": "array",
+            "items": [{ "$ref": "#/definitions/severity" }, { "type": "object" }],
+            "minItems": 2,
+            "maxItems": 2
+          }
+        ]
+      }
+    }
+  }
+}

package/dist/cli/diff.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A unified diff that turns `before` into `after`, with the headers and hunks
+ * of `diff`'s `createTwoFilesPatch`. That function compares the whole texts,
+ * at a cost that grows with their length times the number of changed lines, so
+ * that rewrapping a long document took minutes to show. This one compares only
+ * the regions that changed and their neighbours. Where it removes and adds
+ * other lines than a comparison of the whole texts would, both diffs turn
+ * `before` into `after`.
+ */
+export declare function unifiedDiff(oldFileName: string, newFileName: string, before: string, after: string): string;