@ata-project/unplugin 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mert Can Altin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,192 @@
+# @ata-project/unplugin
+
+Compiles JSON Schema files into self-contained [ata-validator](https://ata-validator.com) modules at build time, with TypeScript declarations, in Vite, Webpack, Rollup, Rolldown, esbuild and Rspack. One plugin, built on [unplugin](https://github.com/unjs/unplugin).
+
+The generated module imports nothing. A typical schema compiles to about 1 KB gzipped, exports `validate`, `isValid` and the inferred type, and runs anywhere plain JavaScript runs.
+
+Schemas can be authored as `.json`, `.js` or `.ts`.
+
+## Install
+
+```bash
+npm install --save-dev @ata-project/unplugin ata-validator
+```
+
+`ata-validator` is a peer dependency and is only used at build time.
+
+## Setup
+
+Vite:
+
+```ts
+// vite.config.ts
+import ata from '@ata-project/unplugin/vite'
+
+export default {
+  plugins: [ata({ schemas: 'src/**/*.schema.json' })],
+}
+```
+
+Webpack:
+
+```js
+// webpack.config.js
+const ata = require('@ata-project/unplugin/webpack')
+
+module.exports = {
+  plugins: [ata({ schemas: 'src/**/*.schema.json' })],
+}
+```
+
+Rollup:
+
+```js
+// rollup.config.js
+import ata from '@ata-project/unplugin/rollup'
+
+export default {
+  // Rollup has no project root; tell the plugin where the globs start.
+  plugins: [ata({ schemas: 'src/**/*.schema.json', root: process.cwd() })],
+}
+```
+
+esbuild:
+
+```js
+import { build } from 'esbuild'
+import ata from '@ata-project/unplugin/esbuild'
+
+await build({
+  entryPoints: ['src/main.ts'],
+  bundle: true,
+  plugins: [ata({ schemas: 'src/**/*.schema.json' })],
+})
+```
+
+Rspack:
+
+```js
+// rspack.config.js
+const ata = require('@ata-project/unplugin/rspack')
+
+module.exports = {
+  plugins: [ata({ schemas: 'src/**/*.schema.json' })],
+}
+```
+
+Rolldown:
+
+```js
+// rolldown.config.js
+import ata from '@ata-project/unplugin/rolldown'
+
+export default {
+  plugins: [ata({ schemas: 'src/**/*.schema.json', root: process.cwd() })],
+}
+```
+
+Next.js uses Webpack, so the Webpack entry goes into `next.config.js`:
+
+```js
+const ata = require('@ata-project/unplugin/webpack')
+
+module.exports = {
+  webpack(config) {
+    config.plugins.push(ata({ schemas: 'schemas/**/*.schema.json' }))
+    return config
+  },
+}
+```
+
+Turbopack has no plugin interface this could attach to. Run the compile as a
+step before the build instead: `ata build 'schemas/**/*.schema.json'` from
+ata-validator's CLI, or the `compile()` function below in a script.
+
+## The `.schema.json` convention
+
+Name a schema `user.schema.json` and import a typed validator by its name:
+
+```ts
+import validate, { type User, isValid } from './user.schema'
+
+const r = validate(input)
+if (r.valid) {
+  // input matched the schema
+}
+if (isValid(input)) {
+  input.id // narrowed to User
+}
+```
+
+The plugin writes `user.schema.js` and `user.schema.d.ts` next to the schema.
+The default export is the `validate` function; `validate`, `isValid` and the
+inferred type are also named exports. The type name comes from the schema's
+`title`, then its `$id`, then the file name.
+
+Add the generated files to `.gitignore`:
+
+```
+*.schema.js
+*.schema.d.ts
+```
+
+Other sources (`.json` without the `.schema` suffix, `.js`, `.ts`) produce
+`<name>.validator.mjs` and `<name>.validator.d.mts`.
+
+## Options
+
+| Option | Default | Description |
+|---|---|---|
+| `schemas` | `**/*.schema.json` | Glob or globs, relative to the root. `node_modules` is skipped. |
+| `outDir` | next to each schema | Directory for generated files, mirroring the source layout. |
+| `format` | `'esm'` | `'esm'` or `'cjs'`. |
+| `abortEarly` | `false` | Emit the smaller validator that stops at the first failure. |
+| `types` | `true` | Emit a `.d.ts` next to each validator. |
+| `nameFromFile` | file name in PascalCase | Type name for schemas without `title` or `$id`. |
+| `root` | from the bundler | Where the globs resolve from. Vite's root, Webpack's and Rspack's `context` and esbuild's `absWorkingDir` are read; Rollup and Rolldown need it passed. |
+| `alias` | Vite's `resolve.alias` | Import aliases inside `.ts` schema files. tsconfig `paths` work without configuration. |
+
+## How it works
+
+Output goes to disk, not to virtual modules. That is what makes the plugin
+identical across bundlers and what lets TypeScript see the generated
+declarations without any bundler-specific type plumbing.
+
+Schemas compile on build start. On a schema change, Vite recompiles through
+its HMR hook and Webpack, Rspack, Rollup and Rolldown through `watchChange`.
+esbuild has no watch hook, so under `esbuild --watch` a schema edit alone does
+not trigger a rebuild; the next build start compiles it.
+
+`.ts` schemas load through [jiti](https://github.com/unjs/jiti). A schema
+module exports the schema as `default` or as a named `schema`.
+
+A schema the standalone compiler cannot represent is reported with a warning
+and skipped; the ata-validator runtime API still validates it.
+
+## Programmatic use
+
+```js
+import { compile } from '@ata-project/unplugin'
+
+const { files, results } = await compile({ schemas: 'schemas/**/*.json', root: process.cwd() })
+```
+
+## Tests
+
+`npm test` compiles the same entry with Vite, Webpack, Rollup, Rolldown,
+esbuild and Rspack, imports each bundle and runs the validator it contains.
+
+## Package name
+
+The package is `@ata-project/unplugin`; the plugin registers itself in the
+bundler as `unplugin-ata`, which is the name in log lines and in
+`plugin.name`. The unscoped name is not available on npm.
+
+## Relation to ata-vite
+
+`ata-vite` is this plugin's Vite entry with the old name. It keeps working;
+new projects can use either.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@ata-project/unplugin",
+  "version": "0.1.0",
+  "description": "Compile JSON, JS and TS schema files to ata-validator standalone modules at build time, in Vite, Webpack, Rollup, Rolldown, esbuild and Rspack.",
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./vite": {
+      "types": "./src/vite.d.ts",
+      "default": "./src/vite.js"
+    },
+    "./webpack": {
+      "types": "./src/webpack.d.ts",
+      "default": "./src/webpack.js"
+    },
+    "./rollup": {
+      "types": "./src/rollup.d.ts",
+      "default": "./src/rollup.js"
+    },
+    "./rolldown": {
+      "types": "./src/rolldown.d.ts",
+      "default": "./src/rolldown.js"
+    },
+    "./esbuild": {
+      "types": "./src/esbuild.d.ts",
+      "default": "./src/esbuild.js"
+    },
+    "./rspack": {
+      "types": "./src/rspack.d.ts",
+      "default": "./src/rspack.js"
+    },
+    "./core": "./src/core.js"
+  },
+  "files": [
+    "src/"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
+  "keywords": [
+    "unplugin",
+    "vite-plugin",
+    "webpack-plugin",
+    "rollup-plugin",
+    "esbuild-plugin",
+    "rspack-plugin",
+    "json-schema",
+    "ata-validator",
+    "typescript",
+    "codegen"
+  ],
+  "author": "Mert Can Altin <mertgold60@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ata-core/unplugin-ata.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ata-core/unplugin-ata/issues"
+  },
+  "homepage": "https://github.com/ata-core/unplugin-ata#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "peerDependencies": {
+    "ata-validator": ">=1.0.0"
+  },
+  "dependencies": {
+    "jiti": "^2.7.0",
+    "unplugin": "^3.3.0"
+  },
+  "devDependencies": {
+    "@rspack/core": "^1.7.0",
+    "ata-validator": "^1.15.0",
+    "esbuild": "^0.28.0",
+    "rolldown": "^1.2.8",
+    "rollup": "^4.60.0",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.2",
+    "webpack": "^5.105.0"
+  },
+  "types": "./src/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/core.js

