ata-validator 1.11.0 → 1.12.0

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 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.
 
+## 1.12.0 - 2026-09-06
+
+### Performance
+
+- `date-time` stopped asking every character where it sits. The scan tested each of nineteen positions against the separator indices before checking the digit; the separators are now read directly by index and each digit becomes its value in the same read that validates it, so the field numbers cost nothing extra. 40.8 to 19.5 ns on a valid value, medians across separate processes. Same answers as before on every month, day and clock boundary and under 150k random mutations.
+
+- `uuid` reads the four hyphens by index and the 32 hex digits in five runs with fixed bounds, instead of a case-insensitive regular expression. A digit is one unsigned compare and a letter one more after folding case with a single OR. 48.4 to 35.1 ns; 300k mutated and random strings against the old expression with 0 mismatches.
+
+- `time` reads fixed positions the same way instead of running a regular expression: 15.6 to 12.1 ns, and 200k mutations against the old pattern with 0 mismatches.
+
+- `uri` reads the scheme from the front and scans the rest once instead of running two regular expressions: 39.3 to 32.8 ns, interleaved medians. The remaining scan then became two tiers, because the measured answer was not the expected one: a hand-written character loop beat the old `\s` expression in isolation but lost to the engine's scanner inside a compiled validator, since `\s` is what forced the Unicode machinery in. The first tier asks whether anything sits outside printable ASCII, a one-byte class the engine scans at its own speed and no ordinary URI ever trips; only a string that trips it pays for the loop that knows the exact reserved set. On a nested schema carrying six URLs, 215.5 to 189.4 ns per document, medians across separate processes. `uri-reference` shares the same scan. Fuzzed over every code point in the BMP in three positions, 0 mismatches.
+
+- The Standard Schema bridge stopped paying for enrichment it throws away. An issue carries a message and a path and nothing else, but `~standard.validate` read the rich error list, which builds suggestions, ranks and source frames per error. It now takes the raw, schema-ordered list through the same build the rich path uses, and `parsePointerPath` walks the pointer in one pass instead of split, filter, map and a regex per segment. A 16-error rejection went from 17.6 to 4.3 microseconds; messages and order are unchanged, and `tests/test_standard_schema.js` holds issues to exact parity with `validate().errors`. Schemas using `errorMessage` keep their custom messages.
+
+### Fixed
+
+- The compiled engine refused a lowercase zone letter in `time` that the interpreter accepted: `00:00:00z` answered differently depending on which engine ran the schema, and `date-time` took either case in both. One implementation now answers for every engine, and it takes both cases, per RFC 3339.
+
+- The ReDoS integration test measured the first call, which includes compiling the schema and the pattern, against a 50 ms budget. On a loaded CI machine that reads as a failure without anything being wrong: the gate exists to separate linear matching from catastrophic backtracking, which differ by minutes, not by milliseconds. It now warms up first and allows 500 ms.
+
 ## 1.11.0 - 2026-08-31
 
 ### Fixed

package/index.js

