ata-validator 0.15.1 → 0.17.0

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 All notable changes to ata-validator are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/), and this project adheres to semantic versioning.
 
+## 0.17.0 - 2026-05-23
+
+### Added
+
+- Static type inference from JSON Schema literals. The new exported `Infer<S>` type maps a schema literal to its data type, and `new Validator(defineSchema({...}))` now returns `Validator<Infer<S>>`, so `validate()` narrows `result.data` with no manual type annotation. Write plain JSON Schema, get the type for free, no builder DSL. Covers primitives, type-array unions, `const`, `enum`, objects (required vs optional keys), and arrays; `$ref`, tuples, and `anyOf`/`oneOf` infer `unknown` for now. Pure `.d.ts` change, no runtime impact.
+
+### Fixed
+
+- `validateAndParse()` is now implemented in JavaScript (`JSON.parse` then validate) and returns `{ valid, value, errors }`. It previously called a native method that does not exist and threw on every call. It now works with or without the native addon and in the browser; malformed JSON returns `valid: false` with an `ATA9001` error instead of throwing.
+
+## 0.16.0 - 2026-05-23
+
+### Added
+
+- `defineSchema` helper and the exported `JSONSchema` type. Wrap a plain schema object in `defineSchema(...)` to author it inline in TypeScript with keyword autocomplete and value checking, no `as const` needed. It is an identity function at runtime, so the returned object drops straight into `Validator`, `toStandaloneModule`, and the rest of the API. Requires TypeScript >= 5.0 for the `const` type parameter.
+- OpenAPI `nullable` keyword. `{ type: 'string', nullable: true }` accepts `null` alongside the declared type, matching OpenAPI 3.0 schemas.
+
+### Fixed
+
+- `coerceTypes` with `type: 'array'` wraps a scalar into a single-element array instead of leaving it unchanged.
+- Codegen resolves a `$defs` entry that carries a fragment `$id` and is reached through a pointer `$ref`.
+- Preprocessing (defaults, coercion, `removeAdditional`) guards against `null` and non-object data instead of throwing.
+
 ## 0.15.1 - 2026-05-23
 
 ### Fixed

package/README.md

