toolcraft-schema 0.0.232 → 0.0.233

package/dist/clone-default.d.ts

@@ -0,0 +1 @@
+export declare function cloneDefaultValue<Value>(value: Value): Value;

package/dist/clone-default.js

@@ -0,0 +1,26 @@
+export function cloneDefaultValue(value) {
+    const copies = new WeakMap();
+    function copy(current) {
+        if (current === null || typeof current !== "object")
+            return current;
+        const existing = copies.get(current);
+        if (existing !== undefined)
+            return existing;
+        const prototype = Object.getPrototypeOf(current);
+        if (!Array.isArray(current) && prototype !== Object.prototype && prototype !== null) {
+            return current;
+        }
+        const result = Array.isArray(current) ? new Array(current.length) : Object.create(prototype);
+        copies.set(current, result);
+        for (const key of Object.keys(current)) {
+            Object.defineProperty(result, key, {
+                value: copy(current[key]),
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+        }
+        return result;
+    }
+    return copy(value);
+}

package/dist/index.compile-check.js

@@ -3,6 +3,7 @@ const ignoredStringSchema = S.String({ description: "Name", default: "guest" });
 const ignoredNumberSchema = S.Number({ description: "Count", default: 1 });
 const ignoredBooleanSchema = S.Boolean({ description: "Enabled", default: false });
 const ignoredEnumSchema = S.Enum(["admin", "user"], { default: "admin" });
+const ignoredNullEnumSchema = S.Enum([null]);
 const ignoredIntegerEnumSchema = S.Enum([1, 2], { jsonType: "integer" });
 const ignoredArraySchema = S.Array(S.String(), { default: ["a"] });
 const ignoredObjectSchema = S.Object({

package/dist/index.d.ts

@@ -2,17 +2,16 @@ import { Json } from "./json.js";
 import { OneOf } from "./oneof.js";
 import { Record as RecordBuilder } from "./record.js";
 import { Union } from "./union.js";
-import { validate } from "./validate.js";
+import { isPlainRecord, validate } from "./validate.js";
 import type { JsonValue, JsonValueSchema } from "./json.js";
 import type { JsonSchemaDocument, JsonSchemaDocumentOptions } from "./json-schema-document.js";
 import type { OneOfSchema } from "./oneof.js";
 import type { RecordSchema } from "./record.js";
 import type { UnionSchema } from "./union.js";
-import type { ValidationIssue, ValidationResult } from "./validate.js";
-type JsonSchemaType = "string" | "number" | "integer" | "boolean" | "array" | "object";
+import type { ValidationIssue, ValidationOptions, ValidationResult } from "./validate.js";
+type JsonSchemaType = "string" | "number" | "integer" | "boolean" | "array" | "object" | "null";
 type SchemaKind = "string" | "number" | "boolean" | "enum" | "array" | "object" | "optional" | "oneOf" | "union" | "record" | "json";
-type EnumValue = string | number | boolean;
-type JsonSchemaEnumValue = EnumValue | null;
+type EnumValue = string | number | boolean | null;
 type NumberJsonType = "number" | "integer";
 type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
 type ObjectShape = Record<string, AnySchema>;
@@ -101,10 +100,13 @@ export interface SchemaBase<TKind extends SchemaKind, TStatic> {
 }
 export interface JsonSchema {
     additionalProperties?: boolean | JsonSchema;
-    type?: JsonSchemaType;
+    allOf?: JsonSchema[];
+    anyOf?: JsonSchema[];
+    type?: JsonSchemaType | JsonSchemaType[];
     description?: string;
     default?: unknown;
-    enum?: ReadonlyArray<JsonSchemaEnumValue>;
+    enum?: ReadonlyArray<JsonValue>;
+    const?: JsonValue;
     format?: string;
     items?: JsonSchema;
     maxItems?: number;
@@ -114,6 +116,7 @@ export interface JsonSchema {
     minimum?: number;
     minLength?: number;
     nullable?: boolean;
+    not?: JsonSchema;
     oneOf?: JsonSchema[];
     pattern?: string;
     properties?: Record<string, JsonSchema>;
@@ -177,8 +180,14 @@ 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 { Json, OneOf, RecordBuilder as Record, Union, isPlainRecord, validate };
+export { isJsonValue } from "./json.js";
+export { cloneDefaultValue } from "./clone-default.js";
+export { unicodeLength } from "./json-schema/utils.js";
 export { compileJsonSchema, formatIssues } from "./json-schema/index.js";
+export { normalizeLegacyNullability } from "./json-schema/normalize-nullability.js";
+export { withJsonSchema, nativeJsonSchema } from "./native-json-schema.js";
+export type { NativeSchema } from "./native-json-schema.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 };
+export type { JsonValue, JsonValueSchema, OneOfSchema, RecordSchema, UnionSchema, ValidationIssue, ValidationOptions, ValidationResult };

package/dist/index.js

@@ -1,18 +1,25 @@
 import { Json } from "./json.js";
+import { nativeJsonSchema } from "./native-json-schema.js";
+import { cloneDefaultValue } from "./clone-default.js";
 import { createJsonSchemaDocument } from "./json-schema-document.js";
 import { OneOf } from "./oneof.js";
 import { Record as RecordBuilder } from "./record.js";
 import { Union } from "./union.js";
-import { validate } from "./validate.js";
+import { isPlainRecord, validate } from "./validate.js";
 function withMetadata(schema, jsonSchema) {
     if (schema.description !== undefined) {
         jsonSchema.description = schema.description;
     }
     if (schema.default !== undefined) {
-        jsonSchema.default = schema.default;
+        jsonSchema.default = cloneDefaultValue(schema.default);
     }
     if (schema.nullable === true) {
-        jsonSchema.nullable = true;
+        if (jsonSchema.type !== undefined) {
+            jsonSchema.type = [...new Set([...(Array.isArray(jsonSchema.type) ? jsonSchema.type : [jsonSchema.type]), "null"])];
+        }
+        if (jsonSchema.oneOf !== undefined) {
+            jsonSchema.oneOf.push({ enum: [null] });
+        }
     }
     return jsonSchema;
 }
@@ -59,6 +66,8 @@ function getEnumJsonType(values) {
         return undefined;
     }
     const firstType = typeof firstValue;
+    if (firstValue === null && values.every((value) => value === null))
+        return "null";
     const isSinglePrimitiveType = values.every((value) => typeof value === firstType);
     if (!isSinglePrimitiveType) {
         return undefined;
@@ -124,8 +133,22 @@ function unwrapOptional(schema) {
     }
     return schema;
 }
+function toObjectBranchJsonSchema(schema) {
+    const objectSchema = { ...schema, nullable: false };
+    const branchJsonSchema = toJsonSchema(objectSchema);
+    if (branchJsonSchema.default === null) {
+        delete branchJsonSchema.default;
+    }
+    return branchJsonSchema;
+}
 function withInjectedDiscriminator(schema, discriminator, branchName) {
-    const branchJsonSchema = toJsonSchema(schema);
+    const branchJsonSchema = toObjectBranchJsonSchema(schema);
+    if (branchJsonSchema.default !== undefined) {
+        branchJsonSchema.default = {
+            ...branchJsonSchema.default,
+            [discriminator]: branchName
+        };
+    }
     const properties = {
         ...(branchJsonSchema.properties ?? {}),
         [discriminator]: {
@@ -227,6 +250,9 @@ export const S = {
 };
 export function toJsonSchema(schema) {
     const unwrappedSchema = unwrapOptional(schema);
+    const native = unwrappedSchema[nativeJsonSchema];
+    if (native !== undefined)
+        return structuredClone(native.document);
     switch (unwrappedSchema.kind) {
         case "string":
             return withStringMetadata(unwrappedSchema, { type: "string" });
@@ -277,19 +303,31 @@ export function toJsonSchema(schema) {
             });
         case "union":
             return withMetadata(unwrappedSchema, {
-                oneOf: unwrappedSchema.branches.map((branchSchema) => toJsonSchema(branchSchema))
+                oneOf: unwrappedSchema.branches.map((branchSchema) => toObjectBranchJsonSchema(branchSchema))
             });
         case "record":
             return withMetadata(unwrappedSchema, {
                 type: "object",
                 additionalProperties: toJsonSchema(unwrappedSchema.value)
             });
-        case "json":
-            return withMetadata(unwrappedSchema, {});
+        case "json": {
+            const constraints = {
+                ...(unwrappedSchema.const !== undefined ? { const: unwrappedSchema.const } : {}),
+                ...(unwrappedSchema.enum !== undefined ? { enum: unwrappedSchema.enum } : {})
+            };
+            return withMetadata(unwrappedSchema, unwrappedSchema.nullable === true && Object.keys(constraints).length > 0
+                ? { anyOf: [constraints, { type: "null" }] }
+                : constraints);
+        }
     }
 }
 export function toJsonSchemaDocument(schema, options = {}) {
     return createJsonSchemaDocument(toJsonSchema(schema), options);
 }
-export { Json, OneOf, RecordBuilder as Record, Union, validate };
+export { Json, OneOf, RecordBuilder as Record, Union, isPlainRecord, validate };
+export { isJsonValue } from "./json.js";
+export { cloneDefaultValue } from "./clone-default.js";
+export { unicodeLength } from "./json-schema/utils.js";
 export { compileJsonSchema, formatIssues } from "./json-schema/index.js";
+export { normalizeLegacyNullability } from "./json-schema/normalize-nullability.js";
+export { withJsonSchema, nativeJsonSchema } from "./native-json-schema.js";

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

@@ -1,5 +1,6 @@
 import type { CompileJsonSchemaOptions, SchemaNode } from "./types.js";
 export interface CompiledGraph {
+    formats: ReadonlyMap<string, (value: string) => boolean>;
     root: SchemaNode;
     locations: Map<string, SchemaNode>;
     resources: Map<string, SchemaNode>;

package/dist/json-schema/compiler.js

@@ -173,6 +173,11 @@ function validateSchemaObject(schema, dialect) {
     }
 }
 export function compileGraph(schema, options = {}) {
+    const formats = new Map(Object.entries(options.formats ?? {}));
+    for (const [name, validator] of formats) {
+        if (typeof validator !== "function")
+            throw new Error(`Format validator must be a function: ${name}`);
+    }
     if (!isSchema(schema)) {
         throw new Error("JSON Schema must be a boolean or object.");
     }
@@ -377,6 +382,7 @@ export function compileGraph(schema, options = {}) {
         }
     }
     return {
+        formats,
         root,
         locations,
         resources,

package/dist/json-schema/evaluate.js

@@ -39,6 +39,12 @@ function evaluateNode(graph, node, value, context) {
     if (node.validationVocabulary) {
         results.push(...evaluateValidationKeywords(node, schema, value, nextContext.instancePath));
     }
+    if (typeof value === "string" && typeof schema.format === "string") {
+        const validator = graph.formats.get(schema.format);
+        if (validator !== undefined && validator(value) !== true) {
+            results.push(invalidResult(issue(nextContext.instancePath, `format ${schema.format}`, value, `must match format ${schema.format}`)));
+        }
+    }
     const merged = mergeResults(results);
     if (isObject(value)) {
         evaluateUnevaluatedProperties(graph, node, schema, value, nextContext, merged);
@@ -246,9 +252,6 @@ function evaluateArrayApplicators(graph, node, schema, value, context) {
 }
 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))) {

package/dist/json-schema/normalize-nullability.d.ts

@@ -0,0 +1 @@
+export declare function normalizeLegacyNullability(source: object): Record<string, unknown>;

package/dist/json-schema/normalize-nullability.js

@@ -0,0 +1,69 @@
+import { dialectFor } from "./utils.js";
+const schemaMaps = new Set(["properties", "$defs", "definitions", "patternProperties", "dependentSchemas", "dependencies"]);
+const schemaArrays = new Set(["allOf", "anyOf", "oneOf", "prefixItems", "items"]);
+const schemaValues = new Set(["items", "additionalProperties", "additionalItems", "contains", "not", "if", "then", "else", "propertyNames", "unevaluatedProperties", "unevaluatedItems"]);
+const schemaIdentity = new Set(["$id", "id", "$schema", "$anchor", "$dynamicAnchor", "$defs", "definitions", "description", "default"]);
+export function normalizeLegacyNullability(source) {
+    const locations = new Map();
+    const resourceIds = new Map();
+    const references = [];
+    const pointer = (path) => path.length === 0 ? "" : `/${path.map((part) => part.split("~").join("~0").split("/").join("~1")).join("/")}`;
+    const walk = (node, before, after, resourceBefore, resourceAfter, base = "https://toolcraft.invalid/schema", inheritedDialect = "draft2020-12") => {
+        if (typeof node !== "object" || node === null || Array.isArray(node))
+            return structuredClone(node);
+        const object = node;
+        const dialect = dialectFor(object, inheritedDialect);
+        const identifier = dialect === "draft7" ? object.$id ?? object.id : object.$id;
+        if (typeof identifier === "string") {
+            resourceBefore = before;
+            resourceAfter = after;
+            base = new URL(identifier, base).href.split("#", 1)[0];
+        }
+        const resource = pointer(resourceBefore);
+        resourceIds.set(base, resource);
+        locations.set(`${resource}|${pointer(before.slice(resourceBefore.length))}`, pointer(after.slice(resourceAfter.length)));
+        const result = {};
+        const validation = {};
+        const nullable = object.nullable === true;
+        for (const [key, value] of Object.entries(object)) {
+            if (key === "nullable")
+                continue;
+            const target = nullable && !schemaIdentity.has(key) ? validation : result;
+            const nextAfter = [...after, ...(target === validation ? ["anyOf", "0"] : []), key];
+            let converted;
+            if (schemaMaps.has(key) && typeof value === "object" && value !== null && !Array.isArray(value)) {
+                converted = Object.fromEntries(Object.entries(value).map(([name, child]) => [name,
+                    walk(child, [...before, key, name], [...nextAfter, name], resourceBefore, resourceAfter, base, dialect)]));
+            }
+            else if (schemaArrays.has(key) && Array.isArray(value)) {
+                converted = value.map((child, index) => walk(child, [...before, key, String(index)], [...nextAfter, String(index)], resourceBefore, resourceAfter, base, dialect));
+            }
+            else if (schemaValues.has(key)) {
+                converted = walk(value, [...before, key], nextAfter, resourceBefore, resourceAfter, base, dialect);
+            }
+            else
+                converted = structuredClone(value);
+            Object.defineProperty(target, key, { value: converted, enumerable: true, configurable: true, writable: true });
+            if ((key === "$ref" || key === "$dynamicRef") && typeof value === "string")
+                references.push({ holder: target, key, value, base });
+        }
+        if (nullable)
+            result.anyOf = [validation, { type: "null" }];
+        return result;
+    };
+    const normalized = walk(source, [], [], [], []);
+    for (const reference of references) {
+        const resolved = new URL(reference.value, reference.base);
+        if (!resolved.hash.startsWith("#/"))
+            continue;
+        const resource = resourceIds.get(resolved.href.slice(0, -resolved.hash.length));
+        if (resource === undefined)
+            continue;
+        const original = decodeURIComponent(resolved.hash.slice(1));
+        const destination = locations.get(`${resource}|${original}`);
+        if (destination !== undefined && destination !== original) {
+            reference.holder[reference.key] = `${reference.value.slice(0, reference.value.indexOf("#") + 1)}${destination}`;
+        }
+    }
+    return normalized;
+}

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

@@ -2,6 +2,7 @@ import type { ValidationIssue, ValidationResult } from "../validate.js";
 export type JsonSchemaRegistry = Record<string, unknown>;
 export interface CompileJsonSchemaOptions {
     registry?: JsonSchemaRegistry;
+    formats?: Readonly<Record<string, (value: string) => boolean>>;
 }
 export interface CompiledJsonSchema {
     validate(value: unknown): ValidationResult<unknown>;

package/dist/json.d.ts

@@ -5,6 +5,9 @@ export type JsonValue = JsonPrimitive | {
 } | JsonValue[];
 export interface JsonValueSchema extends SchemaBase<"json", JsonValue> {
     readonly kind: "json";
+    readonly const?: JsonValue;
+    readonly enum?: readonly JsonValue[];
 }
-export declare function Json(): JsonValueSchema;
+export declare function Json(options?: Omit<JsonValueSchema, "kind">): JsonValueSchema;
+export declare function isJsonValue(value: unknown): boolean;
 export {};

package/dist/json.js

@@ -1,5 +1,61 @@
-export function Json() {
+export function Json(options = {}) {
     return {
         kind: "json",
+        ...options,
     };
 }
+export function isJsonValue(value) {
+    const ancestors = new Set();
+    let nodes = 0;
+    const visit = (item, depth) => {
+        if (++nodes > 10_000 || depth > 64)
+            return false;
+        if (item === null || typeof item === "string" || typeof item === "boolean")
+            return true;
+        if (typeof item === "number")
+            return Number.isFinite(item);
+        if (typeof item !== "object" || ancestors.has(item))
+            return false;
+        if (!Array.isArray(item) && Object.getPrototypeOf(item) !== Object.prototype &&
+            Object.getPrototypeOf(item) !== null)
+            return false;
+        let hookOwner = item;
+        let prototypeDepth = 0;
+        while (hookOwner !== null) {
+            if (++prototypeDepth > 64)
+                return false;
+            const serializationHook = Object.getOwnPropertyDescriptor(hookOwner, "toJSON");
+            if (serializationHook !== undefined) {
+                if (!("value" in serializationHook) || typeof serializationHook.value === "function")
+                    return false;
+                break;
+            }
+            hookOwner = Object.getPrototypeOf(hookOwner);
+        }
+        ancestors.add(item);
+        let valid = true;
+        if (Array.isArray(item)) {
+            if (item.length > 10_000)
+                valid = false;
+            else
+                for (let index = 0; index < item.length; index++) {
+                    const property = Object.getOwnPropertyDescriptor(item, String(index));
+                    if (property === undefined || !("value" in property) || !visit(property.value, depth + 1)) {
+                        valid = false;
+                        break;
+                    }
+                }
+        }
+        else
+            for (const key in item) {
+                const property = Object.getOwnPropertyDescriptor(item, key);
+                if (property !== undefined && (!("value" in property) || !visit(property.value, depth + 1))) {
+                    valid = false;
+                    break;
+                }
+            }
+        ancestors.delete(item);
+        return valid;
+    };
+    return visit(value, 0);
+}

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

@@ -0,0 +1,10 @@
+import type { AnySchema, JsonSchema } from "./index.js";
+import type { CompiledJsonSchema } from "./json-schema/types.js";
+export declare const nativeJsonSchema: unique symbol;
+export type NativeSchema = AnySchema & {
+    [nativeJsonSchema]?: {
+        document: JsonSchema;
+        validator: CompiledJsonSchema;
+    };
+};
+export declare function withJsonSchema<T extends AnySchema>(projection: T, document: object): T;

package/dist/native-json-schema.js

@@ -0,0 +1,11 @@
+import { isJsonValue } from "./json.js";
+import { compileJsonSchema } from "./json-schema/index.js";
+export const nativeJsonSchema = Symbol("toolcraft.nativeJsonSchema");
+export function withJsonSchema(projection, document) {
+    if (!isJsonValue(document) || Array.isArray(document)) {
+        throw new Error("Native JSON Schema must be a JSON object");
+    }
+    const snapshot = structuredClone(document);
+    const validator = compileJsonSchema(snapshot);
+    return { ...projection, [nativeJsonSchema]: { document: snapshot, validator } };
+}

package/dist/validate.d.ts

@@ -14,4 +14,8 @@ export type ValidationResult<T> = {
     ok: false;
     issues: readonly ValidationIssue[];
 };
-export declare function validate<S extends SchemaDescriptor>(schema: S, value: unknown): ValidationResult<Static<S>>;
+export interface ValidationOptions {
+    defaults?: "none" | "optional" | "all";
+}
+export declare function validate<S extends SchemaDescriptor>(schema: S, value: unknown, options?: ValidationOptions): ValidationResult<Static<S>>;
+export declare function isPlainRecord(value: unknown): value is Record<string, unknown>;

package/dist/validate.js

@@ -1,7 +1,11 @@
+import { cloneDefaultValue } from "./clone-default.js";
+import { isJsonValue } from "./json.js";
+import { deepEqual, unicodeLength } from "./json-schema/utils.js";
 import { getRequiredKeyFingerprint } from "./union.js";
+import { nativeJsonSchema } from "./native-json-schema.js";
 const missingValue = Symbol("missingValue");
-export function validate(schema, value) {
-    const state = { issues: [] };
+export function validate(schema, value, options = {}) {
+    const state = { issues: [], defaults: options.defaults ?? "optional" };
     const result = walkSchema(schema, value, [], state);
     if (state.issues.length > 0) {
         return { ok: false, issues: state.issues };
@@ -12,10 +16,25 @@ function walkSchema(schema, value, path, state) {
     if (schema.kind === "optional") {
         return walkOptional(schema, value, path, state);
     }
+    if (value === missingValue && state.defaults === "all" && schema.default !== undefined) {
+        value = cloneDefaultValue(schema.default);
+    }
     if (value === missingValue) {
         addIssue(state, path, expectedFor(schema), "missing", `Expected ${expectedFor(schema)} at ${formatPath(path)}`);
         return { present: false };
     }
+    const native = schema[nativeJsonSchema];
+    if (native !== undefined) {
+        if (!isJsonValue(value)) {
+            addExpectedIssue(state, path, "JSON value", value);
+        }
+        else {
+            const result = native.validator.validate(value);
+            if (!result.ok)
+                state.issues.push(...result.issues.map((issue) => ({ ...issue, path: [...path, ...issue.path] })));
+        }
+        return { present: true, value };
+    }
     if (value === null && schema.nullable === true) {
         return { present: true, value };
     }
@@ -39,14 +58,26 @@ function walkSchema(schema, value, path, state) {
         case "record":
             return walkRecord(schema, value, path, state);
         case "json":
-            return walkJson(value, path, state);
+            return walkJson(schema, value, path, state);
     }
 }
 function walkOptional(schema, value, path, state) {
     if (value === missingValue || value === undefined) {
+        if (state.defaults === "none") {
+            return { present: false };
+        }
         const defaultValue = getDefault(schema.inner);
         if (defaultValue.present) {
-            return walkSchema(schema.inner, cloneDefault(defaultValue.value), path, state);
+            let clonedDefault;
+            try {
+                clonedDefault = structuredClone(defaultValue.value);
+            }
+            catch (error) {
+                if (!(error instanceof Error) || error.name !== "DataCloneError")
+                    throw error;
+                clonedDefault = cloneDefaultValue(defaultValue.value);
+            }
+            return walkSchema(schema.inner, clonedDefault, path, state);
         }
         return { present: false };
     }
@@ -57,13 +88,14 @@ function walkString(schema, value, path, state) {
         addExpectedIssue(state, path, "string", value);
         return { present: true, value };
     }
-    if (schema.minLength !== undefined && value.length < schema.minLength) {
+    const length = unicodeLength(value);
+    if (schema.minLength !== undefined && length < schema.minLength) {
         const expected = `string with length at least ${schema.minLength}`;
-        addIssue(state, path, expected, `string with length ${value.length}`, `Expected ${expected} at ${formatPath(path)}`);
+        addIssue(state, path, expected, `string with length ${length}`, `Expected ${expected} at ${formatPath(path)}`);
     }
-    if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+    if (schema.maxLength !== undefined && length > schema.maxLength) {
         const expected = `string with length at most ${schema.maxLength}`;
-        addIssue(state, path, expected, `string with length ${value.length}`, `Expected ${expected} at ${formatPath(path)}`);
+        addIssue(state, path, expected, `string with length ${length}`, `Expected ${expected} at ${formatPath(path)}`);
     }
     if (schema.pattern !== undefined) {
         const pattern = compilePattern(schema.pattern);
@@ -118,7 +150,8 @@ function walkArray(schema, value, path, state) {
         const expected = `array with at most ${schema.maxItems} items`;
         addIssue(state, path, expected, `array with ${value.length} items`, `Expected ${expected} at ${formatPath(path)}`);
     }
-    const nextValue = value.map((item, index) => {
+    const nextValue = Array.from({ length: value.length }, (_item, index) => {
+        const item = value[index];
         const result = walkSchema(schema.item, item, [...path, String(index)], state);
         return result.present ? result.value : item;
     });
@@ -182,15 +215,17 @@ function walkOneOf(schema, value, path, state) {
     });
 }
 function walkUnion(schema, value, path, state) {
-    if (isPlainRecord(value)) {
-        const candidateBranches = schema.branches.filter((branch) => hasRequiredKeys(branch, value));
-        if (candidateBranches.length === 1) {
-            return walkObject(candidateBranches[0], value, path, state);
-        }
+    if (!isPlainRecord(value)) {
+        addExpectedIssue(state, path, "object", value);
+        return { present: true, value };
+    }
+    const candidateBranches = schema.branches.filter((branch) => hasRequiredKeys(branch, value));
+    if (candidateBranches.length === 1 && state.defaults !== "all") {
+        return walkObject(candidateBranches[0], value, path, state);
     }
     const matches = [];
     for (const branch of schema.branches) {
-        const branchState = { issues: [] };
+        const branchState = { ...state, issues: [] };
         const result = walkObject(branch, value, path, branchState);
         if (branchState.issues.length === 0 && result.present) {
             matches.push({ fingerprint: getRequiredKeyFingerprint(branch), value: result.value });
@@ -229,8 +264,14 @@ function walkRecord(schema, value, path, state) {
     }
     return { present: true, value: nextValue };
 }
-function walkJson(value, path, state) {
+function walkJson(schema, value, path, state) {
     if (isJsonValue(value)) {
+        if (schema.const !== undefined && !deepEqual(value, schema.const)) {
+            addExpectedIssue(state, path, "declared JSON constant", value);
+        }
+        if (schema.enum !== undefined && !schema.enum.some((candidate) => deepEqual(value, candidate))) {
+            addExpectedIssue(state, path, "declared JSON enum value", value);
+        }
         return { present: true, value };
     }
     addExpectedIssue(state, path, "JSON value", value);
@@ -245,43 +286,13 @@ function getDefault(schema) {
     }
     return { present: false };
 }
-function isPlainRecord(value) {
+export function isPlainRecord(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         return false;
     }
     const prototype = Object.getPrototypeOf(value);
     return prototype === Object.prototype || prototype === null;
 }
-function isJsonValue(value, ancestors = new Set()) {
-    if (value === null ||
-        typeof value === "string" ||
-        typeof value === "number" ||
-        typeof value === "boolean") {
-        return typeof value !== "number" || Number.isFinite(value);
-    }
-    if (Array.isArray(value)) {
-        if (ancestors.has(value)) {
-            return false;
-        }
-        ancestors.add(value);
-        const result = value.every((item) => isJsonValue(item, ancestors));
-        ancestors.delete(value);
-        return result;
-    }
-    if (isPlainRecord(value)) {
-        if (ancestors.has(value)) {
-            return false;
-        }
-        ancestors.add(value);
-        const result = Object.values(value).every((item) => isJsonValue(item, ancestors));
-        ancestors.delete(value);
-        return result;
-    }
-    return false;
-}
-function cloneDefault(value) {
-    return structuredClone(value);
-}
 function setOwnValue(target, key, value) {
     Object.defineProperty(target, key, {
         configurable: true,
@@ -357,6 +368,9 @@ function receivedType(value) {
     if (Array.isArray(value)) {
         return "array";
     }
+    if (typeof value === "object" && !isPlainRecord(value)) {
+        return "non-plain object";
+    }
     if (typeof value === "number" && Number.isInteger(value)) {
         return "integer";
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-schema",
-  "version": "0.0.232",
+  "version": "0.0.233",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",