@@ -0,0 +1,351 @@
+// unplugin-ata core: build-time schema compilation, independent of any
+// bundler. src/index.js wraps this in an unplugin; ata-vite delegates here.
+//
+// Schemas may be authored as .json (read as text), .js (native import), or
+// .ts (loaded through jiti). For each schema matched by `schemas`, emit:
+//   - <base>.validator.mjs      (self-contained validator)
+//   - <base>.validator.d.mts    (TypeScript declarations, opt-in)
+// or, for the `<name>.schema.json` convention, `<name>.schema.js` and
+// `<name>.schema.d.ts` with the validate function as the default export.
+//
+// Output is written to disk, never served as virtual modules, so every
+// bundler sees the same files and so does TypeScript.
+
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+function pascal(str) {
+  const cleaned = String(str)
+    .replace(/[^A-Za-z0-9_]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .replace(/^[0-9]/, '_$&')
+  if (!cleaned) return 'Schema'
+  return cleaned.charAt(0).toUpperCase() + cleaned.slice(1)
+}
+
+function deriveTypeName(schema, file, options) {
+  if (schema && typeof schema.title === 'string' && schema.title.trim()) {
+    return pascal(schema.title)
+  }
+  if (schema && typeof schema.$id === 'string' && schema.$id.trim()) {
+    const base = path.basename(schema.$id).replace(/\.[^.]+$/, '')
+    if (base) return pascal(base)
+  }
+  return options.nameFromFile(file)
+}
+
+const DEFAULT_OPTIONS = {
+  schemas: '**/*.schema.json',
+  outDir: null, // default: alongside each input
+  format: 'esm',
+  abortEarly: false,
+  types: true,
+  nameFromFile: (file) => {
+    const base = path.basename(file, path.extname(file)).replace(/\.schema$/i, '')
+    return pascal(base)
+  },
+}
+
+async function loadAta() {
+  // Resolve ata-validator at runtime so peer-dep works cleanly across package managers.
+  // Standalone codegen comes from the ata-validator/build entry: the instance
+  // method it replaced was removed in ata-validator 1.0.
+  const mod = await import('ata-validator')
+  const api = mod.default ?? mod
+  const buildMod = await import('ata-validator/build')
+  const build = buildMod.default ?? buildMod
+  if (!api.Validator || !api.toTypeScript || typeof build.toStandaloneModule !== 'function') {
+    throw new Error(
+      'unplugin-ata requires ata-validator >= 0.19.0 with the ata-validator/build entry.',
+    )
+  }
+  return { ...api, toStandaloneModule: build.toStandaloneModule }
+}
+
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [value]
+}
+
+async function resolveSchemaFiles(patterns, root) {
+  const isVendor = (abs) =>
+    path.relative(root, abs).split(path.sep).includes('node_modules')
+
+  // Node 22+ ships fs.glob. Fall back to a recursive walk for older runtimes.
+  if (typeof fs.glob === 'function') {
+    const found = []
+    for (const pattern of ensureArray(patterns)) {
+      for await (const hit of fs.glob(pattern, { cwd: root })) {
+        const abs = path.resolve(root, hit)
+        if (!isVendor(abs)) found.push(abs)
+      }
+    }
+    return [...new Set(found)]
+  }
+
+  const matched = new Set()
+  for (const pattern of ensureArray(patterns)) {
+    const anchor = path.resolve(root, pattern.split('*')[0] || '.')
+    let stack
+    try {
+      const stat = await fs.stat(anchor)
+      stack = stat.isDirectory() ? [anchor] : [path.dirname(anchor)]
+    } catch {
+      continue
+    }
+    const re = globToRegExp(pattern)
+    while (stack.length > 0) {
+      const dir = stack.pop()
+      let entries
+      try { entries = await fs.readdir(dir, { withFileTypes: true }) } catch { continue }
+      for (const e of entries) {
+        const abs = path.join(dir, e.name)
+        if (e.isDirectory()) {
+          if (e.name !== 'node_modules') stack.push(abs)
+          continue
+        }
+        const rel = path.relative(root, abs).split(path.sep).join('/')
+        if (re.test(rel) && !isVendor(abs)) matched.add(abs)
+      }
+    }
+  }
+  return [...matched]
+}
+
+function globToRegExp(pattern) {
+  let re = '^'
+  for (let i = 0; i < pattern.length; i++) {
+    const c = pattern[i]
+    // `**/` matches zero or more path segments, so schemas/**/*.json
+    // also picks up files that live directly in schemas/.
+    if (c === '*' && pattern[i + 1] === '*') {
+      if (pattern[i + 2] === '/') {
+        re += '(?:.*/)?'
+        i += 2
+      } else {
+        re += '.*'
+        i++
+      }
+    } else if (c === '*') {
+      re += '[^/]*'
+    } else if (c === '?') {
+      re += '[^/]'
+    } else if ('.+^${}()|[]\\'.includes(c)) {
+      re += '\\' + c
+    } else {
+      re += c
+    }
+  }
+  return new RegExp(re + '$')
+}
+
+function isSchemaConvention(file) {
+  return file.toLowerCase().endsWith('.schema.json')
+}
+
+function outputPaths(schemaFile, options, root) {
+  const dir = options.outDir
+    ? path.resolve(root, options.outDir, path.dirname(path.relative(root, schemaFile)))
+    : path.dirname(schemaFile)
+  if (isSchemaConvention(schemaFile)) {
+    // user.schema.json -> base "user.schema" -> import './user.schema'
+    const base = path.basename(schemaFile.replace(/\.json$/i, ''))
+    const cjs = options.format === 'cjs'
+    const mjs = path.join(dir, `${base}.${cjs ? 'cjs' : 'js'}`)
+    const dts = path.join(dir, `${base}.${cjs ? 'd.cts' : 'd.ts'}`)
+    return { dir, mjs, dts }
+  }
+  const base = path.basename(schemaFile, path.extname(schemaFile))
+  const mjs = path.join(dir, `${base}.validator.${options.format === 'cjs' ? 'cjs' : 'mjs'}`)
+  const dts = path.join(dir, `${base}.validator.${options.format === 'cjs' ? 'd.cts' : 'd.mts'}`)
+  return { dir, mjs, dts }
+}
+
+async function readJson(file) {
+  const text = await fs.readFile(file, 'utf8')
+  return JSON.parse(text)
+}
+
+// Vite normalizes resolve.alias to an array of { find, replacement } by the time
+// configResolved runs, but accept the object form too. jiti's `alias` is a
+// Record<string, string>, so only string finds carry over; RegExp finds are
+// dropped (they cannot be expressed as a record key).
+function normalizeAlias(viteAlias) {
+  if (!viteAlias) return undefined
+  const entries = Array.isArray(viteAlias)
+    ? viteAlias
+    : Object.entries(viteAlias).map(([find, replacement]) => ({ find, replacement }))
+  const out = {}
+  for (const { find, replacement } of entries) {
+    if (typeof find === 'string' && typeof replacement === 'string') out[find] = replacement
+  }
+  return Object.keys(out).length ? out : undefined
+}
+
+// jiti instances are created on first .ts schema and reused, keyed by alias map
+// so different alias sets do not share an instance. fsCache keeps transpilation
+// on disk; moduleCache:false re-evaluates each import so HMR picks up edits.
+// tsconfigPaths:true resolves TypeScript `paths` aliases from tsconfig.
+const jitiInstances = new Map()
+function getJiti(alias) {
+  const key = alias ? JSON.stringify(alias) : ''
+  let p = jitiInstances.get(key)
+  if (!p) {
+    p = (async () => {
+      let mod
+      try {
+        mod = await import('jiti')
+      } catch {
+        throw new Error(
+          'unplugin-ata: compiling .ts/.mts schema files needs "jiti". Install it with: npm install jiti',
+        )
+      }
+      const createJiti = mod.createJiti ?? mod.default
+      return createJiti(import.meta.url, {
+        fsCache: true,
+        moduleCache: false,
+        tsconfigPaths: true,
+        ...(alias ? { alias } : {}),
+      })
+    })()
+    jitiInstances.set(key, p)
+  }
+  return p
+}
+
+// A schema module exports the schema as `default` (or a named `schema`).
+// For CJS loaded over the ESM interop, `default` holds module.exports.
+function pickSchema(mod) {
+  return mod?.default ?? mod?.schema ?? mod
+}
+
+// JSON is read as inert text. JS goes through native import. TS goes through
+// jiti. `fresh` busts the native module cache on the HMR/watch path only, so
+// the one-shot buildStart keeps the registry clean.
+async function loadSchema(file, fresh = false, alias) {
+  const ext = path.extname(file).toLowerCase()
+  if (ext === '.json' || ext === '') {
+    return readJson(file)
+  }
+  if (ext === '.js' || ext === '.mjs' || ext === '.cjs') {
+    const url = pathToFileURL(file).href + (fresh ? `?t=${Date.now()}` : '')
+    return pickSchema(await import(url))
+  }
+  const jiti = await getJiti(alias)
+  return pickSchema(await jiti.import(file))
+}
+
+async function writeIfChanged(file, contents) {
+  try {
+    const existing = await fs.readFile(file, 'utf8')
+    if (existing === contents) return false
+  } catch { /* file missing, write fresh */ }
+  await fs.mkdir(path.dirname(file), { recursive: true })
+  await fs.writeFile(file, contents)
+  return true
+}
+
+async function compileOne(schemaFile, options, root, api, logger, fresh = false) {
+  let schema
+  try {
+    schema = await loadSchema(schemaFile, fresh, options.alias)
+  } catch (err) {
+    logger?.warn?.(`[unplugin-ata] cannot load ${path.relative(root, schemaFile)}: ${err.message}`)
+    return { changed: false, typeName: null, paths: null }
+  }
+  if (!schema || typeof schema !== 'object') {
+    logger?.warn?.(`[unplugin-ata] ${path.relative(root, schemaFile)} did not export a schema object`)
+    return { changed: false, typeName: null, paths: null }
+  }
+
+  const v = new api.Validator(schema)
+  const validatorSrc = api.toStandaloneModule(v, { format: options.format, abortEarly: options.abortEarly })
+  if (!validatorSrc) {
+    logger?.warn?.(`[unplugin-ata] schema ${path.relative(root, schemaFile)} is too complex for standalone compilation`)
+    return { changed: false, typeName: null, paths: null }
+  }
+
+  const typeName = deriveTypeName(schema, schemaFile, options)
+  const paths = outputPaths(schemaFile, options, root)
+  let outSrc = validatorSrc
+  let defaultRewritten = false
+  if (isSchemaConvention(schemaFile) && options.format !== 'cjs') {
+    // toStandaloneModule emits `export default { validate, isValid };`.
+    // For the .schema convention we make the default the validate function so
+    // `import validate from './x.schema'` works. Named exports stay intact.
+    const replaced = outSrc.replace(
+      /^export default \{\s*validate(?:\s*,\s*isValid)?\s*\};?\s*$/m,
+      'export default validate;',
+    )
+    if (replaced !== outSrc) {
+      outSrc = replaced
+      defaultRewritten = true
+    } else {
+      // ata's standalone output format changed: do NOT rewrite the .d.ts default
+      // either, or the type would claim a callable default the module does not have.
+      logger?.warn?.(`[unplugin-ata] could not set default export to validate for ${path.relative(root, schemaFile)} (ata output format changed); keeping the { validate, isValid } default`)
+    }
+  }
+  const mjsChanged = await writeIfChanged(paths.mjs, outSrc)
+
+  let dtsChanged = false
+  if (options.types) {
+    let dtsSrc = api.toTypeScript(schema, { name: typeName })
+    // Only rewrite the .d.ts default when the .js default was actually rewritten,
+    // so the declared default and the runtime default can never disagree.
+    if (defaultRewritten) {
+      dtsSrc = dtsSrc.replace(
+        /^declare const _default:[^\n]*\nexport default _default;?\s*$/m,
+        'export { validate as default };',
+      )
+    }
+    dtsChanged = await writeIfChanged(paths.dts, dtsSrc)
+  }
+
+  return { changed: mjsChanged || dtsChanged, typeName, paths }
+}
+
+// Programmatic entry for custom build scripts.
+export async function compile(options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options }
+  const root = options.root ?? process.cwd()
+  const api = await loadAta()
+  const files = await resolveSchemaFiles(opts.schemas, root)
+  const results = await Promise.all(
+    files.map((file) => compileOne(file, opts, root, api, null)),
+  )
+  return { files, results }
+}
+
+// One compilation session: a root, a logger, a lazily loaded ata, and the
+// two operations a bundler hook needs.
+export function createSession(userOptions = {}) {
+  const options = { ...DEFAULT_OPTIONS, ...userOptions }
+  let apiPromise = null
+  const session = {
+    options,
+    root: userOptions.root ?? process.cwd(),
+    logger: null,
+    async compileAll() {
+      const api = await (apiPromise ??= loadAta())
+      const files = await resolveSchemaFiles(options.schemas, session.root)
+      // Compile in parallel so reads, transpiles and writes overlap.
+      const results = await Promise.all(
+        files.map((file) => compileOne(file, options, session.root, api, session.logger)),
+      )
+      return { files, results }
+    },
+    async compileIfMatching(file) {
+      if (!file) return null
+      const api = await (apiPromise ??= loadAta())
+      const files = await resolveSchemaFiles(options.schemas, session.root)
+      if (!files.some((f) => path.resolve(f) === path.resolve(file))) return null
+      // A change event: bypass the JS module cache so edits are seen.
+      return compileOne(file, options, session.root, api, session.logger, true)
+    },
+  }
+  return session
+}
+
+export { normalizeAlias, DEFAULT_OPTIONS }
+export const __internal = { loadAta, resolveSchemaFiles, compileOne, outputPaths, globToRegExp, isSchemaConvention }

