ata-validator 0.18.2 → 0.21.0

package/index.js

@@ -1,7 +1,8 @@
 // Native addon: optional. Core validate() uses JS codegen and works without it.
 // Buffer APIs (isValid, countValid, isValidParallel) require native.
-let native;
-try { native = require("pkg-prebuilds")(__dirname, require("./binding-options")); } catch {}
+// Loading is delegated so this file stays free of `pkg-prebuilds`/`__dirname`/
+// `path` (the browser entry must not pull those in via the bundler).
+const native = require("./lib/native-load")();
 const {
   compileToJS,
   compileToJSCodegen,
@@ -287,45 +288,11 @@ const ABORT_EARLY_RESULT = Object.freeze({
   })]),
 });
 
-// Embedded verbatim in standalone modules so the output file has no runtime
-// dependency on ata-validator. ASCII fast-path plus surrogate-aware slow path.
-const _CP_LEN_SOURCE = `function _cpLen(s) {
-  const len = s.length;
-  for (let i = 0; i < len; i++) {
-    if (s.charCodeAt(i) >= 0xD800 && s.charCodeAt(i) <= 0xDBFF) {
-      let n = 0; for (const _ of s) n++; return n;
-    }
-  }
-  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.
-// Lazy so merely importing ata never touches the filesystem. Bundlers that stub
-// `fs`/`path` for the browser would otherwise crash at module load; the read is
-// deferred to the first standalone compile that actually embeds the engine.
-let _safeRegexEmbed = null;
-function getSafeRegexEmbed() {
-  if (_safeRegexEmbed === null) {
-    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");
-    _safeRegexEmbed = body.trimEnd() + "\nconst __ataSafeRe = compileSafe;";
-  }
-  return _safeRegexEmbed;
-}
-
-// 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) ? getSafeRegexEmbed() + "\n" : "";
-}
+// `_CP_LEN_SOURCE`, the safe-regex embed, and the AOT helpers that consume them
+// now live in `lib/aot.js` — keeping this file free of `fs`/`path`/`__dirname`
+// references so a default import never touches disk. The instance and static
+// AOT methods further down lazily require `./lib/aot`, so they pay nothing
+// until a user calls `toStandaloneModule`/`bundleStandalone`/etc.
 
 // 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.
@@ -1097,6 +1064,44 @@ class Validator {
       };
     }
 
+    // Custom error messages: if any subschema declares an `errorMessage`
+    // keyword, install an outermost decorator that overrides the `message`
+    // field of the errors it owns. Gated on a one-time scan so schemas without
+    // errorMessage keep the validate hot path untouched. Layered after rich
+    // enrichment so `code`/`keyword`/`path` are already final and only the
+    // human-facing message changes.
+    {
+      const emLib = require('./lib/error-messages');
+      const schemaStr = this._schemaStr || (this._schemaObj ? JSON.stringify(this._schemaObj) : '');
+      if (emLib.schemaHasErrorMessages(schemaStr)) {
+        const root = this._schemaObj;
+        const wrap = (inner) => (arg) => {
+          const result = inner(arg);
+          if (result && result.valid === false && result.errors && result.errors.length && result !== ABORT_EARLY_RESULT) {
+            const overridden = emLib.applyErrorMessages(result.errors, root);
+            if (overridden !== result.errors) return { valid: false, errors: overridden };
+          }
+          return result;
+        };
+        if (this.validate) this.validate = wrap(this.validate);
+        if (this.validateJSON) this.validateJSON = wrap(this.validateJSON);
+        // validateAndParse routes through self.validate on the codegen path, but
+        // the native-only path returns directly from the addon — wrap it so both
+        // paths get overrides. The result shape carries `value`, preserved here.
+        if (this.validateAndParse) {
+          const innerVP = this.validateAndParse;
+          this.validateAndParse = (arg) => {
+            const result = innerVP(arg);
+            if (result && result.valid === false && result.errors && result.errors.length) {
+              const overridden = emLib.applyErrorMessages(result.errors, root);
+              if (overridden !== result.errors) return { valid: false, value: result.value, errors: overridden };
+            }
+            return result;
+          };
+        }
+      }
+    }
+
     // Save to identity cache for ultra-fast reuse with same schema object
     if (this._schemaObj && typeof this._schemaObj === 'object') {
       _identityCache.set(this._schemaObj, this);
@@ -1160,157 +1165,18 @@ class Validator {
     }
   }
 
-  // --- Standalone pre-compilation ---
-  // Generate a JS module string that can be written to a file.
-  // On next startup, load with Validator.fromStandalone() -- zero compile time.
+  // --- AOT pre-compilation ---
+  // The bodies of `toStandalone` and `toStandaloneModule` live in `lib/aot.js`
+  // so this entry stays free of `fs`/`path`/`__dirname`. The lazy require runs
+  // only on first call, never during a plain `import 'ata-validator'`. Browser
+  // bundlers swap `lib/aot.js` with `lib/aot.browser.js`, which throws a
+  // pointed error instead of attempting to read source from disk.
   toStandalone() {
-    this._ensureCompiled();
-    const jsFn = this._jsFn;
-    if (!jsFn || !jsFn._source) return null;
-    const src = jsFn._source;
-    const hybridSrc = jsFn._hybridSource || "";
-    const preambleSrc = jsFn._preambleSource || "";
-
-    // Also capture error function source for zero-compile standalone load
-    const jsErrFn = compileToJSCodegenWithErrors(
-      typeof this._schemaObj === "object" ? this._schemaObj : {},
-    );
-    const errSrc = jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : "";
-
-    return `// Auto-generated by ata-validator — do not edit
-'use strict';
-${_CP_LEN_SOURCE}
-${safeRePrelude(jsFn, jsErrFn)}${preambleSrc}
-const boolFn = function(d) {
-  ${src}
-};
-const hybridFactory = function(R, E) {
-  return function(d) {
-    ${hybridSrc}
-  };
-};
-${errSrc ? `const errFn = function(d, _all) {\n  ${errSrc}\n};` : "const errFn = null;"}
-module.exports = { boolFn, hybridFactory, errFn };
-`;
+    return require('./lib/aot').toStandalone(this);
   }
 
-  // --- Fully standalone module ---
-  // Generates a self-contained module that can be imported directly without
-  // pulling in ata-validator at runtime. Browser bundle gets only the
-  // generated validator (~2 KB typical) instead of the 165 KB compiler.
-  //
-  //   import { validate, isValid } from './user-validator.mjs'
-  //   if (isValid(data)) { ... }
-  //
-  // format: 'esm' | 'cjs'. Default 'esm'.
-  // abortEarly: if true, invalid result is a shared stub; smaller output.
   toStandaloneModule(opts) {
-    this._ensureCompiled();
-    const jsFn = this._jsFn;
-    if (!jsFn || !jsFn._source) return null;
-    const format = (opts && opts.format) || 'esm';
-    const abortEarly = !!(opts && opts.abortEarly);
-    const source = !!(opts && opts.source);
-    const sourceMap = opts && opts.sourceMap ? opts.sourceMap : null;
-    const schemaFile = opts && opts.schemaFile ? opts.schemaFile : null;
-    const src = jsFn._source;
-
-    let errCore = '';
-    let jsErrFn = null;
-    if (!abortEarly) {
-      jsErrFn = compileToJSCodegenWithErrors(
-        typeof this._schemaObj === 'object' ? this._schemaObj : {},
-        null,
-        this._userFormats,
-        (source && sourceMap && schemaFile) ? { sourceMap, schemaFile } : null,
-      );
-      const errSrc = jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : '';
-      if (errSrc) {
-        errCore = `const errFn = function(d, _all) {\n  ${errSrc}\n};\n`;
-      }
-    }
-
-    // Schema-source frames are baked as literals inside each emitted error so
-    // consumers don't need a runtime lookup. We still expose the schema file
-    // as a sentinel constant when --source is on — handy for introspection
-    // and visible in source graphs. With --no-source, the constant is omitted
-    // entirely so size budgets and grep-based "is this source-mapped?" checks
-    // both work.
-    const schemaSourceConst = (source && schemaFile)
-      ? `const __ATA_SCHEMA_SOURCE__ = ${JSON.stringify({ file: schemaFile })};\n`
-      : '';
-
-    // Serialize closure vars referenced in _fn body: regex, sub-validators, sets.
-    let closureDecls = '';
-    if (jsFn._closures && jsFn._closures.length > 0) {
-      const lines = [];
-      for (const { name, val } of jsFn._closures) {
-        if (Array.isArray(val)) {
-          lines.push(`const ${name} = ${JSON.stringify(val)};`);
-          continue;
-        }
-        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) {
-          lines.push(`const ${name} = new Set(${JSON.stringify([...val])});`);
-        } else if (typeof val === 'function') {
-          // new Function('_ppv', body) — extract body from toString()
-          const str = val.toString();
-          // Matches: "function anonymous(_ppv\n) {\nbody\n}" or "function(_ppv){body}"
-          const m = str.match(/^function[^(]*\([^)]*\)\s*\{([\s\S]*)\}$/)
-          const body = m ? m[1].trim() : str;
-          lines.push(`const ${name} = function(_ppv) { ${body} };`);
-        }
-      }
-      if (lines.length) closureDecls = lines.join('\n') + '\n';
-    }
-
-    // Hoisted oneOf/anyOf branch checks live in the boolean fn's preamble (the
-    // runtime emits them before the function). The standalone module must declare
-    // 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';
-
-    const exports = format === 'esm'
-      ? `export { validate, isValid };\nexport default { validate, isValid };\n`
-      : `module.exports = { validate, isValid };\nmodule.exports.default = module.exports;\n`;
-
-    return `// Auto-generated by ata-validator — do not edit.
-// Schema is embedded; runtime has zero dependency on ata-validator.
-'use strict';
-${_CP_LEN_SOURCE}
-${safeRePrelude(jsFn, jsErrFn)}${schemaSourceConst}const VALID = Object.freeze({ valid: true, errors: Object.freeze([]) });
-const ABORT = Object.freeze({
-  valid: false,
-  errors: Object.freeze([Object.freeze({
-    code: 'ATA9000',
-    message: 'validation failed',
-    keyword: '__abort_early__',
-    path: '',
-  })]),
-});
-${closureDecls}${preambleDecls}${formatDecls}const _fn = function(d) {
-  ${src}
-};
-${errCore}function isValid(data) { return _fn(data); }
-function validate(data) { ${validBody}; }
-${exports}`;
+    return require('./lib/aot').toStandaloneModule(this, opts);
   }
 
   // Load a pre-compiled standalone module. Zero schema compilation.
@@ -1494,202 +1360,65 @@ function validate(schema, data) {
   return v.validate(data);
 }
 
+// Async validation for schemas built with `t.refine(...)`. Structural
+// validation runs synchronously first; refinements are awaited only when the
+// value is structurally valid (a refinement body may assume the right shape).
+// Accepts a schema literal or an existing Validator instance plus its schema.
+// Returns a Promise<ValidationResult>.
+async function validateAsync(schemaOrValidator, data) {
+  const refineLib = require('./lib/refine');
+  let validator, schema;
+  if (schemaOrValidator instanceof Validator) {
+    validator = schemaOrValidator;
+    schema = validator._schemaObj;
+  } else {
+    schema = schemaOrValidator;
+    validator = new Validator(schema);
+  }
+  const structural = validator.validate(data);
+  if (!structural.valid) return structural;
+  const refinements = refineLib.getRefinements(schema);
+  if (!refinements) return structural;
+  const issues = await refineLib.runRefinements(refinements, structural.data !== undefined ? structural.data : data);
+  if (issues.length) return { valid: false, errors: issues };
+  return structural;
+}
+
+// parseAsync resolves to the validated data, or rejects with an Error whose
+// `.errors` carries the ValidationError list. Mirrors the parse/validate split
+// used by Zod-style callers.
+async function parseAsync(schemaOrValidator, data) {
+  const result = await validateAsync(schemaOrValidator, data);
+  if (result.valid) return result.data !== undefined ? result.data : data;
+  const err = new Error('ata: async validation failed');
+  err.errors = result.errors;
+  throw err;
+}
+
 function version() {
   if (native) return native.version();
-  try { return require("./package.json").version; } catch { return "unknown"; }
+  try { return require("./lib/version"); } catch { return "unknown"; }
 }
 
-// Bundle multiple validators into a single JS file for fast startup.
-// Usage:
-//   const bundle = Validator.bundle([schema1, schema2, ...]);
-//   fs.writeFileSync('validators.js', bundle);
-//   // On startup:
-//   const validators = Validator.loadBundle(require('./validators.js'), [schema1, schema2, ...]);
+// Static AOT entry points are thin lazy-loaders into `lib/aot.js`. The
+// implementation files (and the `fs`/`path` reads they perform) only enter
+// the process when one of these is actually called. See `lib/aot.js` for the
+// generated module shapes; browser bundles get `lib/aot.browser.js` (a stub
+// that throws) via the package.json `browser` field.
 Validator.bundle = function (schemas, opts) {
-  const parts = schemas.map((schema) => {
-    const v = new Validator(schema, opts);
-    const standalone = v.toStandalone();
-    if (!standalone) return "null";
-    return (
-      "(function(){" +
-      standalone
-        .replace("'use strict';", "")
-        .replace("module.exports = ", "return ") +
-      "})()"
-    );
-  });
-  return "'use strict';\nmodule.exports = [\n" + parts.join(",\n") + "\n];\n";
+  return require('./lib/aot').bundle(Validator, schemas, opts);
 };
 
-// Zero-dependency self-contained bundle — no require('ata-validator') needed at runtime.
-// opts.format: 'cjs' (default) or 'esm'.
-// opts.formats: { name: fn } — embedded in the output via Function#toString.
 Validator.bundleStandalone = function (schemas, opts) {
-  // Cross-schema $ref resolution: only meaningful when at least one schema has
-  // an $id. Skip the schemas-as-map plumbing when none of them do.
-  const haveIds = schemas.some((s) => s && typeof s === 'object' && s.$id);
-  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();
-    const jsFn = v._jsFn;
-    if (!jsFn || !jsFn._hybridSource) return "null";
-    const jsErrFn = compileToJSCodegenWithErrors(
-      typeof schema === "string" ? JSON.parse(schema) : schema,
-      v._schemaMap,
-      v._userFormats,
-    );
-    if (jsFn._usesSafeRe || (jsErrFn && jsErrFn._usesSafeRe)) bundleUsesSafeRe = true;
-    const errBody =
-      jsErrFn && jsErrFn._errSource
-        ? jsErrFn._errSource
-        : "return{valid:false,errors:[{code:'error',path:'',message:'validation failed'}]}";
-    // Serialize custom format closures so the bundle has no runtime dep on ata.
-    let preamble = '';
-    if (jsFn._formatClosures) {
-      preamble = jsFn._formatClosures
-        .map(({ name, fn }) => `var ${name}=${fn.toString()};`)
-        .join('\n');
-    }
-    // Include hoisted anyOf/oneOf branch helpers (e.g. `_af1_b0`) so the
-    // bundle output is self-contained. `toStandalone` emits this same source
-    // for single-schema standalone output.
-    if (jsFn._preambleSource) {
-      preamble = preamble ? `${preamble}\n${jsFn._preambleSource}` : jsFn._preambleSource;
-    }
-    if (opts && opts.verbose) {
-      // Embed the schema and a small resolver so errors carry parentSchema.
-      const schemaLit = JSON.stringify(typeof schema === 'string' ? JSON.parse(schema) : schema);
-      return `(function(R){${preamble}var _S=${schemaLit};function _PS(p){if(!p||p[0]!=='#')return undefined;var s=p.slice(1);if(!s)return _S;var ps=s.split('/').filter(Boolean).map(function(x){return x.replace(/~1/g,'/').replace(/~0/g,'~')});var t=_S;for(var i=0;i<ps.length-1;i++){if(t==null||typeof t!=='object')return undefined;t=t[ps[i]]}return t}var E=function(d){var _all=true;${errBody}};var _v=function(d){${jsFn._hybridSource}};return function(d){var r=_v(d);if(r&&r.valid===false&&r.errors){var es=[];for(var i=0;i<r.errors.length;i++){var e=r.errors[i];es.push(Object.assign({},e,{parentSchema:_PS(e.schemaPath)}))}return{valid:false,errors:es}}return r}})(R)`;
-    }
-    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 ? getSafeRegexEmbed() + "\n" : "";
-  if (format === 'esm') {
-    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';\n${safeEmbed}var R=${R};\nmodule.exports=[${fns.join(",")}];\n`;
+  return require('./lib/aot').bundleStandalone(Validator, schemas, opts);
 };
 
