toolcraft-schema 0.0.115 → 0.0.117

package/dist/index.d.ts

@@ -178,5 +178,7 @@ export declare const S: {
 export declare function toJsonSchema(schema: AnySchema): JsonSchema;
 export declare function toJsonSchemaDocument(schema: AnySchema, options?: JsonSchemaDocumentOptions): JsonSchemaDocument;
 export { Json, OneOf, RecordBuilder as Record, Union, validate };
+export { compileJsonSchema, formatIssues } from "./json-schema/index.js";
+export type { CompileJsonSchemaOptions, CompiledJsonSchema } from "./json-schema/index.js";
 export type { JsonSchemaDocument, JsonSchemaDocumentOptions } from "./json-schema-document.js";
 export type { JsonValue, JsonValueSchema, OneOfSchema, RecordSchema, UnionSchema, ValidationIssue, ValidationResult };

package/dist/index.js

@@ -292,3 +292,4 @@ export function toJsonSchemaDocument(schema, options = {}) {
     return createJsonSchemaDocument(toJsonSchema(schema), options);
 }
 export { Json, OneOf, RecordBuilder as Record, Union, validate };
+export { compileJsonSchema, formatIssues } from "./json-schema/index.js";

package/dist/json-schema/compiler.d.ts

@@ -0,0 +1,11 @@
+import type { CompileJsonSchemaOptions, SchemaNode } from "./types.js";
+export interface CompiledGraph {
+    root: SchemaNode;
+    locations: Map<string, SchemaNode>;
+    resources: Map<string, SchemaNode>;
+    anchors: Map<string, SchemaNode>;
+    dynamicAnchors: Map<string, SchemaNode>;
+    resolve(node: SchemaNode, reference: string): SchemaNode;
+    dynamicAnchor(scope: SchemaNode, name: string): SchemaNode | undefined;
+}
+export declare function compileGraph(schema: unknown, options?: CompileJsonSchemaOptions): CompiledGraph;

package/dist/json-schema/compiler.js

@@ -0,0 +1,390 @@
+import { dialectFor, escapePointer, fragmentOf, isObject, isSchema, resolveUri, withoutFragment } from "./utils.js";
+const schemaMapKeywords = new Set([
+    "$defs",
+    "definitions",
+    "properties",
+    "patternProperties",
+    "dependentSchemas",
+    "dependencies"
+]);
+const schemaArrayKeywords = new Set(["allOf", "anyOf", "oneOf", "prefixItems"]);
+const schemaKeywords = new Set([
+    "additionalItems",
+    "additionalProperties",
+    "contains",
+    "else",
+    "if",
+    "items",
+    "not",
+    "propertyNames",
+    "then",
+    "unevaluatedItems",
+    "unevaluatedProperties"
+]);
+const draftTypes = ["null", "boolean", "object", "array", "number", "integer", "string"];
+const draftTypeSet = new Set(draftTypes);
+const metaSchemaKeywordProperties = {
+    type: {
+        anyOf: [
+            { enum: draftTypes },
+            { type: "array", items: { enum: draftTypes }, minItems: 1, uniqueItems: true }
+        ]
+    },
+    minLength: { type: "integer", minimum: 0 },
+    maxLength: { type: "integer", minimum: 0 },
+    minItems: { type: "integer", minimum: 0 },
+    maxItems: { type: "integer", minimum: 0 },
+    minProperties: { type: "integer", minimum: 0 },
+    maxProperties: { type: "integer", minimum: 0 }
+};
+const builtInRegistry = {
+    "https://json-schema.org/draft/2020-12/schema": {
+        $id: "https://json-schema.org/draft/2020-12/schema",
+        type: ["object", "boolean"],
+        properties: {
+            ...metaSchemaKeywordProperties,
+            $defs: { type: "object", additionalProperties: { $ref: "#" } }
+        }
+    },
+    "http://json-schema.org/draft-07/schema": {
+        $id: "http://json-schema.org/draft-07/schema#",
+        type: ["object", "boolean"],
+        properties: {
+            ...metaSchemaKeywordProperties,
+            definitions: { type: "object", additionalProperties: { $ref: "#" } }
+        }
+    }
+};
+function mapKey(dialect, uri) {
+    return `${dialect}\0${uri}`;
+}
+function assertSchemaArray(value, keyword) {
+    if (!Array.isArray(value) || value.length === 0 || !value.every(isSchema)) {
+        throw new Error(`${keyword} must be a non-empty array of schemas.`);
+    }
+}
+function assertStringArray(value, keyword) {
+    if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+        throw new Error(`${keyword} must be an array of strings.`);
+    }
+    if (new Set(value).size !== value.length) {
+        throw new Error(`${keyword} must contain unique strings.`);
+    }
+}
+function assertSchemaMap(value, keyword) {
+    if (!isObject(value) || !Object.values(value).every(isSchema)) {
+        throw new Error(`${keyword} must be an object containing schemas.`);
+    }
+}
+function assertNonNegativeInteger(value, keyword) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${keyword} must be a non-negative integer.`);
+    }
+}
+function validateSchemaObject(schema, dialect) {
+    if (schema.type !== undefined) {
+        const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+        if (types.length === 0 ||
+            !types.every((type) => typeof type === "string" && draftTypeSet.has(type)) ||
+            new Set(types).size !== types.length) {
+            throw new Error("type must be a JSON Schema type or a unique array of JSON Schema types.");
+        }
+    }
+    for (const keyword of ["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum"]) {
+        if (schema[keyword] !== undefined && typeof schema[keyword] !== "number") {
+            throw new Error(`${keyword} must be a number.`);
+        }
+    }
+    if (schema.multipleOf !== undefined &&
+        (typeof schema.multipleOf !== "number" || schema.multipleOf <= 0)) {
+        throw new Error("multipleOf must be a number greater than zero.");
+    }
+    for (const keyword of [
+        "minLength",
+        "maxLength",
+        "minItems",
+        "maxItems",
+        "minContains",
+        "maxContains",
+        "minProperties",
+        "maxProperties"
+    ]) {
+        if (schema[keyword] !== undefined) {
+            assertNonNegativeInteger(schema[keyword], keyword);
+        }
+    }
+    if (schema.pattern !== undefined && typeof schema.pattern !== "string") {
+        throw new Error("pattern must be a string.");
+    }
+    for (const keyword of ["uniqueItems", "$recursiveAnchor"]) {
+        if (schema[keyword] !== undefined && typeof schema[keyword] !== "boolean") {
+            throw new Error(`${keyword} must be a boolean.`);
+        }
+    }
+    if (schema.required !== undefined) {
+        assertStringArray(schema.required, "required");
+    }
+    if (schema.dependentRequired !== undefined) {
+        if (!isObject(schema.dependentRequired)) {
+            throw new Error("dependentRequired must be an object containing string arrays.");
+        }
+        for (const dependencies of Object.values(schema.dependentRequired)) {
+            assertStringArray(dependencies, "dependentRequired");
+        }
+    }
+    for (const keyword of schemaMapKeywords) {
+        const value = schema[keyword];
+        if (value === undefined || keyword === "dependencies")
+            continue;
+        assertSchemaMap(value, keyword);
+    }
+    if (schema.dependencies !== undefined) {
+        if (!isObject(schema.dependencies)) {
+            throw new Error("dependencies must be an object containing schemas or string arrays.");
+        }
+        for (const dependency of Object.values(schema.dependencies)) {
+            if (!isSchema(dependency))
+                assertStringArray(dependency, "dependencies");
+        }
+    }
+    for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+        if (schema[keyword] !== undefined)
+            assertSchemaArray(schema[keyword], keyword);
+    }
+    if (schema.prefixItems !== undefined) {
+        if (!Array.isArray(schema.prefixItems) || !schema.prefixItems.every(isSchema)) {
+            throw new Error("prefixItems must be an array of schemas.");
+        }
+    }
+    for (const keyword of schemaKeywords) {
+        const value = schema[keyword];
+        if (value === undefined)
+            continue;
+        if (keyword === "items" && dialect === "draft7" && Array.isArray(value)) {
+            if (!value.every(isSchema))
+                throw new Error("items must contain only schemas.");
+        }
+        else if (!isSchema(value)) {
+            throw new Error(`${keyword} must be a schema.`);
+        }
+    }
+    if (schema.enum !== undefined && !Array.isArray(schema.enum)) {
+        throw new Error("enum must be an array.");
+    }
+}
+export function compileGraph(schema, options = {}) {
+    if (!isSchema(schema)) {
+        throw new Error("JSON Schema must be a boolean or object.");
+    }
+    const locations = new Map();
+    const resources = new Map();
+    const anchors = new Map();
+    const dynamicAnchors = new Map();
+    const nodesBySchema = new WeakMap();
+    const pendingReferences = [];
+    const registry = { ...builtInRegistry, ...options.registry };
+    const rootBase = "https://toolcraft.invalid/root";
+    function validationVocabularyFor(schemaObject) {
+        const metaSchema = schemaObject.$schema;
+        if (typeof metaSchema !== "string") {
+            return true;
+        }
+        const registered = registry[metaSchema];
+        if (!isObject(registered) || !isObject(registered.$vocabulary)) {
+            return true;
+        }
+        return Object.prototype.hasOwnProperty.call(registered.$vocabulary, "https://json-schema.org/draft/2020-12/vocab/validation");
+    }
+    function recordNode(schemaObject, node) {
+        if (schemaObject === undefined) {
+            return;
+        }
+        const nodes = nodesBySchema.get(schemaObject) ?? [];
+        nodes.push(node);
+        nodesBySchema.set(schemaObject, nodes);
+    }
+    function setLocation(dialect, uri, node) {
+        locations.set(mapKey(dialect, uri), node);
+    }
+    function scan(currentSchema, inheritedDialect, inheritedBase, resourceRoot, pointer, validationVocabulary, documentId) {
+        const schemaObject = isObject(currentSchema) ? currentSchema : undefined;
+        const dialect = schemaObject === undefined ? inheritedDialect : dialectFor(schemaObject, inheritedDialect);
+        if (schemaObject !== undefined) {
+            validateSchemaObject(schemaObject, dialect);
+        }
+        const declaredId = dialect === "draft7" ? (schemaObject?.$id ?? schemaObject?.id) : schemaObject?.$id;
+        const effectiveId = dialect === "draft7" && typeof schemaObject?.$ref === "string" ? undefined : declaredId;
+        const baseUri = typeof effectiveId === "string" ? resolveUri(effectiveId, inheritedBase) : inheritedBase;
+        const node = {
+            schema: currentSchema,
+            documentId,
+            dialect,
+            baseUri,
+            resourceUri: resourceRoot?.resourceUri ?? withoutFragment(baseUri),
+            resourceRoot: undefined,
+            pointer,
+            validationVocabulary,
+            children: new Map()
+        };
+        recordNode(schemaObject, node);
+        if (resourceRoot !== undefined) {
+            setLocation(resourceRoot.dialect, resolveUri(`#${encodeURI(pointer)}`, resourceRoot.resourceUri), node);
+        }
+        const startsResource = resourceRoot === undefined || withoutFragment(baseUri) !== resourceRoot.resourceUri;
+        node.resourceRoot = startsResource ? node : resourceRoot;
+        node.resourceUri = startsResource ? withoutFragment(baseUri) : resourceRoot.resourceUri;
+        const resourcePointer = startsResource ? "" : pointer;
+        node.pointer = resourcePointer;
+        if (startsResource) {
+            resources.set(mapKey(node.dialect, node.resourceUri), node);
+            setLocation(node.dialect, node.resourceUri, node);
+        }
+        setLocation(node.dialect, resolveUri(`#${encodeURI(resourcePointer)}`, node.resourceUri), node);
+        if (schemaObject === undefined) {
+            return node;
+        }
+        if (typeof schemaObject.$anchor === "string") {
+            anchors.set(mapKey(node.dialect, `${node.resourceUri}#${schemaObject.$anchor}`), node);
+        }
+        if (typeof schemaObject.$dynamicAnchor === "string") {
+            const anchorUri = `${node.resourceUri}#${schemaObject.$dynamicAnchor}`;
+            anchors.set(mapKey(node.dialect, anchorUri), node);
+            dynamicAnchors.set(mapKey(node.dialect, anchorUri), node);
+        }
+        if (dialect === "draft7" && typeof effectiveId === "string" && fragmentOf(baseUri) !== "") {
+            anchors.set(mapKey(dialect, baseUri), node);
+        }
+        for (const keyword of ["$ref", "$dynamicRef", "$recursiveRef"]) {
+            const reference = schemaObject[keyword];
+            if (reference !== undefined) {
+                if (typeof reference !== "string") {
+                    throw new Error(`${keyword} must be a string.`);
+                }
+                pendingReferences.push({ node, reference });
+            }
+        }
+        if (typeof schemaObject.pattern === "string") {
+            new RegExp(schemaObject.pattern, "u");
+        }
+        if (isObject(schemaObject.patternProperties)) {
+            for (const pattern of Object.keys(schemaObject.patternProperties)) {
+                new RegExp(pattern, "u");
+            }
+        }
+        const nextValidationVocabulary = resourceRoot === undefined ? validationVocabularyFor(schemaObject) : validationVocabulary;
+        for (const [keyword, value] of Object.entries(schemaObject)) {
+            if (schemaMapKeywords.has(keyword) && isObject(value)) {
+                for (const [key, childSchema] of Object.entries(value)) {
+                    if (isSchema(childSchema)) {
+                        node.children.set(`${keyword}/${key}`, scan(childSchema, dialect, baseUri, node.resourceRoot, `${resourcePointer}/${escapePointer(keyword)}/${escapePointer(key)}`, nextValidationVocabulary, documentId));
+                    }
+                }
+            }
+            else if (schemaArrayKeywords.has(keyword) && Array.isArray(value)) {
+                value.forEach((childSchema, index) => {
+                    if (isSchema(childSchema)) {
+                        node.children.set(`${keyword}/${index}`, scan(childSchema, dialect, baseUri, node.resourceRoot, `${resourcePointer}/${escapePointer(keyword)}/${index}`, nextValidationVocabulary, documentId));
+                    }
+                });
+            }
+            else if (schemaKeywords.has(keyword)) {
+                if (keyword === "items" && Array.isArray(value)) {
+                    value.forEach((childSchema, index) => {
+                        if (isSchema(childSchema)) {
+                            node.children.set(`items/${index}`, scan(childSchema, dialect, baseUri, node.resourceRoot, `${resourcePointer}/items/${index}`, nextValidationVocabulary, documentId));
+                        }
+                    });
+                }
+                else if (isSchema(value)) {
+                    node.children.set(keyword, scan(value, dialect, baseUri, node.resourceRoot, `${resourcePointer}/${escapePointer(keyword)}`, nextValidationVocabulary, documentId));
+                }
+            }
+        }
+        return node;
+    }
+    const root = scan(schema, "draft2020-12", rootBase, undefined, "", true, "root");
+    resources.set(mapKey(root.dialect, rootBase), root);
+    setLocation(root.dialect, rootBase, root);
+    setLocation(root.dialect, `${rootBase}#`, root);
+    for (const [uri, registeredSchema] of Object.entries(registry)) {
+        if (!isSchema(registeredSchema)) {
+            throw new Error(`Registered JSON Schema ${uri} must be a boolean or object.`);
+        }
+        for (const inheritedDialect of ["draft2020-12", "draft7"]) {
+            const remote = scan(registeredSchema, inheritedDialect, uri, undefined, "", true, `${inheritedDialect}:${uri}`);
+            resources.set(mapKey(remote.dialect, withoutFragment(uri)), remote);
+            setLocation(remote.dialect, withoutFragment(uri), remote);
+            setLocation(remote.dialect, `${withoutFragment(uri)}#`, remote);
+        }
+    }
+    function findByDialect(map, dialect, uri) {
+        const alternate = dialect === "draft7" ? "draft2020-12" : "draft7";
+        return map.get(mapKey(dialect, uri)) ?? map.get(mapKey(alternate, uri));
+    }
+    function resolve(node, reference) {
+        const absolute = resolveUri(reference, node.baseUri);
+        const direct = findByDialect(locations, node.dialect, absolute) ??
+            findByDialect(resources, node.dialect, absolute) ??
+            findByDialect(anchors, node.dialect, absolute);
+        if (direct !== undefined) {
+            return direct;
+        }
+        const resource = findByDialect(resources, node.dialect, withoutFragment(absolute));
+        const fragment = fragmentOf(absolute);
+        if (resource !== undefined && fragment === "") {
+            return resource;
+        }
+        if (fragment.startsWith("/")) {
+            const pointerTarget = findByDialect(locations, node.dialect, `${withoutFragment(absolute)}#${fragment}`);
+            if (pointerTarget !== undefined) {
+                return pointerTarget;
+            }
+            if (resource !== undefined && isObject(resource.schema)) {
+                let target = resource.schema;
+                for (const segment of fragment.slice(1).split("/")) {
+                    if (!isObject(target) && !Array.isArray(target)) {
+                        target = undefined;
+                        break;
+                    }
+                    const key = decodeURIComponent(segment).replaceAll("~1", "/").replaceAll("~0", "~");
+                    target = Array.isArray(target) ? target[Number(key)] : target[key];
+                }
+                if (isObject(target)) {
+                    const targetNode = nodesBySchema
+                        .get(target)
+                        ?.find((candidate) => candidate.dialect === node.dialect);
+                    if (targetNode !== undefined) {
+                        return targetNode;
+                    }
+                }
+            }
+        }
+        throw new Error(`Unresolvable $ref: ${reference}`);
+    }
+    const reachableDocuments = new Set([root.documentId]);
+    let discoveredDocument = true;
+    while (discoveredDocument) {
+        discoveredDocument = false;
+        for (const pending of pendingReferences) {
+            if (!reachableDocuments.has(pending.node.documentId)) {
+                continue;
+            }
+            const target = resolve(pending.node, pending.reference);
+            if (!reachableDocuments.has(target.documentId)) {
+                reachableDocuments.add(target.documentId);
+                discoveredDocument = true;
+            }
+        }
+    }
+    return {
+        root,
+        locations,
+        resources,
+        anchors,
+        dynamicAnchors,
+        resolve,
+        dynamicAnchor(scope, name) {
+            return dynamicAnchors.get(mapKey(scope.dialect, `${scope.resourceUri}#${name}`));
+        }
+    };
+}