package/src/esbuild.d.ts

@@ -0,0 +1,4 @@
+import unplugin from './index.js'
+
+declare const plugin: typeof unplugin.esbuild
+export default plugin

package/src/esbuild.js

@@ -0,0 +1,3 @@
+import unplugin from './index.js'
+
+export default unplugin.esbuild

package/src/index.d.ts

@@ -0,0 +1,35 @@
+import type { UnpluginInstance } from 'unplugin'
+
+export interface Options {
+  /** Glob or globs, relative to the project root. Default: `**​/*.schema.json`. */
+  schemas?: string | string[]
+  /** Where generated files go. Default: next to each schema. */
+  outDir?: string | null
+  /** Module format of the generated validator. Default: `'esm'`. */
+  format?: 'esm' | 'cjs'
+  /** Emit the smaller abort-early validator. Default: `false`. */
+  abortEarly?: boolean
+  /** Emit a `.d.ts` next to each validator. Default: `true`. */
+  types?: boolean
+  /** Type name for schemas without `title` or `$id`. */
+  nameFromFile?: (file: string) => string
+  /**
+   * Project root the globs resolve from. Read from the bundler when it has
+   * one (Vite's root, Webpack's and Rspack's `context`, esbuild's
+   * `absWorkingDir`); Rollup has none, so pass it there.
+   */
+  root?: string
+  /** Aliases for imports inside `.ts` schema files. Vite's `resolve.alias` is picked up. */
+  alias?: Record<string, string>
+}
+
+export interface CompileResult {
+  files: string[]
+  results: Array<{ changed: boolean; typeName: string | null; paths: { dir: string; mjs: string; dts: string } | null }>
+}
+
+/** Compile once, outside any bundler. */
+export function compile(options?: Options): Promise<CompileResult>
+
+declare const unplugin: UnpluginInstance<Options | undefined, boolean>
+export default unplugin

