@jterrazz/typescript 9.2.1 → 10.0.0

package/rules/react-native.js

@@ -0,0 +1,48 @@
+import { fragment, on } from './_contract.js';
+import { EXTENSIONS_NEVER } from './core/import.js';
+
+/*
+ * React Native. oxlint 1.83 ships no `react-native` plugin, so this fragment
+ * is not a plugin roster: it is the three decisions the platform forces, plus
+ * the globals its runtime defines.
+ *
+ * Metro resolves an import, so a specifier carries no extension — except an
+ * asset, which Metro resolves BY its extension, and `require()` is how an
+ * asset is named in a React Native tree.
+ */
+export default fragment({
+    id: 'react-native',
+    globals: {
+        __DEV__: 'readonly',
+        ErrorUtils: 'readonly',
+        FormData: 'readonly',
+        XMLHttpRequest: 'readonly',
+        fetch: 'readonly',
+        requestAnimationFrame: 'readonly',
+    },
+    ignorePatterns: ['.expo/**', 'assets/**', 'ios/**', 'android/**'],
+    rules: {
+        'import/extensions': EXTENSIONS_NEVER,
+        'no-restricted-imports': on([
+            {
+                patterns: [
+                    {
+                        group: ['react-dom', 'react-dom/*', 'next', 'next/*'],
+                        message: 'this is a React Native tree — the DOM and Next are not on it',
+                    },
+                ],
+            },
+        ]),
+        'typescript/no-require-imports': on([
+            {
+                allow: [
+                    String.raw`\.gif$`,
+                    String.raw`\.jpeg$`,
+                    String.raw`\.jpg$`,
+                    String.raw`\.png$`,
+                    String.raw`\.webp$`,
+                ],
+            },
+        ]),
+    },
+});

package/rules/react.js

