fastify-ata 0.9.2 → 0.9.4

package/.github/dependabot.yml

@@ -0,0 +1,18 @@
+version: 2
+updates:
+  # ata-validator moves faster than this package does. A bump PR lands here on
+  # its own so the pin never silently falls behind what is published.
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    open-pull-requests-limit: 5
+    commit-message:
+      prefix: "chore"
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    commit-message:
+      prefix: "chore"

package/README.md

@@ -227,26 +227,82 @@ Works with Fastify v5's Standard Schema support, tRPC, TanStack Form, Drizzle OR
 
 All numbers below are reproducible on M4 Pro / Node 25 with the benchmarks in this repo and in `ata-validator/benchmark`. Run-to-run noise is roughly +/- 5% at these scales.
 
-### Fastify pipeline (autocannon, 10 connections, pipelining 10)
+### Throughput: not a reason to switch
 
-| Payload | ajv (default) | ata | delta |
+`bench-realtime.js` reports about 15% more requests per second than ajv on a
+50-route app whose handlers do nothing. That number is reproducible and it is also
+misleading, so here is the whole picture. Sweeping the route count, echo handlers,
+50 connections:
+
+| Routes | ajv req/s | ata req/s | delta |
+|---|---|---|---|
+| 1 | 75,053 | 75,360 | +0.4% |
+| 10 | 64,333 | 74,259 | +15.4% |
+| 50 | 64,554 | 74,643 | +15.6% |
+| 200 | 66,486 | 65,491 | -1.5% |
+
+The gap is not a property of the validator, it is a dispatch effect that appears
+once there are enough distinct compiled validators to spoil V8's call-site caching
+and disappears again once there are many. Give the handler real work and it goes
+away entirely, one route, 50 to 200 connections:
+
+| Per-request work | ajv req/s | ata req/s | delta |
 |---|---|---|---|
-| valid (10 fields) | ~70,000 req/s | ~70,500 req/s | tied |
-| invalid (10 fields) | ~51,000 req/s | ~52,500 req/s | +3% |
-| invalid (abortEarly) | ~51,000 req/s | ~52,800 req/s | +3.5% |
+| none | 75,142 | 74,989 | -0.2% |
+| 1 ms | 70,342 | 71,418 | +1.5% |
+| 5 ms | 33,040 | 33,016 | -0.1% |
+| 20 ms | 9,310 | 9,236 | -0.8% |
 
-HTTP + JSON.parse + routing dominate the pipeline, so validator choice is small on throughput. The real difference is elsewhere.
+`profile-fastify.mjs` explains why: in one request `JSON.parse` is 92% of the cost
+and validation 7%. If your handler touches a database, the validator is not what
+decides your throughput. Switch for the boot numbers below, or for the errors,
+types and portability. Do not switch for requests per second.
 
 ### Where ata-validator moves the needle
 