package/src/index.js

@@ -0,0 +1,75 @@
+// unplugin-ata: build-time schema compilation for Vite, Webpack, Rollup,
+// Rolldown, esbuild and Rspack, through unplugin. The work happens in
+// src/core.js; this file maps it onto the hooks every bundler shares
+// (buildStart, watchChange) and the two Vite has on top (configResolved for
+// the root, the logger and resolve.alias; handleHotUpdate for dev).
+//
+// esbuild has no watch hook in unplugin, so under `esbuild --watch` schemas
+// compile on each build start but a schema edit alone does not trigger one.
+
+import path from 'node:path'
+import { createUnplugin } from 'unplugin'
+import { createSession, normalizeAlias, compile, __internal } from './core.js'
+
+export const unpluginFactory = (userOptions = {}) => {
+  const session = createSession(userOptions)
+
+  return {
+    name: 'unplugin-ata',
+    enforce: 'pre',
+
+    async buildStart() {
+      const { files, results } = await session.compileAll()
+      const changed = results.filter((r) => r.changed).length
+      session.logger?.info?.(`[unplugin-ata] compiled ${files.length} schema(s), ${changed} file(s) written`)
+    },
+
+    async watchChange(id) {
+      await session.compileIfMatching(id)
+    },
+
+    // Where `schemas` globs resolve from. Vite says so in configResolved,
+    // Webpack and Rspack in compiler.context, esbuild in absWorkingDir; Rollup
+    // has no notion of a project root, so it takes the `root` option or the
+    // working directory. `root` given explicitly wins everywhere.
+    webpack(compiler) {
+      if (!userOptions.root && compiler.context) session.root = compiler.context
+      session.logger = compiler.getInfrastructureLogger?.('unplugin-ata') ?? null
+    },
+
+    rspack(compiler) {
+      if (!userOptions.root && compiler.context) session.root = compiler.context
+      session.logger = compiler.getInfrastructureLogger?.('unplugin-ata') ?? null
+    },
+
+    esbuild: {
+      setup(build) {
+        const cwd = build.initialOptions && build.initialOptions.absWorkingDir
+        if (!userOptions.root && cwd) session.root = cwd
+      },
+    },
+
+    vite: {
+      configResolved(config) {
+        if (!userOptions.root) session.root = config.root || session.root
+        session.logger = config.logger
+        // Carry Vite's resolve.alias into the .ts loader so aliased imports in
+        // schema files resolve. tsconfig `paths` are handled by jiti directly.
+        session.options.alias = normalizeAlias(config.resolve && config.resolve.alias)
+      },
+
+      async handleHotUpdate(ctx) {
+        const result = await session.compileIfMatching(ctx.file)
+        if (result && result.changed) {
+          session.logger?.info?.(`[unplugin-ata] recompiled ${path.relative(session.root, ctx.file)}`)
+        }
+        return undefined
+      },
+    },
+  }
+}
+
+const unplugin = /* #__PURE__ */ createUnplugin(unpluginFactory)
+
+export default unplugin
+export { compile, __internal }

