@crewhaus/tool-text 0.7.0 → 0.8.0

package/dist/lib/normalize.d.ts

@@ -1,5 +1,13 @@
 /** Strip ANSI escapes so a captured terminal log compares as plain text. */
 export declare function stripAnsi(text: string): string;
+/**
+ * `line` without its trailing spaces and tabs: what
+ * `line.replace(/[ \t]+$/, "")` returned, in one pass from the end. That
+ * pattern tries every start inside a run of blanks that is not at the end of
+ * the line and rescans the rest of the run from each, so it was quadratic in
+ * the run's length.
+ */
+export declare function withoutTrailingBlanks(line: string): string;
 export type NormalizeOptions = {
     readonly eol?: "lf" | "crlf";
     readonly trimTrailingWhitespace?: boolean;
@@ -32,8 +40,19 @@ export declare function sortLines(text: string, opts: SortOptions): string[];
  * Replace terms using operator-supplied mappings, longest term first so a
  * multi-word entry wins over a substring of itself. Whole-word by default,
  * which is what stops "AI" rewriting the middle of "CHAIN".
+ *
+ * Each term's pass also runs over what earlier terms put in, so a
+ * replacement that holds the next term many times multiplied the text once
+ * per term: a 382-byte call grew it to 639,999 characters, and a fifth term
+ * to 12.8 million. The text may grow to `limit`, and the passes together may
+ * read {@link GLOSSARY_PASSES_PER_LIMIT} times it; past either this throws
+ * a sentence that says which, never a cut text.
+ *
+ * Each pass finds its term the way `new RegExp(<escaped term>, "g" | "gi")`
+ * did, with `(?<![\w-])` and `(?![\w-])` around it for whole words — but
+ * reads each unit of the text once, whatever the term ({@link replaceTerm}).
  */
-export declare function glossaryReplace(text: string, mapping: Readonly<Record<string, string>>, wholeWord: boolean, caseSensitive: boolean): {
+export declare function glossaryReplace(text: string, mapping: Readonly<Record<string, string>>, wholeWord: boolean, caseSensitive: boolean, limit?: number): {
     text: string;
     replacements: Record<string, number>;
 };

package/dist/lib/normalize.js

@@ -1,4 +1,3 @@
-import { escapeFor } from "./format";
 /** CSI/SGR escapes emitted by terminals into captured output. */
 const ANSI_PATTERN = new RegExp(`${String.fromCharCode(27)}\\[[0-9;?]*[ -/]*[@-~]`, "g");
 /** Strip ANSI escapes so a captured terminal log compares as plain text. */
@@ -30,6 +29,22 @@ const INVISIBLE_CODE_POINTS = [
     0x2069,
 ];
 const INVISIBLE_PATTERN = new RegExp(INVISIBLE_CODE_POINTS.map((cp) => `\\u${cp.toString(16).padStart(4, "0")}`).join("|"), "g");
+/**
+ * `line` without its trailing spaces and tabs: what
+ * `line.replace(/[ \t]+$/, "")` returned, in one pass from the end. That
+ * pattern tries every start inside a run of blanks that is not at the end of
+ * the line and rescans the rest of the run from each, so it was quadratic in
+ * the run's length.
+ */
+export function withoutTrailingBlanks(line) {
+    let end = line.length;
+    for (; end > 0; end--) {
+        const c = line.charCodeAt(end - 1);
+        if (c !== 0x20 && c !== 0x09)
+            break;
+    }
+    return end === line.length ? line : line.slice(0, end);
+}
 /**
  * Canonicalize text so two copies differing only in invisible ways compare
  * equal. Run this before hashing, diffing, or de-duplicating; it is why a
@@ -48,10 +63,7 @@ export function normalizeText(text, opts) {
     // Fold to LF first so later rules see one shape, then convert at the end.
     out = out.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
     if (opts.trimTrailingWhitespace === true) {
-        out = out
-            .split("\n")
-            .map((l) => l.replace(/[ \t]+$/, ""))
-            .join("\n");
+        out = out.split("\n").map(withoutTrailingBlanks).join("\n");
     }
     if (opts.collapseBlankLines === true)
         out = out.replace(/\n{3,}/g, "\n\n");
@@ -98,25 +110,177 @@ export function sortLines(text, opts) {
     });
     return opts.order === "desc" ? sorted.reverse() : sorted;
 }
+/** GlossaryReplace's limit for its text: the default for what the mapping may grow it to. */
+const GLOSSARY_LIMIT = 2_000_000;
+/**
+ * Each term is one pass over the whole text, so the passes together may
+ * read this many times the limit: thousands of terms over a long document,
+ * or a hundred over the longest text.
+ */
+const GLOSSARY_PASSES_PER_LIMIT = 100;
 /**
  * Replace terms using operator-supplied mappings, longest term first so a
  * multi-word entry wins over a substring of itself. Whole-word by default,
  * which is what stops "AI" rewriting the middle of "CHAIN".
+ *
+ * Each term's pass also runs over what earlier terms put in, so a
+ * replacement that holds the next term many times multiplied the text once
+ * per term: a 382-byte call grew it to 639,999 characters, and a fifth term
+ * to 12.8 million. The text may grow to `limit`, and the passes together may
+ * read {@link GLOSSARY_PASSES_PER_LIMIT} times it; past either this throws
+ * a sentence that says which, never a cut text.
+ *
+ * Each pass finds its term the way `new RegExp(<escaped term>, "g" | "gi")`
+ * did, with `(?<![\w-])` and `(?![\w-])` around it for whole words — but
+ * reads each unit of the text once, whatever the term ({@link replaceTerm}).
  */
-export function glossaryReplace(text, mapping, wholeWord, caseSensitive) {
+export function glossaryReplace(text, mapping, wholeWord, caseSensitive, limit = GLOSSARY_LIMIT) {
     const replacements = {};
+    const terms = Object.keys(mapping).sort((a, b) => b.length - a.length);
+    const budget = GLOSSARY_PASSES_PER_LIMIT * limit;
     let out = text;
-    for (const term of Object.keys(mapping).sort((a, b) => b.length - a.length)) {
-        const escaped = escapeFor(term, "regex");
-        const source = wholeWord ? `(?<![\\w-])${escaped}(?![\\w-])` : escaped;
-        const re = new RegExp(source, caseSensitive ? "g" : "gi");
-        let count = 0;
-        out = out.replace(re, () => {
-            count++;
-            return mapping[term];
-        });
-        if (count > 0)
-            replacements[term] = count;
+    let read = 0;
+    for (const term of terms) {
+        if (read + out.length > budget) {
+            throw new Error(`${terms.length} glossary terms over ${out.length} characters of text would read more than ${budget} characters, since each term is a pass over the whole text; send fewer terms or a shorter text`);
+        }
+        read += out.length;
+        // What the replacer returned before: a missing value reads "undefined".
+        const value = String(mapping[term]);
+        const replaced = replaceTerm(out, term, value, wholeWord, caseSensitive, limit);
+        if (replaced.count > 0)
+            replacements[term] = replaced.count;
+        out = replaced.text;
     }
     return { text: out, replacements };
 }
+/** `[\w-]`: what a whole word may not touch. The regex `i` flag (without `u`) folds no other unit into it. */
+function isWordUnit(c) {
+    return ((c >= 0x30 && c <= 0x39) ||
+        (c >= 0x41 && c <= 0x5a) ||
+        (c >= 0x61 && c <= 0x7a) ||
+        c === 0x5f ||
+        c === 0x2d);
+}
+/** Canonical code unit per code unit, filled on first use; -1 is "not yet". */
+const CANONICAL = new Int32Array(0x10000).fill(-1);
+/**
+ * The code unit the regex `i` flag (without `u`) compares `c` as: the
+ * ECMAScript Canonicalize — its upper case when that is one code unit, and not
+ * ASCII for a non-ASCII `c` — as this engine's own tables have it. The
+ * engine's case tables can be older than `toUpperCase`'s, so a pairing the
+ * regex does not make is not made here either. The same function is in
+ * tool-secure's `lib/literal.ts`; keep the two in step.
+ */
+function canonicalUnit(c) {
+    const known = CANONICAL[c];
+    if (known !== -1)
+        return known;
+    let out = c;
+    if (c < 0x80) {
+        if (c >= 0x61 && c <= 0x7a)
+            out = c - 0x20;
+    }
+    else {
+        const upper = String.fromCharCode(c).toUpperCase();
+        if (upper.length === 1) {
+            const u = upper.charCodeAt(0);
+            if (u >= 0x80 && u !== c && regexFolds(c, u))
+                out = u;
+        }
+    }
+    CANONICAL[c] = out;
+    return out;
+}
+function regexFolds(a, b) {
+    return new RegExp(`^\\u${a.toString(16).padStart(4, "0")}$`, "i").test(String.fromCharCode(b));
+}
+const sameUnit = (c) => c;
+/**
+ * `text` with `term` replaced by `value` wherever `new RegExp(<escaped
+ * term>, caseSensitive ? "g" : "gi")` matched it — inside
+ * `(?<![\w-])…(?![\w-])` when `wholeWord` — and how many times.
+ *
+ * That regex tried the whole term from every position of the text, so one
+ * pass read the text's length times the term's. Here the term is found with
+ * Knuth–Morris–Pratt, comparing code units folded as the `i` flag folds
+ * them: each unit of the text is read once, and the comparisons that fail
+ * are paid for by ones that matched. Every place the term occurs is found,
+ * overlapping ones too, left to right; one is a match when it starts where
+ * the last match ended or later and, for whole words, the units on either
+ * side of it (in the text as it was, as the lookarounds read it) are not
+ * `[\w-]`. That is the leftmost match from each place the regex resumed. The
+ * empty term occurs before each unit and at the end, as an empty regex
+ * matches.
+ *
+ * Case folds as the term on its own folded. JavaScriptCore folded some units
+ * further when the pattern had the lookbehind, so with whole words the
+ * Kelvin sign matched "k" and the long s "S", where the term on its own
+ * never did; with whole words on or off, they now fold alike.
+ *
+ * Every match is as long as the term, so the text's growth only rises or
+ * only falls: once past `limit` the whole pass ends past it, and this throws
+ * at that match rather than build the text.
+ */
+function replaceTerm(text, term, value, wholeWord, caseSensitive, limit) {
+    const m = term.length;
+    const n = text.length;
+    const fold = caseSensitive ? sameUnit : canonicalUnit;
+    const parts = [];
+    let copied = 0;
+    let count = 0;
+    let grown = 0;
+    const take = (start) => {
+        count++;
+        grown += value.length - m;
+        if (grown > 0 && n + grown > limit) {
+            throw new Error(`the glossary would make the text longer than ${limit} characters, the limit for text; terms apply longest first, each to the text the ones before produced, so a replacement that holds a later term is replaced again`);
+        }
+        parts.push(text.slice(copied, start), value);
+        copied = start + m;
+    };
+    const clearOfWords = (start, end) => !wholeWord ||
+        ((start === 0 || !isWordUnit(text.charCodeAt(start - 1))) &&
+            (end === n || !isWordUnit(text.charCodeAt(end))));
+    if (m === 0) {
+        for (let i = 0; i <= n; i++)
+            if (clearOfWords(i, i))
+                take(i);
+    }
+    else if (m <= n) {
+        // For each prefix of the folded term, its longest proper border.
+        const border = new Int32Array(m);
+        for (let i = 1, k = 0; i < m; i++) {
+            const c = fold(term.charCodeAt(i));
+            while (k > 0 && fold(term.charCodeAt(k)) !== c)
+                k = border[k - 1];
+            if (fold(term.charCodeAt(k)) === c)
+                k += 1;
+            border[i] = k;
+        }
+        let k = 0;
+        for (let i = 0; i < n; i++) {
+            const c = fold(text.charCodeAt(i));
+            while (k > 0 && fold(term.charCodeAt(k)) !== c)
+                k = border[k - 1];
+            if (fold(term.charCodeAt(k)) === c)
+                k += 1;
+            if (k === m) {
+                const start = i + 1 - m;
+                if (start >= copied && clearOfWords(start, i + 1)) {
+                    take(start);
+                    // The next match starts where this one ends.
+                    k = 0;
+                }
+                else {
+                    // Not a match here; one may still start inside it.
+                    k = border[m - 1];
+                }
+            }
+        }
+    }
+    if (count === 0)
+        return { text, count };
+    parts.push(text.slice(copied));
+    return { text: parts.join(""), count };
+}

package/dist/lib/regex.d.ts

@@ -7,14 +7,61 @@ export type RegexMatch = {
     readonly groups: Readonly<Record<string, string>>;
     readonly captures: ReadonlyArray<string | undefined>;
 };
+/** Where a tool call's patterns run: its abort signal, and whose runaway workers they count as. */
+export type RegexRunContext = {
+    readonly signal?: AbortSignal;
+    readonly runawayKey?: string;
+};
+/** The ctx fields a tool's `execute` receives that a regex run uses. */
+export declare function regexRunContext(ctx: unknown): RegexRunContext;
+/** Wall-clock budget for one call's caller patterns. */
+export declare const PATTERN_DEADLINE_MS = 5000;
+/** The screen's limits for a caller pattern. */
+export declare const PATTERN_LIMITS: {
+    readonly maxPatternChars: 10000;
+};
+export type RegexExtractResult = {
+    readonly ok: true;
+    readonly matches: RegexMatch[];
+    /** More matches may exist than were returned. */
+    readonly truncated: boolean;
+    readonly truncatedBy?: "maxMatches" | "maxOutputChars";
+    /**
+     * Set when the pattern could not be run to the end of the text (the
+     * deadline, the engine giving up): `matches` are the ones found before
+     * it stopped, and there may be more. Never read as "no more matches".
+     */
+    readonly undetermined?: string;
+} | {
+    readonly ok: false;
+    readonly invalid: string;
+};
 /**
- * Run a regex over text and return located matches.
+ * Run a caller's regex over text and return located matches.
  *
- * Always compiles with `g` so the scan advances, and a zero-width match bumps
- * `lastIndex` by one so a pattern like `a*` terminates instead of spinning
- * forever at the same offset.
+ * The match runs in `@crewhaus/tool-safety`'s regex worker under a deadline,
+ * never on this thread: a synchronous `RegExp` cannot be interrupted, and
+ * `a*a*a*a*b` over 400 characters held the whole process for 108 s. The
+ * pattern is screened first, so a shape that backtracks exponentially is
+ * refused with the reason. `g` is always applied, and a zero-width match
+ * advances by one character, so a pattern like `a*` terminates.
  */
-export declare function regexExtractAll(text: string, pattern: string, flags: string, maxMatches: number): {
-    matches: RegexMatch[];
-    truncated: boolean;
+export declare function regexExtractAll(text: string, pattern: string, flags: string, maxMatches: number, ctx?: RegexRunContext): Promise<RegexExtractResult>;
+/** One pattern's answer on one text: a verdict, or why there is none. */
+export type PatternAnswer = boolean | {
+    readonly undetermined: string;
 };
+/**
+ * Test every pattern against `text` (case-insensitively, as RuleClassify
+ * reads its regex rules) in one worker run, so a classifier can score
+ * synchronously from the answers. A pattern the screen refuses is reported
+ * as `invalid`, with its reason; one the worker could not finish is
+ * undetermined, never `false`.
+ */
+export declare function answerPatterns(text: string, patterns: ReadonlyArray<string>, flags: string, ctx?: RegexRunContext): Promise<{
+    readonly ok: true;
+    readonly answers: ReadonlyMap<string, PatternAnswer>;
+} | {
+    readonly ok: false;
+    readonly invalid: string;
+}>;

package/dist/lib/regex.js

@@ -1,36 +1,125 @@
+import { describeRegexOutcome, openRegexSession, runRegex, } from "@crewhaus/tool-safety/regex";
 import { lineStarts, offsetToLineCol } from "./locate";
+/** The ctx fields a tool's `execute` receives that a regex run uses. */
+export function regexRunContext(ctx) {
+    const c = ctx;
+    return {
+        ...(c?.signal === undefined ? {} : { signal: c.signal }),
+        ...(typeof c?.runContext?.sessionId === "string" ? { runawayKey: c.runContext.sessionId } : {}),
+    };
+}
+/** Wall-clock budget for one call's caller patterns. */
+export const PATTERN_DEADLINE_MS = 5_000;
+/** The screen's limits for a caller pattern. */
+export const PATTERN_LIMITS = { maxPatternChars: 10_000 };
 /**
- * Run a regex over text and return located matches.
+ * Run a caller's regex over text and return located matches.
  *
- * Always compiles with `g` so the scan advances, and a zero-width match bumps
- * `lastIndex` by one so a pattern like `a*` terminates instead of spinning
- * forever at the same offset.
+ * The match runs in `@crewhaus/tool-safety`'s regex worker under a deadline,
+ * never on this thread: a synchronous `RegExp` cannot be interrupted, and
+ * `a*a*a*a*b` over 400 characters held the whole process for 108 s. The
+ * pattern is screened first, so a shape that backtracks exponentially is
+ * refused with the reason. `g` is always applied, and a zero-width match
+ * advances by one character, so a pattern like `a*` terminates.
  */
-export function regexExtractAll(text, pattern, flags, maxMatches) {
-    const withGlobal = flags.includes("g") ? flags : `${flags}g`;
-    const re = new RegExp(pattern, withGlobal);
+export async function regexExtractAll(text, pattern, flags, maxMatches, ctx = {}) {
+    const outcome = await runRegex({
+        op: "matchAll",
+        pattern,
+        flags,
+        input: text,
+        maxMatches,
+        deadlineMs: PATTERN_DEADLINE_MS,
+        maxInputChars: text.length,
+        limits: PATTERN_LIMITS,
+        ...(ctx.signal === undefined ? {} : { signal: ctx.signal }),
+        ...(ctx.runawayKey === undefined ? {} : { runawayKey: ctx.runawayKey }),
+    });
+    if (outcome.status === "rejected")
+        return { ok: false, invalid: outcome.reason };
+    const found = outcome.status === "ok"
+        ? outcome.result.matches
+        : outcome.status === "gave-up"
+            ? (outcome.partial?.matches ?? [])
+            : [];
     const starts = lineStarts(text);
-    const matches = [];
-    let truncated = false;
-    for (;;) {
-        const m = re.exec(text);
-        if (m === null)
-            break;
-        if (matches.length >= maxMatches) {
-            truncated = true;
-            break;
-        }
+    const matches = found.map((m) => {
         const { line, column } = offsetToLineCol(starts, m.index);
-        matches.push({
-            match: m[0],
-            index: m.index,
-            line,
-            column,
-            groups: { ...(m.groups ?? {}) },
-            captures: m.slice(1),
+        const groups = {};
+        for (const [name, value] of Object.entries(m.groups ?? {})) {
+            if (value !== undefined)
+                groups[name] = value;
+        }
+        return { match: m.match, index: m.index, line, column, groups, captures: m.captures };
+    });
+    if (outcome.status !== "ok") {
+        return {
+            ok: true,
+            matches,
+            truncated: true,
+            undetermined: describeRegexOutcome(outcome),
+        };
+    }
+    return {
+        ok: true,
+        matches,
+        truncated: outcome.result.truncated,
+        ...(outcome.result.truncatedBy === undefined
+            ? {}
+            : { truncatedBy: outcome.result.truncatedBy }),
+    };
+}
+/**
+ * Test every pattern against `text` (case-insensitively, as RuleClassify
+ * reads its regex rules) in one worker run, so a classifier can score
+ * synchronously from the answers. A pattern the screen refuses is reported
+ * as `invalid`, with its reason; one the worker could not finish is
+ * undetermined, never `false`.
+ */
+export async function answerPatterns(text, patterns, flags, ctx = {}) {
+    const distinct = [...new Set(patterns)];
+    const answers = new Map();
+    if (distinct.length === 0)
+        return { ok: true, answers };
+    let total = 0;
+    for (const p of distinct)
+        total += p.length;
+    const session = openRegexSession();
+    try {
+        const outcome = await session.run({
+            op: "testMatrix",
+            patterns: distinct.map((pattern) => ({ pattern, flags })),
+            inputs: [text],
+            onGiveUp: "skip",
+            deadlineMs: PATTERN_DEADLINE_MS,
+            maxInputChars: text.length + 1,
+            maxItemChars: text.length,
+            maxRules: distinct.length,
+            maxTotalPatternChars: total,
+            limits: PATTERN_LIMITS,
+            ...(ctx.signal === undefined ? {} : { signal: ctx.signal }),
+            ...(ctx.runawayKey === undefined ? {} : { runawayKey: ctx.runawayKey }),
         });
-        if (m[0].length === 0)
-            re.lastIndex += 1;
+        if (outcome.status === "rejected") {
+            const which = outcome.ruleIndex === undefined ? "" : `/${distinct[outcome.ruleIndex]}/: `;
+            return { ok: false, invalid: `${which}${outcome.reason}` };
+        }
+        for (const [i, pattern] of distinct.entries()) {
+            if (outcome.status !== "ok") {
+                answers.set(pattern, { undetermined: describeRegexOutcome(outcome) });
+            }
+            else if ((outcome.result.undetermined[i] ?? []).length > 0) {
+                answers.set(pattern, {
+                    undetermined: "the regex engine gave up on the text, which it reports as no match",
+                });
+            }
+            else {
+                answers.set(pattern, (outcome.result.matched[i] ?? []).length > 0);
+            }
+        }
+        return { ok: true, answers };
+    }
+    finally {
+        session.close();
     }
-    return { matches, truncated };
 }

package/dist/lib/similarity.d.ts

@@ -1,4 +1,8 @@
-/** Classic Levenshtein edit distance, two-row variant. */
+/**
+ * Classic Levenshtein edit distance, two-row variant, over UTF-16 code
+ * units. The rows are typed arrays reused across the table, not a fresh
+ * array per row: the same answers at a fraction of the time per cell.
+ */
 export declare function levenshtein(a: string, b: string): number;
 /** Edit distance expressed as a 0..1 similarity. */
 export declare function levenshteinRatio(a: string, b: string): number;
@@ -8,6 +12,21 @@ export declare function jaroWinkler(a: string, b: string): number;
 export declare function nGrams(text: string, n: number): Set<string>;
 export declare function jaccard(a: ReadonlySet<string>, b: ReadonlySet<string>): number;
 export type SimilarityMethod = "levenshtein" | "jaro" | "trigram" | "tokenJaccard";
+/**
+ * The most work one Levenshtein or Jaro comparison may do, in Levenshtein
+ * cells: about a second of one thread. Both methods are O(n x m) and run
+ * synchronously on the harness thread, so two 20,000-character strings
+ * stalled every session in the process; this refuses those and still
+ * answers the sizes 0.7.0 answered in a fraction of a second.
+ */
+export declare const MAX_SIMILARITY_WORK = 200000000;
+/**
+ * The work one comparison does, in Levenshtein cells: the DP table for
+ * Levenshtein, the matching window for Jaro at its measured discount.
+ * Trigram and token overlap are linear, so they cost nothing against the
+ * quadratic budget.
+ */
+export declare function similarityCost(a: string, b: string, method: SimilarityMethod): number;
 export declare function similarity(a: string, b: string, method: SimilarityMethod): number;
 export type FuzzyHit = {
     readonly candidate: string;

package/dist/lib/similarity.js

@@ -1,5 +1,9 @@
 import { tokenize } from "./locate";
-/** Classic Levenshtein edit distance, two-row variant. */
+/**
+ * Classic Levenshtein edit distance, two-row variant, over UTF-16 code
+ * units. The rows are typed arrays reused across the table, not a fresh
+ * array per row: the same answers at a fraction of the time per cell.
+ */
 export function levenshtein(a, b) {
     if (a === b)
         return 0;
@@ -7,17 +11,31 @@ export function levenshtein(a, b) {
         return b.length;
     if (b.length === 0)
         return a.length;
-    let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+    const m = b.length;
+    // Int32, not Uint32: an unsigned element can exceed 2^31, so the engine
+    // reads Uint32 cells as doubles and the table ran four times slower.
+    let prev = new Int32Array(m + 1);
+    let cur = new Int32Array(m + 1);
+    for (let j = 0; j <= m; j++)
+        prev[j] = j;
     for (let i = 1; i <= a.length; i++) {
-        const cur = new Array(b.length + 1);
         cur[0] = i;
-        for (let j = 1; j <= b.length; j++) {
-            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-            cur[j] = Math.min(cur[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+        const ai = a.charCodeAt(i - 1);
+        for (let j = 1; j <= m; j++) {
+            let best = prev[j - 1] + (ai === b.charCodeAt(j - 1) ? 0 : 1);
+            const insert = cur[j - 1] + 1;
+            if (insert < best)
+                best = insert;
+            const remove = prev[j] + 1;
+            if (remove < best)
+                best = remove;
+            cur[j] = best;
         }
+        const done = prev;
         prev = cur;
+        cur = done;
     }
-    return prev[b.length];
+    return prev[m];
 }
 /** Edit distance expressed as a 0..1 similarity. */
 export function levenshteinRatio(a, b) {
@@ -33,17 +51,20 @@ export function jaroWinkler(a, b) {
     if (a.length === 0 || b.length === 0)
         return 0;
     const window = Math.max(0, Math.floor(Math.max(a.length, b.length) / 2) - 1);
-    const aFlags = new Array(a.length).fill(false);
-    const bFlags = new Array(b.length).fill(false);
+    // Typed flags and code units: the same answers, at a fraction of the time
+    // per window step.
+    const aFlags = new Uint8Array(a.length);
+    const bFlags = new Uint8Array(b.length);
     let matches = 0;
     for (let i = 0; i < a.length; i++) {
         const lo = Math.max(0, i - window);
         const hi = Math.min(b.length - 1, i + window);
+        const ai = a.charCodeAt(i);
         for (let j = lo; j <= hi; j++) {
-            if (bFlags[j] === true || a[i] !== b[j])
+            if (bFlags[j] === 1 || ai !== b.charCodeAt(j))
                 continue;
-            aFlags[i] = true;
-            bFlags[j] = true;
+            aFlags[i] = 1;
+            bFlags[j] = 1;
             matches++;
             break;
         }
@@ -53,11 +74,11 @@ export function jaroWinkler(a, b) {
     let transpositions = 0;
     let k = 0;
     for (let i = 0; i < a.length; i++) {
-        if (aFlags[i] !== true)
+        if (aFlags[i] !== 1)
             continue;
-        while (bFlags[k] !== true)
+        while (bFlags[k] !== 1)
             k++;
-        if (a[i] !== b[k])
+        if (a.charCodeAt(i) !== b.charCodeAt(k))
             transpositions++;
         k++;
     }
@@ -86,6 +107,37 @@ export function jaccard(a, b) {
     const union = a.size + b.size - intersection;
     return union === 0 ? 0 : intersection / union;
 }
+/**
+ * The most work one Levenshtein or Jaro comparison may do, in Levenshtein
+ * cells: about a second of one thread. Both methods are O(n x m) and run
+ * synchronously on the harness thread, so two 20,000-character strings
+ * stalled every session in the process; this refuses those and still
+ * answers the sizes 0.7.0 answered in a fraction of a second.
+ */
+export const MAX_SIMILARITY_WORK = 200_000_000;
+/**
+ * A Jaro cell (one step of the matching window) costs about a quarter of a
+ * Levenshtein cell, measured: 25 M of them take 30-40 ms where 25 M
+ * Levenshtein cells take over 100 ms.
+ */
+const JARO_CELLS_PER_UNIT = 4;
+/**
+ * The work one comparison does, in Levenshtein cells: the DP table for
+ * Levenshtein, the matching window for Jaro at its measured discount.
+ * Trigram and token overlap are linear, so they cost nothing against the
+ * quadratic budget.
+ */
+export function similarityCost(a, b, method) {
+    if (a === b || a.length === 0 || b.length === 0)
+        return 0;
+    if (method === "levenshtein")
+        return a.length * b.length;
+    if (method === "jaro") {
+        const window = Math.max(0, Math.floor(Math.max(a.length, b.length) / 2) - 1);
+        return Math.ceil((a.length * Math.min(b.length, 2 * window + 1)) / JARO_CELLS_PER_UNIT);
+    }
+    return 0;
+}
 export function similarity(a, b, method) {
     if (method === "levenshtein")
         return levenshteinRatio(a, b);