@@ -0,0 +1,148 @@
+import { allOn, fragment, off, on } from './_contract.js';
+
+/*
+ * The `react` and `react-perf` plugins, all 88 non-nursery rules decided by
+ * name — the hooks rules, the React Compiler rules (purity, immutability,
+ * static-components, preserve-manual-memoization…) and the class-era
+ * correctness rules alike.
+ */
+export default fragment({
+    id: 'react',
+    plugins: ['react', 'react-perf'],
+    rules: {
+        ...allOn(
+            [
+                'button-has-type',
+                'capitalized-calls',
+                'checked-requires-onchange-or-readonly',
+                'display-name',
+                'error-boundaries',
+                'exhaustive-deps',
+                'exhaustive-effect-dependencies',
+                'forbid-dom-props',
+                'forbid-elements',
+                'forward-ref-uses-ref',
+                'globals',
+                'hook-use-state',
+                'hooks',
+                'iframe-missing-sandbox',
+                'immutability',
+                'incompatible-library',
+                'invariant',
+                'jsx-boolean-value',
+                'jsx-curly-brace-presence',
+                'jsx-fragments',
+                'jsx-handler-names',
+                'jsx-key',
+                'jsx-no-comment-textnodes',
+                'jsx-no-constructed-context-values',
+                'jsx-no-duplicate-props',
+                'jsx-no-script-url',
+                'jsx-no-target-blank',
+                'jsx-no-undef',
+                'jsx-no-useless-fragment',
+                'jsx-pascal-case',
+                'jsx-props-no-spread-multi',
+                'memo-dependencies',
+                'no-array-index-key',
+                'no-children-prop',
+                'no-clone-element',
+                'no-danger',
+                'no-danger-with-children',
+                'no-deriving-state-in-effects',
+                'no-did-mount-set-state',
+                'no-did-update-set-state',
+                'no-direct-mutation-state',
+                'no-find-dom-node',
+                'no-is-mounted',
+                'no-namespace',
+                'no-object-type-as-default-prop',
+                'no-react-children',
+                'no-redundant-should-component-update',
+                'no-render-return-value',
+                'no-set-state',
+                'no-string-refs',
+                'no-this-in-sfc',
+                'no-unescaped-entities',
+                'no-unsafe',
+                'no-unstable-nested-components',
+                'no-will-update-set-state',
+                'prefer-es6-class',
+                'prefer-function-component',
+                'preserve-manual-memoization',
+                'purity',
+                'refs',
+                'rule-suppression',
+                'rules-of-hooks',
+                'self-closing-comp',
+                'set-state-in-effect',
+                'set-state-in-render',
+                'state-in-constructor',
+                'static-components',
+                'style-prop-object',
+                'syntax',
+                'todo',
+                'unsupported-syntax',
+                'use-memo',
+                'void-dom-elements-no-children',
+                'void-use-memo',
+            ].map((rule) => `react/${rule}`),
+        ),
+
+        // -- On, at the value the estate's own shape asks for -------------------
+        'react/function-component-definition': on([
+            { namedComponents: 'function-declaration', unnamedComponents: 'arrow-function' },
+        ]),
+        'react/jsx-filename-extension': on([{ extensions: ['.jsx', '.tsx'] }]),
+
+        // -- Off, each with its one reason -------------------------------------
+        'react-perf/jsx-no-jsx-as-prop': off({
+            by: 'react/static-components, react/use-memo — the React Compiler rules decide memoisation, and an inline prop is the idiom they are written for',
+            kind: 'covered',
+        }),
+        'react-perf/jsx-no-new-array-as-prop': off({
+            by: 'react/static-components, react/use-memo — the React Compiler rules decide memoisation, and an inline prop is the idiom they are written for',
+            kind: 'covered',
+        }),
+        'react-perf/jsx-no-new-function-as-prop': off({
+            by: 'react/static-components, react/use-memo — the React Compiler rules decide memoisation, and an inline prop is the idiom they are written for',
+            kind: 'covered',
+        }),
+        'react-perf/jsx-no-new-object-as-prop': off({
+            by: 'react/static-components, react/use-memo — the React Compiler rules decide memoisation, and an inline prop is the idiom they are written for',
+            kind: 'covered',
+        }),
+        'react/forbid-component-props': off({
+            by: 'docs/07-lint-presets.md — className is how a component takes its styling, and the rule forbids it by default',
+            kind: 'convention',
+        }),
+        'react/jsx-max-depth': off({
+            by: 'max-depth (4) — nesting depth is one property, and one rule owns it',
+            kind: 'covered',
+        }),
+        'react/jsx-no-literals': off({
+            by: 'docs/07-lint-presets.md — the estate has no translation-extraction convention that would need every string hoisted',
+            kind: 'convention',
+        }),
+        'react/jsx-props-no-spreading': off({
+            by: 'docs/07-lint-presets.md — a wrapper component forwards its props by spread',
+            kind: 'convention',
+        }),
+        'react/no-multi-comp': off({
+            by: 'docs/07-lint-presets.md — a file holds a component and the small private pieces only it uses',
+            kind: 'convention',
+        }),
+        'react/no-unknown-property': off({
+            by: 'TypeScript — a JSX attribute is checked against the element props type, which knows the framework attributes this rule does not',
+            kind: 'covered',
+        }),
+        'react/only-export-components': off({
+            by: 'docs/07-lint-presets.md — a Next route file exports its metadata beside its component',
+            kind: 'convention',
+        }),
+        'react/react-in-jsx-scope': off({
+            by: 'presets/tsconfig/next.json — the automatic JSX runtime (jsx: react-jsx) imports it',
+            kind: 'covered',
+        }),
+    },
+});

package/rules/sorted.js

@@ -0,0 +1,41 @@
+import { createRequire } from 'node:module';
+
+import { fragment, off, on } from './_contract.js';
+
+/*
+ * Sorting is formatting. oxfmt owns import order (`sortImports`), package.json
+ * key order (`sortPackageJson`) and Tailwind class order (`sortTailwindcss`);
+ * what is left is what oxfmt does not sort, and that is this fragment.
+ *
+ * Measured against oxfmt 0.68 on a fixture: `sortImports` reorders import
+ * STATEMENTS and leaves the named specifiers inside one statement alone, and
+ * it touches no type union, no JSX attribute and no heritage clause. Those
+ * five are perfectionist's, and nothing else is.
+ *
+ * perfectionist reaches oxlint through the JS-plugin bridge, so the consumer
+ * never declares it — `createRequire` resolves it from THIS package, where it
+ * is a real dependency ([Developing](../docs/02-developing.md)).
+ */
+
+const require = createRequire(import.meta.url);
+
+/** Natural order: `item2` before `item10`, which alphabetical order gets wrong. */
+const NATURAL = [{ type: 'natural' }];
+
+export default fragment({
+    id: 'sorted',
+    jsPlugins: [require.resolve('eslint-plugin-perfectionist')],
+    rules: {
+        'perfectionist/sort-heritage-clauses': on(NATURAL),
+        'perfectionist/sort-intersection-types': on(NATURAL),
+        'perfectionist/sort-jsx-props': on(NATURAL),
+        'perfectionist/sort-named-exports': on(NATURAL),
+        'perfectionist/sort-named-imports': on(NATURAL),
+        'perfectionist/sort-union-types': on(NATURAL),
+
+        'perfectionist/sort-imports': off({
+            by: 'oxfmt sortImports — the formatter reorders import statements, and two tools rewriting the same bytes fight',
+            kind: 'formatter',
+        }),
+    },
+});