@@ -326,15 +326,22 @@ const ABORT_EARLY_RESULT = Object.freeze({
 // the eager shape. Note for tests: deepStrictEqual against a plain object
 // compares prototypes; read `.errors` and compare that.
 class LazyRejection {
-  constructor(build, data) {
+  constructor(build, data, buildRaw) {
     this.valid = false;
     this._build = build;
     this._data = data;
     this._errors = null;
+    this._buildRaw = buildRaw;
   }
   toJSON() {
     return { valid: false, errors: this.errors };
   }
+  // Raw shape for consumers that carry only message and path, such as the
+  // Standard Schema bridge: schema order, no enrichment. Reading `errors`
+  // afterwards still enriches through its own build.
+  _ataRaw() {
+    return this._buildRaw ? this._buildRaw(this._data) : this.errors;
+  }
 }
 Object.defineProperty(LazyRejection.prototype, 'errors', {
   enumerable: true,
@@ -463,18 +470,30 @@ function sortErrorsBySchemaOrder(rootSchema, errors) {
 
 function parsePointerPath(path) {
   if (!path) return [];
-  return path
-    .split("/")
-    .filter(Boolean)
-    .map((seg) => {
-      const decoded = seg.replace(/~1/g, "/").replace(/~0/g, "~");
-      // Per Standard Schema V1: array indices should be emitted as numbers,
-      // object keys as strings. Treat all-digit segments as numeric indices.
-      if (/^(0|[1-9][0-9]*)$/.test(decoded)) {
-        return { key: Number(decoded) };
+  // One pass, no intermediate arrays. Per Standard Schema V1 an array index
+  // is emitted as a number and an object key as a string; a segment is an
+  // index when it is all digits with no leading zero.
+  const out = [];
+  const n = path.length;
+  let start = 1;
+  for (let i = 1; i <= n; i++) {
+    if (i !== n && path.charCodeAt(i) !== 47) continue;
+    if (i > start) {
+      let seg = path.slice(start, i);
+      if (seg.indexOf('~') >= 0) seg = seg.replace(/~1/g, '/').replace(/~0/g, '~');
+      const c0 = seg.charCodeAt(0);
+      let numeric = c0 >= 48 && c0 <= 57 && (seg.length === 1 || c0 !== 48);
+      if (numeric) {
+        for (let k = 1; k < seg.length; k++) {
+          const c = seg.charCodeAt(k);
+          if (c < 48 || c > 57) { numeric = false; break; }
+        }
       }
-      return { key: decoded };
-    });
+      out.push({ key: numeric ? Number(seg) : seg });
+    }
+    start = i + 1;
+  }
+  return out;
 }
 
 function createPaddedBuffer(jsonStr) {
@@ -1379,6 +1398,14 @@ class Validator {
           let cached = null;
           return {
             valid: false,
+            // Raw shape for consumers that carry only message and path, such
+            // as the Standard Schema bridge: schema order, no enrichment.
+            // Reading `errors` afterwards still enriches from the same build.
+            _ataRaw() {
+              let raw = result.errors || [];
+              if (raw.length > 1) raw = sortErrorsBySchemaOrder(root, raw);
+              return raw;
+            },
             get errors() {
               if (cached === null) {
                 let raw = result.errors || [];
@@ -1550,17 +1577,24 @@ class Validator {
       const _full = this.validate;
       const _fast = this._fastVerdict;
       const EMPTY_ERRORS = Object.freeze([]);
+      const _verdictFallback = [{ keyword: 'validation', instancePath: '', schemaPath: '#', params: {}, message: 'schema validation failed' }];
       const _buildErrors = (data) => {
         const r = _full(data);
         return (r && r.valid === false && r.errors && r.errors.length)
           ? r.errors
           // The data changed between the verdict and this read; keep the
           // verdict and say so rather than inventing a specific error.
-          : [{ keyword: 'validation', instancePath: '', schemaPath: '#', params: {}, message: 'schema validation failed' }];
+          : _verdictFallback;
+      };
+      const _buildRawErrors = (data) => {
+        const r = _full(data);
+        if (!r || r.valid !== false) return _verdictFallback;
+        const raw = typeof r._ataRaw === 'function' ? r._ataRaw() : r.errors;
+        return raw && raw.length ? raw : _verdictFallback;
       };
       this.validate = (data) => {
         if (_fast(data)) return { valid: true, data, errors: EMPTY_ERRORS };
-        return new LazyRejection(_buildErrors, data);
+        return new LazyRejection(_buildErrors, data, _buildRawErrors);
       };
     }
 
@@ -2018,12 +2052,24 @@ Object.defineProperty(Validator.prototype, "~standard", {
         if (result.valid) {
           return { value };
         }
-        return {
-          issues: result.errors.map((err) => ({
-            message: err.message,
-            path: parsePointerPath(err.instancePath),
-          })),
-        };
+        // An issue carries a message and a path and nothing else, so the
+        // suggestion and source-frame work the rich error path does would be
+        // thrown away here. Take the raw, schema-ordered list when the result
+        // offers one; fall back to the public list otherwise.
+        const raw = typeof result._ataRaw === 'function' ? result._ataRaw() : result.errors;
+        const issues = new Array(raw.length);
+        for (let i = 0; i < raw.length; i++) {
+          const err = raw[i];
+          const path = err.instancePath != null ? err.instancePath : (err.path || '');
+          let message = err.message;
+          if (!message) {
+            // The native engine reports numeric codes without a message; the
+            // enrich pass knows how to word those. Rare, so required lazily.
+            message = require('./lib/enrich-error').enrich(err, {}).message;
+          }
+          issues[i] = { message, path: parsePointerPath(path) };
+        }
+        return { issues };
       },
     });
     Object.defineProperty(this, "~standard", {

package/lib/formats.js

@@ -42,23 +42,36 @@ function dateTime (s) {
   const n = s.length;
   // The shortest accepted form is 2026-08-31T12:00:00Z
   if (n < 20) return false;
-  for (let i = 0; i < 19; i++) {
-    const c = s.charCodeAt(i);
-    if (i === 4 || i === 7) { if (c !== 45) return false; continue; }
-    if (i === 10) { if (c !== 84 && c !== 116) return false; continue; }
-    if (i === 13 || i === 16) { if (c !== 58) return false; continue; }
-    if (c < 48 || c > 57) return false;
-  }
+  // Separators sit at known indices, so they are read directly rather than
+  // asked for at every step of a scan. Each remaining digit is turned into
+  // its value once and checked as one unsigned compare, which also gives the
+  // field its number without a second read.
+  if (s.charCodeAt(4) !== 45 || s.charCodeAt(7) !== 45) return false;
+  const sep = s.charCodeAt(10);
+  if (sep !== 84 && sep !== 116) return false;
+  if (s.charCodeAt(13) !== 58 || s.charCodeAt(16) !== 58) return false;
+
+  const y0 = s.charCodeAt(0) - 48, y1 = s.charCodeAt(1) - 48;
+  const y2 = s.charCodeAt(2) - 48, y3 = s.charCodeAt(3) - 48;
+  if ((y0 >>> 0) > 9 || (y1 >>> 0) > 9 || (y2 >>> 0) > 9 || (y3 >>> 0) > 9) return false;
+  const year = y0 * 1000 + y1 * 100 + y2 * 10 + y3;
 
-  const year = (s.charCodeAt(0) - 48) * 1000 + (s.charCodeAt(1) - 48) * 100 +
-    (s.charCodeAt(2) - 48) * 10 + (s.charCodeAt(3) - 48);
-  const month = twoDigits(s, 5);
+  const mo0 = s.charCodeAt(5) - 48, mo1 = s.charCodeAt(6) - 48;
+  if ((mo0 >>> 0) > 9 || (mo1 >>> 0) > 9) return false;
+  const month = mo0 * 10 + mo1;
   if (month < 1 || month > 12) return false;
-  const day = twoDigits(s, 8);
+
+  const d0 = s.charCodeAt(8) - 48, d1 = s.charCodeAt(9) - 48;
+  if ((d0 >>> 0) > 9 || (d1 >>> 0) > 9) return false;
+  const day = d0 * 10 + d1;
   if (day < 1 || day > daysInMonth(year, month)) return false;
-  if (twoDigits(s, 11) > 23) return false;
-  if (twoDigits(s, 14) > 59) return false;
-  if (twoDigits(s, 17) > 59) return false;
+
+  const h0 = s.charCodeAt(11) - 48, h1 = s.charCodeAt(12) - 48;
+  if ((h0 >>> 0) > 9 || (h1 >>> 0) > 9 || h0 * 10 + h1 > 23) return false;
+  const mi0 = s.charCodeAt(14) - 48, mi1 = s.charCodeAt(15) - 48;
+  if ((mi0 >>> 0) > 5 || (mi1 >>> 0) > 9) return false;
+  const se0 = s.charCodeAt(17) - 48, se1 = s.charCodeAt(18) - 48;
+  if ((se0 >>> 0) > 5 || (se1 >>> 0) > 9) return false;
 
   let i = 19;
   if (s.charCodeAt(i) === 46) {
@@ -195,6 +208,125 @@ function hostname (s) {
   return labelLength !== 0 && previous !== 45;
 }
 
+// A scheme followed by a colon, and no control characters or spaces after it.
+// Two expressions became one pass: the scheme is read from the front and the
+// rest of the string is scanned once for characters a URI cannot hold.
+function uri (s) {
+  const n = s.length;
+  if (n === 0) return false;
+  const first = s.charCodeAt(0);
+  if (!((first >= 97 && first <= 122) || (first >= 65 && first <= 90))) return false;
+  let colon = -1;
+  for (let i = 1; i < n; i++) {
+    const c = s.charCodeAt(i);
+    if (c === 58) { colon = i; break; }
+    // scheme characters: letters, digits, "+", "-", "."
+    if (!(isDigit(c) || (c >= 97 && c <= 122) || (c >= 65 && c <= 90) ||
+      c === 43 || c === 45 || c === 46)) return false;
+  }
+  if (colon === -1) return false;
+  return noReserved(s, colon + 1);
+}
+
+// The characters a URI cannot hold: C0 controls, space, DEL, and the rest of
+// Unicode whitespace. Asking for that set directly costs more than it looks:
+// `\s` pulls in the engine's Unicode machinery for eleven code points spread
+// across the BMP. Asking instead whether anything at all sits outside printable
+// ASCII is a one-byte character class, which the engine scans at its own speed
+// and which no ordinary URI ever trips. Only a string that does trip it pays
+// for the loop that decides the exact set, and that loop was measured slower
+// than the engine on the common case, which is why it is not the first answer.
+const NON_PRINTABLE = /[^\u0021-\u007e]/;
+
+function noReserved (s, from) {
+  if (!NON_PRINTABLE.test(s)) return true;
+  const n = s.length;
+  for (let i = from; i < n; i++) {
+    const c = s.charCodeAt(i);
+    if (c > 32 && c < 127) continue;
+    if (c <= 32 || c === 127) return false;
+    if (c === 160 || c === 5760 || (c >= 8192 && c <= 8202) || c === 8232 ||
+      c === 8233 || c === 8239 || c === 8287 || c === 12288 || c === 65279) return false;
+  }
+  return true;
+}
+
+// Source twin of noReserved, same two tiers. `from` is an expression for the
+// first index the loop reads; the variable names stay clear of the ones the
+// other format emitters use.
+function noReservedSource (v, from) {
+  return `if(/[^\\u0021-\\u007e]/.test(${v})){` +
+    `for(let _ri=${from};_ri<${v}.length;_ri++){const _rc=${v}.charCodeAt(_ri);` +
+    'if(_rc>32&&_rc<127)continue;' +
+    'if(_rc<=32||_rc===127)return false;' +
+    'if(_rc===160||_rc===5760||(_rc>=8192&&_rc<=8202)||_rc===8232||' +
+    '_rc===8233||_rc===8239||_rc===8287||_rc===12288||_rc===65279)return false}}';
+}
+
+// 8-4-4-4-12 hexadecimal digits. The four hyphens are read by index, then
+// each run of hex digits is read with fixed bounds, so no character pays for a
+// test of where it sits. A digit is one unsigned compare and a letter is one
+// more after folding case with a single OR, which is what a case-insensitive
+// regex spends a state machine on.
+function hexRun (s, from, to) {
+  for (let i = from; i < to; i++) {
+    const c = s.charCodeAt(i);
+    if (!((c - 48 >>> 0) < 10 || ((c | 32) - 97 >>> 0) < 6)) return false;
+  }
+  return true;
+}
+
+function uuid (s) {
+  if (s.length !== 36) return false;
+  if (s.charCodeAt(8) !== 45 || s.charCodeAt(13) !== 45 ||
+    s.charCodeAt(18) !== 45 || s.charCodeAt(23) !== 45) return false;
+  return hexRun(s, 0, 8) && hexRun(s, 9, 13) && hexRun(s, 14, 18) &&
+    hexRun(s, 19, 23) && hexRun(s, 24, 36);
+}
+
+// RFC 3339 full-time: HH:MM:SS, an optional fraction, an optional offset.
+// Every position is known in advance, so the check reads fixed indices and
+// compares digits as numbers instead of running a state machine over the
+// string. The zone letter is accepted in either case, which is what the
+// interpreter and the date-time check already did.
+function time (s) {
+  const n = s.length;
+  if (n < 8) return false;
+  const h1 = s.charCodeAt(0) - 48, h2 = s.charCodeAt(1) - 48;
+  if ((h1 >>> 0) > 9 || (h2 >>> 0) > 9 || h1 * 10 + h2 > 23) return false;
+  if (s.charCodeAt(2) !== 58 || s.charCodeAt(5) !== 58) return false;
+  const m1 = s.charCodeAt(3) - 48, m2 = s.charCodeAt(4) - 48;
+  if ((m1 >>> 0) > 5 || (m2 >>> 0) > 9) return false;
+  const c1 = s.charCodeAt(6) - 48, c2 = s.charCodeAt(7) - 48;
+  if ((c1 >>> 0) > 5 || (c2 >>> 0) > 9) return false;
+  let i = 8;
+  if (i < n && s.charCodeAt(i) === 46) {
+    i++;
+    const start = i;
+    while (i < n) {
+      const c = s.charCodeAt(i) - 48;
+      if ((c >>> 0) > 9) break;
+      i++;
+    }
+    if (i === start) return false;
+  }
+  if (i === n) return true;
+  const z = s.charCodeAt(i);
+  if (z === 90 || z === 122) return i === n - 1;
+  if (z !== 43 && z !== 45) return false;
+  if (n - i !== 6 || s.charCodeAt(i + 3) !== 58) return false;
+  for (let k = 1; k <= 5; k++) {
+    if (k === 3) continue;
+    if ((s.charCodeAt(i + k) - 48 >>> 0) > 9) return false;
+  }
+  return true;
+}
+
+// Anything without a control character or whitespace.
+function uriReference (s) {
+  return noReserved(s, 0);
+}
+
 // Source twins. `v` is the expression holding the string; when `isStr` is
 // false the check is wrapped in a typeof guard, matching FORMAT_CODEGEN's
 // convention. Each returns a statement that `return false`s on mismatch.
@@ -205,14 +337,24 @@ function dateSource (v, isStr) {
 }
 
 function dateTimeSource (v, isStr) {
-  return guard(v, isStr, `const _n=${v}.length;if(_n<20)return false;for(let _i=0;_i<19;_i++){const _c=${v}.charCodeAt(_i);if(_i===4||_i===7){if(_c!==45)return false;continue}if(_i===10){if(_c!==84&&_c!==116)return false;continue}if(_i===13||_i===16){if(_c!==58)return false;continue}if(_c<48||_c>57)return false}` +
-    `const _y=(${v}.charCodeAt(0)-48)*1000+(${v}.charCodeAt(1)-48)*100+(${v}.charCodeAt(2)-48)*10+(${v}.charCodeAt(3)-48);` +
-    `const _mo=(${v}.charCodeAt(5)-48)*10+(${v}.charCodeAt(6)-48);if(_mo<1||_mo>12)return false;` +
+  return guard(v, isStr, `const _n=${v}.length;if(_n<20)return false;` +
+    `if(${v}.charCodeAt(4)!==45||${v}.charCodeAt(7)!==45)return false;` +
+    `const _sep=${v}.charCodeAt(10);if(_sep!==84&&_sep!==116)return false;` +
+    `if(${v}.charCodeAt(13)!==58||${v}.charCodeAt(16)!==58)return false;` +
+    `const _y0=${v}.charCodeAt(0)-48,_y1=${v}.charCodeAt(1)-48,_y2=${v}.charCodeAt(2)-48,_y3=${v}.charCodeAt(3)-48;` +
+    'if((_y0>>>0)>9||(_y1>>>0)>9||(_y2>>>0)>9||(_y3>>>0)>9)return false;' +
+    'const _y=_y0*1000+_y1*100+_y2*10+_y3;' +
+    `const _mo0=${v}.charCodeAt(5)-48,_mo1=${v}.charCodeAt(6)-48;` +
+    'if((_mo0>>>0)>9||(_mo1>>>0)>9)return false;const _mo=_mo0*10+_mo1;if(_mo<1||_mo>12)return false;' +
     `const _dm=_mo===2?(((_y%4===0&&_y%100!==0)||_y%400===0)?29:28):(_mo===4||_mo===6||_mo===9||_mo===11?30:31);` +
-    `const _d=(${v}.charCodeAt(8)-48)*10+(${v}.charCodeAt(9)-48);if(_d<1||_d>_dm)return false;` +
-    `if((${v}.charCodeAt(11)-48)*10+(${v}.charCodeAt(12)-48)>23)return false;` +
-    `if((${v}.charCodeAt(14)-48)*10+(${v}.charCodeAt(15)-48)>59)return false;` +
-    `if((${v}.charCodeAt(17)-48)*10+(${v}.charCodeAt(18)-48)>59)return false;` +
+    `const _d0=${v}.charCodeAt(8)-48,_d1=${v}.charCodeAt(9)-48;` +
+    'if((_d0>>>0)>9||(_d1>>>0)>9)return false;const _d=_d0*10+_d1;if(_d<1||_d>_dm)return false;' +
+    `const _h0=${v}.charCodeAt(11)-48,_h1=${v}.charCodeAt(12)-48;` +
+    'if((_h0>>>0)>9||(_h1>>>0)>9||_h0*10+_h1>23)return false;' +
+    `const _mi0=${v}.charCodeAt(14)-48,_mi1=${v}.charCodeAt(15)-48;` +
+    'if((_mi0>>>0)>5||(_mi1>>>0)>9)return false;' +
+    `const _se0=${v}.charCodeAt(17)-48,_se1=${v}.charCodeAt(18)-48;` +
+    'if((_se0>>>0)>5||(_se1>>>0)>9)return false;' +
     `let _i2=19;if(${v}.charCodeAt(19)===46){_i2=20;const _st=_i2;while(_i2<_n){const _c2=${v}.charCodeAt(_i2);if(_c2<48||_c2>57)break;_i2++}if(_i2===_st)return false}` +
     `const _tz=${v}.charCodeAt(_i2);` +
     `if(_tz===90||_tz===122){if(_i2!==_n-1)return false}` +
@@ -234,6 +376,45 @@ function hostnameSource (v, isStr) {
     `if(_ll===0||_pv===45)return false`);
 }
 
+function uuidSource (v, isStr) {
+  const run = (from, to) => `for(let _ui=${from};_ui<${to};_ui++){const _uc=${v}.charCodeAt(_ui);` +
+    'if(!((_uc-48>>>0)<10||((_uc|32)-97>>>0)<6))return false}';
+  return guard(v, isStr, `if(${v}.length!==36)return false;` +
+    `if(${v}.charCodeAt(8)!==45||${v}.charCodeAt(13)!==45||` +
+    `${v}.charCodeAt(18)!==45||${v}.charCodeAt(23)!==45)return false;` +
+    run(0, 8) + run(9, 13) + run(14, 18) + run(19, 23) + run(24, 36));
+}
+
+function timeSource (v, isStr) {
+  return guard(v, isStr, `const _n=${v}.length;if(_n<8)return false;` +
+    `const _h1=${v}.charCodeAt(0)-48,_h2=${v}.charCodeAt(1)-48;` +
+    'if((_h1>>>0)>9||(_h2>>>0)>9||_h1*10+_h2>23)return false;' +
+    `if(${v}.charCodeAt(2)!==58||${v}.charCodeAt(5)!==58)return false;` +
+    `const _m1=${v}.charCodeAt(3)-48,_m2=${v}.charCodeAt(4)-48;` +
+    'if((_m1>>>0)>5||(_m2>>>0)>9)return false;' +
+    `const _s1=${v}.charCodeAt(6)-48,_s2=${v}.charCodeAt(7)-48;` +
+    'if((_s1>>>0)>5||(_s2>>>0)>9)return false;' +
+    `let _ti=8;if(_ti<_n&&${v}.charCodeAt(_ti)===46){_ti++;const _tf=_ti;` +
+    `while(_ti<_n){const _tc=${v}.charCodeAt(_ti)-48;if((_tc>>>0)>9)break;_ti++}` +
+    'if(_ti===_tf)return false}' +
+    'if(_ti!==_n){' +
+    `const _tz=${v}.charCodeAt(_ti);` +
+    'if(_tz===90||_tz===122){if(_ti!==_n-1)return false}' +
+    'else{if(_tz!==43&&_tz!==45)return false;' +
+    `if(_n-_ti!==6||${v}.charCodeAt(_ti+3)!==58)return false;` +
+    `if((${v}.charCodeAt(_ti+1)-48>>>0)>9||(${v}.charCodeAt(_ti+2)-48>>>0)>9||` +
+    `(${v}.charCodeAt(_ti+4)-48>>>0)>9||(${v}.charCodeAt(_ti+5)-48>>>0)>9)return false}}`);
+}
+
+function uriSource (v, isStr) {
+  return guard(v, isStr, `const _n=${v}.length;if(_n===0)return false;` +
+    `const _f=${v}.charCodeAt(0);if(!((_f>=97&&_f<=122)||(_f>=65&&_f<=90)))return false;` +
+    `let _co=-1;for(let _i=1;_i<_n;_i++){const _c=${v}.charCodeAt(_i);if(_c===58){_co=_i;break}` +
+    `if(!((_c>=48&&_c<=57)||(_c>=97&&_c<=122)||(_c>=65&&_c<=90)||_c===43||_c===45||_c===46))return false}` +
+    `if(_co===-1)return false;` +
+    noReservedSource(v, '_co+1'));
+}
+
 function ipv6Source (v, isStr) {
   return guard(v, isStr, `const _n=${v}.length;if(_n<2||_n>45)return false;let _end=_n,_g=0;` +
     `const _dot=${v}.indexOf('.');` +
@@ -259,4 +440,4 @@ function ipv4Source (v, isStr) {
   return guard(v, isStr, `const _n=${v}.length;if(_n<7||_n>15)return false;let _o=0,_val=0,_dg=0;for(let _i=0;_i<=_n;_i++){const _c=_i<_n?${v}.charCodeAt(_i):46;if(_c===46){if(_dg===0||_val>255)return false;_o++;_val=0;_dg=0;if(_o>4)return false}else if(_c>=48&&_c<=57){if(_dg===1&&_val===0)return false;_val=_val*10+(_c-48);_dg++;if(_dg>3)return false}else return false}if(_o!==4)return false`);
 }
 
-module.exports = { date, ipv4, dateTime, ipv6, hostname, dateSource, ipv4Source, dateTimeSource, ipv6Source, hostnameSource };
+module.exports = { date, ipv4, dateTime, ipv6, hostname, uri, uriReference, uuid, time, noReserved, dateSource, ipv4Source, dateTimeSource, ipv6Source, hostnameSource, uriSource, uuidSource, timeSource, noReservedSource };

package/lib/interpreter.js

@@ -252,11 +252,11 @@ const FORMAT_CHECKS = {
   email: (s) => { const at = s.indexOf('@'); return at > 0 && at < s.length - 1 && s.indexOf('.', at) > at + 1; },
   date: _formats.date,
   'date-time': _formats.dateTime,
-  time: (s) => /^([01]\d|2[0-3]):[0-5]\d:[0-5]\d(\.\d+)?([Zz]|[+-]\d{2}:\d{2})?$/.test(s),
+  time: _formats.time,
   duration: (s) => /^P(?:\d+Y)?(?:\d+M)?(?:\d+W)?(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+(?:\.\d+)?S)?)?$/.test(s) && s !== 'P' && !s.endsWith('T'),
-  uuid: (s) => s.length === 36 && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(s),
-  uri: (s) => /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(s) && !/[\s\u0000-\u001f\u007f]/.test(s),
-  'uri-reference': (s) => !/[\s\u0000-\u001f\u007f]/.test(s),
+  uuid: _formats.uuid,
+  uri: _formats.uri,
+  'uri-reference': _formats.uriReference,
   ipv4: _formats.ipv4,
   ipv6: _formats.ipv6,
   hostname: _formats.hostname,

package/lib/js-compiler.js

@@ -762,7 +762,7 @@ const _formats = require('./formats')
 const FORMAT_CHECKS = {
   email: (s) => { const at = s.indexOf('@'); return at > 0 && at < s.length - 1 && s.indexOf('.', at) > at + 1 },
   date: _formats.date,
-  uuid: (s) => s.length === 36 && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(s),
+  uuid: _formats.uuid,
   ipv4: _formats.ipv4,
   hostname: _formats.hostname,
 }
@@ -2967,22 +2967,16 @@ const FORMAT_CODEGEN = {
       : `if(typeof ${v}==='string'){const _at=${v}.indexOf('@');if(_at<=0||_at>=${v}.length-1||${v}.indexOf('.',_at)<=_at+1)return false}`
   },
   date: _formats.dateSource,
-  uuid: (v, isStr) => isStr
-    ? `if(${v}.length!==36||!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(${v}))return false`
-    : `if(typeof ${v}==='string'&&(${v}.length!==36||!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(${v})))return false`,
+  uuid: _formats.uuidSource,
   'date-time': _formats.dateTimeSource,
-  time: (v, isStr) => isStr
-    ? `if(!/^([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})?$/.test(${v}))return false`
-    : `if(typeof ${v}==='string'&&!/^([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})?$/.test(${v}))return false`,
+  time: _formats.timeSource,
   duration: (v, isStr) => isStr
     ? `if(!/^P(?:\\d+Y)?(?:\\d+M)?(?:\\d+W)?(?:\\d+D)?(?:T(?:\\d+H)?(?:\\d+M)?(?:\\d+(?:\\.\\d+)?S)?)?$/.test(${v})||${v}==='P'||${v}.endsWith('T'))return false`
     : `if(typeof ${v}==='string'&&(!/^P(?:\\d+Y)?(?:\\d+M)?(?:\\d+W)?(?:\\d+D)?(?:T(?:\\d+H)?(?:\\d+M)?(?:\\d+(?:\\.\\d+)?S)?)?$/.test(${v})||${v}==='P'||${v}.endsWith('T')))return false`,
-  uri: (v, isStr) => isStr
-    ? `if(!/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(${v})||/[\\s\\u0000-\\u001f\\u007f]/.test(${v}))return false`
-    : `if(typeof ${v}==='string'&&(!/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(${v})||/[\\s\\u0000-\\u001f\\u007f]/.test(${v})))return false`,
+  uri: _formats.uriSource,
   'uri-reference': (v, isStr) => isStr
-    ? `if(/[\\s\\u0000-\\u001f\\u007f]/.test(${v}))return false`
-    : `if(typeof ${v}==='string'&&/[\\s\\u0000-\\u001f\\u007f]/.test(${v}))return false`,
+    ? `{${_formats.noReservedSource(v, '0')}}`
+    : `if(typeof ${v}==='string'){${_formats.noReservedSource(v, '0')}}`,
   ipv4: _formats.ipv4Source,
   ipv6: _formats.ipv6Source,
   hostname: _formats.hostnameSource,

package/lib/version.js

@@ -7,4 +7,4 @@
 //
 // Kept in lockstep with package.json by `tests/test_version_sync.js`.
 
-module.exports = '1.11.0';
+module.exports = '1.12.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "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",
@@ -112,13 +112,13 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.11.0",
-    "@ata-validator/native-darwin-x64": "1.11.0",
-    "@ata-validator/native-linux-x64-gnu": "1.11.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.11.0",
-    "@ata-validator/native-linux-x64-musl": "1.11.0",
-    "@ata-validator/native-linux-arm64-musl": "1.11.0",
-    "@ata-validator/native-win32-x64": "1.11.0"
+    "@ata-validator/native-darwin-arm64": "1.12.0",
+    "@ata-validator/native-darwin-x64": "1.12.0",
+    "@ata-validator/native-linux-x64-gnu": "1.12.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.12.0",
+    "@ata-validator/native-linux-x64-musl": "1.12.0",
+    "@ata-validator/native-linux-arm64-musl": "1.12.0",
+    "@ata-validator/native-win32-x64": "1.12.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"