@oh-my-pi/omptype 18.16.0 → 18.18.0

package/dist/types/jsonschema/pattern.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Compiles simple anchored `pattern`s into char-code checks for generated
+ * validators: `^[0-9a-f]{8}-…$`, `^\d{4}-\d{2}-\d{2}$`, `^[A-Za-z0-9._-]+$`.
+ *
+ * Supported: ASCII literals and escaped punctuation, `\d`, `\w`, non-negated
+ * ASCII classes, and quantifiers, with at most one variable-length segment.
+ * Fixed segments then pin every position (from the start before the variable
+ * segment, from the end after it), so the check is exact without
+ * backtracking. ASCII-only classes reject every UTF-16 surrogate, so counting
+ * code units agrees with the `u` flag's code points. Anything else returns
+ * `undefined` and stays a `RegExp`.
+ */
+/**
+ * Source of `function name(s)` testing a string against `source` with the
+ * `u` flag's semantics, or `undefined` when the pattern is not simple.
+ */
+export declare function compileSimplePattern(source: string, name: string): string | undefined;

package/dist/types/jsonschema/plan.d.ts

@@ -0,0 +1,128 @@
+import { type Registry } from "./resolve.js";
+/** Boolean check for one `format` name; returning false rejects the string. */
+export type FormatCheck = (value: string) => boolean;
+export declare const T_NULL = 1;
+export declare const T_BOOLEAN = 2;
+export declare const T_INTEGER = 4;
+/** Any finite number, integers included. */
+export declare const T_NUMBER = 8;
+export declare const T_STRING = 16;
+export declare const T_ARRAY = 32;
+export declare const T_OBJECT = 64;
+export declare const T_ANY = 127;
+/** Every number type: `type: "number"`. */
+export declare const T_NUMERIC: number;
+/** The single JSON kind a passing value of `types` has, as a mask; 0 when several. */
+export declare function kindOf(types: number): number;
+/** A `properties`/`dependentSchemas` entry. */
+export interface KeyPlan {
+    readonly key: string;
+    readonly plan: Plan;
+    /** `key` is inherited by plain objects (`constructor`, `__proto__`, ...): reads need an own check. */
+    readonly inherited: boolean;
+}
+/** A `patternProperties` entry. */
+export interface PatternPlan {
+    readonly pattern: RegExp;
+    readonly plan: Plan;
+}
+/** A `dependentRequired` entry. */
+export interface DependentRequired {
+    readonly key: string;
+    readonly required: readonly string[];
+}
+/** A property `default` declared under `properties`. */
+export interface PropertyDefault {
+    readonly key: string;
+    readonly value: unknown;
+}
+/**
+ * Normalized keywords of one schema location in one dynamic scope. Absent
+ * fields impose nothing; type-specific keywords only constrain values of
+ * their type.
+ */
+export interface Plan {
+    /** Accepted JSON types as `T_*` flags; `T_ANY` when unconstrained, 0 for `false`. */
+    types: number;
+    /** No keyword constrains the value (`true`, `{}`, annotation-only schemas). */
+    empty: boolean;
+    /** `F_*` keyword groups present; 0 when `type` is the only constraint. */
+    flags: number;
+    /** `$ref` and resolved `$dynamicRef` targets, applied in place. */
+    refs?: Plan[];
+    hasConst?: boolean;
+    constValue?: unknown;
+    enumValues?: readonly unknown[];
+    multipleOf?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp;
+    formatName?: string;
+    format?: FormatCheck;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    prefixItems?: Plan[];
+    /** Schema for elements after `prefixItems` (or every element). */
+    items?: Plan;
+    contains?: Plan;
+    minContains?: number;
+    maxContains?: number;
+    unevaluatedItems?: Plan;
+    minProperties?: number;
+    maxProperties?: number;
+    required?: string[];
+    properties?: KeyPlan[];
+    patternProperties?: PatternPlan[];
+    additionalProperties?: Plan;
+    propertyNames?: Plan;
+    dependentRequired?: DependentRequired[];
+    dependentSchemas?: KeyPlan[];
+    unevaluatedProperties?: Plan;
+    allOf?: Plan[];
+    anyOf?: Plan[];
+    oneOf?: Plan[];
+    not?: Plan;
+    if?: Plan;
+    /** `then`, applied when `if` passes. */
+    ifThen?: Plan;
+    /** `else`, applied when `if` fails. */
+    ifElse?: Plan;
+    defaults?: PropertyDefault[];
+}
+/** The `true` schema. */
+export declare const TRUE_PLAN: Plan;
+/** The `false` schema. */
+export declare const FALSE_PLAN: Plan;
+export declare const F_CONST = 1;
+export declare const F_ENUM = 2;
+/** Numeric keywords. */
+export declare const F_NUMBER = 4;
+/** String keywords. */
+export declare const F_STRING = 8;
+/** Array keywords. */
+export declare const F_ARRAY = 16;
+/** `required` and `properties`. */
+export declare const F_PROPERTIES = 32;
+/** Keywords that visit every key: `patternProperties`, `additionalProperties`, `propertyNames`, property counts. */
+export declare const F_KEYS = 64;
+/** `dependentRequired`, `dependentSchemas`. */
+export declare const F_DEPENDENT = 128;
+export declare const F_REFS = 256;
+/** `allOf`, `anyOf`, `oneOf`, `not`, `if`. */
+export declare const F_APPLICATORS = 512;
+/** `unevaluatedProperties`, `unevaluatedItems`. */
+export declare const F_UNEVALUATED = 1024;
+/** Lowers one registry's documents into plans. */
+export declare class Planner {
+    #private;
+    /** Whether any `properties` subschema declares a `default`. */
+    sawDefaults: boolean;
+    constructor(registry: Registry, formats: Readonly<Record<string, FormatCheck>> | undefined);
+    /** Plan the registry's root document. */
+    root(schema: unknown): Plan;
+}