+Schema compilation at boot, from `bench-startup.js`. Each figure is the median of
+nine process-isolated runs with a no-route Fastify baseline subtracted, so what is
+left is the cost of compiling the route schemas and nothing else.
+
+| Routes | ajv | ata | delta |
+|---|---|---|---|
+| 50 | 41.6 ms | 1.4 ms | **30x faster** |
+| 100 | 70.0 ms | 4.2 ms | **17x faster** |
+| 250 | 142.7 ms | 11.4 ms | **13x faster** |
+| 500 | 263.0 ms | 18.8 ms | **14x faster** |
+| 1000 | 548.4 ms | 41.2 ms | **13x faster** |
+
+Total boot time, baseline included, is 83.6 ms against 583.9 ms at 1000 routes. Below
+about 20 routes the difference is under measurement noise and not worth quoting.
+
+### Against the standalone build step (`bench-standalone-vs.js`)
+
+Fastify's documented route to the fastest startup is
+[`@fastify/ajv-compiler` in standalone mode](https://backend.cafe/how-to-unlock-the-fastest-fastify-server-startup):
+compile every route schema to a file at build time, load the files at boot. The
+table is process start to `app.ready()`, five schema types reused across routes,
+median of three runs.
+
+| Routes | ajv default | ajv standalone | ata, no build step | ata precompiled |
+|---|---|---|---|---|
+| 50 | 62 ms | 40 ms | 43 ms | 37 ms |
+| 100 | 77 ms | 45 ms | 47 ms | 40 ms |
+| 200 | 111 ms | 55 ms | 50 ms | 41 ms |
+| 500 | 182 ms | 81 ms | **59 ms** | 46 ms |
+
+Past about 200 routes, installing ata and doing nothing else boots faster than ajv
+with the build step in place: 59 ms against 81 ms at 500 routes. Precompiling with
+`fastify-ata/standalone` takes another 20% off, but it is an optimization rather
+than the thing that makes the difference. Under 100 routes the four are close
+enough that boot time should not decide anything.
+
 | Scenario | ajv | ata | delta |
 |---|---|---|---|
-| **Serverless cold start** (10 routes, first request) | 12.4 ms | 0.5 ms | **24x faster** |
-| **Startup** (200 routes) | 7.0 ms | 2.4 ms | **2.9x faster** |
-| **Invalid validation** (with abortEarly) | ~15 ns/op | 3.7 ns/op | **4x faster** |
 | **ReDoS pattern** `^(a+)+$` | 765 ms | 0.3 ms | **immune (RE2)** |
 
-Serverless cold start is the scenario that matters for Vercel, Cloudflare Workers, Fly.io and similar platforms. On a long-running box the gap closes, so classic servers will not see a throughput jump.
+Boot cost is the scenario that matters for Vercel, Fly.io and similar platforms, where
+a process starts far more often than a long-running box does. On a box that stays up,
+the gap is paid once.
 
 ### Build-time compile (optional)
 
@@ -273,7 +329,7 @@ Generated file has zero runtime dependency on `ata-validator`. `isValid` is emit
 - **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** - 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)
+- **Fastify's own suite** - 178 of 184 tests pass with ata as the default validator; the remaining six test the default validator's private extension API rather than validation behaviour. See [compat/COMPATIBILITY.md](compat/COMPATIBILITY.md)
 
 ## License
 

package/bench-realtime.js