package/rules/vitest.js

@@ -0,0 +1,153 @@
+import { allOn, fragment, off, on, scoped } from './_contract.js';
+
+/*
+ * The `vitest` plugin, all 73 rules decided by name — inside an `overrides`
+ * block, because every one of them reads a test file and says nothing about
+ * anything else. The globs are the test shapes the estate writes:
+ * `<name>.test.ts`, `<name>.spec.ts`, their type-test variants, and every file
+ * under a `specs/` or `__tests__/` tree.
+ *
+ * Four of the offs are one half of an exclusive pair; the other half is on, and
+ * `exclusive-pairs.test.ts` proves no profile ever arms both.
+ */
+
+/** Where a vitest rule applies. Nothing outside these globs is a test. */
+export const TEST_FILES = Object.freeze([
+    '**/*.{test,spec,test-d,spec-d}.{ts,tsx,js,jsx}',
+    '**/specs/**/*.{ts,tsx}',
+    '**/__tests__/**/*.{ts,tsx,js,jsx}',
+]);
+
+/** Every vitest rule that is on. The list is the roster minus the eight offs below. */
+const ON_IN_TESTS = [
+    'consistent-each-for',
+    'consistent-test-filename',
+    'consistent-vitest-vi',
+    'expect-expect',
+    'hoisted-apis-on-top',
+    'max-expects',
+    'max-nested-describe',
+    'no-alias-methods',
+    'no-commented-out-tests',
+    'no-conditional-expect',
+    'no-conditional-tests',
+    'no-disabled-tests',
+    'no-duplicate-hooks',
+    'no-focused-tests',
+    'no-identical-title',
+    'no-import-node-test',
+    'no-interpolation-in-snapshots',
+    'no-large-snapshots',
+    'no-mocks-import',
+    'no-restricted-matchers',
+    'no-restricted-vi-methods',
+    'no-standalone-expect',
+    'no-test-prefixes',
+    'no-test-return-statement',
+    'no-unneeded-async-expect-function',
+    'padding-around-after-all-blocks',
+    'padding-around-test-blocks',
+    'prefer-called-exactly-once-with',
+    'prefer-called-once',
+    'prefer-called-with',
+    'prefer-comparison-matcher',
+    'prefer-each',
+    'prefer-equality-matcher',
+    'prefer-expect-resolves',
+    'prefer-expect-type-of',
+    'prefer-hooks-in-order',
+    'prefer-hooks-on-top',
+    'prefer-import-in-mock',
+    'prefer-importing-vitest-globals',
+    'prefer-mock-promise-shorthand',
+    'prefer-mock-return-shorthand',
+    'prefer-snapshot-hint',
+    'prefer-spy-on',
+    'prefer-strict-equal',
+    'prefer-to-be',
+    'prefer-to-be-falsy',
+    'prefer-to-be-object',
+    'prefer-to-be-truthy',
+    'prefer-to-contain',
+    'prefer-to-have-been-called-times',
+    'prefer-to-have-length',
+    'prefer-todo',
+    'require-awaited-expect-poll',
+    'require-local-test-context-for-concurrent-snapshots',
+    'require-mock-type-parameters',
+    'require-to-throw-message',
+    'valid-describe-callback',
+    'valid-expect',
+    'valid-expect-in-promise',
+    'valid-title',
+    'warn-todo',
+].map((rule) => `vitest/${rule}`);
+
+export default fragment({
+    id: 'vitest',
+    plugins: ['vitest'],
+    overrides: [
+        scoped({
+            files: [...TEST_FILES],
+            rules: {
+                ...allOn(ON_IN_TESTS),
+
+                'vitest/consistent-test-it': on([{ fn: 'test' }]),
+                /* No `allowedPrefixes`. The rule is stricter than the `j5` rule
+                 * @jterrazz/test retires for it: it also refuses a title opening
+                 * on an all-caps identifier (`HTTP 404 …`, `DI …`). Strictest
+                 * sensible wins, and an existing title is a rename, not a case
+                 * for an estate-specific escape hatch. */
+                'vitest/prefer-lowercase-title': on(),
+
+                'vitest/no-conditional-in-test': off({
+                    by: "vitest/no-conditional-expect — the defect is an assertion that may not run, and that rule names it; this one also refuses a golden suite's TEST_UPDATE branch and every comparator",
+                    kind: 'covered',
+                }),
+                'vitest/no-hooks': off({
+                    by: 'vitest/prefer-hooks-in-order, vitest/prefer-hooks-on-top — both describe where a hook goes',
+                    kind: 'exclusive',
+                }),
+                'vitest/no-importing-vitest-globals': off({
+                    by: 'vitest/prefer-importing-vitest-globals',
+                    kind: 'exclusive',
+                }),
+                'vitest/prefer-called-times': off({
+                    by: 'vitest/prefer-called-once',
+                    kind: 'exclusive',
+                }),
+                'vitest/prefer-describe-function-title': off({
+                    by: 'vitest/valid-title — a describe of this estate names the behaviour it claims, not the function it calls',
+                    kind: 'exclusive',
+                }),
+                'vitest/prefer-expect-assertions': off({
+                    by: 'docs/07-lint-presets.md — a spec states its assertions; counting them is bookkeeping the reader does not need',
+                    kind: 'convention',
+                }),
+                'vitest/prefer-strict-boolean-matchers': off({
+                    by: 'vitest/prefer-to-be-truthy, vitest/prefer-to-be-falsy',
+                    kind: 'exclusive',
+                }),
+                'vitest/require-top-level-describe': off({
+                    by: 'vitest/consistent-test-filename — the file name is the subject, and a describe that repeats it adds a level without adding meaning',
+                    kind: 'covered',
+                }),
+                'vitest/require-hook': off({
+                    by: 'docs/07-lint-presets.md — the Given narration of a spec is the test body, not a hook',
+                    kind: 'convention',
+                }),
+                'vitest/require-test-timeout': off({
+                    by: 'docs/07-lint-presets.md — vitest.config.ts owns the timeout, once, for every suite',
+                    kind: 'convention',
+                }),
+
+                // A test double is an empty function by definition.
+                'no-empty-function': off({
+                    by: 'docs/07-lint-presets.md — a test double with no behaviour is an empty function',
+                    kind: 'convention',
+                }),
+            },
+        }),
+    ],
+    rules: {},
+});

