@descent-vtt/spec-guard 0.28.0 → 0.29.0

package/CHANGELOG.md

@@ -10,6 +10,49 @@ what to do when upgrading; the family's policy, including how a flag or field
 is deprecated before it goes, is spec-core's
 [ADR-0009](https://github.com/DescentVTT/spec-core/blob/main/docs/adr/0009-versions-before-1-0.md).
 
+## 0.29.0
+
+A regex rule is read in one dialect by both engines, the one ripgrep's
+regex crate documents: `\w`, `\b`, `\d` and `\s` are Unicode's, a
+character is a code point, and what the two dialects read apart is an
+invalid directive that names it, so a rule no longer passes under
+`--engine rg` where the scanner counts it.
+
+### Changed
+
+- **A regex rule is read in one dialect by both engines, the one ripgrep's
+  regex crate documents**, where the scanner read JavaScript's and ripgrep,
+  which names the files the scanner reads, its own: a file the scanner
+  counted in and ripgrep left out passed the rule under `--engine rg`, and
+  under `auto` past its budget. On 0.28.0 `foo\b` over `fooé`, `\Wbar` over
+  `ébar`, `a\sb` with U+FEFF between, `^..$` over an emoji and `baz` with
+  `regex="true"` and `word="true"` over `ébaz` were each counted by
+  `--engine js` and passed by `--engine rg`, as were 441 of 2,500 rules
+  made at random. `\w`, `\d`, `\s`, their negations, `\b` and `\B` are the
+  crate's Unicode classes, a character is a code point, `ignore-case` folds
+  by Unicode's simple case folding, and `word="true"` puts one boundary
+  round a literal and a regex: no word character before or after. What the
+  two dialects read apart is an invalid directive that names it. ripgrep
+  reads a file's bytes as they are, where it took a UTF-8 byte order mark
+  off a file's start, and an empty match after a file's last line end is
+  not counted, as ripgrep counts none there
+  ([ADR-0007](https://github.com/DescentVTT/spec-guard/blob/main/docs/adr/0007-search-scope.md)).
+  Upgrading: a regex rule over text that is not ASCII may count otherwise,
+  and fail or pass where it did not: `\w`, `\b` and `word="true"` take a
+  letter, digit or mark of any script for a word character, `\d` takes
+  `٣`, `\s` takes NEL and not U+FEFF, `.` and a negated class take an emoji
+  as one character, `ignore-case` folds `k` with the Kelvin sign, and
+  `\p{L}` and `\u{41}` are a class and a code point where they were
+  letters. A literal with `word="true"` no longer counts beside a mark,
+  ZWJ, `‿` or `Ⓐ`, and counts beside `²`. A regex rule with `\A`, `\z`,
+  `\<`, `\>`, `\b{...}`, `\a`, `\x{...}`, `\U`, `\pL`, a class inside a
+  class such as `[[:alpha:]]`, `&&`, `--` or `~~` in a class, `[]` or `[^]`
+  before a `]`, or a count with blanks in it is an invalid directive, exit
+  1, and so is one with an escape JavaScript's `v` mode refuses, `\e`,
+  `\é`, an octal escape or a back-reference to no group; write it as both
+  dialects read it. A rule against a byte order mark at a file's start now
+  fails under ripgrep as under the scanner.
+
 ## 0.28.0
 
 A regex rule's `^` and `$` read a line with either engine, where they

package/README.md

@@ -587,8 +587,8 @@ Passes when every listed path exists relative to `--root`. Directories count.
 | `min` / `max` | count (`max` on all but present) | Inclusive bounds |
 | `glob` | absence, count, structure | Include-only file filters, e.g. `*.ts,*.tsx` (ripgrep `-g` semantics) |
 | `exclude` | all but present | Paths to leave out, gitignore-style: `src/config/**`, `tests`, `*.test.ts` |
-| `regex` | absence, count | Treat `symbol` as a regular expression, JavaScript's, where `^` and `$` match at each line's start and end |
-| `word` | absence, count | Require word boundaries, so `Primary` does not match `PrimaryButton` |
+| `regex` | absence, count | Treat `symbol` as a regular expression, written as JavaScript's and read as ripgrep reads it, where `^` and `$` match at each line's start and end (below) |
+| `word` | absence, count | Require word boundaries, so `Primary` does not match `PrimaryButton`: no word character, ripgrep's `\w`, just before the match or just after it |
 | `ignore-case` | absence, count | Case-insensitive matching |
 | `comments` | absence, count | `ignore` (default) or `include` for matches inside comments |
 | `module` | import-absence, import-count | Which dependency, matched like `exclude` |
@@ -611,12 +611,31 @@ than no spec tool.
 A `regex` is read against each file's whole text, so a match may cross a
 line end. `^` and `$` match at the start and the end of every line, a line
 ending at LF, at CRLF or at a lone CR, as ripgrep reads one with `--crlf`;
-U+2028 and U+2029 end none, and no line follows a file's last line end.
+U+2028 and U+2029 end none, and no line follows a file's last line end,
+so an empty match there is not counted.
 `symbol="^\s*-?\s*uses:"` meets `uses:` on any line, with either engine
 ([ADR-0007](https://github.com/DescentVTT/spec-guard/blob/main/docs/adr/0007-search-scope.md)).
 `\s` matches a line end too, so `\s+$` also meets a line followed by an
 empty one; `[ \t]+$` reads only the blanks a line ends with.
 
+Both engines read a `regex` in one dialect: JavaScript's syntax, with the
+meaning ripgrep's regex crate documents wherever the two dialects give the
+same text two, since a file ripgrep's reading leaves out is one the scanner
+never counts in. A character is a code point, and `ignore-case` folds by
+Unicode's simple case folding. `\w` is a letter, a mark, a decimal digit, a
+connector such as `_`, or Join_Control, in any script, and `\b`, `\B` and
+`word="true"` are read with it; `\d` is a decimal digit of any script; `\s`
+is Unicode's white space, so U+FEFF is none and NEL is one. What only
+JavaScript reads, a look-around or a back-reference, is read by the scanner
+alone, as ripgrep refuses it. What the crate reads and JavaScript would
+read otherwise is an invalid directive that names it: `\A`, `\z`, `\<`,
+`\>`, `\b{...}`, `\a`, `\x{...}`, `\U`, `\pL`, a class inside a class such
+as `[[:alpha:]]`, `&&`, `--` or `~~` in a class, and a count with blanks
+in it, `{2, 3}`. An escaped sign such as `\-` or `\#`, a lone `]` or `}`,
+and `[\w-.]` read as they did
+([ADR-0007](https://github.com/DescentVTT/spec-guard/blob/main/docs/adr/0007-search-scope.md),
+amended 2026-10-24).
+
 ### `exclude` - everywhere except
 
 Most real rules are "nowhere except one place", not "not here":
@@ -1700,7 +1719,7 @@ comment on the offending line:
     steps:
       # ...checkout, setup-node and npm ci as above
       - run: npx --no-install @descent-vtt/spec-guard "docs/**/*.md" --format sarif > spec-guard.sarif || true
-      - uses: github/codeql-action/upload-sarif@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
+      - uses: github/codeql-action/upload-sarif@6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee # v4.39.0
         with:
           sarif_file: spec-guard.sarif
           category: spec-guard
@@ -1885,7 +1904,14 @@ Two honest caveats:
   *which files contain this text*, and the scanner does all the counting,
   classification and reporting for both. `--engine` now changes how long a run
   takes and nothing about its verdict, and the suite asserts that on trees built
-  from every case that used to split them.
+  from every case that used to split them. A regex rule kept two readings
+  until its dialect was one, and ripgrep took a byte order mark off a file's
+  start: `foo\b` over `fooé` was counted by the scanner and passed under
+  ripgrep. What still splits them is a file that is not UTF-8, which the
+  scanner reads with U+FFFD for each byte it cannot, and a character newer
+  than one of the two engines' Unicode
+  ([ADR-0007](https://github.com/DescentVTT/spec-guard/blob/main/docs/adr/0007-search-scope.md),
+  amended 2026-10-24).
 
 ## Programmatic API
 
@@ -2026,8 +2052,8 @@ build fails if they stop being true. CI proves every one of those rules can
 fail, and `spec-guard cites` holds every ADR a comment in the code cites to
 existing and being in force.
 
-Line coverage is 100%, CI's full mutation sweep kills 99.23% of 14,224 mutants
-(0.28.0), and every survivor a release adds is replayed before it ships
+Line coverage is 100%, CI's full mutation sweep kills 99.27% of 14,580 mutants
+(0.29.0), and every survivor a release adds is replayed before it ships
 ([ADR-0003](https://github.com/DescentVTT/spec-guard/blob/main/docs/adr/0003-mutation-testing.md));
 [CONTRIBUTING.md](https://github.com/DescentVTT/spec-guard/blob/main/CONTRIBUTING.md)
 has how to build, test and release, and

package/dist/dialect.d.ts

@@ -0,0 +1,51 @@
+/**
+ * One reading of a regex rule, for both engines. ADR-0007, amended
+ * 2026-10-24.
+ *
+ * ripgrep only names the files the scanner reads, so a file its reading of a
+ * pattern leaves out is a file whose matches are never counted, and a rule
+ * they would fail passes. ripgrep reads a pattern as the regex crate's
+ * documentation says, and JavaScript gave some of the same text another
+ * meaning: its `\w`, `\b` and `\d` were ASCII and its `\s` held U+FEFF and not
+ * NEL, where the crate's are Unicode's; a character was a UTF-16 unit; and
+ * `\A`, `\<` or `[[:alpha:]]` were letters and brackets. So the scanner is
+ * given each rule as the crate reads it, in JavaScript's `v` mode, which reads
+ * a character as a code point, folds case by Unicode's simple case folding as
+ * the crate does, and holds a class inside a class:
+ *
+ * - `\w`, `\d`, `\s`, their negations, `\b` and `\B` are the crate's Unicode
+ *   ones, and so is the boundary `word="true"` puts round a rule;
+ * - `^` and `$` meet each line, as ripgrep reads one with `--crlf`;
+ * - what the crate reads and JavaScript read otherwise is refused, naming it,
+ *   since one engine would count what the other never named;
+ * - what JavaScript read without `v` as itself is kept as itself: an escaped
+ *   sign, a lone `]`, a `{` or `}` that is no count, and a `-` beside a class
+ *   escape in a class. The crate reads each the same, but a `{` and that `-`,
+ *   which it refuses, and which the scanner then answers alone;
+ * - what only JavaScript reads, a look-around or a back-reference, is the
+ *   scanner's alone, as before: ripgrep refuses the pattern, and the scanner
+ *   answers the search.
+ */
+/**
+ * The regex crate's `\w`: `\p{Alphabetic}`, `\p{M}`, `\d`, `\p{Pc}` and
+ * `\p{Join_Control}`, as its documentation lists them (regex 1.13.1, read
+ * 2026-10-24). JavaScript's is `[A-Za-z0-9_]`, and a literal's word boundary
+ * here was `\p{L}`, `\p{N}` and `_`, which holds no mark and no ZWJ.
+ */
+export declare const WORD_CHARACTER: string;
+/**
+ * A regex rule's source as the scanner reads it, in JavaScript's `v` mode:
+ * the reading ripgrep has of it, where the two dialects meet.
+ *
+ * Throws a SyntaxError, worded as JavaScript words its own, for a rule the
+ * two engines would read differently.
+ */
+export declare function readRegex(source: string): string;
+/**
+ * The regular expression the scanner matches a regex rule with: the rule as
+ * `readRegex` reads it, between word boundaries for `word="true"`, which
+ * ripgrep's `--word-regexp` puts round a pattern as `\b{start-half}` and
+ * `\b{end-half}`: no word character before the match and none after it.
+ */
+export declare function buildRegexRule(symbol: string, flags: string, word: boolean): RegExp;
+//# sourceMappingURL=dialect.d.ts.map

package/dist/dialect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialect.d.ts","sourceRoot":"","sources":["../src/dialect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,cAAc,QAAgE,CAAC;AA6K5F;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CA6ChD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,CAUnF"}

package/dist/dialect.js

@@ -0,0 +1,265 @@
+/**
+ * One reading of a regex rule, for both engines. ADR-0007, amended
+ * 2026-10-24.
+ *
+ * ripgrep only names the files the scanner reads, so a file its reading of a
+ * pattern leaves out is a file whose matches are never counted, and a rule
+ * they would fail passes. ripgrep reads a pattern as the regex crate's
+ * documentation says, and JavaScript gave some of the same text another
+ * meaning: its `\w`, `\b` and `\d` were ASCII and its `\s` held U+FEFF and not
+ * NEL, where the crate's are Unicode's; a character was a UTF-16 unit; and
+ * `\A`, `\<` or `[[:alpha:]]` were letters and brackets. So the scanner is
+ * given each rule as the crate reads it, in JavaScript's `v` mode, which reads
+ * a character as a code point, folds case by Unicode's simple case folding as
+ * the crate does, and holds a class inside a class:
+ *
+ * - `\w`, `\d`, `\s`, their negations, `\b` and `\B` are the crate's Unicode
+ *   ones, and so is the boundary `word="true"` puts round a rule;
+ * - `^` and `$` meet each line, as ripgrep reads one with `--crlf`;
+ * - what the crate reads and JavaScript read otherwise is refused, naming it,
+ *   since one engine would count what the other never named;
+ * - what JavaScript read without `v` as itself is kept as itself: an escaped
+ *   sign, a lone `]`, a `{` or `}` that is no count, and a `-` beside a class
+ *   escape in a class. The crate reads each the same, but a `{` and that `-`,
+ *   which it refuses, and which the scanner then answers alone;
+ * - what only JavaScript reads, a look-around or a back-reference, is the
+ *   scanner's alone, as before: ripgrep refuses the pattern, and the scanner
+ *   answers the search.
+ */
+/**
+ * The regex crate's `\w`: `\p{Alphabetic}`, `\p{M}`, `\d`, `\p{Pc}` and
+ * `\p{Join_Control}`, as its documentation lists them (regex 1.13.1, read
+ * 2026-10-24). JavaScript's is `[A-Za-z0-9_]`, and a literal's word boundary
+ * here was `\p{L}`, `\p{N}` and `_`, which holds no mark and no ZWJ.
+ */
+export const WORD_CHARACTER = String.raw `[\p{Alphabetic}\p{M}\p{Nd}\p{Pc}\p{Join_Control}]`;
+const NOT_WORD_CHARACTER = `[^${WORD_CHARACTER.slice(1)}`;
+/** The crate's `\d`, `\s`, `\w` and their negations, each of which stands in a class as well as outside one. */
+const CLASS_ESCAPES = {
+    d: String.raw `\p{Nd}`,
+    D: String.raw `\P{Nd}`,
+    s: String.raw `\p{White_Space}`,
+    S: String.raw `\P{White_Space}`,
+    w: WORD_CHARACTER,
+    W: NOT_WORD_CHARACTER,
+};
+/**
+ * A word character on one side and none on the other, the start and the end
+ * of the text standing for none, as the crate's `\b` reads.
+ */
+const BOUNDARY = `(?:(?<=${WORD_CHARACTER})(?!${WORD_CHARACTER})|(?<!${WORD_CHARACTER})(?=${WORD_CHARACTER}))`;
+const NOT_BOUNDARY = `(?:(?<=${WORD_CHARACTER})(?=${WORD_CHARACTER})|(?<!${WORD_CHARACTER})(?!${WORD_CHARACTER}))`;
+/**
+ * U+2028 and U+2029, at which JavaScript's `m` ends a line and ripgrep
+ * does not. Made from their numbers, so that no separator stands in this file
+ * where an editor would show a line break.
+ */
+const SEPARATORS = String.fromCharCode(0x2028, 0x2029);
+/**
+ * `^` and `$` as ripgrep reads them with `--crlf`: at the start and at the
+ * end of each line, a line ending at LF, at CRLF or at a lone CR, with no line
+ * after the last line end. JavaScript's `m` reads three lines more, and each
+ * is taken back out: one between the CR and the LF of a CRLF, one after the
+ * last line end (and so in an empty file), and a line end at each separator.
+ * With `m` alone `\s+$` matched on every line of a CRLF file and on the
+ * last of every file, `^` met each CRLF line twice, and a line begun at a
+ * separator was counted in a file ripgrep never named. ADR-0007, amended
+ * 2026-10-19.
+ */
+const LINE_START = `(?:^(?<![${SEPARATORS}])(?!(?<=\\r)\\n)(?=[\\s\\S]))`;
+const LINE_END = `(?:$(?![${SEPARATORS}])(?!(?<=\\r)\\n)(?!(?<![^\\n\\r])(?![\\s\\S])))`;
+/** What the crate reads in an escape that JavaScript read as the letter or the sign itself. */
+const RIPGREP_ESCAPES = {
+    A: 'the start of the text',
+    z: 'the end of the text',
+    '<': 'the start of a word',
+    '>': 'the end of a word',
+    a: 'a bell, U+0007',
+    U: 'a code point in eight hex digits',
+};
+/** A count JavaScript reads after an atom: `{n}`, `{n,}` or `{n,m}`. */
+const COUNT = /\{\d+(?:,\d*)?\}/y;
+/**
+ * A count with blanks in it, `{2, 3}`, which ripgrep 15.0.0 reads as a count
+ * (measured; its documentation does not say) and JavaScript as characters.
+ */
+const BLANK_COUNT = /\{\s*\d+\s*(?:,\s*\d*\s*)?\}/y;
+/**
+ * An escape that holds a name or a number between brackets: `\p{...}`,
+ * `\P{...}`, `\u{...}` and `\k<...>`. Read as a match of its own, so that no
+ * reading of a rule steps back. One left open is read a character at a time,
+ * and `v` mode refuses it in the words it has for it read whole.
+ */
+const NAMED = /\\[pPu]\{[^}]*\}|\\k<[^>]*>/y;
+/** A group's name, which may hold a `$`; one left open is read as `NAMED` reads one. */
+const GROUP_NAME = /\(\?<(?![=!])[^>]*>/y;
+function refuse(source, reason) {
+    throw new SyntaxError(`Invalid regular expression: /${source}/: ${reason}`);
+}
+/**
+ * ASCII that is neither a letter nor a digit, which the crate reads as itself
+ * after a backslash, `<` and `>` aside, and which `v` mode reads as itself
+ * written as a hex escape, in a class and outside one.
+ */
+function isAsciiSign(char) {
+    return char.charCodeAt(0) < 0x80 && !/[0-9A-Za-z]/.test(char);
+}
+function hex(char) {
+    return `\\x${char.charCodeAt(0).toString(16).padStart(2, '0')}`;
+}
+/** The escape that starts at `at`, which is a backslash. */
+function escapeAt(source, at, inClass) {
+    const next = source.charAt(at + 1);
+    const known = CLASS_ESCAPES[next];
+    if (known !== undefined)
+        return { text: known, length: 2, set: true };
+    const ripgrep = RIPGREP_ESCAPES[next];
+    // In a class the crate refuses a `\<`, a `\A` and a `\z`, and the scanner
+    // answers as JavaScript reads it, which `v` mode accepts or refuses itself.
+    if (ripgrep !== undefined && (!inClass || next === 'a' || next === 'U')) {
+        refuse(source, `"\\${next}" is ${ripgrep} to ripgrep and "${next}" to JavaScript`);
+    }
+    const after = source.charAt(at + 2);
+    if (next === 'b' || next === 'B') {
+        if (inClass)
+            return { text: next === 'b' ? '\\x08' : '\\B', length: 2 };
+        if (next === 'b' && after === '{')
+            refuse(source, '"\\b{" is a word boundary of the kind its braces name to ripgrep, and a word boundary before a "{" to JavaScript');
+        return { text: next === 'b' ? BOUNDARY : NOT_BOUNDARY, length: 2 };
+    }
+    if ((next === 'p' || next === 'P') && after !== '{') {
+        refuse(source, `"\\${next}${after}" is a class of characters to ripgrep and "${next}${after}" to JavaScript`);
+    }
+    if (next === 'x' && after === '{')
+        refuse(source, '"\\x{" is the code point its braces hold to ripgrep, and an "x" and braces to JavaScript');
+    // No sign between the brackets is the class's or the rule's own. `v` mode
+    // refuses a `\k<...>` in a class, read whole or not.
+    NAMED.lastIndex = at;
+    const named = NAMED.exec(source);
+    if (named !== null)
+        return { text: named[0], length: named[0].length, set: next !== 'u' };
+    if (isAsciiSign(next))
+        return { text: hex(next), length: 2 };
+    // A letter, a digit, any other character, or nothing: `v` mode reads it as
+    // JavaScript reads it, or refuses it, as it refuses a trailing backslash.
+    // Two on from a trailing backslash is past the end, where every reading
+    // here stops.
+    return { text: source.slice(at, at + 2), length: 2 };
+}
+/** The class that starts at `at`, which is a `[`, and whether it is `[]` or `[^]`, which the crate does not close where JavaScript does. */
+function classAt(source, at) {
+    let i = at + 1;
+    const negated = source.charAt(i) === '^';
+    if (negated)
+        i += 1;
+    if (source.charAt(i) === ']')
+        return { text: source.slice(at, i + 1), length: i + 1 - at, empty: true };
+    const atoms = [];
+    while (i < source.length && source.charAt(i) !== ']') {
+        const pair = source.slice(i, i + 2);
+        if (pair === '&&' || pair === '--' || pair === '~~') {
+            refuse(source, `"${pair}" in a class is an operation on two classes to ripgrep and two characters to JavaScript`);
+        }
+        const char = source.charAt(i);
+        if (char === '[')
+            refuse(source, '"[" in a class is a class inside it to ripgrep, as in [[:alpha:]], and a "[" to JavaScript');
+        if (char === '\\') {
+            const escape = escapeAt(source, i, true);
+            atoms.push({ text: escape.text, set: escape.set, dash: false });
+            i += escape.length;
+            continue;
+        }
+        const point = String.fromCodePoint(source.codePointAt(i));
+        atoms.push({ text: isAsciiSign(point) ? hex(point) : point, dash: point === '-' });
+        i += point.length;
+    }
+    // A `-` between two characters is a range to both. Beside a class escape,
+    // or after a range, JavaScript read it as itself. Two in a row are refused
+    // above, so neither end of a range is a `-` that could start another.
+    let body = '';
+    for (let k = 0; k < atoms.length; k += 1) {
+        const atom = atoms[k];
+        const end = atoms[k + 2];
+        const ranged = !atom.set && atoms[k + 1]?.dash === true && end !== undefined && !end.set;
+        body += ranged ? `${atom.text}-${end.text}` : atom.text;
+        k += ranged ? 2 : 0;
+    }
+    // The class's `]`, or nothing where the rule ends first: an unterminated
+    // class stays unterminated, for `v` mode to refuse.
+    const closed = source.charAt(i);
+    return { text: `[${negated ? '^' : ''}${body}${closed}`, length: i + closed.length - at, empty: false };
+}
+/**
+ * A regex rule's source as the scanner reads it, in JavaScript's `v` mode:
+ * the reading ripgrep has of it, where the two dialects meet.
+ *
+ * Throws a SyntaxError, worded as JavaScript words its own, for a rule the
+ * two engines would read differently.
+ */
+export function readRegex(source) {
+    let read = '';
+    let at = 0;
+    let empty = '';
+    // `<=` for the `<` reads one place past the end, where `charAt` gives
+    // nothing and nothing is added: an equivalent mutant.
+    while (at < source.length) {
+        const char = source.charAt(at);
+        if (char === '\\') {
+            const escape = escapeAt(source, at, false);
+            read += escape.text;
+            at += escape.length;
+            continue;
+        }
+        if (char === '[') {
+            const found = classAt(source, at);
+            read += found.text;
+            if (found.empty)
+                empty = found.text;
+            at += found.length;
+            continue;
+        }
+        GROUP_NAME.lastIndex = at;
+        const group = GROUP_NAME.exec(source);
+        if (group !== null) {
+            read += group[0];
+            at += group[0].length;
+            continue;
+        }
+        if (char === '{') {
+            COUNT.lastIndex = at;
+            const count = COUNT.exec(source);
+            BLANK_COUNT.lastIndex = at;
+            const blank = count === null ? BLANK_COUNT.exec(source) : null;
+            if (blank !== null)
+                refuse(source, `"${blank[0]}" is a count to ripgrep, which reads one with blanks in it, and those characters to JavaScript`);
+            read += count === null ? '\\{' : count[0];
+            at += count === null ? 1 : count[0].length;
+            continue;
+        }
+        if (char === ']' && empty !== '') {
+            refuse(source, `"${empty}" before a "]" is a class holding the "]" to ripgrep, and ${empty === '[]' ? 'no character' : 'any character'} to JavaScript`);
+        }
+        read += char === '^' ? LINE_START : char === '$' ? LINE_END : char === ']' || char === '}' ? `\\${char}` : char;
+        at += 1;
+    }
+    return read;
+}
+/**
+ * The regular expression the scanner matches a regex rule with: the rule as
+ * `readRegex` reads it, between word boundaries for `word="true"`, which
+ * ripgrep's `--word-regexp` puts round a pattern as `\b{start-half}` and
+ * `\b{end-half}`: no word character before the match and none after it.
+ */
+export function buildRegexRule(symbol, flags, word) {
+    const read = readRegex(symbol);
+    const source = word ? `(?<!${WORD_CHARACTER})(?:${read})(?!${WORD_CHARACTER})` : read;
+    try {
+        return new RegExp(source, `${flags}mv`);
+    }
+    catch (error) {
+        // V8 names the source it was given, which is the reading, not the rule.
+        const message = error.message;
+        refuse(symbol, message.slice(message.lastIndexOf(': ') + 2));
+    }
+}
+//# sourceMappingURL=dialect.js.map

package/dist/dialect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialect.js","sourceRoot":"","sources":["../src/dialect.ts"],"names":[],"mappings":"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"}

package/dist/engine.d.ts

@@ -251,7 +251,12 @@ export declare function parseRipgrepFiles(stdout: string, root: string, excludeF
  * principle that an unexplained line from a subprocess is still information.
  */
 export declare function parseRipgrepErrors(stderr: string): string[];
-/** Builds the matching RegExp shared by the JS engine. */
+/**
+ * Builds the matching RegExp shared by the JS engine. A regex rule is read
+ * as ripgrep reads it (`dialect.ts`), and a literal's word boundary is the
+ * one ripgrep's `--word-regexp` reads: no word character, the regex crate's
+ * `\w`, on either side. ADR-0007, amended 2026-10-24.
+ */
 export declare function buildJsRegExp(symbol: string, options: SearchOptions): RegExp;
 interface CandidateFile {
     absolutePath: string;

package/dist/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"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"}

package/dist/engine.js

@@ -21,6 +21,7 @@
 import { spawn } from 'node:child_process';
 import path from 'node:path';
 import { createCommentMask } from './comments.js';
+import { buildRegexRule, WORD_CHARACTER } from './dialect.js';
 import { createExcludeMatcher, createGlobMatcher, normalizeExclude, normalizeGlob, ripgrepGlobs, toPosix, walkFiles, } from './glob.js';
 import { nodeIo } from './io.js';
 import { NO_MEMO } from './memo.js';
@@ -325,6 +326,15 @@ export function buildRipgrepArgs(request, patterns = [request.symbol]) {
         //                 into memory only for a pattern that can match a line
         //                 end. ADR-0007, amended 2026-10-19.
         '--multiline',
+        //   --encoding=none  a file's bytes as they are, as the scanner reads
+        //                 them. By default ripgrep takes a UTF-8 byte order mark
+        //                 off the start of a file, so a rule against the mark,
+        //                 and the regex crate's `\S` at a file's start, were
+        //                 counted by the scanner in a file ripgrep never named;
+        //                 and it read a UTF-16 file as the text it holds, which
+        //                 the scanner does not.
+        //                 ADR-0007, amended 2026-10-24.
+        '--encoding=none',
     ];
     if (!options.regex)
         args.push('--fixed-strings');
@@ -649,58 +659,17 @@ export function parseRipgrepErrors(stderr) {
 }
 /* --------------------------------------------------------------- javascript */
 /**
- * U+2028 and U+2029, at which JavaScript's `m` ends a line and ripgrep
- * does not. Made from their numbers, so that no separator stands in this file
- * where an editor would show a line break.
+ * Builds the matching RegExp shared by the JS engine. A regex rule is read
+ * as ripgrep reads it (`dialect.ts`), and a literal's word boundary is the
+ * one ripgrep's `--word-regexp` reads: no word character, the regex crate's
+ * `\w`, on either side. ADR-0007, amended 2026-10-24.
  */
-const SEPARATORS = String.fromCharCode(0x2028, 0x2029);
-/**
- * `^` and `$` as ripgrep reads them with `--crlf`: at the start and at the
- * end of each line, a line ending at LF, at CRLF or at a lone CR, with no line
- * after the last line end. JavaScript's `m` reads three lines more, and each
- * is taken back out: one between the CR and the LF of a CRLF, one after the
- * last line end (and so in an empty file), and a line end at each separator.
- * With `m` alone `\s+$` matched on every line of a CRLF file and on the
- * last of every file, `^` met each CRLF line twice, and a line begun at a
- * separator was counted in a file ripgrep never named. ADR-0007, amended
- * 2026-10-19.
- */
-const LINE_START = `(?:^(?<![${SEPARATORS}])(?!(?<=\\r)\\n)(?=[\\s\\S]))`;
-const LINE_END = `(?:$(?![${SEPARATORS}])(?!(?<=\\r)\\n)(?!(?<![^\\n\\r])(?![\\s\\S])))`;
-/**
- * What in a pattern holds a `^` or a `$` that is not an anchor: an escape, a
- * named group's name and a reference to one (a name may hold a `$`), and a
- * character class, which in JavaScript ends at its first unescaped `]`. A
- * regex rule is read without the `u` flag, where nothing else does.
- *
- * Outside a class, an escape taken as a backslash before anything but white
- * space (`\\[\S\S]`) reads every pattern the same: a backslash before
- * white space escapes no `^`, `$`, `[`, `(` or backslash, so left untaken it
- * leaves each token where it was. That mutant is equivalent; inside a class it
- * is not, and `[\ $]` holds it.
- */
-const NOT_ANCHORS = /\\k<[^>]*>|\\[\s\S]|\(\?<(?![=!])[^>]*>|\[(?:\\[\s\S]|[^\\\]])*\]|[$^]/g;
-/** A pattern's source with each `^` and `$` read as the start and the end of a line. */
-function lineAnchors(source) {
-    let read = '';
-    let at = 0;
-    for (const piece of source.matchAll(NOT_ANCHORS)) {
-        const [token] = piece;
-        read += source.slice(at, piece.index) + (token === '^' ? LINE_START : token === '$' ? LINE_END : token);
-        at = piece.index + token.length;
-    }
-    return read + source.slice(at);
-}
-/** Builds the matching RegExp shared by the JS engine. */
 export function buildJsRegExp(symbol, options) {
     const flags = `g${options.ignoreCase ? 'i' : ''}`;
-    if (options.regex) {
-        const anchored = lineAnchors(symbol);
-        const source = options.word ? `(?<![A-Za-z0-9_])(?:${anchored})(?![A-Za-z0-9_])` : anchored;
-        return new RegExp(source, `${flags}m`);
-    }
+    if (options.regex)
+        return buildRegexRule(symbol, flags, options.word);
     const escaped = escapeRegExp(symbol);
-    const source = options.word ? `(?<![\\p{L}\\p{N}_])(?:${escaped})(?![\\p{L}\\p{N}_])` : escaped;
+    const source = options.word ? `(?<!${WORD_CHARACTER})(?:${escaped})(?!${WORD_CHARACTER})` : escaped;
     return new RegExp(source, `${flags}u`);
 }
 /**
@@ -978,12 +947,35 @@ getMask) {
     // module exists to remove.
     let starts = null;
     const lineOf = (index) => locate((starts ??= lineStarts(content)), index);
+    // Past an empty match by one character. A rule's regular expression has
+    // `u` or `v`, where V8 moves an index left between the two units of a
+    // character outside the Basic Multilingual Plane back to its first, so
+    // that one unit on met the same empty match again, for ever. A step of one
+    // unit always is that hang, which no assertion can see before a clock
+    // does: a sweep counts that mutant a timeout.
+    const past = (index) => index + (content.codePointAt(index) > 0xffff ? 2 : 1);
+    // No line follows a file's last line end, and an empty file holds none, so
+    // an empty match there is on no line, and ripgrep, which reads lines,
+    // names no file for it. ADR-0007, amended 2026-10-24.
+    const lineless = content.length === 0 || content.endsWith('\n') ? content.length : -1;
+    // At a character's second unit, between the two of one outside the Basic
+    // Multilingual Plane, where no character starts. V8 tries the place all the
+    // same where a match fails at the character before it, and a look-behind
+    // over a class holding such characters meets an empty match there, the
+    // boundaries of `\b` and of `word="true"` among them; ripgrep, which reads
+    // code points, meets none. Text read from a file holds no second unit
+    // without its first: UTF-8 that would encode one is read as U+FFFD.
+    const splits = (index) => (content.charCodeAt(index) & 0xfc00) === 0xdc00;
     let match;
-    while ((match = regexp.exec(content)) !== null) {
+    while ((match = regexp.exec(content)) !== null && match.index !== lineless) {
+        if (splits(match.index)) {
+            regexp.lastIndex = match.index + 1;
+            continue;
+        }
         if (getMask?.().isComment(match.index)) {
             commentCount += 1;
             if (match[0].length === 0)
-                regexp.lastIndex += 1;
+                regexp.lastIndex = past(regexp.lastIndex);
             continue;
         }
         count += 1;
@@ -1004,7 +996,7 @@ getMask) {
             });
         }
         if (match[0].length === 0)
-            regexp.lastIndex += 1;
+            regexp.lastIndex = past(regexp.lastIndex);
     }
     // No sort: exec scans forward, so lines are discovered in increasing order and
     // a Map preserves insertion order. Sorting here was dead code - mutation