ata-validator 1.23.0 → 1.25.0

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 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.25.0 - 2026-09-17
+
+### Fixed
+
+- Emitted standalone modules compiled their regex patterns on every call. The compiler stores each pattern both as a closure variable and as an inline `const _reN = __ataSafeRe(...)` in the stored source; in process the inline line never runs (the closure binds the compiled matcher once), but every emitter placed it inside the emitted function, where it shadowed the module-scope binding and rebuilt the matcher per call. A schema with one `pattern` validated at 202 thousand ops/s as a standalone module while the in-process path ran at millions. Patterns are now declared once at load scope in all four emitters (`toStandalone`, `toStandaloneModule`, `bundleStandalone`, `bundleCompact`); the same document on the same schema now measures 27.0 million ops/s, 134x. `bundleCompact` needed care: its deduplication keyed on body text alone, and with the pattern no longer in the body, two schemas differing only in their pattern would have merged, so the key now includes the factory-scope declarations.
+
+### Added
+
+- Provably local `unevaluated*` compiles real error detail on the generated-code path, and therefore in standalone modules. When every occurrence of `unevaluatedProperties`/`unevaluatedItems` sits on a node with no `$ref` and no `patternProperties`, and every in-place applicator (`allOf`, `anyOf`, `oneOf`, `if`/`then`/`else`) contributes only property names the node's own `properties` already declares, the keyword is exactly `additionalProperties`/`items` in disguise and both the error and combined generators now emit it as such, keeping the keyword's own identity: one error per stray key with `params.unevaluatedProperty` (ATA7003), one error with `params.limit` for extra items. `toStandaloneModule` with error detail requested no longer degrades on these schemas; a config schema of the common `if/then/else` plus root `unevaluatedProperties: false` shape ships an AOT module with the same per-field errors the runtime reports. Schemas where the annotations cannot be proven local (`unevaluated*` next to a `$ref`, cousin-visible shapes) still decline, loudly, as before. Verified by the error-shape differential (2,816 cases), the engine differential (18,126 cases) and the official suite on all three dialects.
+- `toStandaloneModule(schema, { positions: true })` also exports `validateJSON(text)`: parse, validate, and on failure attach a `dataFrame` (`byteOffset`, `length`, `line`, `col`, `text`) to every error by walking the original text once. The mapping goes through `instancePath`, so a key that appears in several sections frames each error on its own occurrence, which a first-occurrence string search does not. A syntax error is the single ATA9001 error with a frame on the document. The walker is the runtime's own `buildDataPositionMap`, embedded verbatim so the two cannot drift, and it costs about 5 KB in the module (1.7 KB gzipped), which is why it is opt-in.
+- `toStandaloneModule(schema, { parse: true })`'s `parse(data)` now fills declared `default` values for absent optional properties (object and array defaults are fresh per call) and is emitted for composed schemas under the same proof the `unevaluated*` error generators use: in-place applicators are admitted when every property name they mention is already declared in the node's own `properties`. The common config shape, `if`/`then`/`else` over declared fields with root `unevaluatedProperties: false`, now gets a `parse` that enforces the conditional, rejects undeclared keys, and returns the ready object. Two default shapes decline because they are where `parse` and the runtime would disagree: a required property with a default, and a default the property's own schema rejects.
+- Every emitted module exports `schemaHash`, a 16 character content hash of the schema it was compiled from, over canonical JSON so key order does not matter, computed from the schema as the caller wrote it so dialect normalization does not break the comparison. `schemaHash(schema)` from `ata-validator/build` computes the same value; a build detects a stale artifact by comparing the two instead of embedding its own fingerprint.
+- The agreement between compiled modules and the runtime is now a stated contract, in `docs/STABILITY.md` and the API reference: same version, same verdict on every document, enforced by the differential test in every CI run, with the emitters declining or degrading loudly where they cannot prove equivalence.
+- The compat shim exports `attachDataFrames(errors, text)`: the same one-pass mapping for Ajv-shaped errors, for callers that keep the source text around. Not an Ajv API; it exists because hand-written line finders based on a string search get repeated keys wrong.
+
+## 1.24.0 - 2026-09-16
+
+### Added
+
+- A schema-directed scanner: `isValidJSON()` answers the verdict from the JSON text without building the document. Parsing is about three quarters of the cost of a request that only needs yes or no, and a rejection now stops at the byte that caused it. The scanner compiles per schema, on the codegen path only, after 64 calls (generating one costs about 20 µs, so a caller that checks one document never pays), and it declines anything outside its supported core: `type`, `properties`, `required`, `additionalProperties`, `items`, `prefixItems`, the length, size and range keywords, `pattern`, `format`, `const`, `enum`, local `$ref` (inlined, acyclic, no base-changing keywords below the root), `allOf` (merged, with the `additionalProperties` cross-branch rule written out in full), and `unevaluated*` where it is provably a synonym for `additionalProperties`/`items`. Whatever it cannot answer it declines at compile time or bails from at runtime, and the parse path takes over unchanged. `tests/test_scanner_differential.js` holds the scanner and `validate()` to the same verdict on the same text: 413,130 comparisons over the official suite, a malformed-JSON corpus and generated corruptions, zero disagreements, and the count must stay at zero.
+  - Cross-process medians against the same call forced through `JSON.parse`: accepted documents 1.19x to 1.43x by size; rejection at the first element 37x at 4 KB and 385x at 41 KB.
+  - Generated config schemas are first-class: up to 4096 properties per node, and past 48 names the dispatch is a rolling hash accumulated during the key scan, one lookup in a Map passed outside the source, one `startsWith` to confirm, bodies shared per distinct subschema, and an in-order fast path for machine-written JSON that resynchronises across omitted optional keys. A 26.6 KB config with 1300 declared properties: 136.7 µs by parse-and-validate, 43.8 µs by scan.
+  - `isValidJSON` also remembers the last (text, verdict) pair, since the verdict is a pure function of the text: a drift monitor re-reading an unchanged file answers in 0.44 µs by native string compare. Withheld when user formats or custom keywords are present, since user functions may not be pure.
+- Strict mode covers all four cases from issue #44: unknown keywords (with a spelling suggestion), unresolvable local `$ref`s, keywords the node's own `type` makes inert (`minimum` on a string can never fire), and `required` names nothing can satisfy (`additionalProperties: false` with the name absent from `properties`). `ata compile --strict-schema` and `build({ strictSchema: true })` run the same checks at build time and refuse to emit a module from a schema that fails them.
+
+### Fixed
+
+- An AOT module that cannot carry error detail says so. `toStandaloneModule` with error detail requested builds the error function from the error generator, which declines some schemas, `unevaluated*` among them; the runtime validator falls back to the interpreted engine there, but a standalone module has nothing to fall back to, so it shipped with an exact verdict and a single ATA9000 stub for every failure, silently. The module still ships, since the verdict is exact and validating the rare failing document with the runtime `Validator` is a legitimate pattern, but the degradation is loud in every layer: `onWarning` on the emitter, a NOTE in the module header, a `warnings` list in the `build()` report, a printed warning from `ata compile`, and a refused build under `--strict`. Found by a gateway team that lost their per-field startup errors to it.
+
 ## 1.23.0 - 2026-09-16
 
 ### Added

