@scalar/json-schema-validator 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @scalar/json-schema-validator
+
+## 0.1.0
+
+### Minor Changes
+
+- [#9967](https://github.com/scalar/scalar/pull/9967): Add `@scalar/json-schema-validator`, a standalone engine that validates documents against a JSON Schema with Ajv and returns human-friendly errors. It is the shared core that `@scalar/openapi-validator` now builds on (and that a future AsyncAPI validator can reuse).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present Scalar
+
+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,103 @@
+# Scalar JSON Schema Validator
+
+[![Version](https://img.shields.io/npm/v/%40scalar/json-schema-validator)](https://www.npmjs.com/package/@scalar/json-schema-validator)
+[![Downloads](https://img.shields.io/npm/dm/%40scalar/json-schema-validator)](https://www.npmjs.com/package/@scalar/json-schema-validator)
+[![License](https://img.shields.io/npm/l/%40scalar%2Fjson-schema-validator)](https://www.npmjs.com/package/@scalar/json-schema-validator)
+[![Discord](https://img.shields.io/discord/1135330207960678410?style=flat&color=5865F2)](https://discord.gg/scalar)
+
+Validate documents against a JSON Schema with [Ajv](https://ajv.js.org/) and get short, human-friendly error messages.
+
+This is the shared validation engine behind [`@scalar/openapi-validator`](https://www.npmjs.com/package/@scalar/openapi-validator). It knows nothing about OpenAPI or AsyncAPI, so you can use it with any JSON Schema.
+
+---
+
+Scalar is an open-source API platform for teams who want beautiful developer interfaces without vendor lock-in.
+
+- **[API References](https://scalar.com/products/api-references/getting-started)** — Interactive API documentation from OpenAPI and AsyncAPI specs.
+- **[Developer Docs](https://scalar.com/products/docs/getting-started)** — Write in Markdown/MDX, generate API references, sync with two-way Git.
+- **[SDK Generator](https://scalar.com/products/sdk-generator/getting-started)** — Type-safe SDKs and CLIs in TypeScript, Python, Go, PHP, Java, and Ruby.
+- **[API Client](https://scalar.com/products/api-client/getting-started)** — Open-source, offline-first Postman alternative built on OpenAPI.
+
+20M+ monthly npm installs · 15,500+ GitHub stars · MIT licensed · [scalar.com](https://scalar.com)
+
+---
+
+## Installation
+
+```bash
+npm add @scalar/json-schema-validator
+```
+
+## Usage
+
+Pass a document (an object, or a JSON/YAML string) and a JSON Schema:
+
+```ts
+import { validate } from '@scalar/json-schema-validator'
+
+const schema = {
+  $schema: 'https://json-schema.org/draft/2020-12/schema',
+  type: 'object',
+  required: ['name'],
+  properties: { name: { type: 'string' } },
+}
+
+const result = validate({ name: 'Hello' }, schema)
+
+console.log(result.valid)
+
+if (!result.valid) {
+  console.log(result.errors)
+}
+```
+
+The dialect is picked automatically from the schema's `$schema` (JSON Schema draft-04, draft-07, and 2020-12 are supported).
+
+### Reuse a schema
+
+When validating many documents against the same schema, compile it once:
+
+```ts
+import { createValidator } from '@scalar/json-schema-validator'
+
+const validateUser = createValidator(schema)
+
+validateUser({ name: 'Ada' })
+validateUser({ name: 'Grace' })
+```
+
+### Extra formats
+
+Register custom Ajv formats via `formats`:
+
+```ts
+validate(document, schema, {
+  formats: {
+    'media-range': true,
+  },
+})
+```
+
+Formats are applied when a schema is compiled, and `validate` caches the compiled
+schema by identity. So `formats` only takes effect the first time it sees a given
+schema object — later calls reuse the validator built from that first set. When
+different documents need different formats for the same schema, build a validator
+per format set with `createValidator` instead.
+
+### Throw on error
+
+```ts
+try {
+  validate(document, schema, { throwOnError: true })
+} catch (error) {
+  // Handle the first validation error
+}
+```
+
+## Community
+
+We are API nerds. You too? Let's chat on Discord: <https://discord.gg/scalar>
+
+## License
+
+The source code in this repository is licensed under [MIT](https://github.com/scalar/scalar/blob/main/LICENSE).

package/dist/create-specification-validator.d.ts

@@ -0,0 +1,55 @@
+import type { AnyObject } from '@scalar/types/utils';
+import type { ErrorObject, ValidationOutcome } from './types.js';
+type SchemaObject = Record<string, unknown>;
+/** Options every specification validator accepts. */
+export type SpecificationValidatorOptions = {
+    /**
+     * If `true`, throw on the first error instead of returning it.
+     *
+     * @default false
+     */
+    throwOnError?: boolean;
+};
+/**
+ * Everything a single specification (OpenAPI, AsyncAPI, …) contributes on top of
+ * the shared JSON Schema engine.
+ */
+export type SpecificationValidatorConfig<TVersion extends string, TOptions extends SpecificationValidatorOptions> = {
+    /** The JSON Schema for each supported version. */
+    schemas: Record<TVersion, SchemaObject>;
+    /** Detects the specification version from a parsed document. */
+    detectVersion: (document: AnyObject) => TVersion | undefined;
+    /** Extra Ajv formats to register for a version, compiled into its validator. */
+    formats?: (version: TVersion) => Record<string, unknown> | undefined;
+    /** Messages for the two failures that happen before schema validation. */
+    errors: {
+        /** The input is missing or is not a document. */
+        emptyOrInvalid: string;
+        /** The document's version is not supported. */
+        versionNotSupported: string;
+    };
+    /**
+     * Adjusts the document before schema validation without touching the caller's
+     * copy (AsyncAPI, for example, pins `asyncapi` to an exact version). The
+     * original document is still what is returned as `schema` and handed to
+     * `postValidate`. Defaults to validating the document as-is.
+     */
+    prepareDocument?: (specification: AnyObject, version: TVersion) => AnyObject;
+    /**
+     * Extra semantic checks run after a successful schema validation (for example
+     * OpenAPI path-template rules the JSON Schema cannot express). Any returned
+     * errors mark the document invalid.
+     */
+    postValidate?: (specification: AnyObject, version: TVersion, options: TOptions | undefined) => ErrorObject[];
+};
+/**
+ * Builds a `validate` function for a single specification on top of the shared
+ * JSON Schema engine.
+ *
+ * The returned function parses string input, rejects non-documents, detects the
+ * version, validates against the matching schema (compiled once per version and
+ * reused), and runs any specification-specific `postValidate` checks.
+ */
+export declare function createSpecificationValidator<TVersion extends string, TOptions extends SpecificationValidatorOptions = SpecificationValidatorOptions>(config: SpecificationValidatorConfig<TVersion, TOptions>): (document: string | AnyObject, options?: TOptions) => ValidationOutcome<TVersion>;
+export {};
+//# sourceMappingURL=create-specification-validator.d.ts.map

package/dist/create-specification-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-specification-validator.d.ts","sourceRoot":"","sources":["../src/create-specification-validator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAGpD,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAG7D,KAAK,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAE3C,qDAAqD;AACrD,MAAM,MAAM,6BAA6B,GAAG;IAC1C;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,4BAA4B,CAAC,QAAQ,SAAS,MAAM,EAAE,QAAQ,SAAS,6BAA6B,IAAI;IAClH,kDAAkD;IAClD,OAAO,EAAE,MAAM,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAA;IACvC,gEAAgE;IAChE,aAAa,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,QAAQ,GAAG,SAAS,CAAA;IAC5D,gFAAgF;IAChF,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAA;IACpE,0EAA0E;IAC1E,MAAM,EAAE;QACN,iDAAiD;QACjD,cAAc,EAAE,MAAM,CAAA;QACtB,+CAA+C;QAC/C,mBAAmB,EAAE,MAAM,CAAA;KAC5B,CAAA;IACD;;;;;OAKG;IACH,eAAe,CAAC,EAAE,CAAC,aAAa,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,KAAK,SAAS,CAAA;IAC5E;;;;OAIG;IACH,YAAY,CAAC,EAAE,CAAC,aAAa,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,GAAG,SAAS,KAAK,WAAW,EAAE,CAAA;CAC7G,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,SAAS,MAAM,EACvB,QAAQ,SAAS,6BAA6B,GAAG,6BAA6B,EAC9E,MAAM,EAAE,4BAA4B,CAAC,QAAQ,EAAE,QAAQ,CAAC,IAehD,UAAU,MAAM,GAAG,SAAS,EAAE,UAAU,QAAQ,KAAG,iBAAiB,CAAC,QAAQ,CAAC,CAmEvF"}

package/dist/create-specification-validator.js

@@ -0,0 +1,79 @@
+import { isObject } from '@scalar/helpers/object/is-object';
+import { parse as parseYaml } from 'yaml';
+import { createValidator } from './validate.js';
+/**
+ * Builds a `validate` function for a single specification on top of the shared
+ * JSON Schema engine.
+ *
+ * The returned function parses string input, rejects non-documents, detects the
+ * version, validates against the matching schema (compiled once per version and
+ * reused), and runs any specification-specific `postValidate` checks.
+ */
+export function createSpecificationValidator(config) {
+    // Core validators, compiled once per version and reused across calls.
+    const validatorsByVersion = new Map();
+    const getValidator = (version) => {
+        let validator = validatorsByVersion.get(version);
+        if (!validator) {
+            validator = createValidator(config.schemas[version], { formats: config.formats?.(version) });
+            validatorsByVersion.set(version, validator);
+        }
+        return validator;
+    };
+    return (document, options) => {
+        let specification;
+        if (typeof document === 'string') {
+            // A malformed JSON/YAML string is a validation failure like any other, so
+            // it respects `throwOnError` rather than escaping as a parser exception.
+            try {
+                specification = parseYaml(document);
+            }
+            catch (error) {
+                if (options?.throwOnError) {
+                    throw error;
+                }
+                return { valid: false, errors: [{ message: error instanceof Error ? error.message : String(error) }] };
+            }
+        }
+        else {
+            specification = document;
+        }
+        try {
+            // The document is empty or invalid. A YAML/JSON string can parse to a
+            // primitive or an array, neither of which is a document, so guard against
+            // anything that is not a plain object rather than only null/undefined.
+            if (!isObject(specification)) {
+                if (options?.throwOnError) {
+                    throw new Error(config.errors.emptyOrInvalid);
+                }
+                return { valid: false, errors: [{ message: config.errors.emptyOrInvalid }] };
+            }
+            const version = config.detectVersion(specification);
+            if (!version) {
+                if (options?.throwOnError) {
+                    throw new Error(config.errors.versionNotSupported);
+                }
+                return { valid: false, errors: [{ message: config.errors.versionNotSupported }] };
+            }
+            const documentToValidate = config.prepareDocument?.(specification, version) ?? specification;
+            const result = getValidator(version)(documentToValidate, options);
+            if (!result.valid) {
+                return { valid: false, version, errors: result.errors };
+            }
+            const semanticErrors = config.postValidate?.(specification, version, options) ?? [];
+            if (semanticErrors.length > 0) {
+                if (options?.throwOnError) {
+                    throw new Error(semanticErrors[0]?.message ?? 'Validation failed');
+                }
+                return { valid: false, version, errors: semanticErrors, schema: specification };
+            }
+            return { valid: true, version, errors: [], schema: specification };
+        }
+        catch (error) {
+            if (options?.throwOnError) {
+                throw error;
+            }
+            return { valid: false, errors: [{ message: error instanceof Error ? error.message : String(error) }] };
+        }
+    };
+}

package/dist/deduplicate-errors.d.ts

@@ -0,0 +1,9 @@
+import type { ErrorObject } from './types.js';
+/**
+ * Removes errors that share the same message and path.
+ *
+ * The `path` may be a JSON Pointer string (schema errors) or a list of segments
+ * (semantic errors), so both shapes are normalized to the same key.
+ */
+export declare function deduplicateErrors(errors: ErrorObject[]): ErrorObject[];
+//# sourceMappingURL=deduplicate-errors.d.ts.map

package/dist/deduplicate-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deduplicate-errors.d.ts","sourceRoot":"","sources":["../src/deduplicate-errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,WAAW,EAAE,CAetE"}

package/dist/deduplicate-errors.js

@@ -0,0 +1,18 @@
+/**
+ * Removes errors that share the same message and path.
+ *
+ * The `path` may be a JSON Pointer string (schema errors) or a list of segments
+ * (semantic errors), so both shapes are normalized to the same key.
+ */
+export function deduplicateErrors(errors) {
+    const seen = new Set();
+    return errors.filter((error) => {
+        const pathKey = Array.isArray(error.path) ? error.path.join('.') : (error.path ?? '');
+        const key = `${error.message}||${pathKey}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { type SpecificationValidatorConfig, type SpecificationValidatorOptions, createSpecificationValidator, } from './create-specification-validator.js';
+export { deduplicateErrors } from './deduplicate-errors.js';
+export { type AjvError, type PrettyError, prettifyAjvErrors } from './prettify-ajv-errors.js';
+export type { CreateValidatorOptions, ErrorObject, ValidateOptions, ValidationOutcome, ValidationResult, } from './types.js';
+export { createValidator, validate } from './validate.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,4BAA4B,EACjC,KAAK,6BAA6B,EAClC,4BAA4B,GAC7B,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AACxD,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAC1F,YAAY,EACV,sBAAsB,EACtB,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { createSpecificationValidator, } from './create-specification-validator.js';
+export { deduplicateErrors } from './deduplicate-errors.js';
+export { prettifyAjvErrors } from './prettify-ajv-errors.js';
+export { createValidator, validate } from './validate.js';

package/dist/prettify-ajv-errors.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Turns raw Ajv validation errors into a short list of human-friendly messages.
+ *
+ * Ajv reports every failing branch of a schema, which for OpenAPI documents
+ * (full of `oneOf`/`anyOf`) means a lot of noise. We group the errors into a
+ * tree by JSON Pointer, prune the redundant ones so the most actionable message
+ * wins, and then word each remaining error per keyword.
+ */
+/**
+ * A single raw Ajv validation error.
+ *
+ * This is a forgiving, partial shape: Ajv attaches different fields depending on
+ * the keyword, and we only read a handful of them.
+ */
+export type AjvError = {
+    keyword: string;
+    instancePath?: string;
+    /** Ajv < 8 used `dataPath` instead of `instancePath`. */
+    dataPath?: string;
+    schemaPath?: string;
+    message?: string;
+    propertyName?: string;
+    params?: Record<string, any>;
+};
+/** A prettified, human-friendly validation error. */
+export type PrettyError = {
+    message: string;
+    path?: string;
+};
+/**
+ * Prettifies a list of raw Ajv validation errors against the validated document.
+ */
+export declare function prettifyAjvErrors(document: unknown, errors: AjvError[]): PrettyError[];
+//# sourceMappingURL=prettify-ajv-errors.d.ts.map

package/dist/prettify-ajv-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prettify-ajv-errors.d.ts","sourceRoot":"","sources":["../src/prettify-ajv-errors.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,yDAAyD;IACzD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAC7B,CAAA;AAED,qDAAqD;AACrD,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAyXD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,WAAW,EAAE,CAKtF"}

package/dist/prettify-ajv-errors.js

@@ -0,0 +1,312 @@
+/**
+ * Turns raw Ajv validation errors into a short list of human-friendly messages.
+ *
+ * Ajv reports every failing branch of a schema, which for OpenAPI documents
+ * (full of `oneOf`/`anyOf`) means a lot of noise. We group the errors into a
+ * tree by JSON Pointer, prune the redundant ones so the most actionable message
+ * wins, and then word each remaining error per keyword.
+ */
+// Splits an instance path into its `/segment` chunks, keeping a trailing array
+// index attached to its property (`/parameters/0`). The segment class is
+// `[^/]+` (anything up to the next slash) rather than word characters only, so
+// JSON Pointer-escaped keys (`/paths/~1pets`) and keys with dots (`/pet.store`)
+// keep their own node instead of being dropped — dropping them collapsed
+// distinct paths onto the same node and let one error prune away another.
+const JSON_POINTERS_REGEX = /\/[^/]+(\/\d+)?/g;
+const isKeyword = (keyword) => (error) => error.keyword === keyword;
+const isRequiredError = isKeyword('required');
+const isAnyOfError = isKeyword('anyOf');
+const isOneOfError = isKeyword('oneOf');
+const isIfError = isKeyword('if');
+const isEnumError = isKeyword('enum');
+const isAdditionalPropertiesError = isKeyword('additionalProperties');
+const isUnevaluatedPropertiesError = isKeyword('unevaluatedProperties');
+const getChildren = (node) => Object.values(node.children);
+/** Whether the node currently has any child nodes. */
+const hasChildren = (node) => Object.keys(node.children).length > 0;
+/**
+ * Whether this node, or anything below it, carries a non-`enum` error.
+ *
+ * Pruning decisions look at whole subtrees: a sibling that only holds errors on
+ * its own children still counts. Only non-`enum` errors count as "more
+ * specific", so a bare `enum` error is not dropped merely because a sibling also
+ * failed its own `enum` — both of those are equally actionable and must survive.
+ */
+const hasMoreSpecificErrorDeep = (node) => node.errors.some((error) => !isEnumError(error)) || getChildren(node).some(hasMoreSpecificErrorDeep);
+/**
+ * The JSON Pointer to the value that failed validation. Ajv exposes this as
+ * `instancePath`; older versions used `dataPath`.
+ */
+const getInstancePath = (error) => error.instancePath !== undefined ? error.instancePath : (error.dataPath ?? '');
+/**
+ * The name of the property an error points at.
+ *
+ * Ajv only sets `propertyName` for the `propertyNames` keyword, so for every
+ * other keyword the name has to come from the last segment of the instance
+ * path. Returns `undefined` when the error points at the document root or at an
+ * array item, neither of which has a property name to report.
+ *
+ * A numeric segment is only an array index when the value holding it really is
+ * an array — OpenAPI is full of numeric object keys, `responses.404` among them
+ * — so the document decides, not the shape of the segment.
+ */
+const getPropertyName = (error, document) => {
+    if (error.propertyName) {
+        return error.propertyName;
+    }
+    const segments = pointerSegments(getInstancePath(error));
+    const last = segments.at(-1);
+    if (last === undefined) {
+        return undefined;
+    }
+    if (/^\d+$/.test(last) && Array.isArray(resolvePointer(document, segments.slice(0, -1)))) {
+        return undefined;
+    }
+    return last;
+};
+/**
+ * Words a single Ajv error, dispatched by keyword.
+ */
+function formatError(error, document) {
+    const path = getInstancePath(error);
+    switch (error.keyword) {
+        case 'additionalProperties':
+            return { message: `Property ${error.params?.additionalProperty} is not expected to be here`, path };
+        case 'unevaluatedProperties':
+            return { message: `Property ${error.params?.unevaluatedProperty} is not expected to be here`, path };
+        case 'pattern': {
+            const propertyName = getPropertyName(error, document);
+            return {
+                message: propertyName
+                    ? `Property "${propertyName}" must match pattern ${error.params?.pattern}`
+                    : `${error.keyword} ${error.message}`,
+                path,
+            };
+        }
+        case 'required':
+            return { message: `${error.message}`, path };
+        case 'format':
+            return formatFormatError(error, document);
+        default:
+            return { message: `${error.keyword} ${error.message}`, path };
+    }
+}
+/**
+ * Merges the allowed values of one or more `enum` errors into a single message.
+ */
+function formatEnumError(allowedValues, error) {
+    return { message: `${error.message}: ${allowedValues.join(', ')}`, path: getInstancePath(error) };
+}
+/**
+ * Adds context for `format` failures. Currently only `uri-reference` on `$ref`
+ * values, where the raw value is worth surfacing (for example non-ASCII
+ * characters). Everything else falls back to the default message.
+ */
+function formatFormatError(error, document) {
+    const path = getInstancePath(error);
+    if (error.params?.format === 'uri-reference' && path.endsWith('/$ref')) {
+        return { message: uriReferenceMessage(document, path), path };
+    }
+    return { message: `${error.keyword} ${error.message}`, path };
+}
+function uriReferenceMessage(document, path) {
+    const refValue = extractRefValue(document, path);
+    if (refValue && /[^\x00-\x7F]/.test(refValue)) {
+        return `$ref "${refValue}" contains non-ASCII characters`;
+    }
+    if (refValue) {
+        return `$ref "${refValue}" is not a valid URI reference`;
+    }
+    return '$ref is not a valid URI reference';
+}
+/** Decodes the `~1` and `~0` escapes of a single JSON Pointer segment. */
+const unescapePointerSegment = (segment) => segment.replace(/~1/g, '/').replace(/~0/g, '~');
+/** Splits a JSON Pointer into its decoded segments. */
+const pointerSegments = (path) => path.split('/').filter(Boolean).map(unescapePointerSegment);
+/**
+ * Walks the document along a list of JSON Pointer segments.
+ *
+ * Returns `undefined` as soon as the path leaves the document.
+ */
+function resolvePointer(document, segments) {
+    let current = document;
+    for (const segment of segments) {
+        if (current === null || typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+/**
+ * Walks the document along a JSON Pointer to read the actual `$ref` value.
+ */
+function extractRefValue(document, path) {
+    if (!document || typeof document !== 'object' || !path) {
+        return null;
+    }
+    const value = resolvePointer(document, pointerSegments(path));
+    return typeof value === 'string' ? value : null;
+}
+/**
+ * Groups a flat list of Ajv errors into a tree keyed by JSON Pointer segments.
+ */
+function makeTree(ajvErrors) {
+    const root = { errors: [], children: {} };
+    for (const ajvError of ajvErrors) {
+        const instancePath = getInstancePath(ajvError);
+        // A pointer the pattern somehow cannot split still has to be reported, so
+        // give it a node of its own keyed by the whole path. Grouping it under the
+        // root instead would expose it to the root's own pruning rules, which drop
+        // everything next to a `required` error.
+        const paths = instancePath === '' ? [''] : (instancePath.match(JSON_POINTERS_REGEX) ?? [instancePath]);
+        paths.reduce((node, path, index) => {
+            node.children[path] = node.children[path] ?? { errors: [], children: {} };
+            if (index === paths.length - 1) {
+                node.children[path].errors.push(ajvError);
+            }
+            return node.children[path];
+        }, root);
+    }
+    return root;
+}
+/**
+ * Resolves the `oneOf`/`required` tangle at a single node.
+ *
+ * OpenAPI's `oneOf: [Schema, Reference]` unions make `oneOf` and `required` fire
+ * together, and the right message depends on what else failed. `errors` is the
+ * node's list as first seen; every branch resets from it, so the decision never
+ * depends on a prior rule's output.
+ */
+function resolveCompositionAndRequired(node, errors, flags) {
+    if (flags.hasOneOf && flags.hasRequired) {
+        if (flags.hasExtraProperties) {
+            // A concrete `additionalProperties`/`unevaluatedProperties` error is the
+            // actionable one; drop the `required`/`oneOf` branch noise around it.
+            node.errors = errors.filter((error) => !isRequiredError(error) && !isOneOfError(error));
+        }
+        else if (flags.hasChildren) {
+            // The children carry the specific reason, so drop this node's errors.
+            node.errors = [];
+        }
+        else {
+            // Both `oneOf` branches produced a `required` error: one from the schema the
+            // user most likely intended (e.g. a Response needs `description`) and one
+            // from the `Reference` branch (needs `$ref`). Surface the intended error and
+            // drop the `$ref` noise, falling back to the generic `oneOf` error only when
+            // the sole requirement left is `$ref` (i.e. the value looks like a broken ref).
+            const meaningfulRequiredErrors = errors.filter((error) => isRequiredError(error) && error.params?.missingProperty !== '$ref');
+            node.errors = meaningfulRequiredErrors.length > 0 ? meaningfulRequiredErrors : errors.filter(isOneOfError);
+        }
+    }
+    else if (flags.hasOneOf && flags.hasChildren) {
+        // Only a `oneOf` error with children: let the more specific children surface.
+        node.errors = [];
+    }
+    else if (flags.hasOneOf) {
+        // Multiple duplicate `oneOf` errors from different branches: keep just one.
+        const oneOfErrors = errors.filter(isOneOfError);
+        if (oneOfErrors.length > 1) {
+            node.errors = [oneOfErrors[0]];
+        }
+    }
+    else if (flags.hasRequired) {
+        // A missing property makes the rest of that object's errors moot, so a
+        // `required` error wins outright — over `anyOf`, and over the children.
+        node.errors = errors.filter(isRequiredError);
+        node.children = {};
+    }
+}
+/**
+ * Drops a node whose errors are all `enum` errors when a sibling carries a more
+ * specific (non-`enum`) error. Two properties each failing their own `enum` are
+ * equally actionable, so neither silences the other. The root node's key is the
+ * empty string, so compare `key` against `undefined` rather than truthiness.
+ */
+function pruneEnumNextToSpecificSibling(node, parent, key) {
+    if (!(node.errors.length > 0 && node.errors.every(isEnumError) && parent && key !== undefined)) {
+        return;
+    }
+    // The more specific error is often on a grandchild rather than the sibling
+    // itself, so weigh whole subtrees.
+    const siblingsHaveMoreSpecificErrors = getChildren(parent)
+        .filter((sibling) => sibling !== node)
+        .some(hasMoreSpecificErrorDeep);
+    if (siblingsHaveMoreSpecificErrors) {
+        delete parent.children[key];
+    }
+}
+/**
+ * Prunes redundant errors from the tree so the most actionable message wins.
+ *
+ * Ajv reports every failing branch, which for OpenAPI (full of `oneOf`/`anyOf`/
+ * `if`) is mostly noise. The rules rank errors by how specific they are:
+ *
+ *   - "container" errors — `oneOf`, `anyOf`, `if` — only report that a branch
+ *     failed, never why, so they yield to any more specific error that survives.
+ *   - `required` is specific and terminal: a missing property makes the rest of
+ *     that object's errors moot (except the `oneOf: [Schema, Reference]` pattern,
+ *     resolved first).
+ *   - `enum` is specific but weak: a more specific sibling error wins.
+ *   - everything else (`type`, `pattern`, `format`, …) is specific and kept.
+ *
+ * The steps below run in order and mutate the node; the ordering is load-bearing
+ * and called out where it matters.
+ */
+function filterRedundantErrors(node, parent, key) {
+    // Snapshot the errors and the flags derived from them. Later steps reset from
+    // this snapshot, so an earlier filter never hides a keyword a later step weighs.
+    const errors = node.errors;
+    const flags = {
+        hasOneOf: errors.some(isOneOfError),
+        hasAnyOf: errors.some(isAnyOfError),
+        hasRequired: errors.some(isRequiredError),
+        hasIf: errors.some(isIfError),
+        hasExtraProperties: errors.some(isAdditionalPropertiesError) || errors.some(isUnevaluatedPropertiesError),
+        hasChildren: hasChildren(node),
+    };
+    // 1. An `if` error next to an `additionalProperties`/`unevaluatedProperties`
+    //    error is just noise from the if/then/else conditional.
+    if (flags.hasIf && flags.hasExtraProperties) {
+        node.errors = errors.filter((error) => !isIfError(error));
+    }
+    // 2. Resolve the `oneOf`/`required` composition tangle.
+    resolveCompositionAndRequired(node, errors, flags);
+    // 3. A container error whose real cause sits in a surviving child is noise.
+    //    Re-check children live: step 2's `required` branch may have cleared them,
+    //    and wiping the errors then would drop the actionable `required` message.
+    if (flags.hasAnyOf && hasChildren(node)) {
+        node.errors = [];
+    }
+    if (flags.hasIf && hasChildren(node)) {
+        node.errors = node.errors.filter((error) => !isIfError(error));
+    }
+    // 4. An all-`enum` node yields to a more specific sibling.
+    pruneEnumNextToSpecificSibling(node, parent, key);
+    for (const [childKey, child] of Object.entries(node.children)) {
+        filterRedundantErrors(child, node, childKey);
+    }
+}
+/**
+ * Turns the filtered tree into a flat list of prettified errors.
+ */
+function createErrors(node, document) {
+    const errors = node.errors;
+    // When every error at this node is an `enum` error, merge their allowed values
+    // into a single message instead of repeating the same error.
+    if (errors.length > 0 && errors.every(isEnumError)) {
+        const allowedValues = [...new Set(errors.flatMap((error) => error.params?.allowedValues ?? []))];
+        return [formatEnumError(allowedValues, errors[0])];
+    }
+    const own = errors.map((error) => formatError(error, document));
+    const children = getChildren(node).flatMap((child) => createErrors(child, document));
+    return [...own, ...children];
+}
+/**
+ * Prettifies a list of raw Ajv validation errors against the validated document.
+ */
+export function prettifyAjvErrors(document, errors) {
+    const tree = makeTree(errors ?? []);
+    filterRedundantErrors(tree);
+    return createErrors(tree, document);
+}

package/dist/transform-errors.d.ts

@@ -0,0 +1,11 @@
+import type { AnyObject } from '@scalar/types/utils';
+import { type AjvError } from './prettify-ajv-errors.js';
+import type { ErrorObject } from './types.js';
+/**
+ * Transforms raw Ajv errors into enriched, human-friendly error objects.
+ *
+ * A plain string is passed through as a single error message. Otherwise the Ajv
+ * errors are prettified and deduplicated.
+ */
+export declare function transformErrors(specification: AnyObject, errors: string | AjvError[]): ErrorObject[];
+//# sourceMappingURL=transform-errors.d.ts.map

package/dist/transform-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-errors.d.ts","sourceRoot":"","sources":["../src/transform-errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAGpD,OAAO,EAAE,KAAK,QAAQ,EAAqB,MAAM,uBAAuB,CAAA;AACxE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,aAAa,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,EAAE,GAAG,WAAW,EAAE,CAyCpG"}

package/dist/transform-errors.js

@@ -0,0 +1,44 @@
+import { deduplicateErrors } from './deduplicate-errors.js';
+import { prettifyAjvErrors } from './prettify-ajv-errors.js';
+/**
+ * Transforms raw Ajv errors into enriched, human-friendly error objects.
+ *
+ * A plain string is passed through as a single error message. Otherwise the Ajv
+ * errors are prettified and deduplicated.
+ */
+export function transformErrors(specification, errors) {
+    if (typeof errors === 'string') {
+        return [{ message: errors }];
+    }
+    // If the specification is null or invalid, the errors cannot be prettified.
+    // This can happen when reference resolution fails.
+    if (!specification || typeof specification !== 'object') {
+        return [{ message: 'Invalid specification' }];
+    }
+    // Wrap prettifyAjvErrors in a try-catch since it can fail with malformed schemas.
+    let processedErrors;
+    try {
+        processedErrors = prettifyAjvErrors(specification, errors).map((error) => ({
+            ...error,
+            message: error.message.trim(),
+        }));
+    }
+    catch (error) {
+        console.error(error);
+        // If prettifying fails, fall back to the raw Ajv errors. `errors` is always
+        // an array here: the string case returned above.
+        return errors.map((err) => {
+            let message = err.message || 'Validation error';
+            // For additionalProperties errors, include the property name
+            if (err.keyword === 'additionalProperties' && err.params?.additionalProperty) {
+                message = `Property ${err.params.additionalProperty} is not expected to be here`;
+            }
+            return {
+                message,
+                path: err.dataPath || err.instancePath,
+            };
+        });
+    }
+    // Deduplicate errors with the same message and path
+    return deduplicateErrors(processedErrors);
+}

package/dist/types.d.ts

@@ -0,0 +1,64 @@
+import type { UnknownObject } from '@scalar/types/utils';
+/**
+ * A single validation error.
+ *
+ * `path` is either a JSON Pointer string (from schema validation) or a list of
+ * path segments (when a caller adds its own semantic errors).
+ */
+export type ErrorObject = {
+    message: string;
+    path?: string | string[];
+    code?: string;
+};
+/**
+ * The result of validating a document against a specification (OpenAPI,
+ * AsyncAPI, …). Generic over the specification's version union so each validator
+ * reports its own versions.
+ */
+export type ValidationOutcome<TVersion extends string = string> = {
+    valid: true;
+    version: TVersion;
+    errors?: ErrorObject[];
+    schema: UnknownObject;
+} | {
+    valid: false;
+    version?: TVersion;
+    errors: ErrorObject[];
+    schema?: UnknownObject;
+};
+/**
+ * Options for a single validation call.
+ */
+export type ValidateOptions = {
+    /**
+     * If `true`, throw on the first error instead of returning them.
+     *
+     * @default false
+     */
+    throwOnError?: boolean;
+};
+/**
+ * Options that affect how a schema is compiled into a validator.
+ *
+ * These only take effect at compile time, so they belong on `createValidator`
+ * (or the first `validate` call for a given schema), not on individual calls.
+ */
+export type CreateValidatorOptions = {
+    /**
+     * Extra Ajv formats to register beyond `ajv-formats`, keyed by name.
+     *
+     * For example OpenAPI 3.1/3.2 documents use a `media-range` format.
+     */
+    formats?: Record<string, unknown>;
+};
+/**
+ * The result of validating a document against a schema.
+ */
+export type ValidationResult = {
+    valid: true;
+    errors: [];
+} | {
+    valid: false;
+    errors: ErrorObject[];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAExD;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IACxB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,CAAC,QAAQ,SAAS,MAAM,GAAG,MAAM,IAC1D;IACE,KAAK,EAAE,IAAI,CAAA;IACX,OAAO,EAAE,QAAQ,CAAA;IACjB,MAAM,CAAC,EAAE,WAAW,EAAE,CAAA;IACtB,MAAM,EAAE,aAAa,CAAA;CACtB,GACD;IACE,KAAK,EAAE,KAAK,CAAA;IACZ,OAAO,CAAC,EAAE,QAAQ,CAAA;IAClB,MAAM,EAAE,WAAW,EAAE,CAAA;IACrB,MAAM,CAAC,EAAE,aAAa,CAAA;CACvB,CAAA;AAEL;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAClC,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GACxB;IACE,KAAK,EAAE,IAAI,CAAA;IACX,MAAM,EAAE,EAAE,CAAA;CACX,GACD;IACE,KAAK,EAAE,KAAK,CAAA;IACZ,MAAM,EAAE,WAAW,EAAE,CAAA;CACtB,CAAA"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/validate.d.ts

@@ -0,0 +1,23 @@
+import type { CreateValidatorOptions, ValidateOptions, ValidationResult } from './types.js';
+type SchemaObject = Record<string, any>;
+/**
+ * Compiles a JSON Schema once and returns a reusable validator function.
+ *
+ * Prefer this when validating many documents against the same schema.
+ *
+ * Compiling happens up front, so a schema Ajv cannot compile throws from this
+ * call rather than from the returned function. Use `validate` instead when a
+ * schema is untrusted and an uncompilable one should come back as a result.
+ */
+export declare function createValidator(schema: SchemaObject, options?: CreateValidatorOptions): (document: unknown, callOptions?: ValidateOptions) => ValidationResult;
+/**
+ * Validates a document against a JSON Schema.
+ *
+ * The document can be an object, or a JSON or YAML string. Compiled schemas are
+ * cached by identity, so passing the same schema object again is cheap. Because
+ * of that cache, `formats` only take effect the first time a given schema object
+ * is validated; reuse `createValidator` when you need per-schema formats.
+ */
+export declare function validate(document: unknown, schema: SchemaObject, options?: ValidateOptions & CreateValidatorOptions): ValidationResult;
+export {};
+//# sourceMappingURL=validate.d.ts.map

package/dist/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAExF,KAAK,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AA0FvC;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,sBAAsB,IAG5E,UAAU,OAAO,EAAE,cAAc,eAAe,KAAG,gBAAgB,CAE5E;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CACtB,QAAQ,EAAE,OAAO,EACjB,MAAM,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE,eAAe,GAAG,sBAAsB,GACjD,gBAAgB,CAyClB"}

package/dist/validate.js

@@ -0,0 +1,131 @@
+import Ajv, {} from 'ajv';
+import Ajv2020 from 'ajv/dist/2020.js';
+import Ajv04 from 'ajv-draft-04';
+import addFormats from 'ajv-formats';
+import { parse as parseYaml } from 'yaml';
+import { transformErrors } from './transform-errors.js';
+/**
+ * Ajv classes keyed by the JSON Schema dialect a schema declares in `$schema`.
+ *
+ * The keys omit the trailing `#`, which schemas include inconsistently (OpenAPI
+ * draft-04 has it, the AsyncAPI draft-07 schemas do not). Lookups normalize the
+ * `$schema` value the same way so both variants resolve.
+ */
+const ajvClassesByDialect = {
+    'http://json-schema.org/draft-04/schema': Ajv04,
+    'http://json-schema.org/draft-07/schema': Ajv,
+    'https://json-schema.org/draft/2020-12/schema': Ajv2020,
+};
+const compile = (schema, formats) => {
+    const dialect = typeof schema.$schema === 'string' ? schema.$schema.replace(/#$/, '') : '';
+    const AjvClass = ajvClassesByDialect[dialect] ?? Ajv;
+    const ajv = new AjvClass({
+        // Ajv is a bit too strict in its strict validation of these schemas.
+        strict: false,
+        // Enable discriminator support for better oneOf error messages
+        discriminator: true,
+        // Show all errors, not just the first one
+        allErrors: true,
+    });
+    // Register the standard formats, then any caller-provided extras.
+    addFormats(ajv);
+    if (formats) {
+        for (const [name, definition] of Object.entries(formats)) {
+            ajv.addFormat(name, definition);
+        }
+    }
+    return ajv.compile(schema);
+};
+/**
+ * Compiled validators cached by schema identity. Compiling a schema is
+ * expensive, so repeat validations of the same schema object reuse the result.
+ */
+const compiledValidators = new WeakMap();
+/**
+ * Schemas that failed to compile, and why. Cached alongside the successes so a
+ * broken schema fails fast instead of paying the full Ajv setup cost per call.
+ */
+const failedCompilations = new WeakMap();
+const toMessage = (error) => (error instanceof Error ? error.message : String(error));
+const runValidation = (validateFn, document, options) => {
+    let value;
+    if (typeof document === 'string') {
+        // A malformed JSON/YAML string is a validation failure like any other, so it
+        // has to respect `throwOnError` rather than escaping as a parser exception.
+        try {
+            value = parseYaml(document);
+        }
+        catch (error) {
+            if (options?.throwOnError) {
+                throw error;
+            }
+            return { valid: false, errors: [{ message: toMessage(error) }] };
+        }
+    }
+    else {
+        value = document;
+    }
+    if (validateFn(value)) {
+        return { valid: true, errors: [] };
+    }
+    const errors = transformErrors(value, (validateFn.errors ?? []));
+    if (options?.throwOnError) {
+        throw new Error(errors[0]?.message ?? 'Validation failed');
+    }
+    return { valid: false, errors };
+};
+/**
+ * Compiles a JSON Schema once and returns a reusable validator function.
+ *
+ * Prefer this when validating many documents against the same schema.
+ *
+ * Compiling happens up front, so a schema Ajv cannot compile throws from this
+ * call rather than from the returned function. Use `validate` instead when a
+ * schema is untrusted and an uncompilable one should come back as a result.
+ */
+export function createValidator(schema, options) {
+    const validateFn = compile(schema, options?.formats);
+    return (document, callOptions) => runValidation(validateFn, document, callOptions);
+}
+/**
+ * Validates a document against a JSON Schema.
+ *
+ * The document can be an object, or a JSON or YAML string. Compiled schemas are
+ * cached by identity, so passing the same schema object again is cheap. Because
+ * of that cache, `formats` only take effect the first time a given schema object
+ * is validated; reuse `createValidator` when you need per-schema formats.
+ */
+export function validate(document, schema, options) {
+    // Booleans are valid JSON Schemas but cannot key a WeakMap, so they skip the
+    // caches entirely rather than throwing.
+    const isCacheable = typeof schema === 'object' && schema !== null;
+    if (isCacheable && failedCompilations.has(schema)) {
+        const previousFailure = failedCompilations.get(schema);
+        if (options?.throwOnError) {
+            throw previousFailure;
+        }
+        return { valid: false, errors: [{ message: toMessage(previousFailure) }] };
+    }
+    let validateFn = compiledValidators.get(schema);
+    if (!validateFn) {
+        // A schema that cannot be compiled (a malformed `pattern`, an unresolvable
+        // `$ref`, an unknown dialect) is reported like any other failure, so
+        // `throwOnError: false` keeps its promise not to throw.
+        try {
+            validateFn = compile(schema, options?.formats);
+        }
+        catch (error) {
+            if (isCacheable) {
+                failedCompilations.set(schema, error);
+            }
+            if (options?.throwOnError) {
+                throw error;
+            }
+            return { valid: false, errors: [{ message: toMessage(error) }] };
+        }
+        if (isCacheable) {
+            compiledValidators.set(schema, validateFn);
+        }
+    }
+    return runValidation(validateFn, document, options);
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@scalar/json-schema-validator",
+  "description": "Validate documents against a JSON Schema with Ajv and human-friendly errors",
+  "license": "MIT",
+  "author": "Scalar (https://github.com/scalar)",
+  "homepage": "https://github.com/scalar/scalar",
+  "bugs": "https://github.com/scalar/scalar/issues/new/choose",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/scalar/scalar.git",
+    "directory": "packages/json-schema-validator"
+  },
+  "keywords": [
+    "json-schema",
+    "scalar",
+    "ajv",
+    "validator",
+    "typescript"
+  ],
+  "version": "0.1.0",
+  "engines": {
+    "node": ">=22"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "ajv": "^8.20.0",
+    "ajv-draft-04": "^1.0.0",
+    "ajv-formats": "^3.0.1",
+    "yaml": "^2.9.0",
+    "@scalar/helpers": "0.11.2",
+    "@scalar/types": "0.18.3"
+  },
+  "devDependencies": {
+    "@types/node": "^24.1.0",
+    "vite": "8.1.5"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+    "test": "vitest --run",
+    "types:check": "tsgo --noEmit"
+  }
+}