package/dist/json-schema/evaluate.d.ts

@@ -0,0 +1,3 @@
+import type { CompiledGraph } from "./compiler.js";
+import type { EvaluationResult } from "./types.js";
+export declare function evaluateSchema(graph: CompiledGraph, value: unknown): EvaluationResult;

package/dist/json-schema/evaluate.js

@@ -0,0 +1,442 @@
+import { deepEqual, invalidResult, isMultipleOf, isObject, issue, mergeResults, typeMatches, unicodeLength, validResult } from "./utils.js";
+export function evaluateSchema(graph, value) {
+    return evaluateNode(graph, graph.root, value, {
+        instancePath: [],
+        dynamicScope: [],
+        activePairs: new Map()
+    });
+}
+function evaluateNode(graph, node, value, context) {
+    if (node.schema === true) {
+        return validResult();
+    }
+    if (node.schema === false) {
+        return invalidResult(issue(context.instancePath, "valid schema", value, "must NOT be valid"));
+    }
+    const activeValues = context.activePairs.get(node);
+    if (activeValues?.has(value) === true) {
+        return validResult();
+    }
+    const nextActivePairs = new Map(context.activePairs);
+    const nextActiveValues = new Set(activeValues ?? []);
+    nextActiveValues.add(value);
+    nextActivePairs.set(node, nextActiveValues);
+    const lastScope = context.dynamicScope.at(-1);
+    const dynamicScope = lastScope?.resourceUri === node.resourceRoot.resourceUri
+        ? context.dynamicScope
+        : [...context.dynamicScope, node.resourceRoot];
+    const nextContext = { ...context, dynamicScope, activePairs: nextActivePairs };
+    const schema = node.schema;
+    const referenceResult = evaluateReferences(graph, node, schema, value, nextContext);
+    if (node.dialect === "draft7" && typeof schema.$ref === "string") {
+        return referenceResult ?? validResult();
+    }
+    const results = [];
+    if (referenceResult !== undefined) {
+        results.push(referenceResult);
+    }
+    results.push(...evaluateApplicators(graph, node, schema, value, nextContext));
+    if (node.validationVocabulary) {
+        results.push(...evaluateValidationKeywords(node, schema, value, nextContext.instancePath));
+    }
+    const merged = mergeResults(results);
+    if (isObject(value)) {
+        evaluateUnevaluatedProperties(graph, node, schema, value, nextContext, merged);
+    }
+    if (Array.isArray(value)) {
+        evaluateUnevaluatedItems(graph, node, schema, value, nextContext, merged);
+    }
+    return merged;
+}
+function evaluateReferences(graph, node, schema, value, context) {
+    const results = [];
+    if (typeof schema.$ref === "string") {
+        results.push(evaluateNode(graph, graph.resolve(node, schema.$ref), value, context));
+    }
+    if (typeof schema.$dynamicRef === "string") {
+        const staticTarget = graph.resolve(node, schema.$dynamicRef);
+        const fragment = new URL(schema.$dynamicRef, node.baseUri).hash.slice(1);
+        let target = staticTarget;
+        if (fragment !== "" &&
+            !fragment.startsWith("/") &&
+            isObject(staticTarget.schema) &&
+            staticTarget.schema.$dynamicAnchor === fragment) {
+            for (const scope of context.dynamicScope) {
+                const candidate = graph.dynamicAnchor(scope, fragment);
+                if (candidate !== undefined) {
+                    target = candidate;
+                    break;
+                }
+            }
+        }
+        results.push(evaluateNode(graph, target, value, context));
+    }
+    if (typeof schema.$recursiveRef === "string") {
+        let target = graph.resolve(node, schema.$recursiveRef);
+        if (schema.$recursiveRef === "#") {
+            for (const scope of context.dynamicScope) {
+                if (isObject(scope.schema) && scope.schema.$recursiveAnchor === true) {
+                    target = scope;
+                    break;
+                }
+            }
+        }
+        results.push(evaluateNode(graph, target, value, context));
+    }
+    return results.length === 0 ? undefined : mergeResults(results);
+}
+function evaluateApplicators(graph, node, schema, value, context) {
+    const results = [];
+    for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+        const schemas = schema[keyword];
+        if (!Array.isArray(schemas)) {
+            continue;
+        }
+        const branchResults = schemas.map((_, index) => evaluateChild(graph, node, `${keyword}/${index}`, value, context));
+        if (keyword === "allOf") {
+            results.push(mergeResults(branchResults));
+        }
+        else {
+            const successful = branchResults.filter((result) => result.valid);
+            const valid = keyword === "anyOf" ? successful.length > 0 : successful.length === 1;
+            if (valid) {
+                results.push(mergeResults(successful));
+            }
+            else {
+                results.push(invalidResult(issue(context.instancePath, keyword, value, keyword === "anyOf"
+                    ? "must match a schema in anyOf"
+                    : "must match exactly one schema in oneOf")));
+            }
+        }
+    }
+    if (schema.not !== undefined) {
+        const result = evaluateChild(graph, node, "not", value, context);
+        if (result.valid) {
+            results.push(invalidResult(issue(context.instancePath, "not", value, "must NOT be valid")));
+        }
+    }
+    if (schema.if !== undefined) {
+        const condition = evaluateChild(graph, node, "if", value, context);
+        const selected = condition.valid ? "then" : "else";
+        if (condition.valid) {
+            results.push(condition);
+        }
+        if (schema[selected] !== undefined) {
+            results.push(evaluateChild(graph, node, selected, value, context));
+        }
+    }
+    if (isObject(value)) {
+        results.push(...evaluateObjectApplicators(graph, node, schema, value, context));
+    }
+    if (Array.isArray(value)) {
+        results.push(...evaluateArrayApplicators(graph, node, schema, value, context));
+    }
+    return results;
+}
+function evaluateObjectApplicators(graph, node, schema, value, context) {
+    const results = [];
+    const evaluated = new Set();
+    const properties = isObject(schema.properties) ? schema.properties : {};
+    for (const key of Object.keys(properties)) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+            const result = evaluateChild(graph, node, `properties/${key}`, value[key], childContext(context, key));
+            evaluated.add(key);
+            results.push(markProperty(atChildLocation(result), key));
+        }
+    }
+    const patternProperties = isObject(schema.patternProperties) ? schema.patternProperties : {};
+    for (const [pattern] of Object.entries(patternProperties)) {
+        const expression = new RegExp(pattern, "u");
+        for (const [key, propertyValue] of Object.entries(value)) {
+            if (expression.test(key)) {
+                const result = evaluateChild(graph, node, `patternProperties/${pattern}`, propertyValue, childContext(context, key));
+                evaluated.add(key);
+                results.push(markProperty(atChildLocation(result), key));
+            }
+        }
+    }
+    if (schema.additionalProperties !== undefined) {
+        for (const [key, propertyValue] of Object.entries(value)) {
+            if (!evaluated.has(key)) {
+                const result = evaluateChild(graph, node, "additionalProperties", propertyValue, childContext(context, key));
+                results.push(markProperty(atChildLocation(result), key));
+            }
+        }
+    }
+    if (schema.propertyNames !== undefined) {
+        for (const key of Object.keys(value)) {
+            results.push(atChildLocation(evaluateChild(graph, node, "propertyNames", key, childContext(context, key))));
+        }
+    }
+    const dependentSchemas = isObject(schema.dependentSchemas) ? schema.dependentSchemas : {};
+    for (const key of Object.keys(dependentSchemas)) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+            results.push(evaluateChild(graph, node, `dependentSchemas/${key}`, value, context));
+        }
+    }
+    if (node.dialect === "draft7" && isObject(schema.dependencies)) {
+        for (const [key, dependency] of Object.entries(schema.dependencies)) {
+            if (Object.prototype.hasOwnProperty.call(value, key) && !Array.isArray(dependency)) {
+                results.push(evaluateInline(graph, node, dependency, value, context, `dependencies/${key}`));
+            }
+        }
+    }
+    return results;
+}
+function evaluateArrayApplicators(graph, node, schema, value, context) {
+    const results = [];
+    if (node.dialect === "draft2020-12") {
+        const prefixItems = Array.isArray(schema.prefixItems) ? schema.prefixItems : [];
+        prefixItems.forEach((_, index) => {
+            if (index < value.length) {
+                const result = evaluateChild(graph, node, `prefixItems/${index}`, value[index], childContext(context, String(index)));
+                results.push(markItem(atChildLocation(result), index));
+            }
+        });
+        if (schema.items !== undefined && !Array.isArray(schema.items)) {
+            for (let index = prefixItems.length; index < value.length; index += 1) {
+                const result = evaluateChild(graph, node, "items", value[index], childContext(context, String(index)));
+                results.push(markItem(atChildLocation(result), index));
+            }
+        }
+    }
+    else if (Array.isArray(schema.items)) {
+        schema.items.forEach((_, index) => {
+            if (index < value.length) {
+                const result = evaluateChild(graph, node, `items/${index}`, value[index], childContext(context, String(index)));
+                results.push(markItem(atChildLocation(result), index));
+            }
+        });
+        if (schema.additionalItems !== undefined) {
+            for (let index = schema.items.length; index < value.length; index += 1) {
+                const result = evaluateChild(graph, node, "additionalItems", value[index], childContext(context, String(index)));
+                results.push(markItem(atChildLocation(result), index));
+            }
+        }
+    }
+    else if (schema.items !== undefined) {
+        for (let index = 0; index < value.length; index += 1) {
+            const result = evaluateChild(graph, node, "items", value[index], childContext(context, String(index)));
+            results.push(markItem(atChildLocation(result), index));
+        }
+    }
+    if (schema.contains !== undefined) {
+        const containsResults = value.map((item, index) => evaluateChild(graph, node, "contains", item, childContext(context, String(index))));
+        const matching = containsResults
+            .map((result, index) => ({ result, index }))
+            .filter(({ result }) => result.valid);
+        const minimum = node.dialect === "draft2020-12" && typeof schema.minContains === "number"
+            ? schema.minContains
+            : 1;
+        const maximum = node.dialect === "draft2020-12" && typeof schema.maxContains === "number"
+            ? schema.maxContains
+            : Number.POSITIVE_INFINITY;
+        if (matching.length < minimum || matching.length > maximum) {
+            results.push(invalidResult(issue(context.instancePath, "contains", value, "must contain required matching items")));
+        }
+        else if (node.dialect === "draft2020-12") {
+            const result = validResult();
+            for (const match of matching) {
+                result.evaluatedItems.add(match.index);
+            }
+            results.push(result);
+        }
+    }
+    return results;
+}
+function evaluateValidationKeywords(node, schema, value, path) {
+    const results = [];
+    if (schema.nullable === true && value === null) {
+        return results;
+    }
+    const types = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
+    if (types.length > 0 &&
+        !types.some((type) => typeof type === "string" && typeMatches(type, value))) {
+        results.push(invalidResult(issue(path, types.join(","), value, `must be ${types.join(",")}`)));
+        return results;
+    }
+    if (schema.const !== undefined && !deepEqual(schema.const, value)) {
+        results.push(invalidResult(issue(path, "const", value, "must be equal to constant")));
+    }
+    if (Array.isArray(schema.enum) && !schema.enum.some((entry) => deepEqual(entry, value))) {
+        results.push(invalidResult(issue(path, "enum", value, "must be equal to one of the allowed values")));
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        evaluateNumberKeywords(schema, value, path, results);
+    }
+    if (typeof value === "string") {
+        evaluateStringKeywords(schema, value, path, results);
+    }
+    if (Array.isArray(value)) {
+        evaluateArrayKeywords(schema, value, path, results);
+    }
+    if (isObject(value)) {
+        evaluateObjectKeywords(node, schema, value, path, results);
+    }
+    return results;
+}
+function evaluateNumberKeywords(schema, value, path, results) {
+    if (typeof schema.multipleOf === "number" && !isMultipleOf(value, schema.multipleOf)) {
+        results.push(invalidResult(issue(path, `multiple of ${schema.multipleOf}`, value, `must be multiple of ${schema.multipleOf}`)));
+    }
+    if (typeof schema.maximum === "number" && value > schema.maximum) {
+        results.push(invalidResult(issue(path, `<= ${schema.maximum}`, value, `must be <= ${schema.maximum}`)));
+    }
+    if (typeof schema.minimum === "number" && value < schema.minimum) {
+        results.push(invalidResult(issue(path, `>= ${schema.minimum}`, value, `must be >= ${schema.minimum}`)));
+    }
+    if (typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum) {
+        results.push(invalidResult(issue(path, `< ${schema.exclusiveMaximum}`, value, `must be < ${schema.exclusiveMaximum}`)));
+    }
+    if (typeof schema.exclusiveMinimum === "number" && value <= schema.exclusiveMinimum) {
+        results.push(invalidResult(issue(path, `> ${schema.exclusiveMinimum}`, value, `must be > ${schema.exclusiveMinimum}`)));
+    }
+}
+function evaluateStringKeywords(schema, value, path, results) {
+    const length = unicodeLength(value);
+    if (typeof schema.maxLength === "number" && length > schema.maxLength) {
+        results.push(invalidResult(issue(path, `length <= ${schema.maxLength}`, value, `must NOT have more than ${schema.maxLength} characters`)));
+    }
+    if (typeof schema.minLength === "number" && length < schema.minLength) {
+        results.push(invalidResult(issue(path, `length >= ${schema.minLength}`, value, `must NOT have fewer than ${schema.minLength} characters`)));
+    }
+    if (typeof schema.pattern === "string" && !new RegExp(schema.pattern, "u").test(value)) {
+        results.push(invalidResult(issue(path, `pattern ${schema.pattern}`, value, `must match pattern ${schema.pattern}`)));
+    }
+}
+function evaluateArrayKeywords(schema, value, path, results) {
+    if (typeof schema.maxItems === "number" && value.length > schema.maxItems) {
+        results.push(invalidResult(issue(path, `items <= ${schema.maxItems}`, value, `must NOT have more than ${schema.maxItems} items`)));
+    }
+    if (typeof schema.minItems === "number" && value.length < schema.minItems) {
+        results.push(invalidResult(issue(path, `items >= ${schema.minItems}`, value, `must NOT have fewer than ${schema.minItems} items`)));
+    }
+    if (schema.uniqueItems === true) {
+        for (let left = 0; left < value.length; left += 1) {
+            for (let right = left + 1; right < value.length; right += 1) {
+                if (deepEqual(value[left], value[right])) {
+                    results.push(invalidResult(issue(path, "unique items", value, "must NOT have duplicate items")));
+                    return;
+                }
+            }
+        }
+    }
+}
+function evaluateObjectKeywords(node, schema, value, path, results) {
+    const keys = Object.keys(value);
+    if (typeof schema.maxProperties === "number" && keys.length > schema.maxProperties) {
+        results.push(invalidResult(issue(path, `properties <= ${schema.maxProperties}`, value, `must NOT have more than ${schema.maxProperties} properties`)));
+    }
+    if (typeof schema.minProperties === "number" && keys.length < schema.minProperties) {
+        results.push(invalidResult(issue(path, `properties >= ${schema.minProperties}`, value, `must NOT have fewer than ${schema.minProperties} properties`)));
+    }
+    if (Array.isArray(schema.required)) {
+        for (const key of schema.required) {
+            if (typeof key === "string" && !Object.prototype.hasOwnProperty.call(value, key)) {
+                results.push(invalidResult(issue([...path, key], "required", undefined, `must have required property '${key}'`)));
+            }
+        }
+    }
+    const dependentRequired = isObject(schema.dependentRequired) ? schema.dependentRequired : {};
+    for (const [key, dependencies] of Object.entries(dependentRequired)) {
+        if (Object.prototype.hasOwnProperty.call(value, key) && Array.isArray(dependencies)) {
+            addMissingDependencies(value, dependencies, path, results);
+        }
+    }
+    if (node.dialect === "draft7" && isObject(schema.dependencies)) {
+        for (const [key, dependencies] of Object.entries(schema.dependencies)) {
+            if (Object.prototype.hasOwnProperty.call(value, key) && Array.isArray(dependencies)) {
+                addMissingDependencies(value, dependencies, path, results);
+            }
+        }
+    }
+}
+function addMissingDependencies(value, dependencies, path, results) {
+    for (const dependency of dependencies) {
+        if (typeof dependency === "string" &&
+            !Object.prototype.hasOwnProperty.call(value, dependency)) {
+            results.push(invalidResult(issue([...path, dependency], "dependency", undefined, `must have property '${dependency}'`)));
+        }
+    }
+}
+function evaluateUnevaluatedProperties(graph, node, schema, value, context, result) {
+    if (node.dialect !== "draft2020-12" || schema.unevaluatedProperties === undefined) {
+        return;
+    }
+    for (const [key, propertyValue] of Object.entries(value)) {
+        if (!result.evaluatedProperties.has(key)) {
+            const propertyResult = evaluateChild(graph, node, "unevaluatedProperties", propertyValue, childContext(context, key));
+            propertyResult.evaluatedProperties.add(key);
+            mergeInto(result, propertyResult);
+        }
+    }
+}
+function evaluateUnevaluatedItems(graph, node, schema, value, context, result) {
+    if (node.dialect !== "draft2020-12" || schema.unevaluatedItems === undefined) {
+        return;
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        if (!result.evaluatedItems.has(index)) {
+            const itemResult = evaluateChild(graph, node, "unevaluatedItems", value[index], childContext(context, String(index)));
+            itemResult.evaluatedItems.add(index);
+            mergeInto(result, itemResult);
+        }
+    }
+}
+function evaluateChild(graph, node, key, value, context) {
+    const child = node.children.get(key);
+    if (child === undefined) {
+        return validResult();
+    }
+    return evaluateNode(graph, child, value, context);
+}
+function evaluateInline(graph, node, schema, value, context, key) {
+    const child = node.children.get(key);
+    if (child !== undefined) {
+        return evaluateNode(graph, child, value, context);
+    }
+    if (typeof schema !== "boolean" && !isObject(schema)) {
+        return validResult();
+    }
+    const inlineNode = {
+        schema: schema,
+        documentId: node.documentId,
+        dialect: node.dialect,
+        baseUri: node.baseUri,
+        resourceUri: node.resourceUri,
+        resourceRoot: node.resourceRoot,
+        pointer: node.pointer,
+        validationVocabulary: node.validationVocabulary,
+        children: new Map()
+    };
+    return evaluateNode(graph, inlineNode, value, context);
+}
+function childContext(context, segment) {
+    return { ...context, instancePath: [...context.instancePath, segment] };
+}
+function mergeInto(target, source) {
+    target.valid &&= source.valid;
+    target.issues.push(...source.issues);
+    for (const key of source.evaluatedProperties) {
+        target.evaluatedProperties.add(key);
+    }
+    for (const index of source.evaluatedItems) {
+        target.evaluatedItems.add(index);
+    }
+}
+function atChildLocation(result) {
+    return {
+        valid: result.valid,
+        issues: result.issues,
+        evaluatedProperties: new Set(),
+        evaluatedItems: new Set()
+    };
+}
+function markProperty(result, key) {
+    result.evaluatedProperties.add(key);
+    return result;
+}
+function markItem(result, index) {
+    result.evaluatedItems.add(index);
+    return result;
+}

