ata-validator 0.17.2 → 0.17.4

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to ata-validator are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/), and this project adheres to semantic versioning.
 
+## 0.17.4 - 2026-05-25
+
+### Fixed
+
+- Standalone output now embeds user-supplied format functions. `toStandaloneModule` and `bundleCompact` referenced the `_uf_<name>` format helpers without declaring them, so the generated module threw `_uf_<name> is not defined` on the first validation, and their error path skipped the custom format entirely (so `validate` disagreed with `isValid`). Both now serialize the format functions via `Function#toString` and run them on the error path too, matching `bundleStandalone`.
+- Compiled validators report per-property errors for schema-valued `additionalProperties`. The AOT error path previously emitted a single generic `validation failed`; it now validates each undeclared property against the subschema and reports the precise `/<key>` error, matching the runtime validator.
+- `ata --version` (and `-V`) prints the CLI version instead of failing with `unknown command`.
+
+## 0.17.3 - 2026-05-25
+
+### Security
+
+- User-supplied `pattern`, `patternProperties`, and `propertyNames` regexes now run through a linear-time matching engine, so a crafted schema or input can no longer trigger catastrophic backtracking (ReDoS). Patterns the engine cannot represent, such as those using backreferences, fall back to the native `RegExp`. The built-in `format` checks (`email`, `uri`, `uri-reference`, `hostname`, `ipv4`, `ipv6`, `date`, `date-time`, `time`, `duration`, `uuid`) were routed through the same engine and stay linear on adversarial input.
+
 ## 0.17.2 - 2026-05-24
 
 ### Fixed

package/bin/ata.js

@@ -45,6 +45,7 @@ Build options:
   --dual                  Emit both .compiled.mjs (with source) and .compiled.min.mjs (without)
 
   -h, --help              Show this message
+  -V, --version           Print the ata-validator version
 
 Examples:
   ata compile schemas/user.json -o src/generated/user.validator.mjs