@@ -0,0 +1,131 @@
+'use strict'
+
+// Real-time Fastify simulation: actual HTTP requests with autocannon
+// Shows: startup time + request throughput + latency
+
+const { writeFileSync, unlinkSync } = require('fs')
+const { fork, execSync } = require('child_process')
+const path = require('path')
+
+const ROUTES = 50
+const DURATION = 5 // seconds
+const CONNECTIONS = 50
+
+function makeRoutes(count) {
+  return Array.from({ length: count }, (_, i) => ({
+    path: `/api/v1/resource${i}`,
+    schema: {
+      body: {
+        type: 'object',
+        properties: {
+          id: { type: 'integer', minimum: 1 },
+          name: { type: 'string', minLength: 1, maxLength: 100 },
+          email: { type: 'string', format: 'email' },
+          age: { type: 'integer', minimum: 0, maximum: 150 },
+          active: { type: 'boolean' },
+          role: { enum: ['admin', 'user', 'moderator'] },
+        },
+        required: ['id', 'name', 'email', 'active', 'role'],
+      },
+    },
+  }))
+}
+
+const routes = makeRoutes(ROUTES)
+const payload = JSON.stringify({
+  id: 42, name: 'Mert', email: 'mert@example.com',
+  age: 26, active: true, role: 'admin'
+})
+
+function serverScript(useAta) {
+  return `
+'use strict'
+const t0 = process.hrtime.bigint()
+const fastify = require('fastify')()
+${useAta ? "fastify.register(require('./index'))" : ''}
+const routes = ${JSON.stringify(routes)}
+for (const r of routes) {
+  fastify.post(r.path, { schema: r.schema }, (req, reply) => {
+    reply.send({ ok: true, id: req.body.id })
+  })
+}
+fastify.listen({ port: 0 }).then(() => {
+  const startupMs = Number(process.hrtime.bigint() - t0) / 1e6
+  const port = fastify.server.address().port
+  process.send({ port, startupMs })
+})
+`
+}
+
+async function runTest(label, useAta) {
+  const scriptPath = path.join(__dirname, '_realtime_server.js')
+  writeFileSync(scriptPath, serverScript(useAta))
+
+  const child = fork(scriptPath, { stdio: ['pipe', 'pipe', 'pipe', 'ipc'] })
+  const { port, startupMs } = await new Promise(resolve => {
+    child.on('message', msg => resolve(msg))
+  })
+
+  // Pick a random route for each request
+  const targetRoute = routes[Math.floor(Math.random() * routes.length)].path
+  const escaped = payload.replace(/'/g, "'\\''")
+
+  let result
+  try {
+    const raw = execSync(
+      `npx autocannon -c ${CONNECTIONS} -d ${DURATION} -j http://localhost:${port}${targetRoute} -m POST -H "content-type: application/json" -b '${escaped}'`,
+      { cwd: __dirname, timeout: 30000 }
+    ).toString()
+    result = JSON.parse(raw)
+  } catch (e) {
+    child.kill()
+    try { unlinkSync(scriptPath) } catch {}
+    return null
+  }
+
+  child.kill()
+  try { unlinkSync(scriptPath) } catch {}
+
+  return {
+    label,
+    startupMs,
+    reqPerSec: result.requests.average,
+    latencyAvg: result.latency.average,
+    latencyP99: result.latency.p99,
+    throughputMB: (result.throughput.average / 1024 / 1024).toFixed(1),
+    errors: result.errors,
+    timeouts: result.timeouts,
+  }
+}
+
+async function main() {
+  console.log('\n' + '='.repeat(60))
+  console.log('  Real-Time Fastify Simulation')
+  console.log(`  ${ROUTES} routes, ${CONNECTIONS} connections, ${DURATION}s duration`)
+  console.log('  POST with 6-field validated body')
+  console.log('='.repeat(60) + '\n')
+
+  const ata = await runTest('fastify-ata', true)
+  const ajv = await runTest('fastify (ajv)', false)
+
+  if (!ata || !ajv) { console.log('Benchmark failed'); return }
+
+  console.log('                    fastify-ata     fastify (ajv)')
+  console.log('  ─────────────────────────────────────────────────')
+  console.log(`  Startup           ${ata.startupMs.toFixed(1).padStart(8)} ms     ${ajv.startupMs.toFixed(1).padStart(8)} ms`)
+  console.log(`  Requests/sec      ${ata.reqPerSec.toLocaleString().padStart(8)}         ${ajv.reqPerSec.toLocaleString().padStart(8)}`)
+  console.log(`  Latency (avg)     ${ata.latencyAvg.toFixed(2).padStart(8)} ms     ${ajv.latencyAvg.toFixed(2).padStart(8)} ms`)
+  console.log(`  Latency (p99)     ${ata.latencyP99.toFixed(2).padStart(8)} ms     ${ajv.latencyP99.toFixed(2).padStart(8)} ms`)
+  console.log(`  Throughput        ${ata.throughputMB.padStart(8)} MB/s    ${ajv.throughputMB.padStart(8)} MB/s`)
+  console.log(`  Errors            ${String(ata.errors).padStart(8)}         ${String(ajv.errors).padStart(8)}`)
+  console.log(`  Timeouts          ${String(ata.timeouts).padStart(8)}         ${String(ajv.timeouts).padStart(8)}`)
+  console.log()
+
+  const startupRatio = ajv.startupMs / ata.startupMs
+  const rpsRatio = ata.reqPerSec / ajv.reqPerSec
+  console.log(`  Startup: ata ${startupRatio.toFixed(1)}x faster`)
+  console.log(`  Throughput: ata ${rpsRatio.toFixed(2)}x ${rpsRatio >= 1 ? 'faster' : 'slower'}`)
+  console.log()
+}
+
+main().catch(err => { console.error(err); process.exit(1) })

package/bench-realwork.js

@@ -0,0 +1,59 @@
+'use strict'
+// How much of the ata-vs-ajv throughput difference survives once a route does
+// real work? Echo handlers make the validator look decisive. A handler that
+// awaits anything at all does not. This is the benchmark behind the second
+// table in the README's throughput section.
+const { fork } = require('child_process')
+const { writeFileSync, unlinkSync } = require('fs')
+const path = require('path')
+const autocannon = require('autocannon')
+
+const schema = { type:'object', properties:{
+  id:{type:'integer'}, name:{type:'string'}, email:{type:'string'},
+  age:{type:'integer',minimum:0}, active:{type:'boolean'}, role:{type:'string',enum:['admin','user']} },
+  required:['id','name','email','age','active','role'] }
+
+function server(useAta, workMs, port) {
+  return `
+'use strict'
+const fastify = require('fastify')()
+${useAta ? `fastify.register(require(${JSON.stringify(path.resolve(__dirname,'index.js'))}))` : ''}
+const schema = ${JSON.stringify(schema)}
+const WORK = ${workMs}
+fastify.post('/u', { schema: { body: schema } }, async (req, reply) => {
+  if (WORK > 0) await new Promise(r => setTimeout(r, WORK))
+  return { ok: true }
+})
+fastify.listen({ port: ${port} }).then(() => process.send({ up: true }))
+`
+}
+
+function start(src) {
+  return new Promise((res) => {
+    const f = path.join(__dirname, '_srv_' + Math.random().toString(36).slice(2) + '.js')
+    writeFileSync(f, src)
+    const child = fork(f, { silent: true })
+    child.on('message', () => res({ child, f }))
+  })
+}
+
+async function bench(port, connections) {
+  const r = await autocannon({ url: 'http://127.0.0.1:' + port + '/u', method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ id: 1, name: 'Ada', email: 'a@e.com', age: 36, active: true, role: 'admin' }),
+    connections, duration: 5 })
+  return r.requests.average
+}
+
+;(async () => {
+  console.log('per-request work   ajv req/s    ata req/s   delta')
+  let port = 3310
+  for (const workMs of [0, 1, 5, 20]) {
+    const conns = workMs === 0 ? 50 : 200
+    const a = await start(server(false, workMs, port)); const ajv = await bench(port, conns); a.child.kill(); unlinkSync(a.f); port++
+    const b = await start(server(true, workMs, port)); const ata = await bench(port, conns); b.child.kill(); unlinkSync(b.f); port++
+    const label = workMs === 0 ? 'none (echo)' : workMs + ' ms async'
+    console.log(label.padEnd(18), String(Math.round(ajv)).padStart(9), String(Math.round(ata)).padStart(12),
+      ('  ' + (((ata - ajv) / ajv) * 100).toFixed(1) + '%').padStart(8))
+  }
+})()