package/dist/types/jsonschema/resolve.d.ts

@@ -0,0 +1,43 @@
+/** Keyword semantics: draft 2020-12, 2019-09 (array `items`, no `$dynamicRef`), or 7 (also 4/6). */
+export type Draft = "2020-12" | "2019-09" | "7";
+/** Vocabulary flags gating keyword groups; resources default to all of them. */
+export declare const VOCAB_APPLICATOR = 1;
+export declare const VOCAB_VALIDATION = 2;
+export declare const VOCAB_UNEVALUATED = 4;
+/** A schema resource: a document root or a subschema with its own `$id`. */
+export interface Resource {
+    /** Absolute URI without fragment. */
+    readonly uri: string;
+    readonly root: object;
+    readonly draft: Draft;
+    readonly vocab: number;
+    /** `$dynamicAnchor` names declared in this resource, with their subschemas. */
+    readonly dynamicAnchors: Map<string, object>;
+}
+/** Base URI and enclosing resource of a subschema. */
+export interface Location {
+    readonly base: string;
+    readonly resource: Resource;
+}
+/** A schema reached through a reference, with the location it evaluates in. */
+export interface Target {
+    readonly schema: unknown;
+    readonly location: Location;
+}
+/** Registry of the documents one `fromJsonSchema` call can reference. */
+export declare class Registry {
+    #private;
+    constructor(draft: Draft, documents: Readonly<Record<string, unknown>> | undefined);
+    /** Index `schema` as the root document and return its target. */
+    addRoot(schema: unknown): Target;
+    /** Location recorded for an indexed subschema. */
+    location(schema: object): Location | undefined;
+    /**
+     * Resolve `ref` against `base` to a schema and its location.
+     *
+     * # Errors
+     * Throws {@link OmpTypeError} for malformed URI references or fragments, and
+     * for targets no known document contains.
+     */
+    resolve(ref: string, base: string): Target;
+}