package/dist/json-schema/index.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationIssue } from "../validate.js";
+import type { CompileJsonSchemaOptions, CompiledJsonSchema } from "./types.js";
+export type { CompileJsonSchemaOptions, CompiledJsonSchema } from "./types.js";
+export declare function compileJsonSchema(schema: unknown, options?: CompileJsonSchemaOptions): CompiledJsonSchema;
+export declare function formatIssues(issues: readonly ValidationIssue[]): string;

package/dist/json-schema/index.js

@@ -0,0 +1,19 @@
+import { compileGraph } from "./compiler.js";
+import { evaluateSchema } from "./evaluate.js";
+export function compileJsonSchema(schema, options = {}) {
+    const graph = compileGraph(schema, options);
+    return {
+        validate(value) {
+            const result = evaluateSchema(graph, value);
+            return result.valid ? { ok: true, value } : { ok: false, issues: result.issues };
+        }
+    };
+}
+export function formatIssues(issues) {
+    return issues
+        .map((current) => {
+        const path = current.path.length === 0 ? "data" : `data/${current.path.join("/")}`;
+        return `${path} ${current.message}`;
+    })
+        .join(", ");
+}

package/dist/json-schema/types.d.ts

@@ -0,0 +1,33 @@
+import type { ValidationIssue, ValidationResult } from "../validate.js";
+export type JsonSchemaRegistry = Record<string, unknown>;
+export interface CompileJsonSchemaOptions {
+    registry?: JsonSchemaRegistry;
+}
+export interface CompiledJsonSchema {
+    validate(value: unknown): ValidationResult<unknown>;
+}
+export type Dialect = "draft7" | "draft2020-12";
+export type SchemaObject = Record<string, unknown>;
+export type JsonSchema = boolean | SchemaObject;
+export interface SchemaNode {
+    schema: JsonSchema;
+    documentId: string;
+    dialect: Dialect;
+    baseUri: string;
+    resourceUri: string;
+    resourceRoot: SchemaNode;
+    pointer: string;
+    validationVocabulary: boolean;
+    children: Map<string, SchemaNode>;
+}
+export interface EvaluationResult {
+    valid: boolean;
+    issues: ValidationIssue[];
+    evaluatedProperties: Set<string>;
+    evaluatedItems: Set<number>;
+}
+export interface EvaluationContext {
+    instancePath: readonly string[];
+    dynamicScope: readonly SchemaNode[];
+    activePairs: Map<SchemaNode, Set<unknown>>;
+}