package/src/docs.d.ts

@@ -1,5 +1,5 @@
 /** The `docs/` tree of one repository, as a rule engine needs to see it. */
-export interface DocsTree {
+export type DocsTree = {
     /** The root `AGENTS.md`, its whole text, or `null` when the repository has none. */
     readonly agents: null | string;
     /**
@@ -26,14 +26,14 @@ export interface DocsTree {
         /** A `package.json` at either that is not `"private": true`. */
         readonly publishable: boolean;
     };
-}
+};
 
 /** One broken rule, naming the path it is about and the sentence the gate prints. */
-export interface DocsViolation {
+export type DocsViolation = {
     readonly message: string;
     readonly path: string;
     readonly rule: string;
-}
+};
 
 /** How many opening lines of a file a rule may read. */
 export declare const HEAD_LINES: number;

package/src/docs.js

@@ -52,28 +52,28 @@ const STATUSES = new Set(['Proposed', 'Accepted', 'Deprecated']);
  * The fourth status carries the record that replaced it, as a link a reader
  * can follow — a citation is a place a human can look, not just a number.
  */
-const SUPERSEDED = /^Superseded by \[ADR-\d{3}\]\([^)]+\)$/;
+const SUPERSEDED = /^Superseded by \[ADR-\d{3}\]\([^)]+\)$/u;
 
 /** The same status named but not linked — the successor exists, the citation does not. */
-const BARE_SUPERSEDED = /^Superseded by ADR-\d{3}$/;
+const BARE_SUPERSEDED = /^Superseded by ADR-\d{3}$/u;
 
 /** What a chapter's file name must be: two digits, lowercase words, single hyphens. */