-// Compact bundle: deduplicated code. Shared template functions + per-schema params.
-// Much smaller file → faster V8 parse → faster startup.
-// opts.format: 'cjs' (default) or 'esm'.
 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);
-    v._ensureCompiled();
-    const jsFn = v._jsFn;
-    if (!jsFn || !jsFn._hybridSource) return null;
-    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.
-    const hybrid = jsFn._preambleSource
-      ? `${jsFn._preambleSource}\n${jsFn._hybridSource}`
-      : jsFn._hybridSource;
-    return {
-      hybrid,
-      err: jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : null,
-      fmt: jsFn._formatClosures || null,
-    };
-  });
-
-  // Deduplicate function bodies — many schemas produce identical or near-identical code
-  const bodyMap = new Map(); // body → index
-  const bodies = [];
-  const errMap = new Map();
-  const errBodies = [];
-
-  const indices = entries.map((e) => {
-    if (!e) return [-1, -1];
-    let hi = bodyMap.get(e.hybrid);
-    if (hi === undefined) {
-      hi = bodies.length;
-      bodies.push(e.hybrid);
-      bodyMap.set(e.hybrid, hi);
-    }
-    let ei = -1;
-    if (e.err) {
-      ei = errMap.get(e.err);
-      if (ei === undefined) {
-        ei = errBodies.length;
-        errBodies.push(e.err);
-        errMap.set(e.err, ei);
-      }
-    }
-    return [hi, ei];
-  });
-
-  // Generate compact bundle
-  const isEsm = format === 'esm';
-  let out = isEsm
-    ? "// Auto-generated by ata-validator — do not edit\n"
-    : "'use strict';\n";
-  if (bundleUsesSafeRe) out += getSafeRegexEmbed() + "\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
-    .map((b) => `function(R,E){return function(d){${b}}}`)
-    .join(",\n");
-  out += "\n];\n";
-
-  // Shared error functions
-  out += `${declKW} EF=[\n`;
-  out += errBodies.map((b) => `function(d){var _all=true;${b}}`).join(",\n");
-  out += "\n];\n";
-
-  // Build validators from shared templates
-  const arrBody = indices
-    .map(([hi, ei]) => {
-      if (hi < 0) return "null";
-      if (ei >= 0) return `H[${hi}](R,EF[${ei}])`;
-      return `H[${hi}](R,function(){return{valid:false,errors:[]}})`;
-    })
-    .join(",");
-  if (isEsm) {
-    out += `const validators=[${arrBody}];\nexport default validators;\nexport { validators };\n`;
-  } else {
-    out += `module.exports=[${arrBody}];\n`;
-  }
-
-  return out;
+  return require('./lib/aot').bundleCompact(Validator, schemas, opts);
 };
 
 Validator.loadBundle = function (mods, schemas, opts) {
-  return schemas.map((schema, i) => {
-    if (mods[i]) return Validator.fromStandalone(mods[i], schema, opts);
-    return new Validator(schema, opts);
-  });
+  return require('./lib/aot').loadBundle(Validator, mods, schemas, opts);
 };
 
 const parseJSON = native ? native.parseJSON : JSON.parse;
