@scalar/openapi-validator 0.1.0

package/dist/specifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"specifications.d.ts","sourceRoot":"","sources":["../src/specifications.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKjC,CAAA;AAED,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,qBAAqB,CAAA;AAE/D,eAAO,MAAM,eAAe,EAAyC,cAAc,EAAE,CAAA"}

package/dist/specifications.js

@@ -0,0 +1,14 @@
+import Swagger20 from './schemas/v2.0/schema.js';
+import OpenApi30 from './schemas/v3.0/schema.js';
+import OpenApi31 from './schemas/v3.1/schema.js';
+import OpenApi32 from './schemas/v3.2/schema.js';
+/**
+ * The OpenAPI/Swagger JSON Schemas supported by the validator, keyed by version.
+ */
+export const OpenApiSpecifications = {
+    '2.0': Swagger20,
+    '3.0': OpenApi30,
+    '3.1': OpenApi31,
+    '3.2': OpenApi32,
+};
+export const OpenApiVersions = Object.keys(OpenApiSpecifications);

package/dist/types.d.ts

@@ -0,0 +1,17 @@
+import type { ValidationOutcome as GenericValidationOutcome } from '@scalar/json-schema-validator';
+import type { OpenApiVersion } from './specifications.js';
+export type { ErrorObject } from '@scalar/json-schema-validator';
+export type { OpenApiVersion } from './specifications.js';
+export type ThrowOnErrorOption = {
+    /**
+     * If `true`, the function will throw an error if the document is invalid.
+     *
+     * @default false
+     */
+    throwOnError?: boolean;
+};
+/**
+ * The result of validating an OpenAPI document.
+ */
+export type ValidationOutcome = GenericValidationOutcome<OpenApiVersion>;
+//# 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,iBAAiB,IAAI,wBAAwB,EAAE,MAAM,+BAA+B,CAAA;AAElG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEtD,YAAY,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAEhE,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEtD,MAAM,MAAM,kBAAkB,GAAG;IAC/B;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,wBAAwB,CAAC,cAAc,CAAC,CAAA"}

package/dist/types.js

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

package/dist/validate-path-parameters.d.ts

@@ -0,0 +1,7 @@
+import type { AnyObject } from '@scalar/types/utils';
+import type { ErrorObject } from './types.js';
+/**
+ * Validates path-template semantics that are not enforced by the JSON schema.
+ */
+export declare function validatePathParameters(specification: AnyObject): ErrorObject[];
+//# sourceMappingURL=validate-path-parameters.d.ts.map

package/dist/validate-path-parameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-path-parameters.d.ts","sourceRoot":"","sources":["../src/validate-path-parameters.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAEpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAmB1C;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,SAAS,GAAG,WAAW,EAAE,CAoE9E"}

package/dist/validate-path-parameters.js

@@ -0,0 +1,90 @@
+import { isObjectLike } from '@scalar/helpers/object/is-object';
+import { deduplicateErrors } from '@scalar/json-schema-validator';
+/**
+ * Any non-array object, whatever its prototype.
+ *
+ * `isObject` is deliberately not used here: it also rejects objects with a
+ * custom prototype, which would silently skip whole path items in a
+ * hand-constructed document rather than validating them.
+ */
+const isRecord = (value) => isObjectLike(value) && !Array.isArray(value);
+const OPERATION_KEYS = new Set(['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace']);
+const PATH_PARAMETER_PATTERN = /{([^}]+)}/g;
+/**
+ * Validates path-template semantics that are not enforced by the JSON schema.
+ */
+export function validatePathParameters(specification) {
+    const paths = specification?.paths;
+    if (!paths || typeof paths !== 'object') {
+        return [];
+    }
+    const errors = [];
+    for (const [pathName, pathItem] of Object.entries(paths)) {
+        if (!isRecord(pathItem)) {
+            continue;
+        }
+        const operations = Object.entries(pathItem).filter(([key, value]) => OPERATION_KEYS.has(key) && isRecord(value));
+        // Preserve the repo's current behaviour for empty path items.
+        if (operations.length === 0) {
+            continue;
+        }
+        const templateParameters = new Set(getTemplateParameterNames(pathName));
+        const pathLevelParameters = getPathParameters(pathItem.parameters, ['paths', pathName, 'parameters']);
+        for (const parameter of pathLevelParameters) {
+            if (!templateParameters.has(parameter.name)) {
+                errors.push({
+                    path: parameter.path,
+                    message: `Path parameter "${parameter.name}" must have the corresponding {${parameter.name}} segment in the "${pathName}" path`,
+                });
+            }
+        }
+        for (const [operationKey, operation] of operations) {
+            const operationParameters = getPathParameters(operation.parameters, [
+                'paths',
+                pathName,
+                operationKey,
+                'parameters',
+            ]);
+            for (const parameter of operationParameters) {
+                if (!templateParameters.has(parameter.name)) {
+                    errors.push({
+                        path: parameter.path,
+                        message: `Path parameter "${parameter.name}" must have the corresponding {${parameter.name}} segment in the "${pathName}" path`,
+                    });
+                }
+            }
+            const effectiveParameters = new Set([...pathLevelParameters, ...operationParameters].map((parameter) => parameter.name));
+            for (const templateParameter of templateParameters) {
+                if (!effectiveParameters.has(templateParameter)) {
+                    errors.push({
+                        path: ['paths', pathName, operationKey],
+                        message: `Declared path parameter "${templateParameter}" needs to be defined as a path parameter at either the path or operation level`,
+                    });
+                }
+            }
+        }
+    }
+    return deduplicateErrors(errors);
+}
+function getTemplateParameterNames(pathName) {
+    return [...pathName.matchAll(PATH_PARAMETER_PATTERN)].map((match) => normalizeTemplateParameterName(match[1]));
+}
+function normalizeTemplateParameterName(name) {
+    return name.endsWith('+') ? name.slice(0, -1) : name;
+}
+function getPathParameters(parameters, pathPrefix) {
+    if (!Array.isArray(parameters)) {
+        return [];
+    }
+    return parameters.flatMap((parameter, index) => {
+        if (!isRecord(parameter) || parameter.in !== 'path' || typeof parameter.name !== 'string') {
+            return [];
+        }
+        return [
+            {
+                name: parameter.name,
+                path: [...pathPrefix, String(index), 'name'],
+            },
+        ];
+    });
+}