@@ -386,6 +387,10 @@ function main() {
 
   const cmd = argv[0];
   if (cmd === '-h' || cmd === '--help' || cmd === 'help') { usage(); return; }
+  if (cmd === '-V' || cmd === '--version' || cmd === 'version') {
+    process.stdout.write(require('../package.json').version + '\n');
+    return;
+  }
 
   const rest = argv.slice(1);
   let args;

package/index.js

@@ -299,6 +299,27 @@ const _CP_LEN_SOURCE = `function _cpLen(s) {
   return len;
 }`;
 
+// The linear-time regex engine, inlined verbatim into standalone output so a
+// compiled module that uses safe `pattern` matchers has no runtime dependency on
+// ata-validator. Read from the source file (one copy, no drift) with the strict
+// directive and CommonJS exports stripped, plus the `__ataSafeRe` alias the
+// emitted code calls. The engine has no eval/new Function, so the embed is
+// CSP-safe.
+const SAFE_REGEX_EMBED = (() => {
+  const raw = require("fs").readFileSync(require("path").join(__dirname, "lib", "safe-regex.js"), "utf8");
+  const body = raw
+    .replace(/^'use strict'\s*\n/, "")
+    .replace(/\nmodule\.exports[^\n]*\n?/, "\n");
+  return body.trimEnd() + "\nconst __ataSafeRe = compileSafe;";
+})();
+
+// Returns the engine embed when any supplied compiled function references the
+// safe matcher (jsFn._usesSafeRe), else an empty string so non-pattern modules
+// pay zero bytes.
+function safeRePrelude(...fns) {
+  return fns.some((f) => f && f._usesSafeRe) ? SAFE_REGEX_EMBED + "\n" : "";
+}
+
 // Above this size, simdjson On Demand (selective field access) beats JSON.parse
 // (which must materialize the full JS object tree). Buffer.from + NAPI ~2x faster.
 const SIMDJSON_THRESHOLD = 8192;
@@ -1152,7 +1173,7 @@ class Validator {
     return `// Auto-generated by ata-validator — do not edit
 'use strict';
 ${_CP_LEN_SOURCE}
-${preambleSrc}
+${safeRePrelude(jsFn, jsErrFn)}${preambleSrc}
 const boolFn = function(d) {
   ${src}
 };
@@ -1188,11 +1209,12 @@ module.exports = { boolFn, hybridFactory, errFn };
     const src = jsFn._source;
 
     let errCore = '';
+    let jsErrFn = null;
     if (!abortEarly) {
-      const jsErrFn = compileToJSCodegenWithErrors(
+      jsErrFn = compileToJSCodegenWithErrors(
         typeof this._schemaObj === 'object' ? this._schemaObj : {},
         null,
-        undefined,
+        this._userFormats,
         (source && sourceMap && schemaFile) ? { sourceMap, schemaFile } : null,
       );
       const errSrc = jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : '';
@@ -1220,7 +1242,9 @@ module.exports = { boolFn, hybridFactory, errFn };
           lines.push(`const ${name} = ${JSON.stringify(val)};`);
           continue;
         }
-        if (val instanceof RegExp) {
+        if (val && val.__ataSafe) {
+          lines.push(`const ${name} = __ataSafeRe(${JSON.stringify(val.source)});`);
+        } else if (val instanceof RegExp) {
           const flags = val.flags;
           lines.push(`const ${name} = new RegExp(${JSON.stringify(val.source)}${flags ? ', ' + JSON.stringify(flags) : ''});`);
         } else if (val instanceof Set) {
@@ -1242,6 +1266,16 @@ module.exports = { boolFn, hybridFactory, errFn };
     // them at module scope too, or _fn references undefined names (e.g. _af1_b0).
     const preambleDecls = jsFn._preambleSource ? jsFn._preambleSource + '\n' : '';
 
+    // User-supplied format functions are referenced as _uf_<name> by both the
+    // boolean (_fn) and error (errFn) bodies. Embed them via Function#toString
+    // so the standalone module stays self-contained.
+    let formatDecls = '';
+    if (jsFn._formatClosures && jsFn._formatClosures.length > 0) {
+      formatDecls = jsFn._formatClosures
+        .map(({ name, fn }) => `const ${name} = ${fn.toString()};`)
+        .join('\n') + '\n';
+    }
+
     const validBody = errCore
       ? 'return _fn(data) ? VALID : { valid: false, errors: errFn(data, true).errors }'
       : 'return _fn(data) ? VALID : ABORT';
@@ -1254,7 +1288,7 @@ module.exports = { boolFn, hybridFactory, errFn };
 // Schema is embedded; runtime has zero dependency on ata-validator.
 'use strict';
 ${_CP_LEN_SOURCE}
-${schemaSourceConst}const VALID = Object.freeze({ valid: true, errors: Object.freeze([]) });
+${safeRePrelude(jsFn, jsErrFn)}${schemaSourceConst}const VALID = Object.freeze({ valid: true, errors: Object.freeze([]) });
 const ABORT = Object.freeze({
   valid: false,
   errors: Object.freeze([Object.freeze({
@@ -1264,7 +1298,7 @@ const ABORT = Object.freeze({
     path: '',
   })]),
 });
-${closureDecls}${preambleDecls}const _fn = function(d) {
+${closureDecls}${preambleDecls}${formatDecls}const _fn = function(d) {
   ${src}
 };
 ${errCore}function isValid(data) { return _fn(data); }
@@ -1490,6 +1524,7 @@ Validator.bundleStandalone = function (schemas, opts) {
   const bundleOpts = haveIds ? { ...(opts || {}), schemas } : (opts || {});
   const format = (opts && opts.format) || 'cjs';
   const R = "Object.freeze({valid:true,errors:Object.freeze([])})";
+  let bundleUsesSafeRe = false;
   const fns = schemas.map((schema) => {
     const v = new Validator(schema, bundleOpts);
     v._ensureCompiled();
@@ -1500,6 +1535,7 @@ Validator.bundleStandalone = function (schemas, opts) {
       v._schemaMap,
       v._userFormats,
     );
+    if (jsFn._usesSafeRe || (jsErrFn && jsErrFn._usesSafeRe)) bundleUsesSafeRe = true;
     const errBody =
       jsErrFn && jsErrFn._errSource
         ? jsErrFn._errSource
@@ -1525,10 +1561,11 @@ Validator.bundleStandalone = function (schemas, opts) {
     return `(function(R){${preamble}var E=function(d){var _all=true;${errBody}};return function(d){${jsFn._hybridSource}}})(R)`;
   });
   const arr = `[${fns.join(",")}]`;
+  const safeEmbed = bundleUsesSafeRe ? SAFE_REGEX_EMBED + "\n" : "";
   if (format === 'esm') {
-    return `// Auto-generated by ata-validator — do not edit\nconst R=${R};\nconst validators=${arr};\nexport default validators;\nexport { validators };\n`;
+    return `// Auto-generated by ata-validator — do not edit\n${safeEmbed}const R=${R};\nconst validators=${arr};\nexport default validators;\nexport { validators };\n`;
   }
-  return `'use strict';\nvar R=${R};\nmodule.exports=[${fns.join(",")}];\n`;
+  return `'use strict';\n${safeEmbed}var R=${R};\nmodule.exports=[${fns.join(",")}];\n`;
 };
 
 // Compact bundle: deduplicated code. Shared template functions + per-schema params.