package/dist/json-schema/types.js

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

package/dist/json-schema/utils.d.ts

@@ -0,0 +1,19 @@
+import type { ValidationIssue } from "../validate.js";
+import type { Dialect, EvaluationResult, JsonSchema, SchemaObject } from "./types.js";
+export declare function isSchema(value: unknown): value is JsonSchema;
+export declare function isObject(value: unknown): value is SchemaObject;
+export declare function dialectFor(schema: SchemaObject, inherited: Dialect): Dialect;
+export declare function resolveUri(reference: string, baseUri: string): string;
+export declare function withoutFragment(uri: string): string;
+export declare function fragmentOf(uri: string): string;
+export declare function escapePointer(value: string): string;
+export declare function decodePointer(value: string): string;
+export declare function deepEqual(left: unknown, right: unknown): boolean;
+export declare function receivedType(value: unknown): string;
+export declare function issue(path: readonly string[], expected: string, value: unknown, message: string, keyword?: string): ValidationIssue;
+export declare function validResult(): EvaluationResult;
+export declare function invalidResult(problem: ValidationIssue): EvaluationResult;
+export declare function mergeResults(results: readonly EvaluationResult[]): EvaluationResult;
+export declare function typeMatches(type: string, value: unknown): boolean;
+export declare function unicodeLength(value: string): number;
+export declare function isMultipleOf(value: number, divisor: number): boolean;