package/dist/validate.d.ts

@@ -0,0 +1,36 @@
+import type { AnyObject } from '@scalar/types/utils';
+import type { ThrowOnErrorOption, ValidationOutcome } from './types.js';
+export type ValidateOptions = ThrowOnErrorOption & {
+    /**
+     * Run the path-parameter semantic checks (declared parameters match the
+     * `{template}` segments in the path, and vice versa).
+     *
+     * Off by default: these checks need a fully resolved document, because a path
+     * parameter can be declared through a `$ref`, and this validator does not
+     * resolve references — running them on an unresolved document would report
+     * false positives. Callers that resolve references first (bundle or
+     * dereference) can opt in; `@scalar/openapi-parser` leaves them off here and
+     * runs `validatePathParameters` on the resolved document itself.
+     *
+     * @default false
+     */
+    checkPathParameters?: boolean;
+};
+/**
+ * Validates a single OpenAPI document against the OpenAPI Specification.
+ *
+ * Schema validation is delegated to `@scalar/json-schema-validator`; version
+ * detection and the path-parameter semantic checks are OpenAPI-specific.
+ *
+ * This validator is strict about the specification: every required field,
+ * including `info.version`, must be present. Callers that want to be lenient
+ * (as `@scalar/openapi-parser` is) should fill in defaults before validating.
+ *
+ * The input must be a self-contained document. This validator does not resolve
+ * external `$ref`s, so bundle or dereference documents that span multiple files
+ * before validating them.
+ *
+ * @param document - A JSON string, a YAML string, or an object.
+ */
+export declare function validate(document: string | AnyObject, options?: ValidateOptions): ValidationOutcome;
+//# 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":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAKpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAGpE,MAAM,MAAM,eAAe,GAAG,kBAAkB,GAAG;IACjD;;;;;;;;;;;;OAYG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAC9B,CAAA;AAeD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,iBAAiB,CAEnG"}

package/dist/validate.js

@@ -0,0 +1,35 @@
+import { createSpecificationValidator } from '@scalar/json-schema-validator';
+import { detectVersion } from './detect-version.js';
+import { ERRORS } from './errors.js';
+import { OpenApiSpecifications } from './specifications.js';
+import { validatePathParameters } from './validate-path-parameters.js';
+const validateDocument = createSpecificationValidator({
+    schemas: OpenApiSpecifications,
+    detectVersion,
+    // OpenAPI 3.1 and 3.2 use the media-range format.
+    formats: (version) => (version === '3.1' || version === '3.2' ? { 'media-range': true } : undefined),
+    errors: { emptyOrInvalid: ERRORS.EMPTY_OR_INVALID, versionNotSupported: ERRORS.OPENAPI_VERSION_NOT_SUPPORTED },
+    // Path-template semantics that the JSON schema cannot express. These need a
+    // fully resolved document (a path parameter can be declared via `$ref`), so
+    // they are opt-in: callers that resolve references first can enable them.
+    postValidate: (specification, _version, options) => options?.checkPathParameters ? validatePathParameters(specification) : [],
+});
+/**
+ * Validates a single OpenAPI document against the OpenAPI Specification.
+ *
+ * Schema validation is delegated to `@scalar/json-schema-validator`; version
+ * detection and the path-parameter semantic checks are OpenAPI-specific.
+ *
+ * This validator is strict about the specification: every required field,
+ * including `info.version`, must be present. Callers that want to be lenient
+ * (as `@scalar/openapi-parser` is) should fill in defaults before validating.
+ *
+ * The input must be a self-contained document. This validator does not resolve
+ * external `$ref`s, so bundle or dereference documents that span multiple files
+ * before validating them.
+ *
+ * @param document - A JSON string, a YAML string, or an object.
+ */
+export function validate(document, options) {
+    return validateDocument(document, options);
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@scalar/openapi-validator",
+  "description": "Validate OpenAPI documents against the OpenAPI Specification",
+  "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/openapi-validator"
+  },
+  "keywords": [
+    "openapi",
+    "scalar",
+    "swagger",
+    "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": {
+    "yaml": "^2.9.0",
+    "@scalar/types": "0.18.3",
+    "@scalar/json-schema-validator": "0.1.0",
+    "@scalar/helpers": "0.11.2"
+  },
+  "devDependencies": {
+    "@tailwindcss/vite": "^4.3.3",
+    "@types/node": "^24.1.0",
+    "@vitejs/plugin-vue": "^6.0.8",
+    "tailwindcss": "^4.3.3",
+    "vite": "8.1.5",
+    "vue": "^3.5.40",
+    "@scalar/themes": "0.17.4",
+    "@scalar/use-codemirror": "0.14.15"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+    "dev": "pnpm playground",
+    "playground": "cd playground && vite",
+    "test": "vitest --run",
+    "types:check": "tsgo --noEmit"
+  }
+}