@@ -1538,6 +1575,7 @@ Validator.bundleCompact = function (schemas, opts) {
   const haveIds = schemas.some((s) => s && typeof s === 'object' && s.$id);
   const bundleOpts = haveIds ? { ...(opts || {}), schemas } : (opts || {});
   const format = (opts && opts.format) || 'cjs';
+  let bundleUsesSafeRe = false;
   // Analyze schemas and group by structure
   const entries = schemas.map((schema) => {
     const v = new Validator(schema, bundleOpts);
@@ -1547,7 +1585,9 @@ Validator.bundleCompact = function (schemas, opts) {
     const jsErrFn = compileToJSCodegenWithErrors(
       typeof schema === "string" ? JSON.parse(schema) : schema,
       v._schemaMap,
+      v._userFormats,
     );
+    if (jsFn._usesSafeRe || (jsErrFn && jsErrFn._usesSafeRe)) bundleUsesSafeRe = true;
     // Hoisted anyOf/oneOf branch helpers (e.g. `_af1_b0`) must travel with the
     // hybrid body or it references undefined names. Prepending keeps dedup honest:
     // schemas with different branch sets no longer collide on body alone.
@@ -1557,6 +1597,7 @@ Validator.bundleCompact = function (schemas, opts) {
     return {
       hybrid,
       err: jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : null,
+      fmt: jsFn._formatClosures || null,
     };
   });
 
@@ -1591,9 +1632,23 @@ Validator.bundleCompact = function (schemas, opts) {
   let out = isEsm
     ? "// Auto-generated by ata-validator — do not edit\n"
     : "'use strict';\n";
+  if (bundleUsesSafeRe) out += SAFE_REGEX_EMBED + "\n";
   const declKW = isEsm ? "const" : "var";
   out += `${declKW} R=Object.freeze({valid:true,errors:Object.freeze([])});\n`;
 
+  // User format functions are referenced as _uf_<name> by the hybrid and error
+  // bodies. Collect them across all schemas (deduped by name) and embed via
+  // Function#toString so the bundle stays self-contained.
+  const fmtSeen = new Set();
+  for (const e of entries) {
+    if (!e || !e.fmt) continue;
+    for (const { name, fn } of e.fmt) {
+      if (fmtSeen.has(name)) continue;
+      fmtSeen.add(name);
+      out += `${declKW} ${name}=${fn.toString()};\n`;
+    }
+  }
+
   // Shared hybrid factories
   out += `${declKW} H=[\n`;
   out += bodies

package/lib/js-compiler.js

@@ -1,6 +1,15 @@
 'use strict'
 
 const { codeFor } = require('./error-codes')
+const { compileSafe, patternIsSafe } = require('./safe-regex')
+
+// Closure value for a patternProperties/propertyNames regex: the linear-time
+// safe matcher when the pattern is in the supported subset (and flag the ctx so
+// standalone embeds the engine), else a plain RegExp. Both expose `.test`.
+function safeReClosure (ctx, src) {
+  if (patternIsSafe(src)) { ctx.usesSafeRe = true; return compileSafe(src) }
+  return new RegExp(src)
+}
 
 // Compile a JSON Schema into a pure JS validator function.
 // Closure-based validator — no new Function() or eval().
@@ -328,7 +337,7 @@ function compileToJS(schema, defs, schemaMap) {
   }
   if (schema.pattern) {
     try {
-      const re = new RegExp(schema.pattern)
+      const re = patternIsSafe(schema.pattern) ? compileSafe(schema.pattern) : new RegExp(schema.pattern)
       checks.push((d) => typeof d !== 'string' || re.test(d))
     } catch {
       return null
@@ -962,6 +971,12 @@ function compileToJSCodegen(schema, schemaMap, userFormats) {
 
   // Pre-create regex objects once
   for (const code of ctx.helperCode) {
+    const safeMatch = code.match(/^const (_re\d+)=__ataSafeRe\((.+)\)$/)
+    if (safeMatch) {
+      closureNames.push(safeMatch[1])
+      closureValues.push(compileSafe(JSON.parse(safeMatch[2])))
+      continue
+    }
     const match = code.match(/^const (_re\d+)=new RegExp\((.+)\)$/)
     if (match) {
       closureNames.push(match[1])
@@ -1005,6 +1020,7 @@ function compileToJSCodegen(schema, schemaMap, userFormats) {
     boolFn._source = helperStr + body
     boolFn._preambleSource = preambleStr
     boolFn._hybridSource = helperStr + hybridBody
+    boolFn._usesSafeRe = !!ctx.usesSafeRe
     // Custom-format closure entries that the bundle output needs to recreate.
     // Stored as { name, fn } so consumers can serialize via Function#toString.
     if (ctx.userFormats) {
@@ -1454,7 +1470,12 @@ function genCode(schema, v, lines, ctx, knownType) {
       if (!ctx.regExpMap.has(pattern)) {
         const ri = ctx.varCounter++
         ctx.regExpMap.set(pattern, ri)
-        ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`);
+        if (patternIsSafe(schema.pattern)) {
+          ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`);
+          ctx.usesSafeRe = true
+        } else {
+          ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`);
+        }
       }
       const ri = ctx.regExpMap.get(pattern);
       lines.push(isStr ? `if(!_re${ri}.test(${v}))return false` : `if(typeof ${v}==='string'&&!_re${ri}.test(${v}))return false`)
@@ -1552,7 +1573,7 @@ function genCode(schema, v, lines, ctx, knownType) {
       } else {
         const ri = ctx.varCounter++
         ctx.closureVars.push(`_re${ri}`)
-        ctx.closureVals.push(new RegExp(pat))
+        ctx.closureVals.push(safeReClosure(ctx, pat))
         matchers.push({ check: `_re${ri}.test(${kVar})` })
       }
     }
@@ -1587,7 +1608,7 @@ function genCode(schema, v, lines, ctx, knownType) {
           } else {
             const ri = ctx.varCounter++
             ctx.closureVars.push(`_re${ri}`)
-            ctx.closureVals.push(new RegExp(pn.pattern))
+            ctx.closureVals.push(safeReClosure(ctx, pn.pattern))
             lines.push(`if(!_re${ri}.test(${kVar}))return false`)
           }
         }
@@ -1630,7 +1651,7 @@ function genCode(schema, v, lines, ctx, knownType) {
           } else {
             const ri = ctx.varCounter++
             ctx.closureVars.push(`_re${ri}`)
-            ctx.closureVals.push(new RegExp(pn.pattern))
+            ctx.closureVals.push(safeReClosure(ctx, pn.pattern))
             lines.push(`if(!_re${ri}.test(${kVar}))return false`)
           }
         }
@@ -1674,7 +1695,7 @@ function genCode(schema, v, lines, ctx, knownType) {
       } else {
         const ri = ctx.varCounter++
         ctx.closureVars.push(`_re${ri}`)
-        ctx.closureVals.push(new RegExp(pn.pattern))
+        ctx.closureVals.push(safeReClosure(ctx, pn.pattern))
         lines.push(`if(!_re${ri}.test(_k${ki}))return false`)
       }
     }
@@ -2102,7 +2123,7 @@ function genCode(schema, v, lines, ctx, knownType) {
             for (const pat of allPatterns) {
               const ri = ctx.varCounter++
               ctx.closureVars.push(`_ure${ri}`)
-              ctx.closureVals.push(new RegExp(pat))
+              ctx.closureVals.push(safeReClosure(ctx, pat))
               reVars.push(`_ure${ri}`)
             }
             if (schema.if && !schema.then && !schema.else) {
@@ -2119,7 +2140,7 @@ function genCode(schema, v, lines, ctx, knownType) {
               for (const pat of ifPatterns) {
                 const ri = ctx.varCounter++
                 ctx.closureVars.push(`_ure${ri}`)
-                ctx.closureVals.push(new RegExp(pat))
+                ctx.closureVals.push(safeReClosure(ctx, pat))
                 ifReVars.push(`_ure${ri}`)
               }
               const rootReVars = []
@@ -2127,7 +2148,7 @@ function genCode(schema, v, lines, ctx, knownType) {
                 for (const pat of Object.keys(schema.patternProperties)) {
                   const ri = ctx.varCounter++
                   ctx.closureVars.push(`_ure${ri}`)
-                  ctx.closureVals.push(new RegExp(pat))
+                  ctx.closureVals.push(safeReClosure(ctx, pat))
                   rootReVars.push(`_ure${ri}`)
                 }
               }
@@ -2537,9 +2558,6 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
     if (s.includes('unevaluatedProperties') || s.includes('unevaluatedItems')) return null
     // Bail on self-referencing schemas — error codegen doesn't support recursion
     if (s.includes('"$ref":"#"')) return null
-    // Bail on additionalProperties as a schema — genCodeE does not emit the
-    // per-key sub-schema loop. Let the closure path handle detailed errors.
-    if (hasAdditionalPropertiesSchema(schema)) return null
   }
   if (typeof schema === 'boolean') {
     return schema
@@ -2621,8 +2639,17 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
       `\n  return{valid:_e.length===0,errors:_e}`
   }
   try {
-    const fn = new Function('d', '_all', body)
+    let fn
+    if (ctx.usesSafeRe) {
+      // Inlined helperCode references __ataSafeRe; bind the safe-regex factory.
+      // Standalone keeps the inline _errSource — the embed defines __ataSafeRe.
+      const built = new Function('__ataSafeRe', 'd', '_all', body)
+      fn = (d, _all) => built(compileSafe, d, _all)
+    } else {
+      fn = new Function('d', '_all', body)
+    }
     fn._errSource = body
+    fn._usesSafeRe = !!ctx.usesSafeRe
     return fn
   } catch {
     return null
@@ -2856,7 +2883,12 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       if (!ctx.regExpMap.has(pattern)) {
         const ri = ctx.varCounter++
         ctx.regExpMap.set(pattern, ri)
-        ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`)
+        if (patternIsSafe(schema.pattern)) {
+          ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`)
+          ctx.usesSafeRe = true
+        } else {
+          ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`)
+        }
       }
       const ri = ctx.regExpMap.get(pattern);
       const c = isStr ? `!_re${ri}.test(${v})` : `typeof ${v}==='string'&&!_re${ri}.test(${v})`
@@ -2961,7 +2993,12 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       if (!ctx.regExpMap.has(pattern)) {
         const ri = ctx.varCounter++
         ctx.regExpMap.set(pattern, ri)
-        ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`);
+        if (patternIsSafe(pat)) {
+          ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`);
+          ctx.usesSafeRe = true
+        } else {
+          ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`);
+        }
       }
       const ri = ctx.regExpMap.get(pattern);
       const ki = ctx.varCounter++
@@ -2972,6 +3009,21 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     }
   }
 
+  // additionalProperties as a schema — validate each property not declared in
+  // `properties` against the subschema, with a dynamic /<key> path. codegenSafe
+  // guarantees no patternProperties or composition here, so "additional" is
+  // simply "not declared".
+  if (typeof schema.additionalProperties === 'object' && schema.additionalProperties !== null) {
+    const ki = ctx.varCounter++
+    const known = Object.keys(schema.properties || {})
+    const guard = known.length ? `const _ak${ki}=new Set([${known.map((k) => JSON.stringify(k)).join(',')}]);` : ''
+    const keep = known.length ? `if(!_ak${ki}.has(_k${ki})){` : `{`
+    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${guard}for(const _k${ki} in ${v}){${keep}`)
+    const p = pathExpr ? `${pathExpr}+'/'+_k${ki}` : `'/'+_k${ki}`
+    genCodeE(schema.additionalProperties, `${v}[_k${ki}]`, p, lines, ctx, schemaPrefix + '/additionalProperties')
+    lines.push(`}}}`)
+  }
+
   // dependentSchemas
   if (schema.dependentSchemas) {
     for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
@@ -2997,7 +3049,12 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       if (!ctx.regExpMap.has(pattern)) {
         const ri = ctx.varCounter++
         ctx.regExpMap.set(pattern, ri)
-        ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`);
+        if (patternIsSafe(pn.pattern)) {
+          ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`);
+          ctx.usesSafeRe = true
+        } else {
+          ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`);
+        }
       }
       const ri = ctx.regExpMap.get(pattern);
       lines.push(`if(!_re${ri}.test(_k${ki})){${fail('pattern', 'propertyNames/pattern', `{pattern:${JSON.stringify(pn.pattern)}}`, `'must match pattern "${pn.pattern}"'`)}}`)
@@ -3419,7 +3476,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       const ri = ctx.varCounter++
       const reVar = `_re${ri}`
       ctx.closureVars.push(reVar)
-      ctx.closureVals.push(new RegExp(schema.pattern))
+      ctx.closureVals.push(patternIsSafe(schema.pattern) ? compileSafe(schema.pattern) : new RegExp(schema.pattern))
       const c = isStr ? `!${reVar}.test(${v})` : `typeof ${v}==='string'&&!${reVar}.test(${v})`
       lines.push(`if(${c}){${fail('pattern', 'pattern', `{pattern:${JSON.stringify(schema.pattern)}}`, `'must match pattern "${schema.pattern}"'`)}}`)
     }
@@ -3544,7 +3601,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       } else {
         const ri = ctx.varCounter++
         ctx.closureVars.push(`_re${ri}`)
-        ctx.closureVals.push(new RegExp(pat))
+        ctx.closureVals.push(safeReClosure(ctx, pat))
         matchers.push({ check: `_re${ri}.test(_k${pi})` })
       }
     }
@@ -3588,7 +3645,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
           } else {
             const ri = ctx.varCounter++
             ctx.closureVars.push(`_re${ri}`)
-            ctx.closureVals.push(new RegExp(pn.pattern))
+            ctx.closureVals.push(safeReClosure(ctx, pn.pattern))
             lines.push(`if(!_re${ri}.test(${kVar})){${fail('pattern', 'propertyNames/pattern', `{pattern:${JSON.stringify(pn.pattern)}}`, `'must match pattern "${pn.pattern}"'`)}}`)
           }
         }
@@ -3620,7 +3677,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
           } else {
             const ri = ctx.varCounter++
             ctx.closureVars.push(`_re${ri}`)
-            ctx.closureVals.push(new RegExp(pn.pattern))
+            ctx.closureVals.push(safeReClosure(ctx, pn.pattern))
             lines.push(`if(!_re${ri}.test(${kVar})){${fail('pattern', 'propertyNames/pattern', `{pattern:${JSON.stringify(pn.pattern)}}`, `'must match pattern "${pn.pattern}"'`)}}`)
           }
         }
@@ -3662,7 +3719,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     if (pn.pattern) {
       const ri = ctx.varCounter++
       ctx.closureVars.push(`_re${ri}`)
-      ctx.closureVals.push(new RegExp(pn.pattern))
+      ctx.closureVals.push(safeReClosure(ctx, pn.pattern))
       lines.push(`if(!_re${ri}.test(_k${ki})){${fail('pattern', 'propertyNames/pattern', `{pattern:${JSON.stringify(pn.pattern)}}`, `'must match pattern "${pn.pattern}"'`)}}`)
     }
     if (pn.const !== undefined) {

package/lib/safe-regex.js

@@ -0,0 +1,300 @@
+'use strict'
+
+// Linear-time regex engine for JSON Schema `pattern`, used in place of JS RegExp
+// so an adversarial input cannot trigger catastrophic backtracking (ReDoS).
+//
+// It is a Pike VM: the pattern compiles to a small instruction program, and the
+// VM simulates all NFA threads in lockstep over the input, deduping by program
+// counter. Runtime is O(input * program), with no backtracking.
+//
+// Supported (the RE2 subset, which is what ata's native path also accepts):
+// literals, ., character classes, \d \w \s \D \W \S, anchors ^ $, quantifiers
+// * + ? {n} {n,} {n,m} (greedy or lazy, same language for a boolean test),
+// groups ( ) (?: ), alternation |. Backreferences and lookaround are not
+// supported by linear engines; compileSafe throws on them so the caller can
+// decide (ata's codegen rejects such schemas rather than risk a hang).
+
+const WS = [[9, 13], [32, 32], [160, 160]]
+const DIGIT = [[48, 57]]
+const WORD = [[48, 57], [65, 90], [97, 122], [95, 95]]
+
+function parse (src) {
+  let i = 0
+  const len = src.length
+  const peek = () => src[i]
+  const eof = () => i >= len
+
+  function parseAlt () {
+    const opts = [parseConcat()]
+    while (!eof() && peek() === '|') { i++; opts.push(parseConcat()) }
+    return opts.length === 1 ? opts[0] : { t: 'alt', opts }
+  }
+
+  function parseConcat () {
+    const parts = []
+    while (!eof() && peek() !== '|' && peek() !== ')') parts.push(parseRepeat())
+    if (parts.length === 0) return { t: 'empty' }
+    return parts.length === 1 ? parts[0] : { t: 'concat', parts }
+  }
+
+  function parseRepeat () {
+    let node = parseAtom()
+    while (!eof()) {
+      const ch = peek()
+      if (ch === '*') { i++; node = { t: 'star', child: node } }
+      else if (ch === '+') { i++; node = { t: 'plus', child: node } }
+      else if (ch === '?') { i++; node = { t: 'quest', child: node } }
+      else if (ch === '{') {
+        const saved = i
+        const q = tryQuantifier()
+        if (!q) { i = saved; break }
+        node = { t: 'repeat', child: node, min: q.min, max: q.max }
+      } else break
+      // a trailing ? makes the quantifier lazy; same language for a boolean test
+      if (!eof() && peek() === '?') i++
+    }
+    return node
+  }
+
+  function tryQuantifier () {
+    // assumes current char is '{'
+    i++
+    let min = ''
+    while (!eof() && /[0-9]/.test(peek())) { min += peek(); i++ }
+    if (min === '') return null
+    let max
+    if (peek() === '}') { i++; return { min: +min, max: +min } }
+    if (peek() === ',') {
+      i++
+      let m = ''
+      while (!eof() && /[0-9]/.test(peek())) { m += peek(); i++ }
+      if (peek() !== '}') return null
+      i++
+      max = m === '' ? Infinity : +m
+      return { min: +min, max }
+    }
+    return null
+  }
+
+  function parseAtom () {
+    const ch = peek()
+    if (ch === '(') {
+      i++
+      if (src[i] === '?') {
+        if (src[i + 1] === ':') { i += 2 }
+        else throw new Error('unsupported group (lookaround/named) in pattern')
+      }
+      const child = parseAlt()
+      if (peek() !== ')') throw new Error('unbalanced ( in pattern')
+      i++
+      return { t: 'group', child }
+    }
+    if (ch === '[') return parseClass()
+    if (ch === '.') { i++; return { t: 'any' } }
+    if (ch === '^') { i++; return { t: 'bol' } }
+    if (ch === '$') { i++; return { t: 'eol' } }
+    if (ch === '\\') return parseEscape(false)
+    if (ch === ')' || ch === '|') return { t: 'empty' }
+    i++
+    return { t: 'char', c: ch.charCodeAt(0) }
+  }
+
+  function parseClass () {
+    i++ // [
+    let neg = false
+    if (peek() === '^') { neg = true; i++ }
+    const ranges = []
+    while (!eof() && peek() !== ']') {
+      let lo
+      if (peek() === '\\') {
+        const esc = parseEscape(true)
+        if (esc.t === 'classpart') { for (const r of esc.ranges) ranges.push(r); continue }
+        lo = esc.c
+      } else { lo = peek().charCodeAt(0); i++ }
+      if (peek() === '-' && src[i + 1] !== ']' && i + 1 < len) {
+        i++ // -
+        let hi
+        if (peek() === '\\') { const e = parseEscape(true); hi = e.c } else { hi = peek().charCodeAt(0); i++ }
+        ranges.push([lo, hi])
+      } else {
+        ranges.push([lo, lo])
+      }
+    }
+    if (peek() !== ']') throw new Error('unbalanced [ in pattern')
+    i++
+    return { t: 'class', neg, ranges }
+  }
+
+  function parseEscape (inClass) {
+    i++ // backslash
+    if (eof()) throw new Error('trailing backslash in pattern')
+    const ch = peek(); i++
+    switch (ch) {
+      case 'd': return inClass ? { t: 'classpart', ranges: DIGIT } : { t: 'class', neg: false, ranges: DIGIT }
+      case 'w': return inClass ? { t: 'classpart', ranges: WORD } : { t: 'class', neg: false, ranges: WORD }
+      case 's': return inClass ? { t: 'classpart', ranges: WS } : { t: 'class', neg: false, ranges: WS }
+      case 'D': if (inClass) throw new Error('\\D inside a class is not supported'); return { t: 'class', neg: true, ranges: DIGIT }
+      case 'W': if (inClass) throw new Error('\\W inside a class is not supported'); return { t: 'class', neg: true, ranges: WORD }
+      case 'S': if (inClass) throw new Error('\\S inside a class is not supported'); return { t: 'class', neg: true, ranges: WS }
+      case 'n': return { t: 'char', c: 10 }
+      case 'r': return { t: 'char', c: 13 }
+      case 't': return { t: 'char', c: 9 }
+      case 'f': return { t: 'char', c: 12 }
+      case 'v': return { t: 'char', c: 11 }
+      case '0': return { t: 'char', c: 0 }
+      case 'x': { const h = src.slice(i, i + 2); i += 2; return { t: 'char', c: parseInt(h, 16) } }
+      case 'u': { const h = src.slice(i, i + 4); i += 4; return { t: 'char', c: parseInt(h, 16) } }
+      case 'b': if (inClass) return { t: 'char', c: 8 }; throw new Error('\\b word boundary is not supported')
+      default:
+        if (/[1-9]/.test(ch)) throw new Error('backreferences are not supported in pattern')
+        return { t: 'char', c: ch.charCodeAt(0) }
+    }
+  }
+
+  const ast = parseAlt()
+  if (!eof()) throw new Error('unexpected "' + peek() + '" in pattern')
+  return ast
+}
+
+function compileProg (ast) {
+  const prog = []
+  const emit = (op, extra) => { const idx = prog.length; prog.push(Object.assign({ op }, extra)); return idx }
+
+  function rec (n) {
+    switch (n.t) {
+      case 'empty': break
+      case 'char': emit('char', { c: n.c }); break
+      case 'any': emit('any'); break
+      case 'class': emit('class', { neg: n.neg, ranges: n.ranges }); break
+      case 'bol': emit('bol'); break
+      case 'eol': emit('eol'); break
+      case 'group': rec(n.child); break
+      case 'concat': for (const p of n.parts) rec(p); break
+      case 'alt': {
+        const jmps = []
+        for (let k = 0; k < n.opts.length; k++) {
+          if (k < n.opts.length - 1) {
+            const sp = emit('split', { x: 0, y: 0 })
+            prog[sp].x = prog.length
+            rec(n.opts[k])
+            jmps.push(emit('jmp', { x: 0 }))
+            prog[sp].y = prog.length
+          } else {
+            rec(n.opts[k])
+          }
+        }
+        for (const j of jmps) prog[j].x = prog.length
+        break
+      }
+      case 'star': {
+        const sp = emit('split', { x: 0, y: 0 })
+        prog[sp].x = prog.length
+        rec(n.child)
+        emit('jmp', { x: sp })
+        prog[sp].y = prog.length
+        break
+      }
+      case 'plus': {
+        const start = prog.length
+        rec(n.child)
+        const sp = emit('split', { x: start, y: 0 })
+        prog[sp].y = prog.length
+        break
+      }
+      case 'quest': {
+        const sp = emit('split', { x: 0, y: 0 })
+        prog[sp].x = prog.length
+        rec(n.child)
+        prog[sp].y = prog.length
+        break
+      }
+      case 'repeat': {
+        for (let k = 0; k < n.min; k++) rec(n.child)
+        if (n.max === Infinity) {
+          if (n.min === 0) rec({ t: 'star', child: n.child })
+          else rec({ t: 'star', child: n.child })
+        } else {
+          for (let k = 0; k < n.max - n.min; k++) rec({ t: 'quest', child: n.child })
+        }
+        break
+      }
+    }
+  }
+
+  rec(ast)
+  emit('match')
+  return prog
+}
+
+function matchClass (instr, c) {
+  let inside = false
+  const r = instr.ranges
+  for (let k = 0; k < r.length; k++) { if (c >= r[k][0] && c <= r[k][1]) { inside = true; break } }
+  return instr.neg ? !inside : inside
+}
+
+function makeRunner (prog) {
+  const n = prog.length
+  const lastGen = new Int32Array(n).fill(-1)
+  let gen = 0
+  const stack = []
+
+  function addThread (list, pc, pos, len) {
+    stack.length = 0
+    stack.push(pc)
+    while (stack.length) {
+      const p = stack.pop()
+      if (lastGen[p] === gen) continue
+      lastGen[p] = gen
+      const I = prog[p]
+      switch (I.op) {
+        case 'jmp': stack.push(I.x); break
+        case 'split': stack.push(I.y); stack.push(I.x); break
+        case 'bol': if (pos === 0) stack.push(p + 1); break
+        case 'eol': if (pos === len) stack.push(p + 1); break
+        default: list.push(p)
+      }
+    }
+  }
+
+  return function test (s) {
+    const len = s.length
+    let clist = []
+    let nlist = []
+    gen++
+    addThread(clist, 0, 0, len)
+    for (let pos = 0; pos <= len; pos++) {
+      const c = pos < len ? s.charCodeAt(pos) : -1
+      gen++
+      nlist.length = 0
+      for (let k = 0; k < clist.length; k++) {
+        const pc = clist[k]
+        const I = prog[pc]
+        if (I.op === 'match') return true
+        else if (I.op === 'char') { if (c === I.c) addThread(nlist, pc + 1, pos + 1, len) }
+        else if (I.op === 'any') { if (c !== -1 && c !== 10) addThread(nlist, pc + 1, pos + 1, len) }
+        else if (I.op === 'class') { if (c !== -1 && matchClass(I, c)) addThread(nlist, pc + 1, pos + 1, len) }
+      }
+      if (pos < len) addThread(nlist, 0, pos + 1, len)
+      const tmp = clist; clist = nlist; nlist = tmp
+    }
+    return false
+  }
+}
+
+function compileSafe (pattern) {
+  const prog = compileProg(parse(pattern))
+  const runner = makeRunner(prog)
+  // `__ataSafe` brands the result so the standalone serializer can tell a safe
+  // matcher apart from a RegExp and emit `__ataSafeRe(source)` instead.
+  return { test: runner, source: pattern, __ataSafe: true }
+}
+
+// True when the linear engine can represent `src`. Used by the codegen to decide
+// between the safe matcher and a JS RegExp fallback for patterns outside the
+// supported (RE2) subset (backreferences, lookaround, etc.).
+function patternIsSafe (src) {
+  try { compileSafe(src); return true } catch { return false }
+}
+
+module.exports = { compileSafe, patternIsSafe }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "0.17.2",
+  "version": "0.17.4",
   "description": "JSON Schema validation with first-class TypeScript and zero runtime cost. AOT compile to per-schema ESM modules with zero validator dependency. Generic Validator<T> for TypeBox/Zod/Valibot composition. Optional runtime API. Standard Schema V1 compatible.",
   "main": "index.js",
   "module": "index.mjs",
@@ -42,7 +42,7 @@
     "rebuild": "cmake-js rebuild --target ata",
     "prebuild": "pkg-prebuilds-copy --baseDir build/Release --source ata.node --name=ata --strip --napi_version=10",
     "prebuild-all": "npm run prebuild -- --arch x64 && npm run prebuild -- --arch arm64",
-    "test": "node test.js && node tests/test_no_native.js && node tests/test_aot_build.js && node tests/test_aot_differential.js && node tests/test_aot_cli_build.js && node tests/test_aot_cli_smoke.js && node tests/test_bundle_standalone.js && node tests/test_standalone_anyof.js && node tests/test_typed_validator_runner.js && node tests/test_define_schema.js && node tests/test_error_codes_lock.js && node tests/test_nullable.js && node tests/test_validate_and_parse.js && node tests/test_validate_data.js && node tests/test_enrich_error.js && node tests/test_rich_errors_optout.js && node tests/test_source_positions.js && node tests/fuzz_positions.js && node tests/test_data_positions.js && node tests/test_render_shared.js && node tests/test_renderers.js && node tests/test_runtime_error_dx.js && node tests/test_aot_error_dx.js && node tests/test_abort_early.js && node tests/test_branch_collapse.js && node tests/test_suggestions.js && node tests/test_cli_validate.js && node benchmark/bench_aot_size.mjs",
+    "test": "node test.js && node tests/test_no_native.js && node tests/test_safe_regex.js && node tests/test_safe_regex_integration.js && node tests/test_aot_build.js && node tests/test_aot_differential.js && node tests/test_aot_cli_build.js && node tests/test_aot_cli_smoke.js && node tests/test_bundle_standalone.js && node tests/test_standalone_anyof.js && node tests/test_standalone_formats.js && node tests/test_aot_additional_props_errors.js && node tests/test_typed_validator_runner.js && node tests/test_define_schema.js && node tests/test_error_codes_lock.js && node tests/test_nullable.js && node tests/test_validate_and_parse.js && node tests/test_validate_data.js && node tests/test_enrich_error.js && node tests/test_rich_errors_optout.js && node tests/test_source_positions.js && node tests/fuzz_positions.js && node tests/test_data_positions.js && node tests/test_render_shared.js && node tests/test_renderers.js && node tests/test_runtime_error_dx.js && node tests/test_aot_error_dx.js && node tests/test_abort_early.js && node tests/test_branch_collapse.js && node tests/test_suggestions.js && node tests/test_cli_validate.js && node tests/test_cli_version.js && node benchmark/bench_aot_size.mjs",
     "bench:size": "node benchmark/bench_aot_size.mjs",
     "test:suite": "node tests/run_suite.js",
     "test:compat": "node tests/test_compat.js",