package/dist/types/jsonschema/runtime.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Runtime helpers shared by the closure validators (`closures.ts`) and the
+ * generated ones (`codegen.ts`): JSON value equality, `uniqueItems`,
+ * `multipleOf`, code-point string length, and the pattern cache.
+ */
+/** JSON equality: numbers by value, arrays by order, objects by key set regardless of order. */
+export declare function jsonEqual(a: unknown, b: unknown): boolean;
+/** True when `values` contains `value` under {@link jsonEqual}. */
+export declare function jsonIncludes(values: readonly unknown[], value: unknown): boolean;
+/** `uniqueItems`: no two elements are {@link jsonEqual}. */
+export declare function uniqueItems(items: readonly unknown[]): boolean;
+/**
+ * `multipleOf` with float tolerance: `0.0075` is a multiple of `0.0001` even
+ * though the IEEE quotient is `74.99999999999999`. An overflowing quotient is
+ * a multiple only when `divisor` divides 1 (every integer is a multiple of 0.5).
+ */
+export declare function isMultipleOf(value: number, divisor: number): boolean;
+/** String length in Unicode code points, as `minLength`/`maxLength` count it. */
+export declare function codePointLength(value: string): number;
+/**
+ * Compile a JSON Schema `pattern` as an ECMAScript regex with the `u` flag,
+ * falling back to legacy syntax for patterns that only parse without it.
+ * Regexes are stateless (no `g`/`y`), so equal sources share one instance.
+ *
+ * # Errors
+ * Throws `SyntaxError` when the source is not a regular expression at all.
+ */
+export declare function compilePattern(source: string): RegExp;
+/** Property names inherited by plain objects; reading them needs an own-property check. */
+export declare function isInheritedName(key: string): boolean;

package/dist/types/jsonschema/validator.d.ts