package/src/rolldown.d.ts

@@ -0,0 +1,4 @@
+import unplugin from './index.js'
+
+declare const plugin: typeof unplugin.rolldown
+export default plugin

package/src/rolldown.js

@@ -0,0 +1,3 @@
+import unplugin from './index.js'
+
+export default unplugin.rolldown

package/src/rollup.d.ts

@@ -0,0 +1,4 @@
+import unplugin from './index.js'
+
+declare const plugin: typeof unplugin.rollup
+export default plugin

package/src/rollup.js

@@ -0,0 +1,3 @@
+import unplugin from './index.js'
+
+export default unplugin.rollup

package/src/rspack.d.ts

@@ -0,0 +1,4 @@
+import unplugin from './index.js'
+
+declare const plugin: typeof unplugin.rspack
+export default plugin

package/src/rspack.js

@@ -0,0 +1,3 @@
+import unplugin from './index.js'
+
+export default unplugin.rspack

package/src/vite.d.ts

@@ -0,0 +1,4 @@
+import unplugin from './index.js'
+
+declare const plugin: typeof unplugin.vite
+export default plugin

package/src/vite.js

@@ -0,0 +1,3 @@
+import unplugin from './index.js'
+
+export default unplugin.vite

package/src/webpack.d.ts

@@ -0,0 +1,4 @@
+import unplugin from './index.js'
+
+declare const plugin: typeof unplugin.webpack
+export default plugin

package/src/webpack.js

@@ -0,0 +1,3 @@
+import unplugin from './index.js'
+
+export default unplugin.webpack