@@ -158,6 +158,28 @@ if (result.valid) {
 
 The same pattern works with Zod-from-JSON-Schema, Valibot, or a hand-written `type User = {...}` alongside a JSON Schema literal. `Validator<T>` makes no library-specific assumption.
 
+#### Authoring a schema inline: `defineSchema`
+
+If you would rather write a plain JSON Schema object than reach for a schema library, wrap it in `defineSchema`. It returns the schema untouched at runtime, but in TypeScript it gives you keyword autocomplete and an error when a value has the wrong shape, with no `as const` needed.
+
+```ts
+import { defineSchema, Validator } from 'ata-validator'
+
+const userSchema = defineSchema({
+  type: 'object',
+  properties: {
+    id: { type: 'integer', minimum: 1 },
+    role: { type: 'string', enum: ['admin', 'user'] },
+  },
+  required: ['id'],
+})
+
+// type: 123 or required: 'id' would be a compile error here.
+const v = new Validator(userSchema)
+```
+
+The exported `JSONSchema` type is also available directly if you want to annotate a schema yourself. Custom and vendor keywords are allowed, so exotic schemas still type-check. Requires TypeScript >= 5.0.
+
 ### Cross-Schema `$ref`
 
 ```javascript

package/index.d.ts

@@ -75,6 +75,163 @@ export function renderJSON(errors: RichValidationError[], opts?: JSONRenderOptio
 /** A user-supplied format checker. Receives the candidate value, returns true if valid. */
 export type FormatChecker = (value: string) => boolean;
 
+/** The seven primitive `type` values defined by JSON Schema. */
+export type JSONSchemaTypeName =
+  | 'string'
+  | 'number'
+  | 'integer'
+  | 'boolean'
+  | 'object'
+  | 'array'
+  | 'null';
+
+/**
+ * A hand-written type for authoring JSON Schema (draft 2020-12) objects inline
+ * in TypeScript. Known keywords are typed, so you get autocomplete and an error
+ * when a value has the wrong shape (e.g. `type: 123` or `required: 'id'`).
+ * Unknown keywords are permitted, so custom/vendor keywords do not error.
+ *
+ * Pair it with {@link defineSchema} for inline authoring without `as const`.
+ */
+export interface JSONSchema {
+  $id?: string;
+  $schema?: string;
+  $ref?: string;
+  $defs?: Record<string, JSONSchema>;
+  definitions?: Record<string, JSONSchema>;
+  $comment?: string;
+
+  type?: JSONSchemaTypeName | JSONSchemaTypeName[];
+  enum?: ReadonlyArray<unknown>;
+  const?: unknown;
+
+  title?: string;
+  description?: string;
+  default?: unknown;
+  examples?: ReadonlyArray<unknown>;
+  deprecated?: boolean;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+
+  // object
+  properties?: Record<string, JSONSchema>;
+  required?: ReadonlyArray<string>;
+  additionalProperties?: boolean | JSONSchema;
+  patternProperties?: Record<string, JSONSchema>;
+  propertyNames?: JSONSchema;
+  minProperties?: number;
+  maxProperties?: number;
+  dependentRequired?: Record<string, ReadonlyArray<string>>;
+  dependentSchemas?: Record<string, JSONSchema>;
+
+  // array
+  items?: JSONSchema | ReadonlyArray<JSONSchema>;
+  prefixItems?: ReadonlyArray<JSONSchema>;
+  additionalItems?: boolean | JSONSchema;
+  contains?: JSONSchema;
+  minContains?: number;
+  maxContains?: number;
+  minItems?: number;
+  maxItems?: number;
+  uniqueItems?: boolean;
+
+  // string
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  format?: string;
+
+  // number
+  minimum?: number;
+  maximum?: number;
+  exclusiveMinimum?: number;
+  exclusiveMaximum?: number;
+  multipleOf?: number;
+
+  // composition
+  allOf?: ReadonlyArray<JSONSchema>;
+  anyOf?: ReadonlyArray<JSONSchema>;
+  oneOf?: ReadonlyArray<JSONSchema>;
+  not?: JSONSchema;
+  if?: JSONSchema;
+  then?: JSONSchema;
+  else?: JSONSchema;
+
+  /** OpenAPI compatibility: ata honors `nullable` as a JSON Schema extension. */
+  nullable?: boolean;
+
+  /** Custom and vendor keywords are allowed without error. */
+  [keyword: string]: unknown;
+}
+
+/**
+ * Collapse an intersection of mapped object types into a single readable object
+ * type. `& {}` forces TypeScript to evaluate the mapped type eagerly.
+ */
+type Simplify<T> = { [K in keyof T]: T[K] } & {};
+
+/** Keys listed in a schema's `required` array, as a string union (or never). */
+type RequiredKeys<S> = S extends { required: infer R }
+  ? R extends ReadonlyArray<infer K extends string>
+    ? K
+    : never
+  : never;
+
+/** Object shape: required keys are required, all other declared keys optional. */
+type InferObject<S> = S extends { properties: infer P }
+  ? Simplify<
+      { [K in keyof P as K extends RequiredKeys<S> ? K : never]: Infer<P[K]> } &
+      { [K in keyof P as K extends RequiredKeys<S> ? never : K]?: Infer<P[K]> }
+    >
+  : Record<string, unknown>;
+
+/** Array shape: `items` as a single schema maps to an element type; tuple/absent -> unknown[]. */
+type InferArray<S> = S extends { items: infer I }
+  ? I extends ReadonlyArray<unknown>
+    ? unknown[]
+    : Infer<I>[]
+  : unknown[];
+
+/** Map a single JSON Schema type name (+ its schema) to a TS type. */
+type InferByTypeName<N, S> = N extends 'object'
+  ? InferObject<S>
+  : N extends 'array'
+    ? InferArray<S>
+    : N extends 'string'
+      ? string
+      : N extends 'number'
+        ? number
+        : N extends 'integer'
+          ? number
+          : N extends 'boolean'
+            ? boolean
+            : N extends 'null'
+              ? null
+              : unknown;
+
+/**
+ * Infer the TypeScript data type a JSON Schema literal describes (Core scope).
+ *
+ * Handles: primitives, `type` arrays (union), `const`, `enum`, objects
+ * (`properties` + `required` -> required/optional keys), and arrays
+ * (`items` as a single schema). `$ref`/`$defs`, tuples, and `anyOf`/`oneOf`/
+ * `allOf` are not yet inferred and resolve to `unknown` rather than erroring.
+ *
+ * Pair with {@link defineSchema}:
+ * `const s = defineSchema({...}); type T = Infer<typeof s>;`
+ */
+export type Infer<S> = S extends { const: infer C }
+  ? C
+  : S extends { enum: infer E }
+    ? E extends ReadonlyArray<infer U>
+      ? U
+      : unknown
+    : S extends { type: infer T }
+      ? T extends ReadonlyArray<infer N>
+        ? InferByTypeName<N, S>
+        : InferByTypeName<T, S>
+      : unknown;
+
 export type ValidationResult<T = unknown> =
   | { valid: true;  data: T;       errors: ValidationError[] }
   | { valid: false; data?: never;  errors: ValidationError[] };
@@ -142,9 +299,8 @@ export interface StandaloneModule {
   errFn: ((data: unknown, allErrors?: boolean) => ValidationResult) | null;
 }
 
-export class Validator<T = unknown> {
-  constructor(schema: object | string, options?: ValidatorOptions);
-
+/** Instance surface of a compiled validator. */
+export interface Validator<T = unknown> {
   /** Add a schema to the registry for cross-schema $ref resolution */
   addSchema(schema: object): void;
 
@@ -160,7 +316,7 @@ export class Validator<T = unknown> {
   /** Fast boolean check for a JSON string */
   isValidJSON(jsonString: string): boolean;
 
-  /** Parse JSON with simdjson + validate against schema. Returns parsed value and validation result. Requires native addon. */
+  /** Parse JSON and validate against the schema. Returns the parsed value and the validation result. Works without the native addon. */
   validateAndParse(jsonString: string | Buffer): ValidateAndParseResult<T>;
 
   /** Ultra-fast buffer validation via native addon */
@@ -187,41 +343,48 @@ export class Validator<T = unknown> {
   /**
    * Generate a self-contained module string with `validate`/`isValid` exports.
    * The output has zero runtime dependency on ata-validator.
-   *
-   * - format: 'esm' (default) or 'cjs'.
-   * - abortEarly: if true, invalid results are a shared frozen stub (smaller output, no error details).
-   *
-   * Returns null if the schema cannot be compiled to a standalone module.
    */
   toStandaloneModule(options?: { format?: 'esm' | 'cjs'; abortEarly?: boolean }): string | null;
 
+  /** Standard Schema V1 interface, compatible with Fastify, tRPC, TanStack, etc. */
+  readonly "~standard": StandardSchemaV1Props;
+}
+
+/** Constructor + statics for {@link Validator}. */
+export interface ValidatorConstructor {
+  /** Construct from a JSON Schema literal; the validated data type is inferred. */
+  new <const S extends JSONSchema>(schema: S, options?: ValidatorOptions): Validator<Infer<S>>;
+  /** Construct from a plain object/string schema, or with an explicit data type. */
+  new <T = unknown>(schema: object | string, options?: ValidatorOptions): Validator<T>;
+
   /** Load a pre-compiled standalone module. Zero schema compilation at startup. */
-  static fromStandalone<T = unknown>(mod: StandaloneModule, schema: object | string, options?: ValidatorOptions): Validator<T>;
+  fromStandalone<T = unknown>(mod: StandaloneModule, schema: object | string, options?: ValidatorOptions): Validator<T>;
 
   /** Bundle multiple schemas into a single JS module string. Load with Validator.loadBundle(). */
-  static bundle(schemas: object[], options?: ValidatorOptions): string;
+  bundle(schemas: object[], options?: ValidatorOptions): string;
 
   /**
    * Bundle multiple schemas into a self-contained JS module with no
    * ata-validator runtime dependency. Cross-schema `$ref` resolves between
    * the supplied schemas. Set `format: 'esm'` for ESM output (default 'cjs').
    */
-  static bundleStandalone(schemas: object[], options?: BundleStandaloneOptions): string;
+  bundleStandalone(schemas: object[], options?: BundleStandaloneOptions): string;
 
   /**
    * Bundle multiple schemas with deduplicated shared templates. Smaller output
-   * than bundle(). Accepts the same options as bundleStandalone, including
-   * `format: 'esm' | 'cjs'` and cross-schema `$ref` resolution.
+   * than bundle(). Accepts the same options as bundleStandalone.
    */
-  static bundleCompact(schemas: object[], options?: BundleStandaloneOptions): string;
+  bundleCompact(schemas: object[], options?: BundleStandaloneOptions): string;
 
   /** Load a bundle created by Validator.bundle(). Returns array of Validator instances. */
-  static loadBundle(mods: object[], schemas: object[], options?: ValidatorOptions): Validator[];
+  loadBundle(mods: object[], schemas: object[], options?: ValidatorOptions): Validator[];
 
-  /** Standard Schema V1 interface, compatible with Fastify, tRPC, TanStack, etc. */
-  readonly "~standard": StandardSchemaV1Props;
+  readonly prototype: Validator;
 }
 
+/** Compile a schema into a reusable validator. */
+export const Validator: ValidatorConstructor;
+
 /** One-shot validate: creates a Validator, validates data, returns result. */
 export function validate<T = unknown>(
   schema: object | string,
@@ -253,3 +416,25 @@ export const SIMDJSON_PADDING: number;
  * build-time integrations (Vite plugin, custom build steps).
  */
 export function toTypeScript(schema: object, options?: { name?: string }): string;
+
+/**
+ * Authoring helper for writing a JSON Schema inline in TypeScript. Returns the
+ * schema unchanged at runtime; its purpose is to apply the {@link JSONSchema}
+ * type so you get keyword autocomplete and an error on malformed values, while
+ * the `const` type parameter preserves the literal shape (no `as const` needed).
+ *
+ * ```ts
+ * import { defineSchema, Validator } from 'ata-validator';
+ *
+ * const user = defineSchema({
+ *   type: 'object',
+ *   properties: { id: { type: 'integer', minimum: 1 } },
+ *   required: ['id'],
+ * });
+ *
+ * const v = new Validator(user);
+ * ```
+ *
+ * Requires TypeScript >= 5.0 for the `const` type parameter.
+ */
+export declare function defineSchema<const S extends JSONSchema>(schema: S): S;

package/index.js

@@ -8,7 +8,7 @@ const {
   compileToJSCodegenWithErrors,
   compileToJSCombined,
 } = require("./lib/js-compiler");
-const { normalizeDraft7 } = require("./lib/draft7");
+const { normalizeDraft7, normalizeNullable } = require("./lib/draft7");
 const { classify } = require("./lib/shape-classifier");
 const { buildTier0Plan, tier0Validate } = require("./lib/tier0");
 
@@ -242,6 +242,8 @@ function buildPreprocessCodegen(schema, options) {
       } else if (t === 'boolean') {
         lines.push(`if(d[${k}]==='true'||d[${k}]==='1')d[${k}]=true`);
         lines.push(`if(d[${k}]==='false'||d[${k}]==='0')d[${k}]=false`);
+      } else if (t === 'array' && options.coerceTypes === 'array') {
+        lines.push(`if(${k} in d&&d[${k}]!==undefined&&!Array.isArray(d[${k}]))d[${k}]=[d[${k}]]`);
       }
     }
   }
@@ -256,6 +258,9 @@ function buildPreprocessCodegen(schema, options) {
   }
 
   if (lines.length === 0) return null;
+  // Data may legitimately be null or a non-object (e.g. a `['object','null']`
+  // schema), so the per-property mutations must not run on it.
+  lines.unshift(`if(d===null||typeof d!=='object')return`);
   try {
     return new Function('d', lines.join('\n'));
   } catch {
@@ -350,6 +355,7 @@ function buildSchemaMap(schemas) {
   if (Array.isArray(schemas)) {
     for (const s of schemas) {
       normalizeDraft7(s)
+      normalizeNullable(s)
       const id = s.$id
       if (!id) throw new Error('Schema in schemas option must have $id')
       map.set(id, s)
@@ -357,6 +363,7 @@ function buildSchemaMap(schemas) {
   } else {
     for (const [key, s] of Object.entries(schemas)) {
       normalizeDraft7(s)
+      normalizeNullable(s)
       map.set(s.$id || key, s)
     }
   }
@@ -459,6 +466,8 @@ class Validator {
 
     // Draft 7 normalization — convert keywords to 2020-12 equivalents in-place
     normalizeDraft7(schemaObj);
+    // OpenAPI nullable -> type union with 'null'
+    normalizeNullable(schemaObj);
 
     this._schemaStr = null; // lazy: computed on first use
     this._schemaObj = schemaObj;
@@ -859,16 +868,20 @@ class Validator {
               return false;
             }
           };
-      // validateAndParse: requires native addon for simdjson parsing
-      if (native) {
+      // validateAndParse: parse the JSON, then validate. Pure JS (JSON.parse +
+      // validate) so it works with or without the native addon and in browsers.
+      {
         const self = this;
         this.validateAndParse = (jsonStr) => {
-          self._ensureNative();
-          self.validateAndParse = (s) => self._compiled.validateAndParse(s);
-          return self.validateAndParse(jsonStr);
+          let value;
+          try {
+            value = JSON.parse(typeof jsonStr === 'string' ? jsonStr : new TextDecoder().decode(jsonStr));
+          } catch (e) {
+            return { valid: false, value: undefined, errors: [{ code: 'ATA9001', message: 'invalid JSON: ' + e.message, keyword: '__parse__', instancePath: '', schemaPath: '', params: {} }] };
+          }
+          const r = self.validate(value);
+          return { valid: r.valid, value, errors: r.errors };
         };
-      } else {
-        this.validateAndParse = () => { throw new Error('Native addon required for validateAndParse()'); };
       }
       // Buffer APIs: lazy native init — only compile native schema on first buffer call.
       // This keeps cold start fast (JS codegen only) for users who only use validate().
@@ -1074,6 +1087,7 @@ class Validator {
     }
     // Apply Draft 7 normalization if needed
     normalizeDraft7(schema)
+    normalizeNullable(schema)
     this._schemaMap.set(schema.$id, schema)
   }
 
@@ -1642,6 +1656,14 @@ function attachSuggestions (errors, data) {
   return errors;
 }
 
+// Authoring helper: identity at runtime. Its only job is to attach the
+// JSONSchema type (see index.d.ts) to an inline schema object so TypeScript
+// gives autocomplete and value checking while authoring. Returns the schema
+// untouched so it can be passed straight to Validator, toStandaloneModule, etc.
+function defineSchema (schema) {
+  return schema;
+}
+
 module.exports = {
   Validator,
   compile,
@@ -1651,6 +1673,7 @@ module.exports = {
   SIMDJSON_PADDING,
   parseJSON,
   toTypeScript,
+  defineSchema,
   renderPretty,
   renderCompact,
   renderJSON,

package/index.mjs

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

package/lib/draft7.js

@@ -79,4 +79,51 @@ function _normalize(schema) {
   }
 }
 
-module.exports = { isDraft7, normalizeDraft7 }
+// OpenAPI `nullable: true` is not JSON Schema. Convert it to a union with
+// 'null' (`{ type: 'X', nullable: true }` -> `{ type: ['X', 'null'] }`), the
+// same shape AJV produces under its `nullable` option. Recurses only through
+// schema-bearing keywords so it never touches data values (default, const, etc.).
+function normalizeNullable(schema) {
+  if (typeof schema !== 'object' || schema === null) return schema
+  _normalizeNullable(schema)
+  return schema
+}
+
+function _normalizeNullable(schema) {
+  if (typeof schema !== 'object' || schema === null) return
+
+  if (schema.nullable === true && schema.type !== undefined) {
+    if (Array.isArray(schema.type)) {
+      if (!schema.type.includes('null')) schema.type = schema.type.concat('null')
+    } else {
+      schema.type = [schema.type, 'null']
+    }
+  }
+  if ('nullable' in schema) delete schema.nullable
+
+  const objSubs = ['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas']
+  for (const key of objSubs) {
+    if (schema[key] && typeof schema[key] === 'object') {
+      for (const v of Object.values(schema[key])) {
+        if (typeof v === 'object' && v !== null) _normalizeNullable(v)
+      }
+    }
+  }
+  const arrSubs = ['allOf', 'anyOf', 'oneOf', 'prefixItems']
+  for (const key of arrSubs) {
+    if (Array.isArray(schema[key])) {
+      for (const s of schema[key]) {
+        if (typeof s === 'object' && s !== null) _normalizeNullable(s)
+      }
+    }
+  }
+  const singleSubs = ['items', 'contains', 'not', 'if', 'then', 'else',
+                       'additionalProperties', 'propertyNames', 'unevaluatedItems', 'unevaluatedProperties']
+  for (const key of singleSubs) {
+    if (typeof schema[key] === 'object' && schema[key] !== null) {
+      _normalizeNullable(schema[key])
+    }
+  }
+}
+
+module.exports = { isDraft7, normalizeDraft7, normalizeNullable }

package/lib/js-compiler.js

@@ -690,6 +690,23 @@ function canResolveDynamicRefs(target, callingSchema, schemaMap) {
 
 // Recursively check if a schema can be safely compiled to JS codegen.
 // Returns false if any sub-schema contains features codegen gets wrong.
+// Does the schema (recursively) contain an anchor-style `$ref` equal to anchorId
+// (e.g. `$ref: '#address'`)? Used to keep codegen away from anchor refs it can't
+// resolve in the combined/error paths.
+function schemaHasAnchorRef(node, anchorId) {
+  if (!node || typeof node !== 'object') return false
+  if (Array.isArray(node)) {
+    for (const x of node) if (schemaHasAnchorRef(x, anchorId)) return true
+    return false
+  }
+  if (node.$ref === anchorId) return true
+  for (const k in node) {
+    if (k === '$ref') continue
+    if (schemaHasAnchorRef(node[k], anchorId)) return true
+  }
+  return false
+}
+
 function codegenSafe(schema, schemaMap) {
   if (typeof schema === 'boolean') return true
   if (typeof schema !== 'object' || schema === null) return true
@@ -799,7 +816,15 @@ function codegenSafe(schema, schemaMap) {
       if (/[~/"']/.test(name)) return false // special chars in def name
       if (typeof def === 'boolean') return false
       if (typeof def === 'object' && def !== null) {
-        if (def.$id) return false // $id in $defs creates new resolution scope — bail
+        // A non-fragment $id (e.g. 'sub.json', 'http://...') opens a new base URI
+        // scope — bail. A fragment-only $id ('#name') is a draft-07 anchor; it is
+        // safe to codegen when reached by JSON pointer (#/definitions/name), but the
+        // combined/error codegen paths do not resolve anchor refs (`$ref: '#name'`)
+        // to it, so bail if the schema anchor-references this def.
+        if (def.$id) {
+          if (!def.$id.startsWith('#')) return false
+          if (schemaHasAnchorRef(schema, def.$id)) return false
+        }
         if (def.$ref) return false // nested ref chain — bail
         if (!codegenSafe(def, schemaMap)) return false
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "0.15.1",
+  "version": "0.17.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",
@@ -42,7 +42,7 @@
     "rebuild": "cmake-js rebuild --target ata",
     "prebuild": "pkg-prebuilds-copy --baseDir build/Release --source ata.node --name=ata --strip --napi_version=10",
     "prebuild-all": "npm run prebuild -- --arch x64 && npm run prebuild -- --arch arm64",
-    "test": "node test.js && node tests/test_no_native.js && node tests/test_aot_build.js && node tests/test_aot_differential.js && node tests/test_aot_cli_build.js && node tests/test_aot_cli_smoke.js && node tests/test_bundle_standalone.js && node tests/test_typed_validator_runner.js && node tests/test_error_codes_lock.js && node tests/test_enrich_error.js && node tests/test_rich_errors_optout.js && node tests/test_source_positions.js && node tests/fuzz_positions.js && node tests/test_data_positions.js && node tests/test_render_shared.js && node tests/test_renderers.js && node tests/test_runtime_error_dx.js && node tests/test_aot_error_dx.js && node tests/test_abort_early.js && node tests/test_branch_collapse.js && node tests/test_suggestions.js && node tests/test_cli_validate.js && node benchmark/bench_aot_size.mjs",
+    "test": "node test.js && node tests/test_no_native.js && node tests/test_aot_build.js && node tests/test_aot_differential.js && node tests/test_aot_cli_build.js && node tests/test_aot_cli_smoke.js && node tests/test_bundle_standalone.js && node tests/test_typed_validator_runner.js && node tests/test_define_schema.js && node tests/test_error_codes_lock.js && node tests/test_nullable.js && node tests/test_validate_and_parse.js && node tests/test_enrich_error.js && node tests/test_rich_errors_optout.js && node tests/test_source_positions.js && node tests/fuzz_positions.js && node tests/test_data_positions.js && node tests/test_render_shared.js && node tests/test_renderers.js && node tests/test_runtime_error_dx.js && node tests/test_aot_error_dx.js && node tests/test_abort_early.js && node tests/test_branch_collapse.js && node tests/test_suggestions.js && node tests/test_cli_validate.js && node benchmark/bench_aot_size.mjs",
     "bench:size": "node benchmark/bench_aot_size.mjs",
     "test:suite": "node tests/run_suite.js",
     "test:compat": "node tests/test_compat.js",