fastify-ata 0.7.0 → 0.8.0

package/README.md

@@ -104,12 +104,14 @@ app.post('/users', { schema: { body: Body } }, (req, reply) => {
 
 ## Options
 
+Defaults mirror Fastify's stock validator: `coerceTypes: 'array'` (path params and querystring values arrive as strings and coerce to the schema types, single-element arrays collapse for querystrings) and `removeAdditional: true` (properties outside the schema are stripped, not rejected). Override either to opt out:
+
 ```js
 fastify.register(fastifyAta, {
-  coerceTypes: true,       // convert "42" -> 42 for integer fields
-  removeAdditional: true,  // strip properties not in schema
-  abortEarly: true,        // skip detailed error collection (faster invalid path)
-  prettyErrors: true,      // 400 message carries the ATA code + a did-you-mean
+  coerceTypes: false,       // reject "42" for integer fields instead of coercing
+  removeAdditional: false,  // 400 on properties outside the schema
+  abortEarly: true,         // skip detailed error collection (faster invalid path)
+  prettyErrors: true,       // 400 message carries the ATA code + a did-you-mean
 })
 ```
 
@@ -270,7 +272,8 @@ Generated file has zero runtime dependency on `ata-validator`. `isValid` is emit
 - **simdjson** - SIMD-accelerated JSON parsing for buffer-input paths
 - **Multi-core** - `countValid(ndjsonBuf)` validates many messages in one native call
 - **Standard Schema V1** - native support, works with Fastify v5, tRPC, TanStack Form, Drizzle
-- **Draft 2020-12 and Draft 7** - 98.5% compliance on the official JSON Schema Test Suite
+- **Draft 2020-12 and Draft 7** - every applicable draft 2020-12 case in the official JSON Schema Test Suite passes with the native engine installed (1190/1190); 99.8% pure JS
+- **Fastify's own suite** - 181 of 187 tests pass with ata as the default validator; the remaining six test the default validator's private extension API. See [compat/COMPATIBILITY.md](compat/COMPATIBILITY.md)
 
 ## License
 

package/compat/COMPATIBILITY.md

@@ -0,0 +1,36 @@
+# Fastify test suite compatibility
+
+fastify-ata can serve as Fastify's global default validator. To measure what that actually means, we run Fastify's own schema and validation test files against ata instead of the default validator, using the preload harness in this directory:
+
+```
+cd <fastify checkout>
+node --require <fastify-ata>/compat/ata-default-preload.js \
+  --test $(ls test/*schema*.test.js test/*valid*.test.js | tr '\n' ' ')
+```
+
+The preload swaps the single `require('@fastify/ajv-compiler')` inside Fastify's schema controller for the ata factory in `../compiler.js`. Tests that build their own AJV instance or set a custom `validatorCompiler` bypass the swap and keep using AJV, as they should.
+
+## Current score
+
+**181 of 187 tests pass** (Fastify v5.8.4 checkout, ata-validator 1.2.0, fastify-ata main).
+
+Everything Fastify's suite asserts about validation behavior passes: type checks and coercion (including the `array` coercion mode), defaults, `removeAdditional`, required and enum handling, cross-schema `$ref` through `addSchema`, draft-07 `$id` anchors, `nullable`, `oneOf`/`anyOf` branching, custom error messages via `errorMessage`, `$merge`/`$patch` keywords, fail-fast startup errors for unresolvable references, encapsulation scoping, error shape (exact default error object layout, mutable for plugins like ajv-i18n), the error paths in `validation-error-handling`, and shared-schema `$ref` into `/definitions` across the validator AND the serializer (ata never mutates caller-provided schema objects, so fast-json-stringify sees them untouched).
+
+## The remaining 6, one by one
+
+These tests do not check validation behavior; they check that the validator IS AJV, by exercising AJV's own extension API or internals. Any validator that is not AJV fails them by definition.
+
+| Test | Why it cannot apply |
+|---|---|
+| Check how many AJV instances are built #1 | Counts AJV instance allocations inside the validator pool. ata has no AJV instances to count. |
+| Check how many AJV instances are built #2 - verify validatorPool | Same, via the pool object identity. |
+| Ajv plugins array parameter | Passes AJV plugin functions through `ajv: { plugins: [...] }`. ata does not execute AJV plugins; equivalent behavior is configured through ata options. |
+| Supports async AJV validation | Requires `$async: true` schemas compiled by AJV's async mode. ata's async story is `validateAsync`/refinements, a different (non-AJV) API. |
+| Check all the async AJV validation paths | Same `$async` mechanism, more paths. |
+| Check if hooks and attachValidation work with AJV validations | Registers a custom async AJV keyword (`idExists`) via `ajv.customOptions.keywords`, then uses `$async`. Custom-keyword registration is AJV's extension API. |
+
+All six are AJV-identity tests. The former seventh (ajv-errors message ordering) passes since ata-validator 1.2.0: validation errors follow the schema's keyword declaration order.
+
+## Reading the number honestly
+
+The suite contains 187 tests because it grew around AJV; a hypothetical perfect drop-in that is not AJV tops out at 181. ata passes all 181. If you find a behavior difference not covered here, that is a bug in fastify-ata or ata: please open an issue.

package/compiler.js

@@ -1,6 +1,8 @@
 'use strict'
 
 const { Validator } = require('ata-validator')
+const { expandMergePatch } = require('./merge-patch')
+const { checkRefs } = require('./ref-check')
 
 // @fastify/ajv-compiler-compatible factory so ata can be installed as
 // Fastify's global default validator:
@@ -30,9 +32,15 @@ function AtaCompiler() {
       schemas: externalSchemas,
       coerceTypes,
       removeAdditional,
+      // Fastify's ecosystem (error handlers, tests, ajv-errors consumers)
+      // asserts the exact ajv error object shape; the rich fields belong to
+      // the plugin path, not the default-validator path.
+      richErrors: false,
     }
 
     return function buildValidatorFunction({ schema }) {
+      schema = expandMergePatch(schema)
+      checkRefs(schema, externalSchemas)
       const validator = new Validator(schema, validatorOpts)
       function validate(data) {
         const result = validator.validate(data)
@@ -40,7 +48,11 @@ function AtaCompiler() {
           validate.errors = null
           return hasCoercion ? { value: data } : true
         }
-        validate.errors = firstErrorOnly ? [result.errors[0]] : result.errors
+        // Plain mutable copies: ajv ecosystem plugins (ajv-i18n, error
+        // decorators) assign to error fields, and ata's error objects are
+        // frozen.
+        const errors = firstErrorOnly ? [result.errors[0]] : result.errors
+        validate.errors = errors.map((e) => ({ ...e }))
         return false
       }
       validate.errors = null

package/index.js

@@ -2,6 +2,7 @@
 
 const fp = require('fastify-plugin')
 const { Validator } = require('ata-validator')
+const { expandMergePatch } = require('./merge-patch')
 
 function prettyFormat(errors, dataVar) {
   const message = errors.map((e) => {
@@ -17,10 +18,16 @@ function prettyFormat(errors, dataVar) {
 
 function fastifyAta(fastify, opts, done) {
   const cache = new WeakMap()
-  const hasCoercion = !!(opts.coerceTypes || opts.removeAdditional)
+  // Defaults mirror Fastify's stock validator configuration (and compiler.js):
+  // types are coerced with querystring array support and additional properties
+  // are removed. Anything else breaks `/users/:id` on the documented
+  // `register(fastifyAta)` path, because path params always arrive as strings.
+  const coerceTypes = opts.coerceTypes !== undefined ? opts.coerceTypes : 'array'
+  const removeAdditional = opts.removeAdditional !== undefined ? !!opts.removeAdditional : true
+  const hasCoercion = !!(coerceTypes || removeAdditional)
   const validatorOpts = {
-    coerceTypes: opts.coerceTypes || false,
-    removeAdditional: opts.removeAdditional || false,
+    coerceTypes,
+    removeAdditional,
     abortEarly: opts.abortEarly || false,
   }
 
@@ -31,6 +38,7 @@ function fastifyAta(fastify, opts, done) {
   fastify.setValidatorCompiler(({ schema }) => {
     let validator = cache.get(schema)
     if (!validator) {
+      schema = expandMergePatch(schema)
       // Pass schemas registered via `fastify.addSchema` so cross-schema `$ref`
       // (e.g. `{ $ref: 'shared#' }`) resolves. Compilers run at ready() time,
       // after every addSchema, so getSchemas() returns the full bucket.

package/merge-patch.js

@@ -0,0 +1,124 @@
+'use strict'
+
+// Structural pre-processor: expand $merge (RFC 7386) and $patch (RFC 6902 subset)
+// keywords before handing the schema to ata-validator. Fastify passes schemas
+// containing these keywords when ajv-merge-patch is listed in ajv.plugins; we
+// handle them here so ata never sees them.
+//
+// Rules:
+//   $merge: { source, with }  -> JSON Merge Patch (RFC 7386): W applied to S
+//   $patch: { source, with }  -> RFC 6902 JSON Patch (ops: add, replace, remove only)
+//
+// Expansion is recursive: keywords may be nested anywhere; results may contain
+// further keywords. Never mutates the input.
+
+function hasMergePatch(schema) {
+  if (!schema || typeof schema !== 'object') return false
+  if (Array.isArray(schema)) return schema.some(hasMergePatch)
+  if ('$merge' in schema || '$patch' in schema) return true
+  return Object.values(schema).some(hasMergePatch)
+}
+
+// RFC 7386 JSON Merge Patch: apply patch W onto target S.
+// Objects merge recursively; null in W deletes the key; arrays/scalars replace.
+function applyMergePatch(source, patch) {
+  if (patch === null || typeof patch !== 'object' || Array.isArray(patch)) {
+    return patch
+  }
+  if (source === null || typeof source !== 'object' || Array.isArray(source)) {
+    source = {}
+  }
+  const result = Object.assign({}, source)
+  for (const key of Object.keys(patch)) {
+    if (patch[key] === null) {
+      delete result[key]
+    } else {
+      result[key] = applyMergePatch(result[key], patch[key])
+    }
+  }
+  return result
+}
+
+// JSON Pointer resolution with ~0/~1 unescaping (RFC 6901).
+function resolvePointer(obj, pointer) {
+  if (pointer === '') return { obj, key: null, parent: null }
+  const parts = pointer.slice(1).split('/').map(p => p.replace(/~1/g, '/').replace(/~0/g, '~'))
+  let parent = null
+  let current = obj
+  let lastKey = null
+  for (const part of parts) {
+    parent = current
+    lastKey = part
+    if (current == null || typeof current !== 'object') {
+      throw new Error(`$patch: cannot traverse into non-object at /${part}`)
+    }
+    current = current[part]
+  }
+  return { parent, key: lastKey, value: current }
+}
+
+// RFC 6902 JSON Patch: apply array of ops to document. Supported: add, replace, remove.
+function applyJsonPatch(source, ops) {
+  // Deep-clone so ops can mutate freely without touching input.
+  let doc = JSON.parse(JSON.stringify(source == null ? {} : source))
+  for (const op of ops) {
+    const { op: opName, path, value } = op
+    if (opName === 'add' || opName === 'replace') {
+      if (path === '') {
+        doc = value
+        continue
+      }
+      const { parent, key } = resolvePointer(doc, path)
+      if (parent == null) throw new Error(`$patch: invalid path "${path}"`)
+      if (opName === 'replace' && !(key in parent)) {
+        throw new Error(`$patch: cannot replace non-existent path "${path}"`)
+      }
+      parent[key] = value
+    } else if (opName === 'remove') {
+      if (path === '') throw new Error('$patch: cannot remove root')
+      const { parent, key } = resolvePointer(doc, path)
+      if (parent == null) throw new Error(`$patch: invalid path "${path}"`)
+      if (!(key in parent)) {
+        throw new Error(`$patch: cannot remove non-existent path "${path}"`)
+      }
+      delete parent[key]
+    } else {
+      throw new Error(`$patch: unsupported op "${opName}" (only add/replace/remove supported)`)
+    }
+  }
+  return doc
+}
+
+// Recursively expand $merge/$patch in schema. Returns a new object; never mutates.
+function expand(schema, depth = 0) {
+  if (depth > 100) {
+    throw new Error('$merge/$patch: expansion exceeded depth limit (circular?)')
+  }
+  if (!schema || typeof schema !== 'object') return schema
+  if (Array.isArray(schema)) return schema.map(s => expand(s, depth))
+
+  if ('$merge' in schema) {
+    const source = expand(schema.$merge.source, depth + 1)
+    const patch = expand(schema.$merge.with, depth + 1)
+    return expand(applyMergePatch(source, patch), depth + 1)
+  }
+
+  if ('$patch' in schema) {
+    const source = expand(schema.$patch.source, depth + 1)
+    const ops = schema.$patch.with
+    return expand(applyJsonPatch(source, ops), depth + 1)
+  }
+
+  const result = {}
+  for (const key of Object.keys(schema)) {
+    result[key] = expand(schema[key], depth)
+  }
+  return result
+}
+
+function expandMergePatch(schema) {
+  if (!hasMergePatch(schema)) return schema
+  return expand(schema)
+}
+
+module.exports = { expandMergePatch }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify-ata",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Fastify plugin for ata-validator. Runtime-competitive with the default, 24x faster serverless cold start, Standard Schema V1.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -26,7 +26,7 @@
   },
   "homepage": "https://github.com/ata-core/fastify-ata#readme",
   "dependencies": {
-    "ata-validator": "^1.0.0",
+    "ata-validator": "^1.2.0",
     "fastify-plugin": "^5.1.0",
     "sanitize-filename": "^1.6.4"
   },

package/ref-check.js

@@ -0,0 +1,145 @@
+'use strict'
+
+// Conservative compile-time $ref resolvability check.
+// Only throws on clearly-unresolvable refs; when in doubt, stays silent.
+// Message format matches ajv: "can't resolve reference <ref> from id #"
+
+/**
+ * Collect all $ref string values from a schema (recursive).
+ * @param {object} schema
+ * @param {string[]} refs
+ */
+function collectRefs(schema, refs) {
+  if (!schema || typeof schema !== 'object') return
+  if (Array.isArray(schema)) {
+    for (const item of schema) collectRefs(item, refs)
+    return
+  }
+  if (typeof schema.$ref === 'string') refs.push(schema.$ref)
+  for (const key of Object.keys(schema)) {
+    if (key === '$ref') continue
+    collectRefs(schema[key], refs)
+  }
+}
+
+/**
+ * Collect all $id and $anchor string values from a schema (recursive).
+ * @param {object} schema
+ * @param {Set<string>} ids
+ */
+function collectIds(schema, ids) {
+  if (!schema || typeof schema !== 'object') return
+  if (Array.isArray(schema)) {
+    for (const item of schema) collectIds(item, ids)
+    return
+  }
+  if (typeof schema.$id === 'string') ids.add(schema.$id)
+  if (typeof schema.$anchor === 'string') ids.add(schema.$anchor)
+  for (const key of Object.keys(schema)) {
+    if (key === '$id' || key === '$anchor') continue
+    collectIds(schema[key], ids)
+  }
+}
+
+/**
+ * Trailing-slash-insensitive identifier comparison. Per RFC 3986
+ * normalization, 'http://x.test/' and 'http://x.test' identify the same
+ * resource and the default resolver accepts either spelling; comparing
+ * literally would produce false positives. This only ADDS acceptance.
+ * @param {string} a
+ * @param {string} b
+ * @returns {boolean}
+ */
+function idMatches(a, b) {
+  if (a === b) return true
+  const stripA = a.endsWith('/') ? a.slice(0, -1) : a
+  const stripB = b.endsWith('/') ? b.slice(0, -1) : b
+  return stripA === stripB
+}
+
+/**
+ * @param {Set<string>} ids
+ * @param {string} value
+ * @returns {boolean}
+ */
+function idSetHas(ids, value) {
+  // The linear fallback handles trailing-slash URI variants the O(1)
+  // membership check misses; do not replace this with a bare ids.has().
+  if (ids.has(value)) return true
+  for (const id of ids) {
+    if (idMatches(id, value)) return true
+  }
+  return false
+}
+
+/**
+ * Check whether a $ref is clearly unresolvable. Throws with ajv-compatible
+ * message on the FIRST clearly-unresolvable ref found.
+ *
+ * @param {object} schema - the route schema (already merge-patch-expanded)
+ * @param {object} externalSchemas - the externalSchemas map from the pool
+ */
+function checkRefs(schema, externalSchemas) {
+  const refs = []
+  collectRefs(schema, refs)
+  if (refs.length === 0) return
+
+  const localIds = new Set()
+  collectIds(schema, localIds)
+
+  const extKeys = externalSchemas ? Object.keys(externalSchemas) : []
+
+  for (const ref of refs) {
+    // Local JSON-pointer refs (#/...) are always accepted.
+    if (ref.startsWith('#/')) continue
+
+    // Anchor-style local ref: starts with '#' but has no slash.
+    if (ref.startsWith('#')) {
+      const name = ref.slice(1) // e.g. "notExist" from "#notExist"
+      // Accept if we find a matching $id or $anchor in the local schema.
+      // Two lookups on purpose: collectIds stores $id values verbatim
+      // ("#notExist" matches via ref) while $anchor values are stored bare
+      // ("notExist" matches via name). This branch uses strict equality
+      // throughout: anchor names are never URI-style, so trailing-slash
+      // normalization does not apply here.
+      if (localIds.has(ref) || localIds.has(name)) continue
+      // Accept if any external schema key or nested $id resolves it.
+      if (extKeys.some(k => k === ref || k === name)) continue
+      if (extKeys.some(k => {
+        const ext = externalSchemas[k]
+        if (!ext || typeof ext !== 'object') return false
+        const extIds = new Set()
+        collectIds(ext, extIds)
+        return extIds.has(ref) || extIds.has(name)
+      })) continue
+      // Clearly unresolvable anchor.
+      throw new Error(`can't resolve reference ${ref} from id #`)
+    }
+
+    // External ref: "base" or "base#fragment"
+    const hashIdx = ref.indexOf('#')
+    const base = hashIdx === -1 ? ref : ref.slice(0, hashIdx)
+    if (!base) continue // bare '#' or '#/...' already handled above
+
+    // Accept if base matches any external schema key
+    // (trailing-slash-insensitive for URI-style ids).
+    if (extKeys.some(k => idMatches(k, base))) continue
+
+    // Accept if base is found as any nested $id in the local schema.
+    if (idSetHas(localIds, base)) continue
+
+    // Accept if base matches any nested $id in any external schema.
+    if (extKeys.some(k => {
+      const ext = externalSchemas[k]
+      if (!ext || typeof ext !== 'object') return false
+      const extIds = new Set()
+      collectIds(ext, extIds)
+      return idSetHas(extIds, base)
+    })) continue
+
+    // Clearly unresolvable external ref.
+    throw new Error(`can't resolve reference ${ref} from id #`)
+  }
+}
+
+module.exports = { checkRefs }

package/test-compiler.js

@@ -5,6 +5,7 @@
 
 const Fastify = require('fastify')
 const AtaCompiler = require('./compiler')
+const { expandMergePatch } = require('./merge-patch')
 
 let pass = 0
 let fail = 0
@@ -24,7 +25,15 @@ async function run() {
   assert(validate({ n: 1 }) === true || (validate({ n: 1 }) && validate({ n: 1 }).value), 'compiler: valid input accepted')
   const bad = validate({})
   assert(bad === false, 'compiler: invalid input rejected')
-  assert(validate.errors && validate.errors[0].code, `compiler: rich errors present (got ${JSON.stringify(validate.errors && validate.errors[0])})`)
+  // The compiler path is Fastify's default-validator route: errors must be
+  // the exact ajv shape (no rich fields) and mutable, because ecosystem
+  // plugins like ajv-i18n assign to error.message. Rich errors belong to the
+  // plugin path.
+  const err0 = validate.errors && validate.errors[0]
+  assert(err0 && err0.keyword && err0.message && err0.code === undefined && err0.docUrl === undefined,
+    `compiler: ajv-shaped errors (got ${JSON.stringify(err0)})`)
+  err0.message = 'mutated'
+  assert(err0.message === 'mutated', 'compiler: error objects are mutable')
 
   // As Fastify's GLOBAL default via schemaController, with cross-schema $ref
   const app = Fastify({
@@ -62,6 +71,241 @@ async function run() {
   assert(JSON.parse(qRes.payload).typ === 'number', `compiler: querystring coerced to number (got ${qRes.payload})`)
   await app2.close()
 
+  // --- $merge / $patch expansion tests ---
+
+  // root $merge: required added via with
+  const mergeResult = expandMergePatch({
+    $merge: {
+      source: { type: 'object', properties: { q: { type: 'string' } } },
+      with: { required: ['q'] }
+    }
+  })
+  assert(
+    mergeResult.type === 'object' &&
+    Array.isArray(mergeResult.required) &&
+    mergeResult.required[0] === 'q',
+    '$merge: required added via with'
+  )
+
+  // root $patch: add op changes a property type
+  const patchResult = expandMergePatch({
+    $patch: {
+      source: { type: 'object', properties: { q: { type: 'string' } } },
+      with: [{ op: 'add', path: '/properties/q', value: { type: 'number' } }]
+    }
+  })
+  assert(
+    patchResult.properties && patchResult.properties.q && patchResult.properties.q.type === 'number',
+    '$patch: add op changes property type'
+  )
+
+  // nested $merge inside a larger schema
+  const nestedSchema = {
+    type: 'object',
+    properties: {
+      inner: {
+        $merge: {
+          source: { type: 'object', properties: { n: { type: 'integer' } } },
+          with: { required: ['n'] }
+        }
+      }
+    }
+  }
+  const nestedResult = expandMergePatch(nestedSchema)
+  assert(
+    nestedResult.properties.inner.required &&
+    nestedResult.properties.inner.required[0] === 'n' &&
+    nestedResult.properties.inner.type === 'object',
+    '$merge nested: expansion works inside properties'
+  )
+
+  // null deletes key in $merge
+  const nullDeleteResult = expandMergePatch({
+    $merge: {
+      source: { type: 'object', required: ['x'], properties: { x: { type: 'string' } } },
+      with: { required: null }
+    }
+  })
+  assert(
+    !('required' in nullDeleteResult),
+    '$merge null: null in with deletes the key'
+  )
+
+  // unsupported op throws
+  let threw = false
+  try {
+    expandMergePatch({
+      $patch: {
+        source: { type: 'object' },
+        with: [{ op: 'move', from: '/a', path: '/b' }]
+      }
+    })
+  } catch (e) {
+    threw = e.message.includes('unsupported op')
+  }
+  assert(threw, '$patch: unsupported op throws with clear message')
+
+  // remove on non-existent path throws
+  let removeMissingThrew = false
+  try {
+    expandMergePatch({
+      $patch: {
+        source: { type: 'object', properties: { x: { type: 'string' } } },
+        with: [{ op: 'remove', path: '/properties/y' }]
+      }
+    })
+  } catch (e) {
+    removeMissingThrew = e.message.includes('cannot remove non-existent path')
+  }
+  assert(removeMissingThrew, '$patch: remove on non-existent path throws')
+
+  // replace on non-existent path throws
+  let replaceMissingThrew = false
+  try {
+    expandMergePatch({
+      $patch: {
+        source: { type: 'object', properties: { x: { type: 'string' } } },
+        with: [{ op: 'replace', path: '/properties/z', value: { type: 'number' } }]
+      }
+    })
+  } catch (e) {
+    replaceMissingThrew = e.message.includes('cannot replace non-existent path')
+  }
+  assert(replaceMissingThrew, '$patch: replace on non-existent path throws')
+
+  // expansion depth limit: construct deeply nested $merge chain that exceeds limit
+  let depthThrew = false
+  const buildDeepMerge = (depth) => {
+    if (depth === 0) return { type: 'object' }
+    return { $merge: { source: buildDeepMerge(depth - 1), with: { properties: { x: { type: 'string' } } } } }
+  }
+  try {
+    expandMergePatch(buildDeepMerge(105))
+  } catch (e) {
+    depthThrew = e.message.includes('expansion exceeded depth limit')
+  }
+  assert(depthThrew, '$merge/$patch: expansion depth limit enforced')
+
+  // schema without $merge/$patch passes through unchanged (no copy)
+  const plain = { type: 'object', properties: { x: { type: 'string' } } }
+  assert(expandMergePatch(plain) === plain, '$merge/$patch: plain schema passes through without copy')
+
+  // $merge integration: compiler accepts expanded schema
+  const factory2 = AtaCompiler()
+  const build2 = factory2({}, { customOptions: {} })
+  const mergeSchema = {
+    $merge: {
+      source: { type: 'object', properties: { n: { type: 'integer' } } },
+      with: { required: ['n'] }
+    }
+  }
+  const validateMerge = build2({ schema: mergeSchema })
+  assert(validateMerge({ n: 1 }) !== false, '$merge compiler integration: valid input accepted')
+  assert(validateMerge({}) === false, '$merge compiler integration: missing required rejected')
+
+  // --- $ref resolvability checks ---
+
+  // (a) anchor-style local ref that does not exist -> must throw
+  {
+    const factory3 = AtaCompiler()
+    const build3 = factory3({}, { customOptions: {} })
+    let threw = false
+    let thrownMsg = ''
+    try {
+      build3({ schema: { type: 'object', properties: { name: { $ref: '#notExist' } } } })
+    } catch (e) {
+      threw = true
+      thrownMsg = e.message
+    }
+    assert(threw, 'ref-check: #notExist with no externals throws')
+    assert(thrownMsg === "can't resolve reference #notExist from id #",
+      `ref-check: #notExist message exact (got: ${thrownMsg})`)
+  }
+
+  // (b) external ref with no matching external schema -> must throw
+  {
+    const factory4 = AtaCompiler()
+    const build4 = factory4({}, { customOptions: {} })
+    let threw = false
+    let thrownMsg = ''
+    try {
+      build4({ schema: { type: 'object', properties: { id: { $ref: 'encapsulation#/properties/id' } } } })
+    } catch (e) {
+      threw = true
+      thrownMsg = e.message
+    }
+    assert(threw, 'ref-check: encapsulation#/properties/id with no externals throws')
+    assert(thrownMsg === "can't resolve reference encapsulation#/properties/id from id #",
+      `ref-check: encapsulation message exact (got: ${thrownMsg})`)
+  }
+
+  // (c) external ref WITH matching external schema -> must NOT throw
+  {
+    const factory5 = AtaCompiler()
+    const build5 = factory5(
+      { encapsulation: { $id: 'encapsulation', type: 'object', properties: { id: { type: 'number' } } } },
+      { customOptions: {} }
+    )
+    let threw = false
+    try {
+      build5({ schema: { type: 'object', properties: { id: { $ref: 'encapsulation#/properties/id' } } } })
+    } catch (e) {
+      threw = true
+    }
+    assert(!threw, 'ref-check: encapsulation#/properties/id with external schema does NOT throw')
+  }
+
+  // (d) local JSON-pointer ref -> always accepted even when definitions absent
+  {
+    const factory6 = AtaCompiler()
+    const build6 = factory6({}, { customOptions: {} })
+    let threw = false
+    try {
+      build6({ schema: { type: 'object', properties: { x: { $ref: '#/definitions/x' } } } })
+    } catch (e) {
+      threw = true
+    }
+    assert(!threw, 'ref-check: local JSON-pointer #/definitions/x does NOT throw (conservative)')
+  }
+
+  // (e) anchor that EXISTS as $id in a local definition -> must NOT throw
+  {
+    const factory7 = AtaCompiler()
+    const build7 = factory7({}, { customOptions: {} })
+    let threw = false
+    try {
+      build7({
+        schema: {
+          type: 'object',
+          definitions: { addr: { $id: '#addr', type: 'string' } },
+          properties: { city: { $ref: '#addr' } }
+        }
+      })
+    } catch (e) {
+      threw = true
+    }
+    assert(!threw, 'ref-check: anchor #addr existing as $id in local definitions does NOT throw')
+  }
+
+  // (f) trailing-slash URI variant: external key 'http://fastify.test/' must
+  // satisfy ref base 'http://fastify.test' (RFC 3986 normalization, ajv resolves it)
+  {
+    const factory8 = AtaCompiler()
+    const build8 = factory8(
+      { 'http://fastify.test/': { $id: 'http://fastify.test/', type: 'object', properties: { hello: { type: 'string' } } } },
+      { customOptions: {} }
+    )
+    let threw = false
+    let thrownMsg = ''
+    try {
+      build8({ schema: { type: 'array', items: { $ref: 'http://fastify.test#/properties/hello' } } })
+    } catch (e) {
+      threw = true
+      thrownMsg = e.message
+    }
+    assert(!threw, `ref-check: trailing-slash URI id variant does NOT throw (got: ${thrownMsg})`)
+  }
+
   console.log(`\n${pass}/${pass + fail} tests passed\n`)
   process.exit(fail > 0 ? 1 : 0)
 }

package/test.js

@@ -59,7 +59,7 @@ async function run() {
   const r3 = await app.inject({
     method: 'POST',
     url: '/user',
-    payload: { name: 123 },
+    payload: { name: {} }, // objects never coerce to string, so this stays a type error under Fastify-parity coercion defaults
   })
   assert(r3.statusCode === 400, `wrong type returns 400 (got ${r3.statusCode})`)
 
@@ -103,7 +103,7 @@ async function run() {
   const r4 = await app.inject({
     method: 'POST',
     url: '/user',
-    payload: { name: 123 },
+    payload: { name: {} }, // objects never coerce to string, so this stays a type error under Fastify-parity coercion defaults
   })
   const errBody4 = JSON.parse(r4.payload)
   assert(r4.statusCode === 400, `ajv-style: returns 400 (got ${r4.statusCode})`)
@@ -205,18 +205,32 @@ async function run() {
   await app7.close()
 
   // 14. additionalProperties: false
+  // Default config mirrors Fastify's stock validator: removeAdditional is on,
+  // so extra properties are stripped before the handler, not rejected.
   const app8 = fastify()
   await app8.register(fastifyAta)
   app8.post('/strict', {
     schema: { body: { type: 'object', properties: { id: { type: 'integer' } }, additionalProperties: false } },
-  }, (req, reply) => reply.send({ ok: true }))
+  }, (req, reply) => reply.send({ body: req.body }))
   await app8.ready()
   const rs1 = await app8.inject({ method: 'POST', url: '/strict', payload: { id: 1 } })
   const rs2 = await app8.inject({ method: 'POST', url: '/strict', payload: { id: 1, extra: 'x' } })
   assert(rs1.statusCode === 200, 'additionalProperties: valid accepted')
-  assert(rs2.statusCode === 400, `additionalProperties: extra rejected (got ${rs2.statusCode})`)
+  assert(rs2.statusCode === 200, `additionalProperties: extra stripped, request accepted (got ${rs2.statusCode})`)
+  assert(!('extra' in JSON.parse(rs2.payload).body), 'additionalProperties: extra property removed from body')
   await app8.close()
 
+  // 14b. removeAdditional: false restores strict rejection.
+  const app8b = fastify()
+  await app8b.register(fastifyAta, { removeAdditional: false })
+  app8b.post('/strict', {
+    schema: { body: { type: 'object', properties: { id: { type: 'integer' } }, additionalProperties: false } },
+  }, (req, reply) => reply.send({ ok: true }))
+  await app8b.ready()
+  const rs3 = await app8b.inject({ method: 'POST', url: '/strict', payload: { id: 1, extra: 'x' } })
+  assert(rs3.statusCode === 400, `additionalProperties: extra rejected with removeAdditional: false (got ${rs3.statusCode})`)
+  await app8b.close()
+
   // 15. array items validation
   const app9 = fastify()
   await app9.register(fastifyAta)
@@ -393,7 +407,7 @@ async function run() {
   const t3 = await tApp.inject({
     method: 'POST',
     url: '/user',
-    payload: { name: 123 },
+    payload: { name: {} }, // objects never coerce to string, so this stays a type error under Fastify-parity coercion defaults
   })
   assert(t3.statusCode === 400, `turbo: wrong type returns 400 (got ${t3.statusCode})`)