package/dist/json-schema/utils.js

@@ -0,0 +1,171 @@
+export function isSchema(value) {
+    return typeof value === "boolean" || isObject(value);
+}
+export function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function dialectFor(schema, inherited) {
+    const dialect = schema.$schema;
+    if (typeof dialect !== "string") {
+        return inherited;
+    }
+    if (dialect.includes("draft-07")) {
+        return "draft7";
+    }
+    if (dialect.includes("2020-12")) {
+        return "draft2020-12";
+    }
+    return inherited;
+}
+export function resolveUri(reference, baseUri) {
+    try {
+        return new URL(reference, baseUri).href;
+    }
+    catch {
+        throw new Error(`Invalid schema URI: ${reference}`);
+    }
+}
+export function withoutFragment(uri) {
+    const index = uri.indexOf("#");
+    return index === -1 ? uri : uri.slice(0, index);
+}
+export function fragmentOf(uri) {
+    const index = uri.indexOf("#");
+    return index === -1 ? "" : uri.slice(index + 1);
+}
+export function escapePointer(value) {
+    return value.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+export function decodePointer(value) {
+    return decodeURIComponent(value).replaceAll("~1", "/").replaceAll("~0", "~");
+}
+export function deepEqual(left, right) {
+    if (Object.is(left, right)) {
+        return true;
+    }
+    if (typeof left !== typeof right || left === null || right === null) {
+        return false;
+    }
+    if (Array.isArray(left)) {
+        return (Array.isArray(right) &&
+            left.length === right.length &&
+            left.every((value, index) => deepEqual(value, right[index])));
+    }
+    if (isObject(left) && isObject(right)) {
+        const leftKeys = Object.keys(left);
+        const rightKeys = Object.keys(right);
+        return (leftKeys.length === rightKeys.length &&
+            leftKeys.every((key) => Object.prototype.hasOwnProperty.call(right, key) && deepEqual(left[key], right[key])));
+    }
+    return false;
+}
+export function receivedType(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return "array";
+    }
+    if (typeof value === "number" && Number.isInteger(value)) {
+        return "integer";
+    }
+    return typeof value;
+}
+export function issue(path, expected, value, message, keyword = keywordFor(expected)) {
+    return { path, expected, received: receivedType(value), message, keyword };
+}
+function keywordFor(expected) {
+    if (["null", "boolean", "object", "array", "number", "integer", "string"].includes(expected)) {
+        return "type";
+    }
+    if (expected.startsWith("multiple of"))
+        return "multipleOf";
+    if (expected.startsWith("length <="))
+        return "maxLength";
+    if (expected.startsWith("length >="))
+        return "minLength";
+    if (expected.startsWith("pattern "))
+        return "pattern";
+    if (expected.startsWith("items <="))
+        return "maxItems";
+    if (expected.startsWith("items >="))
+        return "minItems";
+    if (expected === "unique items")
+        return "uniqueItems";
+    if (expected.startsWith("properties <="))
+        return "maxProperties";
+    if (expected.startsWith("properties >="))
+        return "minProperties";
+    if (expected.startsWith("<= "))
+        return "maximum";
+    if (expected.startsWith(">= "))
+        return "minimum";
+    if (expected.startsWith("< "))
+        return "exclusiveMaximum";
+    if (expected.startsWith("> "))
+        return "exclusiveMinimum";
+    if (expected === "valid schema")
+        return "false schema";
+    return expected;
+}
+export function validResult() {
+    return {
+        valid: true,
+        issues: [],
+        evaluatedProperties: new Set(),
+        evaluatedItems: new Set()
+    };
+}
+export function invalidResult(problem) {
+    return {
+        valid: false,
+        issues: [problem],
+        evaluatedProperties: new Set(),
+        evaluatedItems: new Set()
+    };
+}
+export function mergeResults(results) {
+    const merged = validResult();
+    for (const result of results) {
+        merged.valid &&= result.valid;
+        merged.issues.push(...result.issues);
+        for (const key of result.evaluatedProperties) {
+            merged.evaluatedProperties.add(key);
+        }
+        for (const index of result.evaluatedItems) {
+            merged.evaluatedItems.add(index);
+        }
+    }
+    return merged;
+}
+export function typeMatches(type, value) {
+    switch (type) {
+        case "null":
+            return value === null;
+        case "boolean":
+            return typeof value === "boolean";
+        case "object":
+            return isObject(value);
+        case "array":
+            return Array.isArray(value);
+        case "number":
+            return typeof value === "number" && Number.isFinite(value);
+        case "integer":
+            return typeof value === "number" && Number.isInteger(value);
+        case "string":
+            return typeof value === "string";
+        default:
+            return true;
+    }
+}
+export function unicodeLength(value) {
+    return [...value].length;
+}
+export function isMultipleOf(value, divisor) {
+    if (divisor === 0) {
+        return false;
+    }
+    const quotient = value / divisor;
+    return (Math.abs(quotient - Math.round(quotient)) <=
+        Number.EPSILON * Math.max(1, Math.abs(quotient)) * 4);
+}

package/dist/validate.d.ts

@@ -5,6 +5,7 @@ export type ValidationIssue = {
     expected: string;
     received: string;
     message: string;
+    keyword?: string;
 };
 export type ValidationResult<T> = {
     ok: true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-schema",
-  "version": "0.0.115",
+  "version": "0.0.117",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -13,8 +13,8 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsc",
-    "test": "cd ../.. && vitest run packages/toolcraft-schema/src/*.test.ts",
-    "test:unit": "cd ../.. && vitest run packages/toolcraft-schema/src/*.test.ts",
+    "test": "cd ../.. && vitest run packages/toolcraft-schema/src",
+    "test:unit": "cd ../.. && vitest run packages/toolcraft-schema/src",
     "lint": "cd ../.. && eslint packages/toolcraft-schema/src --ext ts && tsc -p packages/toolcraft-schema/tsconfig.json --noEmit"
   },
   "files": [