package/bench-standalone-vs.js

@@ -114,6 +114,23 @@ app.ready().then(() => {
 }
 
 // ============================================================
+// 0. ata plain: just register the plugin, no build step, no precompile
+// ============================================================
+function ataPlainScript(routes) {
+  return `
+'use strict'
+const start = performance.now()
+const fastify = require('fastify')()
+fastify.register(require(${JSON.stringify(path.resolve(__dirname, 'index.js'))}))
+const routes = ${JSON.stringify(routes)}
+routes.forEach(r => { fastify.post(r.url, { schema: { body: r.schema } }, (req, reply) => reply.send({ ok: true })) })
+fastify.ready().then(() => {
+  process.send({ ms: performance.now() - start })
+  process.exit()
+})
+`
+}
+
 // 3. ata compact standalone
 // ============================================================
 function ataStandaloneScript(routes, bundlePath) {
@@ -205,13 +222,21 @@ async function main() {
     const ataStandalone = times3[1]
     try { unlinkSync(bundlePath) } catch {}
 
-    console.log(`  ajv default:    ${ajvDefault.toFixed(0)}ms`)
-    console.log(`  ajv standalone: ${ajvStandalone >= 0 ? ajvStandalone.toFixed(0) + 'ms' : 'FAILED'}`)
-    console.log(`  ata compact:    ${ataStandalone.toFixed(0)}ms`)
+    // 0b. ata plain, no build step at all
+    const times0 = []
+    for (let r = 0; r < 3; r++) times0.push(await runScript(ataPlainScript(routes)))
+    times0.sort((a, b) => a - b)
+    const ataPlain = times0[1]
+
+    console.log(`  ajv default:       ${ajvDefault.toFixed(0)}ms`)
+    console.log(`  ajv standalone:    ${ajvStandalone >= 0 ? ajvStandalone.toFixed(0) + 'ms' : 'FAILED'}`)
+    console.log(`  ata plain:         ${ataPlain.toFixed(0)}ms   (no build step)`)
+    console.log(`  ata compact:       ${ataStandalone.toFixed(0)}ms   (precompiled bundle)`)
     if (ajvStandalone > 0) {
-      console.log(`  ata vs ajv standalone: ${(ajvStandalone / ataStandalone).toFixed(1)}x faster`)
+      console.log(`  ata plain vs ajv standalone:   ${(ajvStandalone / ataPlain).toFixed(1)}x faster`)
+      console.log(`  ata compact vs ajv standalone: ${(ajvStandalone / ataStandalone).toFixed(1)}x faster`)
     }
-    console.log(`  ata vs ajv default:    ${(ajvDefault / ataStandalone).toFixed(1)}x faster`)
+    console.log(`  ata plain vs ajv default:     ${(ajvDefault / ataPlain).toFixed(1)}x faster`)
     console.log()
   }
 }

package/bench-startup.js

@@ -1,11 +1,24 @@
 'use strict'
 
-// Matteo's scenario: Fastify startup time with N routes
-// This is what he cares about most
+// Fastify startup cost, split into the part that is Fastify booting and the
+// part that is compiling route schemas.
+//
+// Total boot time hides the interesting number: a bare Fastify instance costs
+// tens of milliseconds before any schema is involved, so comparing totals
+// understates the difference between validators. Subtracting a no-schema
+// baseline leaves the schema compilation cost on its own.
+//
+// TypeBox is deliberately not in the comparison. It builds schemas, it does not
+// compile them; under Fastify a TypeBox schema is still compiled by whichever
+// validator is installed, so it has no separate compile cost to measure.
 
 const { writeFileSync, unlinkSync } = require('fs')
+const { fork } = require('child_process')
 const path = require('path')
 
+const ROUTE_COUNTS = [0, 10, 50, 100, 250, 500, 1000]
+const RUNS = 9
+
 function makeRouteSchemas(count) {
   const routes = []
   for (let i = 0; i < count; i++) {
@@ -38,63 +51,100 @@ function makeRouteSchemas(count) {
 
 function serverScript(useAta, routeCount) {
   const routes = makeRouteSchemas(routeCount)
+  const register = useAta
+    ? `fastify.register(require(${JSON.stringify(path.join(__dirname, 'index.js'))}))`
+    : ''
   return `
 'use strict'
 const t0 = process.hrtime.bigint()
 const fastify = require('fastify')()
-${useAta ? "fastify.register(require('./index'))" : ''}
+${register}
 const routes = ${JSON.stringify(routes)}
 for (const r of routes) {
-  fastify.post(r.path, { schema: r.schema }, (req, reply) => {
-    reply.send({ ok: true })
-  })
+  fastify.post(r.path, { schema: r.schema }, (req, reply) => reply.send({ ok: true }))
 }
 fastify.ready().then(() => {
-  const dt = Number(process.hrtime.bigint() - t0) / 1e6
-  process.send({ startupMs: dt })
+  process.send({ startupMs: Number(process.hrtime.bigint() - t0) / 1e6 })
   process.exit(0)
 })
 `
 }
 
-async function measureStartup(useAta, routeCount, runs) {
-  const scriptPath = path.join(__dirname, '_startup_bench.js')
+async function measure(useAta, routeCount, runs) {
+  const scriptPath = path.join(
+    __dirname,
+    `_startup_bench_${useAta ? 'ata' : 'ajv'}_${routeCount}.js`,
+  )
+  writeFileSync(scriptPath, serverScript(useAta, routeCount))
   const times = []
 
   for (let r = 0; r < runs; r++) {
-    writeFileSync(scriptPath, serverScript(useAta, routeCount))
-    const { fork } = require('child_process')
     const child = fork(scriptPath, { stdio: ['pipe', 'pipe', 'pipe', 'ipc'] })
     const ms = await new Promise((resolve, reject) => {
-      child.on('message', msg => resolve(msg.startupMs))
+      child.on('message', (msg) => resolve(msg.startupMs))
       child.on('error', reject)
-      setTimeout(() => { child.kill(); reject(new Error('timeout')) }, 10000)
+      setTimeout(() => {
+        child.kill()
+        reject(new Error('timeout'))
+      }, 30000)
     })
     times.push(ms)
   }
 
-  try { unlinkSync(scriptPath) } catch {}
+  try {
+    unlinkSync(scriptPath)
+  } catch {}
   times.sort((a, b) => a - b)
-  return times[Math.floor(times.length / 2)]
+  return {
+    median: times[Math.floor(times.length / 2)],
+    min: times[0],
+    max: times[times.length - 1],
+  }
 }
 
+const fmt = (n) => n.toFixed(1).padStart(7)
+
 async function main() {
-  console.log('\n==============================================')
-  console.log('  Fastify Startup Benchmark (cold start)')
-  console.log('  Median of 5 runs, process-isolated')
-  console.log('==============================================\n')
+  console.log(`\nFastify startup, median of ${RUNS} process-isolated runs`)
+  console.log(`node ${process.version}\n`)
+
+  const baseline = { ata: null, ajv: null }
+  const rows = []
 
-  for (const count of [5, 10, 25, 50, 100]) {
-    console.log(`--- ${count} routes (body + querystring schemas) ---`)
+  for (const count of ROUTE_COUNTS) {
+    const ata = await measure(true, count, RUNS)
+    const ajv = await measure(false, count, RUNS)
 
-    const ata = await measureStartup(true, count, 5)
-    const ajv = await measureStartup(false, count, 5)
+    if (count === 0) {
+      baseline.ata = ata.median
+      baseline.ajv = ajv.median
+      console.log('Baseline, no routes and no schemas:')
+      console.log(`  with ata plugin ${fmt(ata.median)} ms   (${fmt(ata.min)} to ${fmt(ata.max)})`)
+      console.log(`  stock fastify   ${fmt(ajv.median)} ms   (${fmt(ajv.min)} to ${fmt(ajv.max)})`)
+      console.log('\nSchema compilation cost, baseline subtracted:\n')
+      console.log('  routes        ata        ajv     ratio')
+      console.log('  ------------------------------------------')
+      continue
+    }
 
-    console.log(`  ata: ${ata.toFixed(1).padStart(8)} ms`)
-    console.log(`  ajv: ${ajv.toFixed(1).padStart(8)} ms`)
-    console.log(`  >>> ata ${(ajv / ata).toFixed(1)}x faster startup`)
-    console.log()
+    const ataCost = ata.median - baseline.ata
+    const ajvCost = ajv.median - baseline.ajv
+    rows.push({ count, ataCost, ajvCost, ataTotal: ata.median, ajvTotal: ajv.median })
+    console.log(
+      `  ${String(count).padStart(5)}  ${fmt(ataCost)} ms ${fmt(ajvCost)} ms   ${(ajvCost / ataCost).toFixed(1)}x`,
+    )
   }
+
+  console.log('\nTotal boot time for reference:\n')
+  console.log('  routes        ata        ajv')
+  console.log('  ------------------------------')
+  for (const r of rows) {
+    console.log(`  ${String(r.count).padStart(5)}  ${fmt(r.ataTotal)} ms ${fmt(r.ajvTotal)} ms`)
+  }
+  console.log()
 }
 
-main().catch(err => { console.error(err); process.exit(1) })
+main().catch((err) => {
+  console.error(err)
+  process.exit(1)
+})

package/bench-turbo.js

@@ -0,0 +1,118 @@
+'use strict'
+
+const { execSync } = require('child_process')
+const { writeFileSync, unlinkSync } = require('fs')
+const path = require('path')
+
+const schema = {
+  body: {
+    type: 'object',
+    properties: {
+      users: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            id: { type: 'integer', minimum: 1 },
+            name: { type: 'string', minLength: 1 },
+            email: { type: 'string', format: 'email' },
+            age: { type: 'integer', minimum: 0, maximum: 150 },
+            active: { type: 'boolean' },
+            role: { enum: ['admin', 'user', 'moderator'] },
+          },
+          required: ['id', 'name', 'email', 'active', 'role'],
+        },
+      },
+      metadata: {
+        type: 'object',
+        properties: {
+          total: { type: 'integer' },
+          page: { type: 'integer', minimum: 1 },
+        },
+        required: ['total', 'page'],
+      },
+    },
+    required: ['users', 'metadata'],
+  },
+}
+
+function makePayload(n) {
+  const users = []
+  for (let i = 0; i < n; i++) {
+    users.push({
+      id: i + 1,
+      name: `User ${i}`,
+      email: `user${i}@example.com`,
+      age: 25,
+      active: true,
+      role: 'user',
+    })
+  }
+  return JSON.stringify({ users, metadata: { total: n, page: 1 } })
+}
+
+function serverScript(turbo) {
+  return `
+'use strict'
+const fastify = require('fastify')()
+fastify.register(require('./index'), { turbo: ${turbo} })
+const schema = ${JSON.stringify(schema)}
+fastify.post('/users', { schema }, (req, reply) => {
+  reply.send({ ok: true, count: req.body.users.length })
+})
+fastify.listen({ port: 0 }).then(() => {
+  process.send({ port: fastify.server.address().port })
+})
+`
+}
+
+async function bench(label, turbo, payload) {
+  const scriptPath = path.join(__dirname, '_bench_turbo_server.js')
+  writeFileSync(scriptPath, serverScript(turbo))
+
+  const { fork } = require('child_process')
+  const child = fork(scriptPath, { stdio: ['pipe', 'pipe', 'pipe', 'ipc'] })
+  const port = await new Promise((resolve) => {
+    child.on('message', (msg) => resolve(msg.port))
+  })
+
+  const escaped = payload.replace(/'/g, "'\\''")
+  const result = execSync(
+    `npx autocannon -c 10 -d 5 -j http://localhost:${port}/users -m POST -H "content-type: application/json" -b '${escaped}'`,
+    { cwd: __dirname, timeout: 30000 },
+  ).toString()
+
+  child.kill()
+  try { unlinkSync(scriptPath) } catch {}
+
+  const parsed = JSON.parse(result)
+  return parsed.requests.average
+}
+
+async function main() {
+  console.log('\n==============================================')
+  console.log('  Turbo Mode Benchmark: normal vs turbo')
+  console.log('  10 connections, 5 seconds, real HTTP')
+  console.log('==============================================\n')
+
+  for (const count of [1, 10, 50, 100]) {
+    const payload = makePayload(count)
+    console.log(`--- ${count} users (${(payload.length / 1024).toFixed(1)} KB) ---`)
+
+    const normal = await bench('normal', false, payload)
+    const turbo = await bench('turbo', true, payload)
+
+    console.log(`  normal: ${normal.toLocaleString().padStart(10)} req/sec`)
+    console.log(`  turbo:  ${turbo.toLocaleString().padStart(10)} req/sec`)
+
+    const ratio = turbo / normal
+    if (ratio >= 1) console.log(`  >>> turbo ${ratio.toFixed(2)}x faster`)
+    else console.log(`  >>> normal ${(1 / ratio).toFixed(2)}x faster`)
+    console.log()
+  }
+}
+
+main().catch((err) => {
+  console.error(err)
+  process.exit(1)
+})

package/compat/COMPATIBILITY.md

@@ -12,7 +12,7 @@ The preload swaps the single `require('@fastify/ajv-compiler')` inside Fastify's
 
 ## Current score
 
-**182 of 188 tests pass** (Fastify v5.8.5 checkout, ata-validator 1.3.0, fastify-ata main).
+**178 of 184 tests pass** (Fastify main at dce0d47a, ata-validator 1.11.0, fastify-ata 0.9.4).
 
 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).
 
@@ -33,4 +33,4 @@ All six are AJV-identity tests. The former seventh (ajv-errors message ordering)
 
 ## 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.
+The suite grew around AJV, so six of its 184 tests assert that the validator is AJV rather than that validation is correct. A perfect drop-in that is not AJV tops out at 178. ata passes all 178. If you find a behavior difference not covered here, that is a bug in fastify-ata or ata: please open an issue.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify-ata",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "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.7.2",
+    "ata-validator": "^1.11.0",
     "fastify-plugin": "^5.1.0",
     "sanitize-filename": "^1.6.4"
   },

package/profile-fastify.mjs

@@ -0,0 +1,87 @@
+'use strict'
+
+// Profile validation overhead in Fastify context
+import { createRequire } from 'module'
+const require = createRequire(import.meta.url)
+
+const { Validator } = require('ata-validator')
+
+// Simulate what Fastify does: JSON.parse + validate
+const schema = {
+  type: 'object',
+  properties: {
+    users: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          id: { type: 'integer', minimum: 1 },
+          name: { type: 'string', minLength: 1 },
+          email: { type: 'string', format: 'email' },
+          age: { type: 'integer', minimum: 0, maximum: 150 },
+          active: { type: 'boolean' },
+          role: { enum: ['admin', 'user', 'moderator'] },
+        },
+        required: ['id', 'name', 'email', 'active', 'role'],
+      },
+    },
+    metadata: {
+      type: 'object',
+      properties: {
+        total: { type: 'integer' },
+        page: { type: 'integer', minimum: 1 },
+      },
+      required: ['total', 'page'],
+    },
+  },
+  required: ['users', 'metadata'],
+}
+
+function makePayload(n) {
+  const users = []
+  for (let i = 0; i < n; i++) {
+    users.push({ id: i+1, name: `User ${i}`, email: `u${i}@x.com`, age: 25, active: true, role: 'user' })
+  }
+  return JSON.stringify({ users, metadata: { total: n, page: 1 } })
+}
+
+const v = new Validator(schema)
+const payloads = [1, 10, 50, 100].map(n => ({ n, json: makePayload(n) }))
+
+// Warmup
+for (const p of payloads) {
+  for (let i = 0; i < 1000; i++) {
+    const obj = JSON.parse(p.json)
+    v.validate(obj)
+  }
+}
+
+console.log('Breakdown: JSON.parse vs validate vs total\n')
+
+const N = 100000
+for (const p of payloads) {
+  // JSON.parse only
+  let t = process.hrtime.bigint()
+  for (let i = 0; i < N; i++) JSON.parse(p.json)
+  const dtParse = Number(process.hrtime.bigint() - t) / 1e6
+
+  // validate only (pre-parsed)
+  const obj = JSON.parse(p.json)
+  t = process.hrtime.bigint()
+  for (let i = 0; i < N; i++) v.validate(obj)
+  const dtValidate = Number(process.hrtime.bigint() - t) / 1e6
+
+  // parse + validate
+  t = process.hrtime.bigint()
+  for (let i = 0; i < N; i++) { const o = JSON.parse(p.json); v.validate(o) }
+  const dtTotal = Number(process.hrtime.bigint() - t) / 1e6
+
+  const parsePct = (dtParse / dtTotal * 100).toFixed(0)
+  const valPct = (dtValidate / dtTotal * 100).toFixed(0)
+
+  console.log(`${p.n} users (${(p.json.length/1024).toFixed(1)}KB):`)
+  console.log(`  JSON.parse: ${(dtParse/N*1000).toFixed(1)} us (${parsePct}%)`)
+  console.log(`  validate:   ${(dtValidate/N*1000).toFixed(1)} us (${valPct}%)`)
+  console.log(`  total:      ${(dtTotal/N*1000).toFixed(1)} us`)
+  console.log()
+}