@@ -0,0 +1,33 @@
+import { type Issue } from "./interpret.js";
+import { type FormatCheck } from "./plan.js";
+/** Options shared by the validator engine and `fromJsonSchema`. */
+export interface ValidatorOptions {
+    /** Semantics for resources that declare no `$schema`: `"2020-12"` (default) or `"7"`. */
+    readonly draft?: "2020-12" | "7";
+    /** Documents by URI that `$ref`s may name: remote schemas, meta-schemas. */
+    readonly schemas?: Readonly<Record<string, unknown>>;
+    /** Assertions by `format` name. Without one, `format` is an annotation, as draft 2020-12 specifies. */
+    readonly formats?: Readonly<Record<string, FormatCheck>>;
+}
+/** A compiled JSON Schema. */
+export declare class Validator {
+    #private;
+    /** Allocation-free validity test; safe to detach (`const check = validator.check`). */
+    readonly check: (value: unknown) => boolean;
+    /** Whether some `properties` subschema declares a `default` for {@link fillDefaults} to apply. */
+    readonly hasDefaults: boolean;
+    /**
+     * `onCompile` receives the steady-state check once the schema turns hot
+     * (generated code, or the interpreter where code generation is forbidden), so
+     * callers holding their own reference can drop the dispatch through `check`.
+     *
+     * # Errors
+     * Throws `OmpTypeError` for unresolvable or malformed `$ref`s, invalid
+     * patterns, and schema nodes that are neither booleans nor objects.
+     */
+    constructor(schema: unknown, options?: ValidatorOptions, onCompile?: (check: (value: unknown) => value is unknown) => void);
+    /** Every issue that makes `value` invalid (empty when it is valid). */
+    explain(value: unknown): Issue[];
+    /** `value` with absent declared properties set to their `default`, copied on write. */
+    fillDefaults(value: unknown): unknown;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/omptype",
-	"version": "18.16.0",
+	"version": "18.18.0",
 	"description": "ArkType-compatible runtime schema validation with lazy JIT compilation",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -27,7 +27,7 @@
 	"types": "./dist/types/index.d.ts",
 	"scripts": {
 		"check": "oxlint . && oxfmt --check --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts' && bun run check:types",
-		"check:types": "tsgo -p tsconfig.json --noEmit",
+		"check:types": "bun check --no-script -p tsconfig.json",
 		"lint": "oxlint .",
 		"fix": "oxlint --fix --fix-suggestions . && bun run fmt",
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'",
@@ -35,9 +35,6 @@
 		"bench": "bun bench/bench.ts"
 	},
 	"devDependencies": {
-		"@ark/attest": "0.56.3",
-		"@ark/schema": "0.56.2",
-		"@ark/util": "0.56.2",
 		"@sinclair/typebox": "^0.34.0",
 		"@types/bun": "^1.3.14",
 		"arkregex": "0.0.8",

package/src/compile.ts

@@ -263,6 +263,9 @@ class Builder {
 			}
 			case "sub":
 				return `!(${this.ref(node.schema.run)}(${v}) instanceof AE)`;
+			case "refine":
+				if (node.check !== undefined) return `(${this.predicate(node.base, v)})&&${this.ref(node.check)}(${v})`;
+				return `!(${this.ref(boundWalk(node))}(${v}) instanceof AE)`;
 			default:
 				return `!(${this.ref(boundWalk(node))}(${v}) instanceof AE)`;
 		}
@@ -1095,6 +1098,21 @@ function resolvedRoot(ir: IR): IR {
 	return ir.k === "alias" ? ir.resolve() : ir;
 }
 
+/** Set once the runtime refuses code generation from strings (strict CSP); the interpreter serves from then on. */
+let jitBlocked = false;
+
+/** Build with `build`, or `undefined` when code generation from strings is forbidden. */
+function tryBuild<T>(build: () => T): T | undefined {
+	if (jitBlocked) return undefined;
+	try {
+		return build();
+	} catch (error) {
+		if (!(error instanceof EvalError)) throw error;
+		jitBlocked = true;
+		return undefined;
+	}
+}
+
 const compiledCache = new WeakMap<IR, (value: unknown) => unknown>();
 const allowsCache = new WeakMap<IR, (value: unknown) => value is unknown>();
 
@@ -1109,8 +1127,9 @@ export function compile(ir: IR): (value: unknown) => unknown {
 		// fresh one forever. The wrapper resolves to the built validator by call
 		// time; the interpreter is a safety net that never triggers post-build.
 		const built: { value?: (value: unknown) => unknown } = {};
-		compiledCache.set(root, value => (built.value === undefined ? walk(root, value) : built.value(value)));
-		const compiled = new Builder().build(root);
+		const deferred = (value: unknown) => (built.value === undefined ? walk(root, value) : built.value(value));
+		compiledCache.set(root, deferred);
+		const compiled = tryBuild(() => new Builder().build(root)) ?? ((value: unknown) => walk(root, value));
 		built.value = compiled;
 		compiledCache.set(root, compiled);
 		return compiled;
@@ -1128,7 +1147,9 @@ export function compileAllows(ir: IR): (value: unknown) => value is unknown {
 			built.value === undefined ? !(walk(root, value) instanceof OmpErrors) : built.value(value)) as (
 			value: unknown,
 		) => value is unknown);
-		const compiled = new Builder().buildAllows(root);
+		const compiled =
+			tryBuild(() => new Builder().buildAllows(root)) ??
+			((value: unknown): value is unknown => !(walk(root, value) instanceof OmpErrors));
 		built.value = compiled;
 		allowsCache.set(root, compiled);
 		return compiled;

package/src/from-json-schema.ts

@@ -1,233 +1,84 @@
 /**
  * JSON Schema → omptype importer.
  *
- * Rebuilds a callable schema from JSON Schema documents — the inverse of
- * `Type.toJsonSchema()` for the dialect omptype (and its Zod/TypeBox
- * adapters) emits: draft-07 and draft-2020-12 structural keywords, string
- * formats, `$defs`/`definitions` references (including recursion), enums,
- * and composition via `anyOf`/`oneOf`/`allOf`.
+ * Validates exactly as JSON Schema drafts 2020-12 and 7 specify: every
+ * keyword including `$dynamicRef`, `unevaluatedProperties`/`unevaluatedItems`,
+ * `$id`/`$anchor` resolution, remote references, and vocabularies declared by
+ * meta-schemas. Validation runs on an eval-free closure engine and moves to
+ * generated code once a schema is hot (see `jsonschema/`).
  *
- * Unknown or non-structural keywords are ignored, matching lenient importer
- * behavior: the result validates every constraint the schema can express in
- * omptype IR and passes the rest through.
+ * The result is a regular omptype schema: callable, composable, emitting the
+ * source document from `toJsonSchema()`, and filling absent properties from
+ * their `default` when called (never in `allows`).
+ *
+ * # Example
+ * ```ts
+ * const read = fromJsonSchema({
+ * 	type: "object",
+ * 	properties: { path: { type: "string" }, offset: { type: "integer", minimum: 0 } },
+ * 	required: ["path"],
+ * });
+ * read.allows({ path: "a.ts" }); // true
+ * read({ offset: -1 }); // OmpErrors: path missing, offset below 0
+ * ```
  */
-import { OmpTypeError } from "./errors";
-import { parseLocalRefPointer } from "./local-ref";
-import { type EmbeddableSchema, type IR, IR_BRAND, type PropIR, type TupleItemIR } from "./ir";
-import { keywordIR, patternIR } from "./keywords";
+import { OmpErrors } from "./errors";
+import { type EmbeddableSchema, type IR, IR_BRAND } from "./ir";
+import type { Issue } from "./jsonschema/interpret";
+import { Validator, type ValidatorOptions } from "./jsonschema/validator";
 import { type BaseType, type } from "./type";
 
-type JsonSchema = Record<string, unknown>;
-
-/** `format` values lowered to built-in keyword validators. */
-const FORMAT_KEYWORDS: Record<string, string> = {
-	email: "string.email",
-	uuid: "string.uuid",
-	"date-time": "string.date.iso",
-	date: "string.date.iso",
-	ipv4: "string.ip.v4",
-	ipv6: "string.ip.v6",
-	regex: "string.regex",
-};
-
-class Importer {
-	readonly #root: JsonSchema;
-	readonly #aliases = new Map<string, IR>();
-
-	constructor(root: JsonSchema) {
-		this.#root = root;
-	}
-
-	resolveRef(ref: string): IR {
-		const cached = this.#aliases.get(ref);
-		if (cached !== undefined) return cached;
-
-		let target: unknown;
-		if (ref === "#") {
-			target = this.#root;
-		} else {
-			const pointer = parseLocalRefPointer(ref);
-			if (pointer === undefined || pointer.length !== 2 || (pointer[0] !== "$defs" && pointer[0] !== "definitions"))
-				throw new OmpTypeError(`unsupported $ref: ${ref}`);
-			const defs = this.#root[pointer[0]];
-			target = typeof defs === "object" && defs !== null ? (defs as JsonSchema)[pointer[1]!] : undefined;
-			if (target === undefined) throw new OmpTypeError(`unresolved $ref: ${ref}`);
-		}
-
-		// Register the alias before lowering so recursive references resolve
-		// to the same node instead of recursing forever.
-		let lowered: IR | undefined;
-		const alias: IR = {
-			k: "alias",
-			name: ref,
-			resolve: () => {
-				lowered ??= this.lower(target);
-				return lowered;
-			},
-		};
-		this.#aliases.set(ref, alias);
-		return alias;
-	}
-
-	lower(schema: unknown): IR {
-		if (schema === true) return { k: "unknown" };
-		if (schema === false) return { k: "never" };
-		if (typeof schema !== "object" || schema === null) {
-			throw new OmpTypeError("JSON Schema nodes must be booleans or objects");
-		}
-		const node = schema as JsonSchema;
-		const desc = typeof node.description === "string" ? node.description : undefined;
-		const ir = this.#lowerNode(node);
-		return desc === undefined ? ir : { ...ir, desc };
-	}
-
-	#lowerNode(node: JsonSchema): IR {
-		if (typeof node.$ref === "string") return this.resolveRef(node.$ref);
-
-		if (Array.isArray(node.enum)) {
-			const members = node.enum.map((v): IR => ({ k: "lit", v }));
-			return members.length === 1 ? members[0] : { k: "union", members };
-		}
-		if ("const" in node) return { k: "lit", v: node.const };
-
-		const branches = node.anyOf ?? node.oneOf;
-		if (Array.isArray(branches)) {
-			return { k: "union", members: branches.map(branch => this.lower(branch)) };
-		}
-		if (Array.isArray(node.allOf)) {
-			const members = node.allOf.map(branch => this.lower(branch));
-			return members.length === 1 ? members[0] : { k: "intersection", members };
-		}
-		if (typeof node.not === "object" && node.not !== null && Object.keys(node.not).length === 0) {
-			return { k: "never" };
-		}
-
-		if (Array.isArray(node.type)) {
-			const members = node.type.map(t => this.#lowerTyped(node, String(t)));
-			return members.length === 1 ? members[0] : { k: "union", members };
-		}
-		if (typeof node.type === "string") return this.#lowerTyped(node, node.type);
-
-		// No explicit type: infer from structural keywords, else accept anything.
-		if (node.properties !== undefined || node.required !== undefined) return this.#lowerObject(node);
-		if (node.items !== undefined || node.prefixItems !== undefined) return this.#lowerArray(node);
-		return { k: "unknown" };
-	}
-
-	#lowerTyped(node: JsonSchema, kind: string): IR {
-		switch (kind) {
-			case "null":
-				return { k: "null" };
-			case "boolean":
-				return { k: "boolean" };
-			case "string":
-				return this.#lowerString(node);
-			case "number":
-			case "integer": {
-				const ir: IR = { k: "number" };
-				if (kind === "integer") ir.int = true;
-				if (typeof node.minimum === "number") ir.min = node.minimum;
-				if (typeof node.maximum === "number") ir.max = node.maximum;
-				if (typeof node.exclusiveMinimum === "number") {
-					ir.min = node.exclusiveMinimum;
-					ir.xmin = true;
-				}
-				if (typeof node.exclusiveMaximum === "number") {
-					ir.max = node.exclusiveMaximum;
-					ir.xmax = true;
-				}
-				if (typeof node.multipleOf === "number") ir.divisor = node.multipleOf;
-				return ir;
-			}
-			case "object":
-				return this.#lowerObject(node);
-			case "array":
-				return this.#lowerArray(node);
-			default:
-				throw new OmpTypeError(`unsupported JSON Schema type: ${kind}`);
-		}
-	}
-
-	#lowerString(node: JsonSchema): IR {
-		const base: IR = { k: "string" };
-		if (typeof node.minLength === "number") base.min = node.minLength;
-		if (typeof node.maxLength === "number") base.max = node.maxLength;
-		if (node.format === "uri" || node.format === "url") base.url = true;
-
-		const members: IR[] = [];
-		if (typeof node.format === "string") {
-			const keyword = FORMAT_KEYWORDS[node.format];
-			if (keyword !== undefined) {
-				const formatIR = keywordIR(keyword);
-				if (formatIR !== undefined) members.push(formatIR);
-			}
-		}
-		if (typeof node.pattern === "string") members.push(patternIR(new RegExp(node.pattern)));
-
-		if (members.length === 0) return base;
-		if (base.min !== undefined || base.max !== undefined || base.url) members.unshift(base);
-		return members.length === 1 ? members[0] : { k: "intersection", members };
-	}
-
-	#lowerObject(node: JsonSchema): IR {
-		const required = new Set(Array.isArray(node.required) ? node.required.map(String) : []);
-		const props: PropIR[] = [];
-		if (typeof node.properties === "object" && node.properties !== null) {
-			for (const [key, value] of Object.entries(node.properties)) {
-				const prop: PropIR = { key, opt: !required.has(key), val: this.lower(value) };
-				if (typeof value === "object" && value !== null && "default" in value) {
-					prop.hasDefault = true;
-					prop.def = (value as JsonSchema).default;
-					prop.opt = true;
-				}
-				props.push(prop);
-			}
-		}
-		const extra = node.additionalProperties;
-		return {
-			k: "object",
-			props,
-			extras: extra === false ? "reject" : "keep",
-			...(typeof extra === "object" && extra !== null ? { index: this.lower(extra) } : {}),
-		};
-	}
-
-	#lowerArray(node: JsonSchema): IR {
-		if (Array.isArray(node.prefixItems)) {
-			const minItems = typeof node.minItems === "number" ? node.minItems : node.prefixItems.length;
-			const prefix: TupleItemIR[] = node.prefixItems.map((item, index) => ({
-				val: this.lower(item),
-				opt: index >= minItems,
-			}));
-			return {
-				k: "tuple",
-				prefix,
-				postfix: [],
-				...(node.items !== undefined && node.items !== false ? { variadic: this.lower(node.items) } : {}),
-			};
-		}
-		const ir: IR = { k: "array", el: node.items === undefined ? { k: "unknown" } : this.lower(node.items) };
-		if (typeof node.minItems === "number") ir.min = node.minItems;
-		if (typeof node.maxItems === "number") ir.max = node.maxItems;
-		return ir;
-	}
-}
+/** Options for {@link fromJsonSchema}. */
+export type FromJsonSchemaOptions = ValidatorOptions;
 
 /**
  * Build a callable omptype schema from a JSON Schema document.
  *
  * # Errors
- * Throws {@link OmpTypeError} on malformed nodes, unresolvable `$ref`s, or
- * types omptype cannot represent.
+ * Throws `OmpTypeError` when a `$ref` is malformed or names a document or
+ * location that neither `schema` nor `options.schemas` contains, when a
+ * `pattern` is not a regular expression, or when a schema node is neither a
+ * boolean nor an object.
  */