@@ -1764,6 +1493,8 @@ module.exports = {
   Validator,
   compile,
   validate,
+  validateAsync,
+  parseAsync,
   version,
   createPaddedBuffer,
   SIMDJSON_PADDING,

package/index.mjs

@@ -1,3 +1,3 @@
 import mod from './index.js';
-export const { Validator, validate, version, createPaddedBuffer, SIMDJSON_PADDING, defineSchema, renderPretty, renderCompact, renderJSON } = mod;
+export const { Validator, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, defineSchema, renderPretty, renderCompact, renderJSON } = mod;
 export default mod;

package/lib/aot-build.js

@@ -231,4 +231,33 @@ async function watch(opts, onReport) {
   };
 }
 
-module.exports = { build, expandGlobs, parseSchemaFile, outputPathFor, watch };
+// AOT primitives also surface here so consumers can do
+//   import { bundleStandalone, toStandaloneModule, bundleCompact } from 'ata-validator/build'
+// without poking at the Validator class. The Validator-bound forms (Validator.bundleStandalone,
+// validator.toStandaloneModule) remain available from the default entry; this is the
+// programmatic alias for code that wants the build surface in one place.
+const aot = require('./aot');
+
+function bundleStandalone(schemas, opts) {
+  return aot.bundleStandalone(Validator, schemas, opts);
+}
+
+function bundleCompact(schemas, opts) {
+  return aot.bundleCompact(Validator, schemas, opts);
+}
+
+function toStandaloneModule(schema, opts) {
+  const v = schema instanceof Validator ? schema : new Validator(schema, opts);
+  return aot.toStandaloneModule(v, opts);
+}
+
+module.exports = {
+  build,
+  expandGlobs,
+  parseSchemaFile,
+  outputPathFor,
+  watch,
+  bundleStandalone,
+  bundleCompact,
+  toStandaloneModule,
+};