har2sdk 0.6.4 → 0.6.5

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.6.5
+
+Regexes that CodeQL flagged as polynomial, and one that was exponential, are replaced with linear code. A crafted capture could make the CLI, the MCP server or the mock take seconds or minutes; nothing leaked and no code ran. Output is unchanged: every replacement is compared with the code it replaces on 3,000 generated inputs, and `test/fixtures/demo-snapshot.json` is unchanged.
+
+**Slow inputs**
+- GraphQL documents: spaces before the last character of a document (`withoutComments`: 100 KB took 17 s) and a fragment head with no `{` after it (`withoutFragments`: 100 KB, about 5 s, also from a GraphQL request to the running mock) (#7).
+- GraphQL strings: a string that doesn't close, made of escaped quotes (`"\"\"\"…`), was scanned again from every escaped quote, in `model.ts` and `leak.ts` (a 200 KB capture: 27 s) (#10, #11).
+- A GraphQL list argument that doesn't close (`ids: [1  1  1 …`) was exponential in `liftGraphQLLiterals`: 60 bytes took 29 s, and each further item doubled it (#11).
+- The leak guard's tokens: trimming `.`, `-` and `~` from a token scanned a run of them again from each character (`scanText` and `scrubText` on a 200 KB token: about 25 s) (#10).
+- Replaced as a precaution: trailing slashes (`plan.ts`, `openapi.ts`), percent-encoded runs (`leak.ts`) and the JSON fence in a pasted reply (`annotations.ts`) were quadratic in isolation but not reached slowly from any capture we built; the relative-link cut (`redact.ts`) was flagged but was already linear (#7).
+
+**CI**
+- `ci.yml` gives its token read-only access (`permissions: contents: read`) (#7).
+
+**Dependencies**
+- fast-uri 3.1.8 → 3.1.9 (#8) and body-parser 2.3.0 → 2.4.0 (#9): lockfile updates to dependencies of `@modelcontextprotocol/sdk`.
+
+**Tests**
+- `test/review9.test.ts` (G1–G7) and `test/review10.test.ts` (H1–H12): each replacement has an attack input with a time limit and a generated comparison with the original on 3,000 inputs. The replacements are in `src/linear.ts`.
+
 ## 0.6.4
 
 A privacy fix in the mock's fake data, an Auth section in the README, and tests that pin both.

package/README.md

@@ -121,7 +121,7 @@ HAR files contain live session cookies, tokens and often other people's data. ha
 
 The guard is a heuristic with evidence from the capture, not a proof: a value with **no evidence anywhere** (a word used once as a path segment that nothing else names) can't be recognised, and one-word names of things (a category `"Books"`) are treated as vocabulary. Look over `har2sdk inspect` before publishing generated code. Details, and exactly what is and isn't collected: [SECURITY.md](SECURITY.md).
 
-It's tested with the inputs of eight review rounds (`test/review*.test.ts`) and a generated privacy test that builds a random person and hides them in 30 kinds of places in a random capture, then checks every output, including a real MCP session, the CLI's `inspect --json` and every mock response (30 seeds in CI; the long run of 1,000 seeds passes).
+It's tested with the inputs of ten review rounds (`test/review*.test.ts`) and a generated privacy test that builds a random person and hides them in 30 kinds of places in a random capture, then checks every output, including a real MCP session, the CLI's `inspect --json` and every mock response (30 seeds in CI; the long run of 1,000 seeds passes).
 
 **Treat `.har` files like passwords.** **Use it responsibly:** reverse-engineering an API you don't own can break its terms of use. Good uses: your own apps, legacy internal systems, services you're allowed to integrate with. Please don't publish SDKs for other companies' services.
 

package/dist/annotations.js

@@ -17,6 +17,7 @@
  * }
  */
 import { z } from "zod";
+import { fencedBody } from "./linear.js";
 import { RESERVED_METHOD_NAMES } from "./naming.js";
 import { tokenText } from "./template.js";
 import { isIdentifier, pascal, safeIdentifier } from "./words.js";
@@ -35,8 +36,8 @@ export const ANNOTATIONS_SCHEMA = z.object({
 });
 export function parseAnnotations(text) {
     // Accept a chat reply as-is: strip prose and ```json fences around the object.
-    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/);
-    const body = fenced ? fenced[1] : text.slice(Math.max(0, text.indexOf("{")), text.lastIndexOf("}") + 1);
+    const fenced = fencedBody(text);
+    const body = fenced !== undefined ? fenced : text.slice(Math.max(0, text.indexOf("{")), text.lastIndexOf("}") + 1);
     const data = JSON.parse(body);
     if (typeof data !== "object" || data === null || Array.isArray(data))
         throw new Error("Annotations must be a JSON object");

package/dist/codegen.d.ts

@@ -3,7 +3,7 @@
  * runtime dependencies (uses the global `fetch`, Node 18+ or any browser).
  */
 import type { Plan, PlannedOp } from "./plan.js";
-export declare const VERSION = "0.6.4";
+export declare const VERSION = "0.6.5";
 export declare function generateTypeScript(plan: Plan): string;
 /** Just the type declarations (used for prompts and MCP responses). */
 export declare function generateTypesOnly(plan: Plan, onlyOps?: PlannedOp[]): string;

package/dist/codegen.js

@@ -1,6 +1,6 @@
 import { printTs, printTsInterface } from "./types.js";
 import { propertyKey } from "./words.js";
-export const VERSION = "0.6.4";
+export const VERSION = "0.6.5";
 export function generateTypeScript(plan) {
     const { model, clientName, ops } = plan;
     const out = [];

package/dist/leak.js

@@ -1,4 +1,5 @@
 import { isObject } from "./har.js";
+import { graphqlLiteralMatches, quotedStrings, replacePercentRuns, trimDotsDashesTildes } from "./linear.js";
 import { isContactName, isDataKey, isEmail, isPersonalName, isSecretValue, isSensitiveName, Scrubber } from "./redact.js";
 import { singular, words } from "./words.js";
 export function emptyTaint() {
@@ -522,13 +523,13 @@ function mapJsonish(text, fn) {
 }
 /** String literals (block strings too) and long numbers inside a GraphQL document. */
 function graphqlLiterals(doc, c) {
-    for (const m of doc.matchAll(/#[^\n]*|(?:\b([A-Za-z_]\w*)\s*:\s*)?(?:"""([\s\S]*?)"""|"((?:[^"\\\n]|\\.)*)"|(?<![\w$.])(-?\d{6,})(?![\w.]))/g)) {
+    for (const m of graphqlLiteralMatches(doc)) {
         // `login: "mdemir"`: the argument name says what the value is.
         const identity = !!m[1] && (isIdentityKey(m[1]) || isIdKey(m[1]));
         if (m[0].startsWith("#")) {
             // Comments stay in the document: anything data-like in them is data.
-            for (const q of m[0].matchAll(/"((?:[^"\\\n]|\\.)*)"/g))
-                c.addAlways(q[1]);
+            for (const [start, end] of quotedStrings(m[0]))
+                c.addAlways(m[0].slice(start + 1, end - 1));
             for (const w of m[0].match(/[^\s"'<>,;()[\]{}]{4,}/g) ?? [])
                 if (isDataLike(w))
                     c.add(w);
@@ -623,7 +624,7 @@ function index(text, taint) {
     for (const raw of text.split(TOKEN_SPLIT)) {
         if (!raw)
             continue;
-        const t = raw.replace(/^[.\-~]+|[.\-~]+$/g, "").toLowerCase();
+        const t = trimDotsDashesTildes(raw).toLowerCase();
         if (!t || tokens.has(t))
             continue;
         tokens.add(t);
@@ -694,8 +695,8 @@ export function scanText(input, taint, where, ignore) {
         if (!parts.length)
             continue;
         if (parts.length === 1
-            ? (tokens.has(parts[0].replace(/^[.\-~]+|[.\-~]+$/g, "")) || inPieces(taint, pieces, v)) && lower.includes(v)
-            : parts.every((p) => tokens.has(p.replace(/^[.\-~]+|[.\-~]+$/g, ""))) && lower.includes(v)) {
+            ? (tokens.has(trimDotsDashesTildes(parts[0])) || inPieces(taint, pieces, v)) && lower.includes(v)
+            : parts.every((p) => tokens.has(trimDotsDashesTildes(p))) && lower.includes(v)) {
             found.push({ where, preview: maskPreview(v), kind: "value" });
             hit.add(aliasOf(v));
         }
@@ -735,7 +736,7 @@ export function scrubText(text, taint) {
         if (taint.allowed.has(v))
             continue;
         const parts = v.split(TOKEN_SPLIT).filter(Boolean);
-        if (parts.length && (parts.every((p) => tokens.has(p.replace(/^[.\-~]+|[.\-~]+$/g, ""))) || (parts.length === 1 && inPieces(taint, pieces, v))) && lower.includes(v))
+        if (parts.length && (parts.every((p) => tokens.has(trimDotsDashesTildes(p))) || (parts.length === 1 && inPieces(taint, pieces, v))) && lower.includes(v))
             findings.add(v);
     }
     for (const t of tokens)
@@ -762,7 +763,7 @@ export function scrubText(text, taint) {
         return out;
     };
     // Percent-encoded tokens are matched in their decoded form ("G%C3%BCl%C5%9Fen").
-    return redact(text).replace(/[^\s"'<>`|()[\]{},;]*%[0-9A-Fa-f]{2}[^\s"'<>`|()[\]{},;]*/g, (tok) => {
+    return replacePercentRuns(redact(text), (tok) => {
         let d;
         try {
             d = decodeURIComponent(tok);

package/dist/linear.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Linear-time replacements for regexes that CodeQL flagged as polynomial. All
+ * but withoutQueryOrHash backtracked quadratically on crafted input. Each
+ * function returns exactly what the regex in its comment returns;
+ * test/review9.test.ts and test/review10.test.ts compare them on generated input.
+ */
+/** `s.replace(/[ \t]+$/gm, "")`: spaces and tabs at the end of every line. */
+export declare function trimLineEnds(s: string): string;
+/** `s.replace(/\/+$/, "")`: trailing slashes. */
+export declare function trimTrailingSlashes(s: string): string;
+/**
+ * `s.replace(/[?#].*$/, "")` for a string without line terminators (the caller
+ * has checked `/^\/[^\s]*$/`): everything from the first `?` or `#`.
+ */
+export declare function withoutQueryOrHash(s: string): string;
+/** `text.match(/```(?:json)?\s*([\s\S]*?)```/)?.[1]`: the body of the first fenced block. */
+export declare function fencedBody(text: string): string | undefined;
+/**
+ * `text.replace(/[^\s"'<>`|()[\]{},;]*%[0-9A-Fa-f]{2}[^\s"'<>`|()[\]{},;]*\/g, fn)`:
+ * every run of token characters that holds a percent escape. The regex's
+ * leftmost match always spans a whole run, so runs are matched once each.
+ */
+export declare function replacePercentRuns(text: string, fn: (token: string) => string): string;
+/**
+ * `/(^|\})\s*fragment\s+[A-Za-z_]\w*\s+on\s+[A-Za-z_]\w*[^{]*\{/.exec(s)` as
+ * `{ index, prefix, end }`: where the match starts, its first group, and the
+ * index after its `{`. The regex's tail `[^{]*\{` ends at the first `{` after
+ * the type condition; if there is none, no later start can match either.
+ */
+export declare function findFragmentHead(s: string): {
+    index: number;
+    prefix: string;
+    end: number;
+} | undefined;
+/** `s.replace(/^[.\-~]+|[.\-~]+$/g, "")`: dots, dashes and tildes at either end. */
+export declare function trimDotsDashesTildes(s: string): string;
+/**
+ * The `/"(?:[^"\\\n]|\\.)*"/g` matches in `s` (`/"(?:[^"\\]|\\.)*"/g` when
+ * `newline` is true), as `[start, end]`.
+ */
+export declare function quotedStrings(s: string, newline?: boolean): Generator<[number, number]>;
+/** `s.replace(/"(?:[^"\\\n]|\\.)*"/g, fn)` (`/"(?:[^"\\]|\\.)*"/g` when `newline` is true). */
+export declare function replaceQuoted(s: string, fn: (quoted: string) => string, newline?: boolean): string;
+/**
+ * `s.replace(/"""[\s\S]*?"""|"(?:[^"\\\n]|\\.)*"|#[^\n\r]*\/g, (m) => (m.startsWith("#") ? "" : m))`:
+ * a GraphQL document without its comments.
+ */
+export declare function removeHashComments(s: string): string;
+/**
+ * The matches of
+ * `/([{}()])|(\.\.\.\s*[A-Za-z_]\w*)|([A-Za-z_]\w*)(\s*:\s*([A-Za-z_]\w*))?|"(?:[^"\\]|\\.)*"/g`
+ * from `start`: GraphQL punctuation, spreads, fields with their aliases, and strings.
+ */
+export declare function graphqlTokens(doc: string, start: number): Generator<RegExpExecArray>;
+/** A match of {@link graphqlLiteralMatches}: the whole match and its four groups. */
+export type GraphqlLiteral = [string, string | undefined, string | undefined, string | undefined, string | undefined] & {
+    index: number;
+};
+/**
+ * The matches of
+ * `/#[^\n]*|(?:\b([A-Za-z_]\w*)\s*:\s*)?(?:"""([\s\S]*?)"""|"((?:[^"\\\n]|\\.)*)"|(?<![\w$.])(-?\d{6,})(?![\w.]))/g`:
+ * comments, and string and long number literals with the argument name before them.
+ */
+export declare function graphqlLiteralMatches(doc: string): Generator<GraphqlLiteral>;
+/** What `\s` matches (without the u flag). */
+export declare function isSpaceCode(c: number): boolean;
+/** A match of {@link graphqlLiftMatches}: the whole match, the argument name, the separator and the literal. */
+export type GraphqlLift = [string, string | undefined, string | undefined, string | undefined] & {
+    index: number;
+};
+/**
+ * The matches of the regex model.ts used to read literals with (GQL_LIFT),
+ * `/#[^\n]*|"""[\s\S]*?"""|"(?:[^"\\\n]|\\.)*"|\b([A-Za-z_][A-Za-z0-9_]*)(\s*:\s*)(STRING|NUMBER|\[\s*(?:(?:STRING|NUMBER)\s*,?\s*)+\])/g`
+ * with STRING = `"""[\s\S]*?"""|"(?:[^"\\\n]|\\.)*"(?!")` and NUMBER = `-?\d+(?![\w.])`:
+ * comments, strings, and arguments with a literal value.
+ */
+export declare function graphqlLiftMatches(doc: string): Generator<GraphqlLift>;
+/**
+ * The matches of `/"""[\s\S]*?"""|"(?:[^"\\\n]|\\.)*"(?!")|-?\d+(?![\w.])/g`:
+ * the items of a list literal, as `[start, end]`.
+ */
+export declare function graphqlListItems(lit: string): Generator<[number, number]>;

package/dist/linear.js

@@ -0,0 +1,446 @@
+/**
+ * Linear-time replacements for regexes that CodeQL flagged as polynomial. All
+ * but withoutQueryOrHash backtracked quadratically on crafted input. Each
+ * function returns exactly what the regex in its comment returns;
+ * test/review9.test.ts and test/review10.test.ts compare them on generated input.
+ */
+/** `s.replace(/[ \t]+$/gm, "")`: spaces and tabs at the end of every line. */
+export function trimLineEnds(s) {
+    // `$` with the m flag matches before \n, \r, \u2028, \u2029 and at the end.
+    return s.replace(/[^\n\r\u2028\u2029]+/g, (line) => {
+        let end = line.length;
+        while (end > 0 && (line.charCodeAt(end - 1) === 32 || line.charCodeAt(end - 1) === 9))
+            end--;
+        return end === line.length ? line : line.slice(0, end);
+    });
+}
+/** `s.replace(/\/+$/, "")`: trailing slashes. */
+export function trimTrailingSlashes(s) {
+    let end = s.length;
+    while (end > 0 && s.charCodeAt(end - 1) === 47)
+        end--;
+    return end === s.length ? s : s.slice(0, end);
+}
+/**
+ * `s.replace(/[?#].*$/, "")` for a string without line terminators (the caller
+ * has checked `/^\/[^\s]*$/`): everything from the first `?` or `#`.
+ */
+export function withoutQueryOrHash(s) {
+    const cut = s.search(/[?#]/);
+    return cut < 0 ? s : s.slice(0, cut);
+}
+/** `text.match(/```(?:json)?\s*([\s\S]*?)```/)?.[1]`: the body of the first fenced block. */
+export function fencedBody(text) {
+    const open = text.indexOf("```");
+    if (open < 0)
+        return undefined;
+    let start = open + 3;
+    if (text.startsWith("json", start))
+        start += 4;
+    while (start < text.length && /\s/.test(text[start]))
+        start++;
+    // "json" and whitespace hold no backtick, so no closing fence can start
+    // before `start`; and if none follows the first opening, none follows a later one.
+    const close = text.indexOf("```", start);
+    return close < 0 ? undefined : text.slice(start, close);
+}
+/**
+ * `text.replace(/[^\s"'<>`|()[\]{},;]*%[0-9A-Fa-f]{2}[^\s"'<>`|()[\]{},;]*\/g, fn)`:
+ * every run of token characters that holds a percent escape. The regex's
+ * leftmost match always spans a whole run, so runs are matched once each.
+ */
+export function replacePercentRuns(text, fn) {
+    return text.replace(/[^\s"'<>`|()[\]{},;]+/g, (run) => (/%[0-9A-Fa-f]{2}/.test(run) ? fn(run) : run));
+}
+const FRAGMENT_HEAD = /(^|\})\s*fragment\s+[A-Za-z_]\w*\s+on\s+(?=([A-Za-z_]\w*))\2/;
+/**
+ * `/(^|\})\s*fragment\s+[A-Za-z_]\w*\s+on\s+[A-Za-z_]\w*[^{]*\{/.exec(s)` as
+ * `{ index, prefix, end }`: where the match starts, its first group, and the
+ * index after its `{`. The regex's tail `[^{]*\{` ends at the first `{` after
+ * the type condition; if there is none, no later start can match either.
+ */
+export function findFragmentHead(s) {
+    const m = FRAGMENT_HEAD.exec(s);
+    if (!m)
+        return undefined;
+    const brace = s.indexOf("{", m.index + m[0].length);
+    return brace < 0 ? undefined : { index: m.index, prefix: m[1], end: brace + 1 };
+}
+/** `s.replace(/^[.\-~]+|[.\-~]+$/g, "")`: dots, dashes and tildes at either end. */
+export function trimDotsDashesTildes(s) {
+    const edge = (c) => c === 46 || c === 45 || c === 126;
+    let start = 0;
+    while (start < s.length && edge(s.charCodeAt(start)))
+        start++;
+    let end = s.length;
+    while (end > start && edge(s.charCodeAt(end - 1)))
+        end--;
+    return start === 0 && end === s.length ? s : s.slice(start, end);
+}
+/** What `.` matches outside the s flag: anything but a line terminator. */
+function isDot(c) {
+    return c !== 10 && c !== 13 && c !== 0x2028 && c !== 0x2029;
+}
+/**
+ * Where `/"(?:[^"\\]|\\.)*"/y` (or `/"(?:[^"\\\n]|\\.)*"/y` when `newline` is
+ * false) stops when started at the `"` at `q`: `{ end }` after the closing
+ * quote, or `{ fail }` at the backslash or newline it can't get past.
+ *
+ * A string that fails at `fail` also fails from every `"` between `q` and
+ * `fail`: each of those was escaped, so a scan from it continues exactly as
+ * the scan from `q` did. Callers remember `fail` and skip those quotes, which
+ * the regexes tried one by one (quadratic on `"\"\"\"…`).
+ */
+function quotedEnd(s, q, newline) {
+    let i = q + 1;
+    while (i < s.length) {
+        const c = s.charCodeAt(i);
+        if (c === 34)
+            return { end: i + 1 };
+        if (c === 92) {
+            if (i + 1 < s.length && isDot(s.charCodeAt(i + 1)))
+                i += 2;
+            else
+                return { fail: i };
+        }
+        else if (c === 10 && !newline)
+            return { fail: i };
+        else
+            i++;
+    }
+    return { fail: i };
+}
+/**
+ * The `/"(?:[^"\\\n]|\\.)*"/g` matches in `s` (`/"(?:[^"\\]|\\.)*"/g` when
+ * `newline` is true), as `[start, end]`.
+ */
+export function* quotedStrings(s, newline = false) {
+    let unclosedUntil = -1;
+    for (let q = s.indexOf('"'); q >= 0;) {
+        if (q < unclosedUntil) {
+            q = s.indexOf('"', q + 1);
+            continue;
+        }
+        const r = quotedEnd(s, q, newline);
+        if ("end" in r) {
+            yield [q, r.end];
+            q = s.indexOf('"', r.end);
+        }
+        else {
+            unclosedUntil = r.fail;
+            q = s.indexOf('"', q + 1);
+        }
+    }
+}
+/** `s.replace(/"(?:[^"\\\n]|\\.)*"/g, fn)` (`/"(?:[^"\\]|\\.)*"/g` when `newline` is true). */
+export function replaceQuoted(s, fn, newline = false) {
+    let out = "";
+    let last = 0;
+    for (const [start, end] of quotedStrings(s, newline)) {
+        out += s.slice(last, start) + fn(s.slice(start, end));
+        last = end;
+    }
+    return last === 0 ? s : out + s.slice(last);
+}
+/**
+ * `s.replace(/"""[\s\S]*?"""|"(?:[^"\\\n]|\\.)*"|#[^\n\r]*\/g, (m) => (m.startsWith("#") ? "" : m))`:
+ * a GraphQL document without its comments.
+ */
+export function removeHashComments(s) {
+    const re = /"""|"|#[^\n\r]*/g;
+    let out = "";
+    let last = 0;
+    let unclosedUntil = -1;
+    let noBlockEnd = false;
+    let m;
+    while ((m = re.exec(s))) {
+        const q = m.index;
+        if (m[0][0] === "#") {
+            out += s.slice(last, q);
+            last = re.lastIndex;
+            continue;
+        }
+        if (m[0] === '"""' && !noBlockEnd) {
+            const close = s.indexOf('"""', q + 3);
+            if (close >= 0) {
+                re.lastIndex = close + 3;
+                continue;
+            }
+            // No `"""` after this one, so none after a later one either.
+            noBlockEnd = true;
+        }
+        // A `"` inside a string that doesn't close (see quotedEnd).
+        if (q < unclosedUntil) {
+            re.lastIndex = q + 1;
+            continue;
+        }
+        const r = quotedEnd(s, q, false);
+        if ("end" in r)
+            re.lastIndex = r.end;
+        else {
+            unclosedUntil = r.fail;
+            re.lastIndex = q + 1;
+        }
+    }
+    return last === 0 ? s : out + s.slice(last);
+}
+const GQL_TOKEN = /([{}()])|(\.\.\.\s*[A-Za-z_]\w*)|([A-Za-z_]\w*)(\s*:\s*([A-Za-z_]\w*))?|"/g;
+/**
+ * The matches of
+ * `/([{}()])|(\.\.\.\s*[A-Za-z_]\w*)|([A-Za-z_]\w*)(\s*:\s*([A-Za-z_]\w*))?|"(?:[^"\\]|\\.)*"/g`
+ * from `start`: GraphQL punctuation, spreads, fields with their aliases, and strings.
+ */
+export function* graphqlTokens(doc, start) {
+    const re = new RegExp(GQL_TOKEN);
+    re.lastIndex = start;
+    let unclosedUntil = -1;
+    let m;
+    while ((m = re.exec(doc))) {
+        if (m[0] !== '"') {
+            yield m;
+            continue;
+        }
+        // The other alternatives can't start at a `"`: if the string doesn't
+        // close, the regex moved on to the next character.
+        if (m.index < unclosedUntil)
+            continue;
+        const r = quotedEnd(doc, m.index, true);
+        if ("end" in r) {
+            // The string closes: the match the regex made, with its five groups unset.
+            const text = doc.slice(m.index, r.end);
+            yield Object.assign([text, undefined, undefined, undefined, undefined, undefined], { index: m.index, input: doc, groups: undefined });
+            re.lastIndex = r.end;
+        }
+        else
+            unclosedUntil = r.fail;
+    }
+}
+const GQL_LITERAL = /#[^\n]*|(?:\b([A-Za-z_]\w*)\s*:\s*)?(?:(""")|"|(?<![\w$.])(-?\d{6,})(?![\w.]))/g;
+/**
+ * The matches of
+ * `/#[^\n]*|(?:\b([A-Za-z_]\w*)\s*:\s*)?(?:"""([\s\S]*?)"""|"((?:[^"\\\n]|\\.)*)"|(?<![\w$.])(-?\d{6,})(?![\w.]))/g`:
+ * comments, and string and long number literals with the argument name before them.
+ */
+export function* graphqlLiteralMatches(doc) {
+    const re = new RegExp(GQL_LITERAL);
+    const literal = (index, end, groups) => Object.assign([doc.slice(index, end), ...groups], { index });
+    let unclosedUntil = -1;
+    let noBlockEnd = false;
+    let m;
+    while ((m = re.exec(doc))) {
+        if (m[0][0] === "#" || m[3] !== undefined) {
+            yield literal(m.index, re.lastIndex, [m[1], undefined, undefined, m[3]]);
+            continue;
+        }
+        // The literal starts at the `"` the match ends with.
+        const q = re.lastIndex - (m[2] ? 3 : 1);
+        if (m[2] && !noBlockEnd) {
+            const close = doc.indexOf('"""', q + 3);
+            if (close >= 0) {
+                yield literal(m.index, close + 3, [m[1], doc.slice(q + 3, close), undefined, undefined]);
+                re.lastIndex = close + 3;
+                continue;
+            }
+            noBlockEnd = true;
+        }
+        const r = q < unclosedUntil ? undefined : quotedEnd(doc, q, false);
+        if (r && "end" in r) {
+            yield literal(m.index, r.end, [m[1], undefined, doc.slice(q + 1, r.end - 1), undefined]);
+            re.lastIndex = r.end;
+            continue;
+        }
+        if (r)
+            unclosedUntil = r.fail;
+        // The string doesn't close. Without it, nothing matches at m.index (a
+        // name or a `"`): the regex moved on to the next character.
+        re.lastIndex = m.index + 1;
+    }
+}
+/** What `\s` matches (without the u flag). */
+export function isSpaceCode(c) {
+    return ((c >= 9 && c <= 13) || c === 32 || c === 0xa0 || c === 0x1680 || (c >= 0x2000 && c <= 0x200a) ||
+        c === 0x2028 || c === 0x2029 || c === 0x202f || c === 0x205f || c === 0x3000 || c === 0xfeff);
+}
+const isDigitCode = (c) => c >= 48 && c <= 57;
+const isWordCode = (c) => isDigitCode(c) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 95;
+/**
+ * Lookup tables over a GraphQL document, filled right to left in one pass so
+ * that no position is scanned twice:
+ * - `space[i]`: the first index at or after `i` that `\s` doesn't match;
+ * - `digits[i]`: the first index at or after `i` that isn't a digit;
+ * - `body[i]`: the index after the `"` that closes a string whose body
+ *   (`(?:[^"\\\n]|\\.)*`) starts at `i`, or -1 if it doesn't close.
+ */
+class GraphqlTables {
+    doc;
+    space;
+    digits;
+    body;
+    lastTriple;
+    list;
+    constructor(doc) {
+        this.doc = doc;
+        const n = doc.length;
+        this.space = new Int32Array(n + 1);
+        this.digits = new Int32Array(n + 1);
+        this.body = new Int32Array(n + 2).fill(-1);
+        this.space[n] = n;
+        this.digits[n] = n;
+        for (let i = n - 1; i >= 0; i--) {
+            const c = doc.charCodeAt(i);
+            this.space[i] = isSpaceCode(c) ? this.space[i + 1] : i;
+            this.digits[i] = isDigitCode(c) ? this.digits[i + 1] : i;
+            if (c === 34)
+                this.body[i] = i + 1;
+            else if (c === 92)
+                this.body[i] = i + 1 < n && isDot(doc.charCodeAt(i + 1)) ? this.body[i + 2] : -1;
+            else
+                this.body[i] = c === 10 ? -1 : this.body[i + 1];
+        }
+        this.lastTriple = doc.lastIndexOf('"""');
+    }
+    triple(i) {
+        return this.doc.startsWith('"""', i);
+    }
+    /** `"""[\s\S]*?"""` at `i` (a `"""` there): the end, or -1. */
+    block(i) {
+        // The last `"""` bounds every search, so a failed one costs nothing.
+        if (i + 3 > this.lastTriple)
+            return -1;
+        return this.doc.indexOf('"""', i + 3) + 3;
+    }
+    /** `"(?:[^"\\\n]|\\.)*"(?!")` at `i` (a `"` there): the end, or -1. */
+    string(i) {
+        const end = this.body[i + 1];
+        return end >= 0 && this.doc.charCodeAt(end) !== 34 ? end : -1;
+    }
+    /** `-?\d+(?![\w.])` at `i`: the end, or -1. */
+    number(i) {
+        const start = this.doc.charCodeAt(i) === 45 ? i + 1 : i;
+        if (!isDigitCode(this.doc.charCodeAt(start)))
+            return -1;
+        const end = this.digits[start];
+        const next = this.doc.charCodeAt(end);
+        return isWordCode(next) || next === 46 ? -1 : end;
+    }
+    /**
+     * `\[\s*(?:(?:STRING|NUMBER)\s*,?\s*)+\]` at the `[` at `i`, where STRING
+     * and NUMBER are {@link block}/{@link string} and {@link number}: the end, or -1.
+     *
+     * The regex backtracks exponentially over the ways `\s*,?\s*` can split
+     * the spaces between items, but only the longest split can be followed by
+     * an item or `]`. What remains is a choice for block strings: the regex
+     * tries each later `"""` as the end of one, in order, until the rest of the
+     * list matches. So, right to left over the document:
+     * - `item[j]`: where a list whose next item starts at `j` ends, or -1;
+     * - `close[j]`: the same for the first `"""` at or after `j` that ends a
+     *   block string the rest of the list can follow, or -1.
+     */
+    listAt(i) {
+        const item = (this.list ??= this.fillList());
+        const j = this.space[i + 1];
+        return j < this.doc.length ? item[j] : -1;
+    }
+    fillList() {
+        const { doc, space } = this;
+        const n = doc.length;
+        const item = new Int32Array(n + 1).fill(-1);
+        const close = new Int32Array(n + 4).fill(-1);
+        // After an item that ends at `e`: the separator, then `]` or another item.
+        const after = (e) => {
+            let s = space[e];
+            if (doc.charCodeAt(s) === 44)
+                s = space[s + 1];
+            if (s >= n)
+                return -1;
+            return doc.charCodeAt(s) === 93 ? s + 1 : item[s];
+        };
+        for (let j = n - 1; j >= 0; j--) {
+            const c = doc.charCodeAt(j);
+            const triple = this.triple(j);
+            if (triple)
+                item[j] = close[j + 3];
+            else if (c === 34) {
+                const e = this.string(j);
+                item[j] = e < 0 ? -1 : after(e);
+            }
+            else if (c === 45 || isDigitCode(c)) {
+                const e = this.number(j);
+                item[j] = e < 0 ? -1 : after(e);
+            }
+            const end = triple ? after(j + 3) : -1;
+            close[j] = end >= 0 ? end : close[j + 1];
+        }
+        return item;
+    }
+}
+/**
+ * The matches of the regex model.ts used to read literals with (GQL_LIFT),
+ * `/#[^\n]*|"""[\s\S]*?"""|"(?:[^"\\\n]|\\.)*"|\b([A-Za-z_][A-Za-z0-9_]*)(\s*:\s*)(STRING|NUMBER|\[\s*(?:(?:STRING|NUMBER)\s*,?\s*)+\])/g`
+ * with STRING = `"""[\s\S]*?"""|"(?:[^"\\\n]|\\.)*"(?!")` and NUMBER = `-?\d+(?![\w.])`:
+ * comments, strings, and arguments with a literal value.
+ */
+export function* graphqlLiftMatches(doc) {
+    const t = new GraphqlTables(doc);
+    const n = doc.length;
+    const match = (index, end, arg, sep, lit) => Object.assign([doc.slice(index, end), arg, sep, lit], { index });
+    for (let p = 0; p < n;) {
+        const c = doc.charCodeAt(p);
+        if (c === 35) {
+            const nl = doc.indexOf("\n", p);
+            const end = nl < 0 ? n : nl;
+            yield match(p, end);
+            p = end;
+            continue;
+        }
+        if (c === 34) {
+            const block = t.triple(p) ? t.block(p) : -1;
+            const end = block >= 0 ? block : t.body[p + 1];
+            if (end >= 0) {
+                yield match(p, end);
+                p = end;
+            }
+            else
+                p++;
+            continue;
+        }
+        // `\b` before a letter: the start of a name.
+        if (isWordCode(c) && !isDigitCode(c) && (p === 0 || !isWordCode(doc.charCodeAt(p - 1)))) {
+            let q = p + 1;
+            while (q < n && isWordCode(doc.charCodeAt(q)))
+                q++;
+            const colon = t.space[q];
+            if (doc.charCodeAt(colon) === 58) {
+                const b = t.space[colon + 1];
+                const l = doc.charCodeAt(b);
+                const end = l === 34 ? (t.triple(b) ? t.block(b) : t.string(b)) : l === 91 ? t.listAt(b) : l === 45 || isDigitCode(l) ? t.number(b) : -1;
+                if (end >= 0) {
+                    yield match(p, end, doc.slice(p, q), doc.slice(q, b), doc.slice(b, end));
+                    p = end;
+                    continue;
+                }
+            }
+            // No literal follows: nothing matches inside the name either.
+            p = q;
+            continue;
+        }
+        p++;
+    }
+}
+/**
+ * The matches of `/"""[\s\S]*?"""|"(?:[^"\\\n]|\\.)*"(?!")|-?\d+(?![\w.])/g`:
+ * the items of a list literal, as `[start, end]`.
+ */
+export function* graphqlListItems(lit) {
+    const t = new GraphqlTables(lit);
+    for (let p = 0; p < lit.length;) {
+        const c = lit.charCodeAt(p);
+        const end = c === 34 ? (t.triple(p) ? t.block(p) : t.string(p)) : c === 45 || isDigitCode(c) ? t.number(p) : -1;
+        if (end >= 0) {
+            yield [p, end];
+            p = end;
+        }
+        else
+            p++;
+    }
+}

package/dist/model.js

@@ -6,6 +6,7 @@
  */
 import { filterExchanges } from "./filter.js";
 import { isJsonMime, isObject, loadHar, NOT_JSON, parseJson } from "./har.js";
+import { findFragmentHead, graphqlListItems, graphqlLiftMatches, graphqlTokens, removeHashComments, replaceQuoted, trimLineEnds } from "./linear.js";
 import { emptyShape, observe, observeText } from "./infer.js";
 import { assignNames } from "./naming.js";
 import { collectTaint, isDataLike, isIdentity, isIdentityKey, isIdKey, isTainted, scrubberFor } from "./leak.js";
@@ -252,10 +253,7 @@ export function graphqlRootFields(doc) {
     const fields = [];
     let depth = 0;
     let parens = 0;
-    const re = /([{}()])|(\.\.\.\s*[A-Za-z_]\w*)|([A-Za-z_]\w*)(\s*:\s*([A-Za-z_]\w*))?|"(?:[^"\\]|\\.)*"/g;
-    re.lastIndex = start;
-    let m;
-    while ((m = re.exec(doc))) {
+    for (const m of graphqlTokens(doc, start)) {
         if (m[1] === "{")
             depth++;
         else if (m[1] === "}") {
@@ -309,17 +307,17 @@ function gqlFromObject(body, path, viaGet) {
  * Strings and block strings are kept as they are.
  */
 export function withoutComments(doc) {
-    return doc.replace(/"""[\s\S]*?"""|"(?:[^"\\\n]|\\.)*"|#[^\n\r]*/g, (m) => (m.startsWith("#") ? "" : m)).replace(/[ \t]+$/gm, "");
+    return trimLineEnds(removeHashComments(doc));
 }
 /** The document without its fragment definitions (they may precede the operation). */
 export function withoutFragments(doc) {
     let out = doc;
     for (let guard = 0; guard < 50; guard++) {
-        const m = /(^|\})\s*fragment\s+[A-Za-z_]\w*\s+on\s+[A-Za-z_]\w*[^{]*\{/.exec(out);
+        const m = findFragmentHead(out);
         if (!m)
             break;
         let depth = 1;
-        let i = m.index + m[0].length;
+        let i = m.end;
         for (; i < out.length && depth > 0; i++) {
             if (out[i] === "{")
                 depth++;
@@ -328,15 +326,13 @@ export function withoutFragments(doc) {
             else if (out[i] === '"')
                 i = Math.max(i, out.indexOf('"', i + 1));
         }
-        out = out.slice(0, m.index + m[1].length) + " " + out.slice(i);
+        out = out.slice(0, m.index + m.prefix.length) + " " + out.slice(i);
     }
     return out;
 }
 /** Whitespace and literal values folded away: two recordings of the same operation compare equal. */
 export function normalizeGraphQL(doc) {
-    return doc
-        .replace(/#[^\n]*/g, "")
-        .replace(/"(?:[^"\\]|\\.)*"/g, '""')
+    return replaceQuoted(doc.replace(/#[^\n]*/g, ""), () => '""', true)
         .replace(/(?<![A-Za-z_$])-?\d+(\.\d+)?/g, "0")
         .replace(/\s+/g, " ")
         .replace(/\s*([{}():,!$=@\[\]])\s*/g, "$1")
@@ -348,10 +344,10 @@ export function normalizeGraphQL(doc) {
  * strings) become variables: the document stays valid, the SDK method takes
  * them as parameters, and no recorded value is baked in. Small numbers
  * (`first: 20`) and enum values stay: they are part of the query's logic.
+ * The document is read by graphqlLiftMatches (linear.ts), which matches what
+ * the regex GQL_LIFT that it replaces (quoted in its comment) matched, without
+ * that regex's exponential backtracking.
  */
-const GQL_STRING = String.raw `"""[\s\S]*?"""|"(?:[^"\\\n]|\\.)*"(?!")`;
-const GQL_NUMBER = String.raw `-?\d+(?![\w.])`;
-const GQL_LIFT = new RegExp(String.raw `#[^\n]*|"""[\s\S]*?"""|"(?:[^"\\\n]|\\.)*"|\b([A-Za-z_][A-Za-z0-9_]*)(\s*:\s*)(${GQL_STRING}|${GQL_NUMBER}|\[\s*(?:(?:${GQL_STRING}|${GQL_NUMBER})\s*,?\s*)+\])`, "g");
 function liftGraphQLLiterals(doc, variables) {
     const taken = new Set([...doc.matchAll(/\$([A-Za-z_][A-Za-z0-9_]*)/g)].map((m) => m[1]));
     const defs = [];
@@ -373,13 +369,13 @@ function liftGraphQLLiterals(doc, variables) {
     };
     // Numbers are data when they look like ids: an id argument, or six digits or more.
     const dataNumber = (arg, n) => Number.isInteger(n) && (idArg(arg) || String(Math.abs(n)).length >= 6);
-    const body = doc.replace(GQL_LIFT, (m, arg, sep, lit) => {
+    const lift = (m, arg, sep, lit) => {
         if (!arg)
             return m; // a comment or a string that isn't an argument value
         let value;
         let type;
         if (lit.startsWith("[")) {
-            const items = [...lit.matchAll(new RegExp(`${GQL_STRING}|${GQL_NUMBER}`, "g"))].map((x) => scalar(x[0]));
+            const items = [...graphqlListItems(lit)].map(([start, end]) => scalar(lit.slice(start, end)));
             if (!items.some((x) => typeof x === "string" || dataNumber(arg, x)))
                 return m;
             value = items;
@@ -405,12 +401,19 @@ function liftGraphQLLiterals(doc, variables) {
         defs.push(`$${name}: ${type}!`);
         setOwn(values, name, value);
         return `${arg}${sep}$${name}`;
-    });
+    };
+    let body = "";
+    let last = 0;
+    for (const m of graphqlLiftMatches(doc)) {
+        body += doc.slice(last, m.index) + lift(m[0], m[1], m[2], m[3]);
+        last = m.index + m[0].length;
+    }
+    body += doc.slice(last);
     if (!defs.length)
         return { query: doc, variables, names };
     const query = insertVariableDefinitions(body, defs);
     if (query === undefined)
-        return { query: doc.replace(/"(?:[^"\\\n]|\\.)*"/g, (s) => (isDataLike(s.slice(1, -1)) ? JSON.stringify(REDACTED) : s)), variables, names: [] };
+        return { query: replaceQuoted(doc, (s) => (isDataLike(s.slice(1, -1)) ? JSON.stringify(REDACTED) : s)), variables, names: [] };
     return { query, variables: { ...(isObject(variables) ? variables : {}), ...values }, names };
 }
 /** Add `$x: String!` definitions to the (first) operation of a document. */

package/dist/openapi.js

@@ -1,5 +1,6 @@
 /** OpenAPI 3.1 emitter, sharing the plan (and named schemas) with the TS SDK. */
 import { VERSION } from "./codegen.js";
+import { trimTrailingSlashes } from "./linear.js";
 import { namedToJsonSchema, toJsonSchema } from "./types.js";
 export function generateOpenApi(plan, opts = {}) {
     const { model, registry, ops } = plan;
@@ -15,7 +16,7 @@ export function generateOpenApi(plan, opts = {}) {
     }
     // tRPC procedures each get their own path: /api/trpc/user.byId
     for (const op of ops.filter((o) => o.ep.rpc?.kind === "trpc")) {
-        const path = op.ep.path.replace(/\/+$/, "") + "/" + op.ep.rpc.procedure;
+        const path = trimTrailingSlashes(op.ep.path) + "/" + op.ep.rpc.procedure;
         const item = (paths[path] ??= {});
         item[op.ep.method.toLowerCase()] = trpcOperation(op);
     }

package/dist/plan.js

@@ -6,6 +6,7 @@
 import { applyAnnotations, clientNameFor, isValidClientName } from "./annotations.js";
 import { mergeShapes, emptyShape } from "./infer.js";
 import { renameRefs, TypeRegistry } from "./types.js";
+import { trimTrailingSlashes } from "./linear.js";
 import { isActionEndpoint } from "./naming.js";
 import { isIdentifier, isPlural, pascal, singular, words } from "./words.js";
 const RUNTIME_NAMES = ["ClientOptions", "RequestOptions", "ApiError", "GraphQLError", "RpcError", "QueryValue", "DEFAULT_HEADERS"];
@@ -50,7 +51,7 @@ export function buildPlan(model, opts = {}) {
         renameTypes(registry, ops, opts.annotations.types, warnings);
     if (opts.baseUrl !== undefined)
         checkBaseUrl(opts.baseUrl);
-    const baseUrl = (opts.baseUrl ?? model.primaryOrigin).replace(/\/+$/, "");
+    const baseUrl = trimTrailingSlashes(opts.baseUrl ?? model.primaryOrigin);
     return { model, clientName, baseUrl, registry, ops, warnings };
 }
 function singularPascal(s) {

package/dist/redact.js

@@ -5,6 +5,7 @@
  * engine (examples in OpenAPI, text handed to an LLM, the chat prompt) goes
  * through these functions first.
  */
+import { withoutQueryOrHash } from "./linear.js";
 import { setOwn, words } from "./words.js";
 export const REDACTED = "<redacted>";
 const SENSITIVE_WORDS = new Set([
@@ -454,7 +455,7 @@ export class Scrubber {
         }
         // The API's own relative links ("/v1/customers?page=2"): the same rules as a URL's path.
         if (/^\/[^\s]*$/.test(v) && !v.startsWith("//"))
-            return personal ? REDACTED : this.path(v.replace(/[?#].*$/, ""));
+            return personal ? REDACTED : this.path(withoutQueryOrHash(v));
         // IP addresses become documentation addresses (RFC 5737 / 3849).
         if (/^\d{1,3}(\.\d{1,3}){3}$/.test(v))
             return `192.0.2.${(Number.parseInt(this.fake(v).replace(/\D/g, "").slice(0, 3) || "1", 10) % 254) + 1}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "har2sdk",
-  "version": "0.6.4",
+  "version": "0.6.5",
   "description": "Turn browser network traffic (HAR) into a typed TypeScript SDK, an OpenAPI 3.1 spec and a mock server. Local, deterministic, no API key. Ships an MCP server so Claude can name and document every endpoint.",
   "keywords": [
     "har",