tempest-react-sdk 0.80.0 → 0.82.0

package/bin/lib/openapi/escape.mjs

@@ -16,7 +16,11 @@
  *   {@link assertNoCollision}, never silently merged;
  * - string position → `JSON.stringify` at the call site;
  * - doc comment → {@link commentText};
- * - URL template literal → {@link urlTemplate}.
+ * - URL template literal → {@link urlTemplate};
+ * - the developer's terminal → {@link terminalText}.
+ *
+ * One more check covers the text that becomes a URL rather than being escaped
+ * into one: {@link assertSafePath}.
  */
 
 const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
@@ -150,19 +154,79 @@ export function assertNoCollision(entries, what) {
     }
 }
 
+/**
+ * C0 and C1 control characters except tab and line feed: everything a terminal
+ * may read as the start of an escape sequence (`ESC`, the 8-bit `CSI` and
+ * `OSC`), plus `CR` and backspace, which rewrite what is already on the line.
+ */
+const TERMINAL_CONTROLS = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g;
+
+/**
+ * Make spec text safe to print to the developer's terminal.
+ *
+ * `tempest gen api` echoes the spec's tag names, and its errors quote spec
+ * names. `JSON.stringify` escapes the C0 range but leaves the C1 range raw, so
+ * neither path was safe on its own: a tag carrying `ESC ] 0 ; ... BEL` retitled
+ * the terminal window, and an OSC 8 sequence printed a clickable link whose
+ * target the developer never saw (#533). Every control character a terminal
+ * acts on is dropped; tab and line feed are kept so a multi-line error still
+ * reads as one.
+ *
+ * @param {unknown} text - Text that may come from the spec.
+ * @returns {string} The text without terminal control characters.
+ */
+export function terminalText(text) {
+    return String(text).replace(TERMINAL_CONTROLS, "");
+}
+
 /**
  * Make spec text safe inside a `/** ... *\/` block comment.
  *
  * Line terminators collapse to a space, so the text cannot start a new line of
  * the comment, and every `*\/` is broken as `*\\/` so it cannot close it.
+ * Terminal control characters are dropped too ({@link terminalText}): they are
+ * not code, but printing the generated file with `cat` would replay them.
  *
  * @param {unknown} text - The spec text (tag, summary, path).
  * @returns {string} The neutralized single-line text.
  */
 export function commentText(text) {
-    return String(text)
-        .replace(/[\r\n\u2028\u2029]+/g, " ")
-        .replace(/\*\//g, "*\\/");
+    return terminalText(String(text).replace(/[\r\n\u2028\u2029]+/g, " ")).replace(/\*\//g, "*\\/");
+}
+
+/**
+ * Throw when an OpenAPI path key would not stay a path under the client's
+ * `baseURL`.
+ *
+ * The key becomes the URL the generated method requests, and the client passes
+ * an absolute URL through untouched: a key `"https://other.example/x"` made the
+ * method call another origin \u2014 the Bearer is withheld there, but the body and,
+ * with `credentials: "include"`, the cookies were not. A static `.` or `..`
+ * segment (`"/../x"`) climbs out of the `baseURL`'s path prefix once the URL is
+ * normalized. OpenAPI requires a path key to start with `/` and to be relative
+ * to the server URL, so neither is a valid spec; both are refused before any
+ * file is written instead of becoming a call the developer never reads. `\` is
+ * a separator and `%2e` a dot here because the WHATWG URL parser normalizes them
+ * that way.
+ *
+ * @param {unknown} path - The key from `paths`.
+ * @throws {Error} When the key does not start with `/` or has a dot segment.
+ */
+export function assertSafePath(path) {
+    if (typeof path !== "string" || !path.startsWith("/")) {
+        throw new Error(
+            `OpenAPI path ${JSON.stringify(path)} does not start with "/". A path key is relative to the server URL; an absolute URL here would send the request to another origin.`,
+        );
+    }
+    const dotSegment = path
+        .replace(/[?#][\s\S]*$/, "")
+        .split(/[/\\]/)
+        .some((segment) => /^(?:\.|%2e){1,2}$/i.test(segment));
+    if (dotSegment) {
+        throw new Error(
+            `OpenAPI path ${JSON.stringify(path)} has a "." or ".." segment, which leaves the baseURL's path once the URL is normalized. Rename the path in the spec.`,
+        );
+    }
 }
 
 /**

package/bin/lib/openapi/generate.hostile.test.mjs

@@ -4,11 +4,23 @@ import { fileURLToPath } from "node:url";
 import vm from "node:vm";
 
 import ts from "typescript";
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 
 import { encodeIdSegment } from "../../../src/data";
 import { generate } from "./generate.mjs";
 
+/**
+ * Gives the tests in this file 60 s instead of Vitest's 5 s default.
+ *
+ * Several of them build a TypeScript program (and, some, an ESLint instance)
+ * in-process over the generated files. That takes 3-5 s on an idle machine,
+ * right at the default, so a busy one — another suite, a model training — failed
+ * them by timeout while the code was correct: 5.1-5.7 s measured in three
+ * `make check` runs on 2026-11-01, load average between 21 and 48.
+ * `test/docs-guard.test.ts` gives its compile 120 s for the same reason.
+ */
+vi.setConfig({ testTimeout: 60_000 });
+
 const require = createRequire(import.meta.url);
 /**
  * Transpile one generated TypeScript file and run it in a fresh VM context.
@@ -660,3 +672,140 @@ describe("generate — names that collide with what the generator itself declare
         );
     });
 });
+
+describe("generate — spec text that would leave its place in the output (#533)", () => {
+    const ESC_TAG = "items\u001b]0;PWNED\u0007\u009b31m\r";
+    const POST_BODY = {
+        "/a": { post: { tags: ["t"], requestBody: JSON_BODY("Body"), responses: OK } },
+    };
+
+    it("a path key that is an absolute URL is refused, so no method calls another origin", () => {
+        expect(() =>
+            generate(spec({ "https://other.example/x": { get: { tags: ["t"], responses: OK } } })),
+        ).toThrow(/path "https:\/\/other\.example\/x" does not start with "\/"/);
+    });
+
+    it.each(["/../x", "/a/./b", "/a/..", "/%2e%2E/x", "/a\\..\\x", "/./x?y=1"])(
+        "a path key with a dot segment (%s) is refused, so it cannot climb out of the baseURL path",
+        (path) => {
+            expect(() =>
+                generate(spec({ [path]: { get: { tags: ["t"], responses: OK } } })),
+            ).toThrow(/has a "\." or "\.\." segment/);
+        },
+    );
+
+    it("dots inside a segment, dots in the query and a doubled slash still generate", () => {
+        const { files } = generate(
+            spec({
+                "/v1.2/..cache/file.json": { get: { tags: ["t"], responses: OK } },
+                "//double/slash": { get: { tags: ["t"], responses: OK } },
+                "/search?q=..": { get: { tags: ["t"], responses: OK } },
+            }),
+        );
+        expect(files["t/service.ts"]).toContain('"/v1.2/..cache/file.json"');
+        expect(files["t/service.ts"]).toContain('"/search?q=.."');
+    });
+
+    it("a property named __proto__ is refused instead of silently vanishing from the Zod shape", () => {
+        const Body = JSON.parse(
+            '{"type":"object","required":["__proto__"],"properties":{"__proto__":{"type":"string"}}}',
+        );
+        expect(() => generate(spec(POST_BODY, { Body }))).toThrow(
+            /schema "Body" at \(root\): a property named "__proto__" cannot be validated/,
+        );
+    });
+
+    it("a default value with a nested __proto__ key is refused", () => {
+        const Body = JSON.parse(
+            '{"type":"object","properties":{"meta":{"type":"object","default":{"a":{"__proto__":{"admin":true}}}}}}',
+        );
+        expect(() => generate(spec(POST_BODY, { Body }))).toThrow(
+            /schema "Body" at properties\.meta: the default value has a "__proto__" key/,
+        );
+    });
+
+    it("properties called constructor or prototype still generate and are validated", () => {
+        const { files } = generate(
+            spec(POST_BODY, {
+                Body: {
+                    type: "object",
+                    required: ["constructor"],
+                    properties: {
+                        constructor: { type: "string" },
+                        prototype: { type: "string" },
+                    },
+                },
+            }),
+        );
+        const schemas = evaluate(files["t/schemas.ts"], vm.createContext({}), {});
+        expect(schemas.BodySchema.safeParse({ constructor: 1 }).success).toBe(false);
+        expect(schemas.BodySchema.safeParse({ constructor: "x" }).success).toBe(true);
+    });
+
+    it("a nested-quantifier pattern still generates and comes back as a warning naming the schema", () => {
+        const { files, warnings } = generate(
+            spec(POST_BODY, {
+                Body: {
+                    type: "object",
+                    properties: {
+                        slug: { type: "string", pattern: "^([a-z0-9]+-)*[a-z0-9]+$" },
+                        evil: { type: "string", pattern: "^(a+)+$" },
+                    },
+                },
+            }),
+        );
+        expect(files["t/schemas.ts"]).toContain('new RegExp("^(a+)+$")');
+        expect(warnings).toHaveLength(1);
+        expect(warnings[0]).toMatch(/schema "Body" at properties\.evil: pattern "\^\(a\+\)\+\$"/);
+    });
+
+    it("terminal control characters in a tag do not reach the generated doc comment", () => {
+        const { files, tags } = generate(
+            spec({ "/a": { get: { tags: [ESC_TAG], responses: OK } } }),
+        );
+        const service = Object.entries(files).find(([f]) => f.endsWith("/service.ts"))[1];
+        expect(tags).toEqual([ESC_TAG]);
+        expect(service).not.toMatch(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/);
+        expect(service).toContain('the "items]0;PWNED31m " routes');
+    });
+
+    it("the folder and class reported for each group are the ones written", () => {
+        const { files, services } = generate(
+            spec({ "/a": { get: { tags: ["Items API"], responses: OK } } }),
+        );
+        expect(services).toEqual([{ slug: "items-api", className: "ItemsApiService" }]);
+        expect(files["items-api/service.ts"]).toContain("export class ItemsApiService");
+    });
+
+    it("the output for a spec with control characters and a flagged pattern typechecks", () => {
+        const { files } = generate(
+            spec(
+                {
+                    "/a/{id}": {
+                        post: {
+                            tags: ["t"],
+                            summary: "x\u001b[2J\u009d8;;https://evil/\u009c",
+                            parameters: [
+                                {
+                                    name: "id",
+                                    in: "path",
+                                    required: true,
+                                    schema: { type: "string" },
+                                },
+                            ],
+                            requestBody: JSON_BODY("Body"),
+                            responses: OK,
+                        },
+                    },
+                },
+                {
+                    Body: {
+                        type: "object",
+                        properties: { evil: { type: "string", pattern: "(\\w+\\s?)*" } },
+                    },
+                },
+            ),
+        );
+        expect(typecheck(files, "t")).toEqual([]);
+    });
+});

package/bin/lib/openapi/generate.mjs

@@ -1,6 +1,13 @@
 // OpenAPI 3.x → per-tag { schemas.ts (Zod), types.ts, service.ts (class) }.
 // Pure: takes the parsed spec object, returns a { path: contents } map. No I/O.
-import { assertNoCollision, commentText, toIdentifier, urlTemplate } from "./escape.mjs";
+import {
+    assertNoCollision,
+    assertSafePath,
+    commentText,
+    toIdentifier,
+    urlTemplate,
+} from "./escape.mjs";
+import { hasNestedQuantifier } from "./pattern-risk.mjs";
 import { refName, schemaToZod, typeName, zodName } from "./schema-to-zod.mjs";
 
 const HTTP_METHODS = ["get", "post", "put", "patch", "delete"];
@@ -157,30 +164,77 @@ function isSegmentScalar(schema, schemas, depth = 0) {
 }
 
 /**
- * Check every `pattern` in a schema compiles as a JavaScript regex.
+ * Whether a JSON value has an own key `__proto__` at any depth.
  *
- * The generated Zod schema builds it with `new RegExp(...)` when the module is
- * imported, so an invalid one would only surface in the app at runtime — a blank
- * screen. Failing here names the schema and where in it the pattern sits.
+ * @param {unknown} value - A value parsed from the spec.
+ * @returns {boolean}
+ */
+function hasProtoKey(value) {
+    if (!value || typeof value !== "object") return false;
+    if (Object.hasOwn(value, "__proto__")) return true;
+    return Object.values(value).some(hasProtoKey);
+}
+
+/**
+ * Check a component schema before it is turned into Zod source.
+ *
+ * - Every `pattern` must compile as a JavaScript regex. The generated schema
+ *   builds it with `new RegExp(...)` when the module is imported, so an invalid
+ *   one would only surface in the app at runtime — a blank screen.
+ * - A `pattern` with the nested-quantifier shape ({@link hasNestedQuantifier})
+ *   is pushed to `warnings`: it compiles, and it can freeze the tab on one
+ *   crafted value, but a heuristic does not get to fail the run.
+ * - A property, or a key inside a `default`, named `__proto__` is refused. The
+ *   generated source is an object literal, where `"__proto__": ...` sets the
+ *   prototype instead of adding a key: the field vanished from the Zod shape and
+ *   the value went unvalidated, and Zod 4 drops the key even when it is written
+ *   as a computed `["__proto__"]` (measured on 4.6.7: a required `__proto__:
+ *   z.string()` accepted `{}` and `5`). There is no source that validates it, so
+ *   the spec is refused (#533).
+ *
+ * Every failure names the schema and where in it the problem sits.
  *
  * @param {unknown} node - The schema (sub)node.
- * @param {string} schema - The component schema name, for the error.
+ * @param {string} schema - The component schema name, for the messages.
+ * @param {string[]} warnings - Collects the non-fatal findings.
  * @param {string[]} [at] - Keys from the schema root to `node`.
- * @throws {Error} When a pattern does not compile.
+ * @throws {Error} When a pattern does not compile, or a `__proto__` key would be
+ *   emitted.
  */
-function assertPatterns(node, schema, at = []) {
+function checkSchema(node, schema, warnings, at = []) {
     if (!node || typeof node !== "object") return;
+    const where = `OpenAPI schema ${JSON.stringify(schema)} at ${at.join(".") || "(root)"}`;
     if (typeof node.pattern === "string") {
         try {
             new RegExp(node.pattern);
         } catch (err) {
             throw new Error(
-                `OpenAPI schema ${JSON.stringify(schema)} at ${at.join(".") || "(root)"}: pattern ${JSON.stringify(node.pattern)} is not a valid JavaScript regular expression (${err.message}).`,
+                `${where}: pattern ${JSON.stringify(node.pattern)} is not a valid JavaScript regular expression (${err.message}).`,
             );
         }
+        if (hasNestedQuantifier(node.pattern)) {
+            warnings.push(
+                `${where}: pattern ${JSON.stringify(node.pattern)} repeats a group that ends in a repetition; it can backtrack exponentially on a near-miss value and freeze the tab that validates it.`,
+            );
+        }
+    }
+    if (
+        node.properties &&
+        typeof node.properties === "object" &&
+        Object.hasOwn(node.properties, "__proto__")
+    ) {
+        throw new Error(
+            `${where}: a property named "__proto__" cannot be validated — in the generated object literal it sets the prototype instead of declaring the field. Rename it in the spec.`,
+        );
+    }
+    if (hasProtoKey(node.default)) {
+        throw new Error(
+            `${where}: the default value has a "__proto__" key, which the generated object literal would turn into its prototype. Remove it from the spec.`,
+        );
     }
     for (const [key, value] of Object.entries(node)) {
-        if (key !== "pattern") assertPatterns(value, schema, [...at, key]);
+        if (key !== "pattern" && key !== "default")
+            checkSchema(value, schema, warnings, [...at, key]);
     }
 }
 
@@ -432,8 +486,15 @@ function compareNames(a, b) {
  * because a browser `fetch` cannot set `Cookie` — the browser sends its own
  * cookies with `credentials`, which is how a cookie parameter reaches the server.
  *
+ * Every path key that has an operation goes through {@link assertSafePath}, and
+ * every emitted component schema through {@link checkSchema}: spec text that
+ * would turn into a call to another origin, or into an object literal whose
+ * prototype the spec picks, fails the run before anything is written (#533).
+ *
  * @param {object} doc - The parsed OpenAPI 3.x spec.
- * @returns {{ files: Record<string, string>, tags: string[] }}
+ * @returns {{ files: Record<string, string>, tags: string[], services: { slug: string, className: string }[], warnings: string[] }}
+ *   The files by relative path; each group's spec tag, folder and service class
+ *   (in the same order); and the non-fatal findings the CLI prints.
  */
 export function generate(doc) {
     const schemas = doc.components?.schemas ?? {};
@@ -444,6 +505,7 @@ export function generate(doc) {
         for (const method of HTTP_METHODS) {
             const op = item[method];
             if (!op) continue;
+            assertSafePath(path);
             const tag = op.tags?.[0] ?? "default";
             const slug = tagSlug(tag);
             if (!groups.has(slug)) groups.set(slug, { tag, slug, ops: [] });
@@ -459,10 +521,13 @@ export function generate(doc) {
 
     const files = {};
     const tags = [];
+    const services = [];
+    const warnings = [];
 
     for (const { tag, slug, ops } of groups.values()) {
         tags.push(tag);
         const Class = `${slugIdent(pascal(slug))}Service`;
+        services.push({ slug, className: Class });
 
         const usedNames = new Set(CLASS_MEMBERS);
         const signature = { refs: new Set(), validates: false, sendsHeaders: false };
@@ -483,7 +548,7 @@ export function generate(doc) {
             sorted.map((n) => [n, typeName(n)]),
             "schema names",
         );
-        for (const name of sorted) assertPatterns(schemas[name], name);
+        for (const name of sorted) checkSchema(schemas[name], name, warnings);
 
         const schemaLines = sorted.map((name) => {
             const expr = schemaToZod(schemas[name], (ref) => {
@@ -542,7 +607,7 @@ export function generate(doc) {
             .map((slug) => `export * as ${slugIdent(slug)} from "./${slug}";`)
             .join("\n") + "\n";
 
-    return { files, tags };
+    return { files, tags, services, warnings };
 }
 
 /**

package/bin/lib/openapi/generate.test.mjs

@@ -4,11 +4,23 @@ import { fileURLToPath } from "node:url";
 
 import { ESLint } from "eslint";
 import ts from "typescript";
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 
 import { encodeIdSegment } from "../../../src/data";
 import { generate } from "./generate.mjs";
 
+/**
+ * Gives the tests in this file 60 s instead of Vitest's 5 s default.
+ *
+ * Several of them build a TypeScript program (and, some, an ESLint instance)
+ * in-process over the generated files. That takes 3-5 s on an idle machine,
+ * right at the default, so a busy one — another suite, a model training — failed
+ * them by timeout while the code was correct: 5.1-5.7 s measured in three
+ * `make check` runs on 2026-11-01, load average between 21 and 48.
+ * `test/docs-guard.test.ts` gives its compile 120 s for the same reason.
+ */
+vi.setConfig({ testTimeout: 60_000 });
+
 const SPEC = {
     openapi: "3.1.0",
     components: {

package/bin/lib/openapi/pattern-risk.mjs

@@ -0,0 +1,134 @@
+/**
+ * Static check for the regular expressions a spec's `pattern` keywords become.
+ *
+ * The generated Zod schema compiles each `pattern` with `new RegExp(...)` and
+ * runs it on every value the app validates. V8 backtracks, so a pattern with a
+ * repeated group whose body can itself match a variable amount — `^(a+)+$` — is
+ * exponential on a near-miss input: 28 characters took 873 ms and every extra
+ * one doubles it (Node 24.15, `/^(a+)+$/.test("a".repeat(28) + "!")`). The app
+ * tab freezes on its own data. A spec is input the developer does not control,
+ * so `tempest gen api` flags such a pattern when it generates the schema (#533).
+ */
+
+/**
+ * Parse the quantifier starting at `pattern[i]`, if any.
+ *
+ * @param {string} pattern - The regex source.
+ * @param {number} i - Index right after an atom.
+ * @returns {{ min: number, max: number, length: number } | null} The bounds
+ *   (`max` is `Infinity` when unbounded) and how many characters the quantifier
+ *   spans, its lazy `?` included; `null` when no quantifier starts there.
+ */
+function quantifierAt(pattern, i) {
+    const ch = pattern[i];
+    let q = null;
+    if (ch === "*") q = { min: 0, max: Infinity, length: 1 };
+    else if (ch === "+") q = { min: 1, max: Infinity, length: 1 };
+    else if (ch === "?") q = { min: 0, max: 1, length: 1 };
+    else if (ch === "{") {
+        const m = /^\{(\d+)(,(\d*))?\}/.exec(pattern.slice(i));
+        if (m) {
+            const min = Number(m[1]);
+            const max = m[2] === undefined ? min : m[3] === "" ? Infinity : Number(m[3]);
+            q = { min, max, length: m[0].length };
+        }
+    }
+    if (q && pattern[i + q.length] === "?") q.length += 1;
+    return q;
+}
+
+/**
+ * Index right after the character class that opens at `pattern[i]` (`[`).
+ *
+ * @param {string} pattern - The regex source.
+ * @param {number} i - Index of the `[`.
+ * @returns {number} Index after the closing `]`, or the pattern's length.
+ */
+function classEnd(pattern, i) {
+    let j = i + 1;
+    while (j < pattern.length && pattern[j] !== "]") j += pattern[j] === "\\" ? 2 : 1;
+    return j + 1;
+}
+
+/**
+ * Length of a group's opening syntax at `pattern[i]` (`(`, `(?:`, `(?=`,
+ * `(?<name>`, ...), so its `?` is not read as a quantifier.
+ *
+ * @param {string} pattern - The regex source.
+ * @param {number} i - Index of the `(`.
+ * @returns {number} Characters to skip.
+ */
+function groupOpenLength(pattern, i) {
+    if (pattern[i + 1] !== "?") return 1;
+    if (pattern[i + 2] === "<" && pattern[i + 3] !== "=" && pattern[i + 3] !== "!") {
+        const close = pattern.indexOf(">", i);
+        return close === -1 ? 1 : close - i + 1;
+    }
+    return pattern[i + 2] === "<" ? 4 : 3;
+}
+
+/**
+ * Whether a regex source has a repeated group whose body ends in a
+ * variable-length repetition — the nested-quantifier shape behind most
+ * catastrophic backtracking (`(a+)+`, `(\w+\s?)*`, `((x*))+`).
+ *
+ * "Ends in" is what keeps the common safe patterns quiet: in
+ * `^([a-z0-9]+-)*[a-z0-9]+$` every iteration must end on the mandatory `-`, so
+ * the inner `+` cannot trade characters with the next iteration and the group is
+ * not flagged; only optional atoms (`?`, `*`, `{0,n}`) may follow the inner
+ * repetition for the group to count. Fixed counts (`(\d{3})+`) are not variable
+ * and do not count.
+ *
+ * This is a heuristic for one shape, not a proof of safety: overlapping
+ * alternation (`(a|aa)+`) and backreferences are not analysed. A flag is a
+ * warning to read the pattern, not a verdict.
+ *
+ * @param {string} pattern - The regex source from the spec.
+ * @returns {boolean} `true` when the nested-quantifier shape is present.
+ */
+export function hasNestedQuantifier(pattern) {
+    const frames = [{ tail: false, anyAlternative: false }];
+    let i = 0;
+    while (i < pattern.length) {
+        const ch = pattern[i];
+        const frame = frames[frames.length - 1];
+        if (ch === "|") {
+            frame.anyAlternative ||= frame.tail;
+            frame.tail = false;
+            i += 1;
+            continue;
+        }
+        if (ch === "(") {
+            frames.push({ tail: false, anyAlternative: false });
+            i += groupOpenLength(pattern, i);
+            continue;
+        }
+        let groupTail = false;
+        let isGroup = false;
+        if (ch === ")") {
+            if (frames.length === 1) {
+                i += 1;
+                continue;
+            }
+            const closed = frames.pop();
+            groupTail = closed.anyAlternative || closed.tail;
+            isGroup = true;
+            i += 1;
+        } else if (ch === "[") {
+            i = classEnd(pattern, i);
+        } else if (ch === "\\") {
+            i += 2;
+        } else {
+            i += 1;
+        }
+        const outer = frames[frames.length - 1];
+        const q = quantifierAt(pattern, i);
+        if (q) i += q.length;
+        const repeats = q !== null && q.max > 1;
+        if (isGroup && groupTail && repeats) return true;
+        const variable = repeats && q.max > q.min;
+        if (variable || (isGroup && groupTail && !repeats)) outer.tail = true;
+        else if (!q || q.min > 0) outer.tail = false;
+    }
+    return false;
+}

package/bin/lib/openapi/pattern-risk.test.mjs

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+
+import { hasNestedQuantifier } from "./pattern-risk.mjs";
+
+describe("hasNestedQuantifier — flags the repeated-repetition shape (#533)", () => {
+    it.each([
+        "^(a+)+$",
+        "^(a*)*$",
+        "(\\w+\\s?)*",
+        "^((x+))+$",
+        "(?:a+){2,}",
+        "(?<word>\\d+)+",
+        "^(a|b+)*$",
+        "(a{1,5})+",
+    ])("%s is flagged", (pattern) => {
+        expect(hasNestedQuantifier(pattern)).toBe(true);
+    });
+
+    it.each([
+        "^[a-z]+$",
+        "^([a-z0-9]+-)*[a-z0-9]+$",
+        "^(\\d{3})+$",
+        "^(ab)+$",
+        "^(a+)$",
+        "^(a+)?$",
+        "[(a+)+]",
+        "\\(a+\\)+",
+        "^(?=a+)b$",
+        "^\\d{5}-?\\d{3}$",
+        "^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$",
+        ")a+(",
+    ])("%s is not flagged", (pattern) => {
+        expect(hasNestedQuantifier(pattern)).toBe(false);
+    });
+
+    it("the flagged shape really is exponential in V8, so the warning is not theoretical", () => {
+        const time = (n) => {
+            const start = performance.now();
+            /^(a+)+$/.test(`${"a".repeat(n)}!`);
+            return performance.now() - start;
+        };
+        time(14);
+        expect(time(22)).toBeGreaterThan(time(14) * 4);
+    });
+});