ata-validator 0.18.2 → 0.20.0

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 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.20.0 - 2026-05-27
+
+### Added
+
+- New chainable schema builder at `ata-validator/t`. Each `t.X(...)` returns a plain JSON Schema literal, so the output drops straight into `new Validator(...)`, `defineSchema`, `Infer<S>`, and the AOT pipeline with no adapter. The migration target is TypeBox: rename `import { Type } from '@sinclair/typebox'` to `import { t } from 'ata-validator/t'` and keep the same authoring shape while picking up ata's runtime and AOT precompile.
+
+  ```ts
+  import { t } from 'ata-validator/t'
+  import { Validator, type Infer } from 'ata-validator'
+
+  const User = t.object({
+    id: t.integer(),
+    name: t.string({ minLength: 1 }),
+    email: t.optional(t.string({ format: 'email' })),
+    role: t.union([t.literal('admin'), t.literal('user')]),
+  })
+  type User = Infer<typeof User>
+  const v = new Validator(User)
+  ```
+
+  Covered: primitives (`string`, `number`, `integer`, `boolean`, `null`), composites (`object` with `optional` keys, `array`, `tuple`, `record`, `union`, `intersect`, `literal`, `const`, `enum`), and refs (`ref`). Optionality is carried by a Symbol-keyed marker that the emitted JSON Schema, `Object.keys`, `JSON.stringify`, and ata's codegen never see; the parent `t.object` reads it to compute `required`.
+
+### Changed
+
+- `Infer<S>` now resolves object schemas without `properties` but with a schema-valued `additionalProperties` to `Record<string, V>` instead of `Record<string, unknown>`. Closes the last common JSON Schema shape that was not inferred.
+
+## 0.19.0 - 2026-05-27
+
+### Added
+
+- `ata-validator/build` now exports the AOT primitives `bundleStandalone`, `bundleCompact`, and `toStandaloneModule` as named functions, so callers that want the build surface in one place (bundler plugins, build scripts) no longer have to go through the `Validator` class. Same code paths as the Validator-bound forms, no behaviour difference.
+- New top-level `ARCHITECTURE.md` reference document covering design principles, runtime dispatch, AOT pipeline, error enrichment, the two TypeScript paths, and the native layer.
+
+### Changed
+
+- Internal refactor: AOT (`toStandalone`, `toStandaloneModule`, `bundle`, `bundleStandalone`, `bundleCompact`, `loadBundle`) lives in `lib/aot.js`, the native addon loader in `lib/native-load.js`, the version string in `lib/version.js`. `index.js` lazy-requires the AOT module so a plain import never pays for code it does not call. The browser bundle drops `pkg-prebuilds`, `__dirname`, and `package.json` (with its dependency strings) entirely; it is roughly 15 KB smaller and contains no Node-only identifiers outside comments.
+- The safe-regex engine is now embedded into standalone output from a baked string (`lib/safe-regex-source.js`, generated from `lib/safe-regex.js`) instead of a runtime `fs.readFileSync`. Browser AOT calls (`Validator.bundle`, `toStandaloneModule`, …) work in any bundler without an fs polyfill. A structural test (`tests/test_browser_imports_guard.js`) bundles both entries with esbuild and asserts no `readFileSync`, `pkg-prebuilds`, or `__dirname` survives outside comments; sync tests catch drift between the bundled strings and their sources.
+
 ## 0.18.2 - 2026-05-26
 
 ### Fixed

package/build.d.ts

@@ -67,3 +67,31 @@ export interface WatchHandle {
   close(): void;
 }
 export function watch(opts: BuildOptions, onReport?: (r: BuildReport) => void): Promise<WatchHandle>;
+
+// --- AOT primitives ---
+// Programmatic counterparts to `Validator.bundleStandalone` / `bundleCompact`
+// and `validator.toStandaloneModule`. Kept here so callers that only want the
+// build surface (e.g. a bundler plugin) don't have to import the full runtime.
+
+export interface BundleStandaloneOptions {
+  format?: 'cjs' | 'esm';
+  formats?: Record<string, (value: unknown) => boolean>;
+  verbose?: boolean;
+}
+
+export interface ToStandaloneModuleOptions {
+  format?: 'cjs' | 'esm';
+  abortEarly?: boolean;
+  source?: boolean;
+  sourceMap?: unknown;
+  schemaFile?: string;
+}
+
+/** Bundle multiple schemas into one self-contained module (no ata-validator runtime). */
+export function bundleStandalone(schemas: unknown[], options?: BundleStandaloneOptions): string;
+
+/** Like {@link bundleStandalone} but deduplicates shared bodies for smaller output. */
+export function bundleCompact(schemas: unknown[], options?: BundleStandaloneOptions): string;
+
+/** Emit a self-contained `validate`/`isValid` module string for a single schema. */
+export function toStandaloneModule(schema: unknown, options?: ToStandaloneModuleOptions): string | null;

package/build.mjs

@@ -5,4 +5,7 @@ export const expandGlobs = mod.expandGlobs;
 export const parseSchemaFile = mod.parseSchemaFile;
 export const outputPathFor = mod.outputPathFor;
 export const watch = mod.watch;
+export const bundleStandalone = mod.bundleStandalone;
+export const bundleCompact = mod.bundleCompact;
+export const toStandaloneModule = mod.toStandaloneModule;
 export default mod;

package/index.d.ts

@@ -202,13 +202,19 @@ type ResolveRef<R, D> = [RefName<R>] extends [never]
     ? InferWith<D[RefName<R>], D>
     : unknown;
 
-/** Object shape: required keys are required, all other declared keys optional. */
+/** Object shape: required keys are required, all other declared keys optional.
+ * When `properties` is absent and `additionalProperties` is a schema, infer
+ * a `Record<string, V>` (the JSON Schema "dictionary"/"record" shape). */
 type InferObject<S, D> = S extends { properties: infer P }
   ? Simplify<
       { [K in keyof P as K extends RequiredKeys<S> ? K : never]: InferWith<P[K], D> } &
       { [K in keyof P as K extends RequiredKeys<S> ? never : K]?: InferWith<P[K], D> }
     >
-  : Record<string, unknown>;
+  : S extends { additionalProperties: infer A }
+    ? A extends boolean
+      ? Record<string, unknown>
+      : Record<string, InferWith<A, D>>
+    : Record<string, unknown>;
 
 /** Array shape: `prefixItems` -> tuple; `items` (single schema) -> element type; otherwise unknown[]. */
 type InferArray<S, D> = S extends { prefixItems: infer P }

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.
@@ -1160,157 +1127,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.
@@ -1496,200 +1324,28 @@ function validate(schema, data) {
 
 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;

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,
+};