package/bin/ata.js

@@ -38,6 +38,10 @@ Build options:
   --cache-file <path>     Cache file for incremental builds (default: cache disabled)
   --max-size <bytes>      Fail build if any compiled module exceeds this gzipped size
   --strict                Treat any AOT-incompatible schema as a build error (default: skip + warn)
+  --strict-schema         Fail the build on schema authoring mistakes: unknown
+                          keywords (with a spelling suggestion), keywords the
+                          node's type makes inert, unresolvable local $refs,
+                          and required names nothing can satisfy
   --watch                 Re-emit on schema change (Ctrl-C to exit)
   --no-types              Skip .d.mts/.d.cts emission alongside compiled modules
   --source                Embed schema source map (default in development)
@@ -80,6 +84,7 @@ function parseArgs(argv) {
     if (a === '--abort-early') { out.opts.abortEarly = true; continue; }
     if (a === '--check') { out.opts.check = true; continue; }
     if (a === '--strict') { out.opts.strict = true; continue; }
+    if (a === '--strict-schema') { out.opts.strictSchema = true; continue; }
     if (a === '--out-dir') { out.opts.outDir = argv[++i]; continue; }
     if (a === '--suffix') { out.opts.suffix = argv[++i]; continue; }
     if (a === '--cache-file') { out.opts.cacheFile = argv[++i]; continue; }
@@ -156,7 +161,13 @@ function cmdCompile(args) {
     process.exit(1);
   }
   const input = args._[0];
-  const format = args.opts.format || 'esm';
+  // With no --format, the output filename already says what the caller wants:
+  // -o validator.cjs used to emit an ES module into a .cjs file, which Node
+  // then refused to load.
+  const extFormat = args.opts.output && /\.cjs$/.test(args.opts.output) ? 'cjs'
+    : args.opts.output && /\.mjs$/.test(args.opts.output) ? 'esm'
+    : null;
+  const format = args.opts.format || extFormat || 'esm';
   if (format !== 'esm' && format !== 'cjs') {
     process.stderr.write(`error: --format must be esm or cjs (got "${format}")\n`);
     process.exit(1);
@@ -180,6 +191,19 @@ function cmdCompile(args) {
     process.exit(1);
   }
 
+  // The build is where an authoring mistake is cheapest to stop: a typo like
+  // maxLenght compiles into a module that simply lacks the rule, and nobody
+  // revisits a compiled module. Findings fail the compile, with the path and
+  // the suggested spelling.
+  if (args.opts.strictSchema) {
+    const { checkSchemaStrict } = require('../lib/strict-check');
+    const problems = checkSchemaStrict(schema, {});
+    if (problems.length > 0) {
+      for (const x of problems) reportCompileError(input, `strict mode: ${x.message} at ${x.path}`);
+      process.exit(1);
+    }
+  }
+
   const { Validator } = require('..');
   const aot = require('../lib/aot');
   let v;
@@ -200,7 +224,15 @@ function cmdCompile(args) {
     }
   }
   const schemaFile = path.relative(process.cwd(), input) || input;
-  const src = aot.toStandaloneModule(v, { format, abortEarly, source, sourceMap, schemaFile });
+  const compileWarnings = [];
+  const src = aot.toStandaloneModule(v, { format, abortEarly, source, sourceMap, schemaFile, onWarning: (w) => compileWarnings.push(w) });
+  if (compileWarnings.length > 0) {
+    if (args.opts.strict) {
+      for (const w of compileWarnings) reportCompileError(input, w);
+      process.exit(1);
+    }
+    for (const w of compileWarnings) process.stderr.write(`ata: warning: ${input}: ${w}\n`);
+  }
   if (!src) {
     reportCompileError(input, 'schema is too complex for standalone compilation');
     process.exit(1);

package/build.d.ts

@@ -89,6 +89,18 @@ export interface BundleStandaloneOptions {
 }
 
 export interface ToStandaloneModuleOptions {
+  /**
+   * Run the authoring-time schema checks before emitting: unknown keywords
+   * (with a spelling suggestion), inert keywords, unsatisfiable required
+   * names, unresolvable local $refs. Throws with every finding.
+   */
+  strictSchema?: boolean;
+  /**
+   * Called when the module ships degraded: error detail was requested but the
+   * error generator declined this schema, so failures report the single
+   * ATA9000 abort-early error while the verdict stays exact.
+   */
+  onWarning?: (message: string) => void;
   format?: 'cjs' | 'esm';
   abortEarly?: boolean;
   source?: boolean;
@@ -99,12 +111,27 @@ export interface ToStandaloneModuleOptions {
   formatMode?: 'embed' | 'inject';
   /**
    * Also export `parse(data)`: validate, then return a copy of the input
-   * holding only the properties the schema declares. Off by default because
-   * it adds to the emitted module's size. Emitted only where the copy is
-   * provably exact; a schema using `$ref`, a composition, `patternProperties`,
-   * an `additionalProperties` schema or an array of objects gets no `parse`.
+   * holding only the properties the schema declares, with declared `default`
+   * values filled in for absent optional properties (object and array
+   * defaults are fresh per call). Off by default because it adds to the
+   * emitted module's size. Emitted only where the copy is provably exact:
+   * `$ref` and `patternProperties` decline; in-place applicators (`allOf`,
+   * `anyOf`, `oneOf`, `if`/`then`/`else`, and `unevaluatedProperties: false`)
+   * are admitted when every property name they mention is already declared
+   * in the node's own `properties`. A required property with a default, or
+   * a default its own schema rejects, also declines, because those are the
+   * two shapes where parse() and the runtime would disagree.
    */
   parse?: boolean;
+  /**
+   * Also export `validateJSON(text)`: parse the JSON text, validate, and on
+   * failure attach a `dataFrame` ({ byteOffset, length, line, col, text })
+   * to every error by walking the original text once, so errors point at the
+   * right occurrence even when the same key appears in several sections.
+   * Off by default because the embedded position walker adds to the emitted
+   * module's size.
+   */
+  positions?: boolean;
 }
 
 /** Bundle multiple schemas into one self-contained module (no ata-validator runtime). */
@@ -113,6 +140,16 @@ export function bundleStandalone(schemas: unknown[], options?: BundleStandaloneO
 /** Like {@link bundleStandalone} but deduplicates shared bodies for smaller output. */
 export function bundleCompact(schemas: unknown[], options?: BundleStandaloneOptions): string;
 
+/**
+ * Stable content hash of a schema, 16 hex characters, over a canonical JSON
+ * form (keys sorted at every level). Every module from
+ * {@link toStandaloneModule} exports its own `schemaHash`; comparing that
+ * against `schemaHash(currentSchema)` tells a build the module is stale.
+ * An integrity aid, not a security boundary.
+ */
+export function schemaHash(schema: unknown): string;
+
 /** Emit a self-contained `validate`/`isValid` module string for a single
- * schema, plus `parse` when {@link ToStandaloneModuleOptions.parse} is set. */
+ * schema, plus `parse` when {@link ToStandaloneModuleOptions.parse} is set
+ * and `validateJSON` when {@link ToStandaloneModuleOptions.positions} is. */
 export function toStandaloneModule(schema: unknown, options?: ToStandaloneModuleOptions): string | null;

package/compat.d.ts

@@ -25,6 +25,14 @@ declare class Ata {
   removeKeyword(keyword: string): this;
 
   errorsText(errors?: Ata.ErrorObject[] | null, options?: { separator?: string; dataVar?: string }): string;
+
+  /**
+   * Attach a `dataFrame` ({ byteOffset, length, line, col, text }) to each
+   * error by mapping its `instancePath` into the JSON text the data was
+   * parsed from. One walk of the text; correct when the same key appears in
+   * several sections. Not an Ajv API. Mutates and returns `errors`.
+   */
+  static attachDataFrames(errors: Ata.ErrorObject[] | null | undefined, text: string | Buffer): Ata.ErrorObject[] | null | undefined;
 }
 
 declare namespace Ata {

package/compat.js

@@ -409,6 +409,26 @@ function metaValidator(id) {
   return v;
 }
 
+// Maps each error's instancePath to its position in the JSON text the data
+// was parsed from and attaches it as `dataFrame` ({ byteOffset, length,
+// line, col, text }). One walk of the text, and correct when the same key
+// appears in several sections, which a first-occurrence string search is
+// not. Not an Ajv API: exported for callers that keep the source text
+// around and want file positions on Ajv-shaped errors.
+Ata.attachDataFrames = function attachDataFrames(errors, text) {
+  if (!errors || !errors.length || text == null) return errors;
+  const { buildDataPositionMap } = require('./lib/data-positions');
+  let map;
+  try { map = buildDataPositionMap(text); } catch { return errors; }
+  for (const e of errors) {
+    if (!e || e.dataFrame) continue;
+    const ptr = e.instancePath != null ? e.instancePath : (e.dataPath || '');
+    const p = map[ptr];
+    if (p) e.dataFrame = { byteOffset: p.byteOffset, length: p.length, line: p.line, col: p.col, text: p.text };
+  }
+  return errors;
+};
+
 module.exports = Ata;
 module.exports.default = Ata;
 module.exports.Ata = Ata;

package/index.d.ts

@@ -395,9 +395,20 @@ export interface ValidatorOptions {
   keywords?: Record<string, KeywordDefinition | KeywordValidate>;
   /**
    * When true, validation errors include `parentSchema` (the schema object
-   * that produced the error). Matches ajv's `verbose: true`.
+   * that produced the error), `schema` (the failing keyword's own value) and
+   * `data` (the value the error points at). Matches ajv's `verbose: true`.
    */
   verbose?: boolean;
+  /**
+   * Authoring-time schema checks, run at construction on the schema as
+   * written: unknown keywords (with a spelling suggestion), keywords the
+   * node's own `type` makes inert, `required` names nothing can satisfy, and
+   * local `$ref`s that do not resolve. `true` throws with every finding;
+   * `'log'` warns through `logger` (or the console) and continues.
+   */
+  strictSchema?: boolean | 'log';
+  /** Receives `strictSchema: 'log'` warnings; `false` silences them. */
+  logger?: { warn(...args: unknown[]): void } | false;
   /**
    * When true, validate() returns a shared frozen result on the first failure
    * instead of collecting full error details. Smaller hot-path allocation.

package/index.js

@@ -933,6 +933,8 @@ class Validator {
     // to attach dataFrame entries to each enriched error.
     this._posCache = null; // created by _pos() on first use, only the JSON text path needs it
     this._lastRawInput = null;
+    // undefined: not built yet. null: this schema has no scanner.
+    this._scanner = undefined;
 
     // Public methods start as memoized accessors on the prototype; nothing is
     // allocated per instance until one is first read. See _defineLazyMethod
@@ -1426,6 +1428,23 @@ class Validator {
             return verdictFromText(jsonStr);
           }
         : verdictFromText;
+
+      // A schema-directed scanner answers the verdict from the JSON text
+      // without building the document. Parsing is around three quarters of the
+      // cost of a real request, and a caller that only wants yes or no should
+      // not pay it; a rejection can also stop at the byte that caused it
+      // instead of parsing the rest of a document that is already refused.
+      //
+      // It is wired only where the verdict IS the answer. On a path that has
+      // to produce errors, scanning an invalid document is work thrown away,
+      // so those keep parsing. `abortEarly` has no errors to produce, so it
+      // counts as a verdict path.
+      //
+      // Not wired when a preprocess pass is configured: coercion, removal and
+      // defaults rewrite the document before it is judged, and the scanner
+      // reads what arrived. The compiler declines any schema it cannot answer
+      // and a compiled scanner returns BAIL for a document shape it cannot
+      // answer, and then the parse path below takes over unchanged.
       // validateAndParse: parse the JSON, then validate. Pure JS (JSON.parse +
       // validate) so it works with or without the native addon and in browsers.
       {
@@ -1799,6 +1818,83 @@ class Validator {
       const { bufferNeedsSlowPath, installSlowBufferApis } = require('./lib/buffer-gate.js');
       if (bufferNeedsSlowPath(schemaObj, this._schemaMap, this._keywords)) installSlowBufferApis(this);
     }
+    // Installed after the buffer gate on purpose: the gate replaces
+    // isValidJSON for schemas whose shapes the native walker gets wrong,
+    // unevaluatedProperties among them, and the scanner wiring has to wrap
+    // whatever answers last or a gated schema silently loses its scanner.
+    if (this._jsFn && !this._preprocess) {
+        const self = this;
+        // Generating a scanner costs about 20 microseconds, measured, and it
+        // saves from around 85 nanoseconds on a small accepted document to
+        // several microseconds on a rejected one. Building it on the first
+        // call would therefore be a straight loss for a caller that checks one
+        // document and exits, so it is built once a caller has asked often
+        // enough that it is plainly doing this in a loop. A server passes the
+        // line during warm-up and never sees it.
+        const SCAN_AFTER = 64;
+        let calls = 0;
+        // undefined: not built. null: this schema has no scanner. Passing true
+        // builds it now, which is how the differential test reaches it.
+        this._ensureScanner = (now) => {
+          if (self._scanner === undefined) {
+            if (!now && ++calls < SCAN_AFTER) return undefined;
+            const built = require('./lib/scan-compiler').compileScanner(schemaObj, { userFormats: self._userFormats });
+            self._scanner = built ? built.scan : null;
+          }
+          return self._scanner;
+        };
+        const byParsing = this.isValidJSON;
+        // The verdict is a pure function of the text, and the caller a
+        // gateway or a drift monitor keeps asking about is usually the same
+        // text: a config file re-read on a timer, a heartbeat body. One
+        // remembered (text, verdict) pair answers that case with a native
+        // string compare, which is a memcmp, instead of a scan. Withheld when
+        // user formats or custom keywords are present, since those are user
+        // functions and nothing guarantees they are pure.
+        const memoizable = !self._userFormats && !self._usesKeywords;
+        let _memoText = null;
+        let _memoVerdict = false;
+        this.isValidJSON = (jsonStr) => {
+          const scan = self._ensureScanner();
+          if (scan === undefined) return byParsing(jsonStr);
+          if (scan === null) { self.isValidJSON = byParsing; return byParsing(jsonStr); }
+          self.isValidJSON = memoizable
+            ? (text) => {
+                if (typeof text !== 'string') return byParsing(text);
+                if (text === _memoText) return _memoVerdict;
+                const r = scan(text);
+                const verdict = r === -1 ? byParsing(text) : r === 1;
+                _memoText = text;
+                _memoVerdict = verdict;
+                return verdict;
+              }
+            : (text) => {
+                if (typeof text !== 'string') return byParsing(text);
+                const r = scan(text);
+                if (r === -1) return byParsing(text);
+                return r === 1;
+              };
+          return self.isValidJSON(jsonStr);
+        };
+        if (options.abortEarly) {
+          const validateByParsing = this.validateJSON;
+          this.validateJSON = (jsonStr) => {
+            const scan = self._ensureScanner();
+            if (scan === undefined) return validateByParsing(jsonStr);
+            if (scan === null) { self.validateJSON = validateByParsing; return validateByParsing(jsonStr); }
+            self.validateJSON = (text) => {
+              if (typeof text === 'string') {
+                const r = scan(text);
+                if (r === 1) return VALID_RESULT;
+                if (r === 0) return ABORT_EARLY_RESULT;
+              }
+              return validateByParsing(text);
+            };
+            return self.validateJSON(jsonStr);
+          };
+        }
+      }
+
 
     // Save to identity cache for ultra-fast reuse with same schema object.
     // Only an instance built without options may answer a later

package/lib/aot-build.js

@@ -94,6 +94,7 @@ async function build(opts) {
   const cached = [];
   const skipped = [];
   const failed = [];
+  const warnings = [];
 
   for (const input of inputs) {
     try {
@@ -126,6 +127,18 @@ async function build(opts) {
         continue;
       }
       const schema = parseSchemaFile(input);
+      // The build is where an authoring mistake is cheapest to stop: a typo
+      // like maxLenght compiles into a validator that simply lacks the rule,
+      // and a compiled module fails even more quietly than a runtime one,
+      // since nobody ever revisits it. Findings fail the input's build.
+      if (opts.strictSchema) {
+        const { checkSchemaStrict } = require('./strict-check');
+        const problems = checkSchemaStrict(schema, {});
+        if (problems.length > 0) {
+          failed.push({ input, error: problems.map((x) => `strict mode: ${x.message} at ${x.path}`).join('; ') });
+          continue;
+        }
+      }
       const v = new Validator(schema);
       const source = resolveSourceDefault(opts);
       let sourceMap = null;
@@ -138,6 +151,7 @@ async function build(opts) {
         }
       }
       const schemaFile = path.relative(process.cwd(), input) || input;
+      const inputWarnings = [];
       const src = aot.toStandaloneModule(v, {
         format,
         abortEarly: !!opts.abortEarly,
@@ -145,7 +159,15 @@ async function build(opts) {
         sourceMap,
         schemaFile,
         formatMode: opts.formatMode,
+        onWarning: (w) => inputWarnings.push(w),
       });
+      if (inputWarnings.length > 0) {
+        if (opts.strict) {
+          failed.push({ input, error: inputWarnings.join('; ') });
+          continue;
+        }
+        for (const w of inputWarnings) warnings.push({ input, warning: w });
+      }
       if (!src) {
         const reason = 'schema is not AOT-compatible (toStandaloneModule returned null)';
         if (opts.strict) failed.push({ input, error: reason });
@@ -190,12 +212,12 @@ async function build(opts) {
 
   if (opts.check) {
     const staleCount = inputs.length - cached.length;
-    return { compiled: [], cached, skipped, failed, staleCount };
+    return { compiled: [], cached, skipped, failed, warnings, staleCount };
   }
 
   writeCache(opts.cacheFile, newCache);
 
-  return { compiled, cached, skipped, failed };
+  return { compiled, cached, skipped, failed, warnings };
 }
 
 async function watch(opts, onReport) {
@@ -248,10 +270,22 @@ function bundleCompact(schemas, opts) {
 }
 
 function toStandaloneModule(schema, opts) {
+  // The same authoring-time checks `ata compile --strict-schema` runs, for
+  // callers driving the build API directly: a typo in a schema headed for a
+  // compiled module is the quietest place a typo can live.
+  if (opts && opts.strictSchema) {
+    const { checkSchemaStrict } = require('./strict-check');
+    const problems = checkSchemaStrict(schema, {});
+    if (problems.length > 0) {
+      throw new Error(problems.map((x) => `strict mode: ${x.message} at ${x.path}`).join('\n'));
+    }
+  }
   const v = schema instanceof Validator ? schema : new Validator(schema, opts);
   return aot.toStandaloneModule(v, opts);
 }
 
+const { schemaHash } = require('./schema-hash');
+
 module.exports = {
   build,
   expandGlobs,
@@ -261,4 +295,5 @@ module.exports = {
   bundleStandalone,
   bundleCompact,
   toStandaloneModule,
+  schemaHash,
 };