-const CHAPTER_NAME = /^\d{2}-[a-z\d]+(?:-[a-z\d]+)*\.md$/;
+const CHAPTER_NAME = /^\d{2}-[a-z\d]+(?:-[a-z\d]+)*\.md$/u;
 
 /** What a decision record's file name must be: three digits, then the same words. */
-const DECISION_NAME = /^\d{3}-[a-z\d]+(?:-[a-z\d]+)*\.md$/;
+const DECISION_NAME = /^\d{3}-[a-z\d]+(?:-[a-z\d]+)*\.md$/u;
 
 /** A decision record's first heading, carrying the number the file claims. */
-const DECISION_HEADING = /^# ADR-(?<number>\d{3}): \S/;
+const DECISION_HEADING = /^# ADR-(?<number>\d{3}): \S/u;
 
 /** The `**Status:**` line of a decision record, wherever it sits in the head. */
-const DECISION_STATUS = /^\*\*Status:\*\*\s*(?<status>.+?)\s*$/;
+const DECISION_STATUS = /^\*\*Status:\*\*\s*(?<status>.+?)\s*$/u;
 
 /** The marker every file under `reference/` carries — it is generated, never authored. */
 const GENERATED = 'GENERATED';
 
 /** A link with a scheme (`https:`, `mailto:`) cites; it never reaches into a tree. */