-export function fromJsonSchema(schema: unknown): BaseType {
-	const importer = new Importer(typeof schema === "object" && schema !== null ? (schema as JsonSchema) : {});
+export function fromJsonSchema(schema: unknown, options?: FromJsonSchemaOptions): BaseType {
+	// Runs after 64 checks, long after `imported` below exists.
+	const validator = new Validator(schema, options, compiled => {
+		imported.allows = compiled;
+	});
+	const check = validator.check;
+	const node = typeof schema === "object" && schema !== null ? (schema as Record<string, unknown>) : undefined;
+	const refine: IR = {
+		k: "refine",
+		base: { k: "unknown" },
+		check,
+		pred: value => check(value) || toErrors(validator.explain(value), value),
+		expected: "a value matching the JSON Schema",
+		json: node ?? (schema === false ? { not: {} } : {}),
+	};
+	if (typeof node?.description === "string") refine.desc = node.description;
+	const ir: IR = validator.hasDefaults
+		? { k: "morph", input: refine, fn: value => validator.fillDefaults(value) }
+		: refine;
 	const embedded: EmbeddableSchema = {
 		[IR_BRAND]: true,
-		ir: importer.lower(schema),
+		ir,
 		hasSteps: false,
 		hasDefault: false,
 		run: value => value,
 	};
-	return type.raw(embedded);
+	const imported = type.raw(embedded);
+	// The engine's check is the whole boolean path; skip the generic dispatcher.
+	// Once generated code exists, `onCompile` above rebinds `allows` to it.
+	Object.defineProperty(imported, "allows", { value: check, writable: true, configurable: true });
+	return imported;
+}
+
+function toErrors(issues: readonly Issue[], value: unknown): OmpErrors {
+	if (issues.length === 0) return new OmpErrors([], "a value matching the JSON Schema", value);
+	const errors = new OmpErrors(issues[0].path, issues[0].expected, issues[0].data);
+	for (let index = 1; index < issues.length; index++) {
+		const issue = issues[index];
+		errors.append(new OmpErrors(issue.path, issue.expected, issue.data));
+	}
+	return errors;
 }

package/src/interp.ts

@@ -182,6 +182,7 @@ function checkNode(ir: IR, v: unknown): boolean {
 			return v instanceof ir.ctor;
 		case "refine":
 			if (!checks(ir.base, v)) return false;
+			if (ir.check !== undefined) return ir.check(v);
 			try {
 				return ir.pred(v) === true;
 			} catch {

package/src/ir.ts

@@ -136,6 +136,8 @@ export type IR = IRAnalysis &
 				k: "refine";
 				base: IR;
 				pred: (value: unknown) => boolean | OmpErrors;
+				/** Allocation-free equivalent of `pred(value) === true` for boolean-only paths (`allows`, unions). */
+				check?: (value: unknown) => boolean;
 				expected: string;
 				json?: Record<string, unknown>;
 				desc?: string;