-const SCHEME = /^[a-z][\d+.a-z-]*:/i;
+const SCHEME = /^[a-z][\d+.a-z-]*:/iu;
 
 /** What each of the three presence facts means, in the sentence `04` is asked for. */
 const SHIPPING_REASONS = [
@@ -84,7 +84,7 @@ const SHIPPING_REASONS = [
 
 /** Directly under `docs/` — a file, or a directory with its trailing slash. */
 function directChildren(files) {
-    return files.filter((path) => /^docs\/[^/]+\/?$/.test(path));
+    return files.filter((path) => /^docs\/[^/]+\/?$/u.test(path));
 }
 
 /** Everything under a folder of `docs/`, named relative to that folder. */
@@ -103,12 +103,12 @@ function padded(value) {
 
 /** The link target itself, without the anchor a reader lands on. */
 function targetPath(link) {
-    return link.split('#')[0].replace(/^\.\//, '');
+    return link.split('#')[0].replace(/^\.\//u, '');
 }
 
 /** A link that names a chapter of the same folder — `03-testing.md`, no slash. */
 function isChapterLink(target) {
-    return /^\d/.test(target) && !target.includes('/');
+    return /^\d/u.test(target) && !target.includes('/');
 }
 
 /**
@@ -198,20 +198,7 @@ function auditChapters(report, { chapters, ships }) {
         }
     }
 
-    const numbers = chapters.map((chapter) => chapter.number).sort((a, b) => a - b);
-    const hasOperating = numbers.includes(4);
-    // 04 is the one number the spine never requires (`docs-operating-missing`
-    // Asks for it on its own terms), so a run missing it is still contiguous —
-    // Every number from 05 on shifts down one slot to close the gap.
-    const expected = (index) => (!hasOperating && index + 1 >= 4 ? index + 2 : index + 1);
-    const contiguous = numbers.every((number, index) => number === expected(index));
-    if (numbers.length > 0 && !contiguous) {
-        report(
-            'docs-chapter-numbering',
-            'docs/',
-            `chapter numbers run ${numbers.map(padded).join(', ')}: they are contiguous from 01, one file per number, except that 04 may be absent`,
-        );
-    }
+    auditChapterNumbering(report, chapters);
 
     for (const chapter of chapters) {
         const reserved = SPINE[chapter.number - 1];
@@ -244,8 +231,33 @@ function auditChapters(report, { chapters, ships }) {
         );
     }
 
+    auditChapterWords(report, chapters);
+}
+
+/** The run of numbers: contiguous from 01, one file per number, 04 the one that may be absent. */
+function auditChapterNumbering(report, chapters) {
+    const numbers = chapters.map((chapter) => chapter.number).toSorted((a, b) => a - b);
+    const hasOperating = numbers.includes(4);
+    // 04 is the one number the spine never requires (`docs-operating-missing`
+    // Asks for it on its own terms), so a run missing it is still contiguous —
+    // Every number from 05 on shifts down one slot to close the gap.
+    const expected = (index) => (!hasOperating && index + 1 >= 4 ? index + 2 : index + 1);
+    const contiguous = numbers.every((number, index) => number === expected(index));
+    if (numbers.length === 0 || contiguous) {
+        return;
+    }
+
+    report(
+        'docs-chapter-numbering',
+        'docs/',
+        `chapter numbers run ${numbers.map(padded).join(', ')}: they are contiguous from 01, one file per number, except that 04 may be absent`,
+    );
+}
+
+/** A chapter named for a journal rather than a subject — the record is an ADR. */
+function auditChapterWords(report, chapters) {
     for (const chapter of chapters) {
-        const word = chapter.name.split(/[.-]/).find((segment) => JOURNAL_WORDS.has(segment));
+        const word = chapter.name.split(/[.-]/u).find((segment) => JOURNAL_WORDS.has(segment));
         if (word !== undefined) {
             report(
                 'docs-journal-chapter',
@@ -256,6 +268,37 @@ function auditChapters(report, { chapters, ships }) {
     }
 }
 
+/** The run of record numbers: from 001, with no gap, and no number claimed twice. */
+function auditDecisionNumbers(report, records) {
+    const numbers = [...new Set(records.map((record) => record.name.slice(0, 3)))].toSorted(
+        (left, right) => left.localeCompare(right),
+    );
+    const sequential = numbers.every((number, index) => Number.parseInt(number, 10) === index + 1);
+    if (numbers.length > 0 && !sequential) {
+        report(
+            'docs-decision-sequence',
+            'docs/decisions/',
+            `docs/decisions/ numbers run ${numbers.join(', ')}: they run from 001 with no gap — a decision that moved folders takes the next number where it lands`,
+        );
+    }
+
+    const claimed = new Map();
+    for (const record of records) {
+        const number = record.name.slice(0, 3);
+        const first = claimed.get(number);
+
+        if (first === undefined) {
+            claimed.set(number, record.name);
+        } else {
+            report(
+                'docs-decision-number',
+                'docs/decisions/',
+                `ADR-${number} is claimed by ${first} and ${record.name}`,
+            );
+        }
+    }
+}
+
 /** What sits directly under `docs/` and is neither the map, a chapter, nor one of the three folders. */
 function auditFolder(report, { children }) {
     for (const path of children) {
@@ -269,7 +312,7 @@ function auditFolder(report, { children }) {
                     `${path} is not one of decisions/, reference/, _assets/`,
                 );
             }
-        } else if (name !== 'README.md' && !/^\d/.test(name)) {
+        } else if (name !== 'README.md' && !/^\d/u.test(name)) {
             report(
                 'docs-loose-file',
                 path,
@@ -312,33 +355,18 @@ function auditDecisions(report, { files, heads }) {
     const entries = under(files, 'decisions/');
 
     for (const entry of entries) {
-        if (entry.name !== '_template.md' && entry.name !== 'README.md') {
-            if (!DECISION_NAME.test(entry.name)) {
-                report('docs-decision-name', entry.path, `${entry.path} is not NNN-kebab.md`);
-            }
+        const mold = entry.name === '_template.md' || entry.name === 'README.md';
+        if (!mold && !DECISION_NAME.test(entry.name)) {
+            report('docs-decision-name', entry.path, `${entry.path} is not NNN-kebab.md`);
         }
     }
 
-    const records = entries.filter((entry) => /^\d{3}-/.test(entry.name));
+    const records = entries.filter((entry) => /^\d{3}-/u.test(entry.name));
     for (const record of records) {
         auditRecord(report, record, heads);
     }
 
-    const claimed = new Map();
-    for (const record of records) {
-        const number = record.name.slice(0, 3);
-        const first = claimed.get(number);
-
-        if (first === undefined) {
-            claimed.set(number, record.name);
-        } else {
-            report(
-                'docs-decision-number',
-                'docs/decisions/',
-                `ADR-${number} is claimed by ${first} and ${record.name}`,
-            );
-        }
-    }
+    auditDecisionNumbers(report, records);
 
     if (files.includes('docs/decisions/README.md')) {
         report(
@@ -417,7 +445,7 @@ export function auditDocs(tree) {
 
     const children = directChildren(files);
     const chapters = children
-        .filter((path) => !path.endsWith('/') && /^\d/.test(path.slice('docs/'.length)))
+        .filter((path) => !path.endsWith('/') && /^\d/u.test(path.slice('docs/'.length)))
         .map((path) => ({
             name: path.slice('docs/'.length),
             number: Number.parseInt(path.slice('docs/'.length), 10),