@veryfront/ext-schema-zod 0.1.1186 → 0.1.1189

package/README.md

@@ -78,6 +78,30 @@ register("SchemaValidator", createZodAdapter());
 
 `toJsonSchema(schema)` converts any `Schema<T>` to a JSON Schema object for OpenAPI or tool-call definitions.
 
+`compileJsonSchema(schema)` compiles raw JSON Schema with strict validation,
+standard formats, and no coercion, default insertion, or removal of additional
+properties.
+
+| Boundary                          | Limit                                         |
+| --------------------------------- | --------------------------------------------- |
+| Schema depth                      | 64 levels                                     |
+| Schema nodes                      | 8,192                                         |
+| Serialized schema                 | 512 KiB                                       |
+| Schema string                     | 256 KiB                                       |
+| Schema property name              | 4 KiB UTF-8                                   |
+| Code-generating collection fanout | 256 entries                                   |
+| Nested compilation work           | 24,000 units                                  |
+| Validation input                  | 128 levels, 100,000 nodes, 4 MiB serialized   |
+| Compiled-validator cache          | 128 entries and 2 MiB aggregate source weight |
+
+Schemas and inputs must be data-only JSON. Accessors, symbol or hidden keys,
+custom object prototypes, cycles, sparse arrays, and revoked proxies are
+rejected without invoking property getters, setters, iterators, or `toJSON`.
+Inspecting a Proxy necessarily invokes its reflection traps; a trap may run or
+throw before the value is rejected. Successful validation returns the
+adapter-owned input snapshot. Cache eviction is least-recently used when either
+cache limit is exceeded.
+
 ## Running Tests
 
 ```sh

package/esm/adapter.d.ts

@@ -13,10 +13,12 @@ import type { SchemaValidator } from "veryfront/extensions/schema";
 /**
  * Build a zod-backed `SchemaValidator` instance.
  *
- * Stateless — safe to call once at extension setup and pass the returned
- * value to `ctx.provide("SchemaValidator", …)`. Tests that need to register
- * the validator without going through full extension bootstrap can call this
- * factory directly.
+ * Adapter instances snapshot schemas into plain JSON and retain validators in
+ * an entry- and weight-bounded LRU cache. Each unique validator owns an isolated
+ * Ajv compiler, so unrelated `$id` values cannot collide or accumulate in a
+ * process-wide registry. It is therefore safe to call this once at extension setup and pass the returned value to
+ * `ctx.provide("SchemaValidator", …)`. Tests that need to register the
+ * validator without full extension bootstrap can call this factory directly.
  */
 export declare function createZodAdapter(): SchemaValidator;
 //# sourceMappingURL=adapter.d.ts.map

package/esm/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAKV,eAAe,EAIhB,MAAM,6BAA6B,CAAC;AAiHrC;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,IAAI,eAAe,CA8FlD"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH,OAAO,KAAK,EASV,eAAe,EAIhB,MAAM,6BAA6B,CAAC;AA4vBrC;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,IAAI,eAAe,CAiGlD"}

package/esm/adapter.js

@@ -9,8 +9,15 @@
  *
  * @module extensions/ext-schema-zod/adapter
  */
+import { Ajv as AjvDraft7 } from "ajv";
+import { Ajv2019 } from "ajv/dist/2019.js";
+import { Ajv2020 } from "ajv/dist/2020.js";
+import addFormatsModule from "ajv-formats";
 import { z } from "zod";
-import { isOptionalSchema, zodToJsonSchema } from "./json-schema.js";
+import { isOptionalSchema, recordStaticJsonSchemaDefault, zodToJsonSchema } from "./json-schema.js";
+// Deno exposes the CommonJS default as a callable value at runtime while the
+// package declaration describes the imported value as a module namespace.
+const addFormats = addFormatsModule;
 /** Unwrap our opaque Schema<T> back to the underlying zod schema. */
 function toZod(schema) {
     return schema.__zod;
@@ -27,7 +34,13 @@ function wrap(zs) {
         optional: () => wrap(zs.optional()),
         nullable: () => wrap(zs.nullable()),
         nullish: () => wrap(zs.nullish()),
-        default: (value) => wrap(anyZs.default(value)),
+        default: (value) => {
+            const defaulted = anyZs.default(value);
+            if (typeof value !== "function") {
+                recordStaticJsonSchemaDefault(defaulted, value);
+            }
+            return wrap(defaulted);
+        },
         describe: (description) => wrap(zs.describe(description)),
         refine: (check, message) => wrap(zs.refine(check, message)),
         superRefine: (check) => wrap(
@@ -94,25 +107,545 @@ function wrap(zs) {
 function toZodShape(shape) {
     const out = {};
     for (const [key, value] of Object.entries(shape)) {
-        out[key] = toZod(value);
+        defineOwnDataProperty(out, key, toZod(value));
     }
     return out;
 }
+function defineOwnDataProperty(target, key, value) {
+    // A data descriptor preserves keys such as `__proto__` as ordinary data
+    // without invoking inherited setters in runtimes that expose them.
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true,
+    });
+}
 const coerce = {
     string: () => wrap(z.coerce.string()),
     number: () => wrap(z.coerce.number()),
     boolean: () => wrap(z.coerce.boolean()),
     date: () => wrap(z.coerce.date()),
 };
+const JSON_SCHEMA_VALIDATOR_CACHE_SIZE = 128;
+const JSON_SCHEMA_VALIDATOR_CACHE_MAX_WEIGHT = 2 * 1024 * 1024;
+// Raw schemas can originate in extensions and tool metadata, so snapshot them
+// through a deliberately bounded JSON boundary before handing them to Ajv.
+// These ceilings are comfortably above practical tool schemas while keeping a
+// single compilation from consuming unbounded stack, CPU, or memory.
+const JSON_SCHEMA_MAX_DEPTH = 64;
+const JSON_SCHEMA_MAX_NODES = 8_192;
+const JSON_SCHEMA_MAX_SERIALIZED_BYTES = 512 * 1024;
+const JSON_SCHEMA_MAX_STRING_BYTES = 256 * 1024;
+const JSON_SCHEMA_MAX_KEY_BYTES = 4 * 1024;
+const JSON_SCHEMA_MAX_COMBINATOR_FANOUT = 256;
+const JSON_SCHEMA_MAX_COMPILATION_WORK = 24_000;
+const JSON_INSTANCE_MAX_DEPTH = 128;
+const JSON_INSTANCE_MAX_NODES = 100_000;
+const JSON_INSTANCE_MAX_SERIALIZED_BYTES = 4 * 1024 * 1024;
+const JSON_INSTANCE_MAX_STRING_BYTES = 1024 * 1024;
+const JSON_INSTANCE_MAX_KEY_BYTES = 16 * 1024;
+const JSON_UTF8_ENCODER = new TextEncoder();
+const JSON_SCHEMA_LIMITS = {
+    maxDepth: JSON_SCHEMA_MAX_DEPTH,
+    maxNodes: JSON_SCHEMA_MAX_NODES,
+    maxSerializedBytes: JSON_SCHEMA_MAX_SERIALIZED_BYTES,
+    maxStringBytes: JSON_SCHEMA_MAX_STRING_BYTES,
+    maxKeyBytes: JSON_SCHEMA_MAX_KEY_BYTES,
+};
+const JSON_INSTANCE_LIMITS = {
+    maxDepth: JSON_INSTANCE_MAX_DEPTH,
+    maxNodes: JSON_INSTANCE_MAX_NODES,
+    maxSerializedBytes: JSON_INSTANCE_MAX_SERIALIZED_BYTES,
+    maxStringBytes: JSON_INSTANCE_MAX_STRING_BYTES,
+    maxKeyBytes: JSON_INSTANCE_MAX_KEY_BYTES,
+};
+const JSON_SCHEMA_COMPILER_OPTIONS = {
+    strict: true,
+    allErrors: true,
+    addUsedSchema: false,
+    allowUnionTypes: true,
+    coerceTypes: false,
+    ownProperties: true,
+    useDefaults: false,
+    removeAdditional: false,
+};
+const DRAFT_7_META_SCHEMA_URI = "https://json-schema.org/draft-07/schema";
+const AJV_DRAFT_7_META_SCHEMA_URI = "http://json-schema.org/draft-07/schema#";
+function normalizeMetaSchemaUri(uri) {
+    return uri.trim().replace(/#$/, "").replace(/^http:/, "https:");
+}
+function createJsonSchemaCompiler(schema) {
+    const declaredDraft = typeof schema.$schema === "string"
+        ? normalizeMetaSchemaUri(schema.$schema)
+        : "https://json-schema.org/draft/2020-12/schema";
+    const compiler = declaredDraft === DRAFT_7_META_SCHEMA_URI
+        ? new AjvDraft7(JSON_SCHEMA_COMPILER_OPTIONS)
+        : declaredDraft === "https://json-schema.org/draft/2019-09/schema"
+            ? new Ajv2019(JSON_SCHEMA_COMPILER_OPTIONS)
+            : declaredDraft === "https://json-schema.org/draft/2020-12/schema"
+                ? new Ajv2020(JSON_SCHEMA_COMPILER_OPTIONS)
+                : undefined;
+    if (!compiler) {
+        throw new Error(`Unsupported JSON Schema draft: ${schema.$schema}`);
+    }
+    addFormats(compiler);
+    return compiler;
+}
+function schemaForCompilation(schema) {
+    if (typeof schema.$schema !== "string" ||
+        normalizeMetaSchemaUri(schema.$schema) !== DRAFT_7_META_SCHEMA_URI) {
+        return schema;
+    }
+    // Ajv's Draft 7 compiler registers the canonical HTTP identifier. Compile
+    // an isolated root snapshot using that identifier while leaving the
+    // caller-owned and cache-key snapshots unchanged.
+    return {
+        ...schema,
+        $schema: AJV_DRAFT_7_META_SCHEMA_URI,
+    };
+}
+function boundedUtf8Length(value, limit, label) {
+    // Every UTF-16 code unit contributes at least one UTF-8 byte. This cheap
+    // guard avoids allocating an encoded copy once the value is already known
+    // to exceed the byte ceiling.
+    if (value.length > limit) {
+        throw new TypeError(`JSON Schema ${label} exceeds the ${limit}-byte limit`);
+    }
+    const byteLength = JSON_UTF8_ENCODER.encode(value).byteLength;
+    if (byteLength > limit) {
+        throw new TypeError(`JSON Schema ${label} exceeds the ${limit}-byte limit`);
+    }
+    return byteLength;
+}
+function serializedJsonTokenByteLength(value) {
+    const serialized = JSON.stringify(value);
+    if (serialized === undefined) {
+        throw new TypeError("JSON Schema must contain only JSON values");
+    }
+    return JSON_UTF8_ENCODER.encode(serialized).byteLength;
+}
+class JsonSchemaCanonicalizer {
+    limits;
+    activeAncestors = new Set();
+    stack = [];
+    canonicalRoot;
+    rootAssigned = false;
+    nodeCount = 0;
+    serializedBytes = 0;
+    constructor(limits) {
+        this.limits = limits;
+    }
+    canonicalize(value) {
+        this.stack.push({ kind: "visit", value, depth: 0 });
+        while (this.stack.length > 0) {
+            const frame = this.stack.pop();
+            if (!frame)
+                break;
+            if (frame.kind === "exit") {
+                this.activeAncestors.delete(frame.value);
+            }
+            else {
+                this.visit(frame);
+            }
+        }
+        if (!this.rootAssigned) {
+            throw new TypeError("JSON Schema must contain a JSON value");
+        }
+        return {
+            value: this.canonicalRoot,
+            nodeCount: this.nodeCount,
+            serializedBytes: this.serializedBytes,
+        };
+    }
+    visit(frame) {
+        this.consumeNode(frame.depth);
+        if (this.visitScalar(frame))
+            return;
+        const current = frame.value;
+        if (typeof current !== "object" || current === null) {
+            throw new TypeError("JSON Schema must contain only JSON values");
+        }
+        if (this.activeAncestors.has(current)) {
+            throw new TypeError("JSON Schema must not contain cycles");
+        }
+        if (Array.isArray(current)) {
+            this.visitArray(frame, current);
+        }
+        else {
+            this.visitObject(frame, current);
+        }
+    }
+    visitScalar(frame) {
+        const current = frame.value;
+        if (current === null || typeof current === "boolean") {
+            this.assign(frame, current);
+            this.addSerializedBytes(serializedJsonTokenByteLength(current));
+            return true;
+        }
+        if (typeof current === "string") {
+            boundedUtf8Length(current, this.limits.maxStringBytes, "string");
+            this.assign(frame, current);
+            this.addSerializedBytes(serializedJsonTokenByteLength(current));
+            return true;
+        }
+        if (typeof current === "number") {
+            if (!Number.isFinite(current)) {
+                throw new TypeError("JSON Schema numbers must be finite");
+            }
+            this.assign(frame, current);
+            this.addSerializedBytes(serializedJsonTokenByteLength(current));
+            return true;
+        }
+        if (typeof current !== "object") {
+            throw new TypeError("JSON Schema must contain only JSON values");
+        }
+        return false;
+    }
+    visitArray(frame, current) {
+        const lengthDescriptor = Reflect.getOwnPropertyDescriptor(current, "length");
+        const length = lengthDescriptor && "value" in lengthDescriptor
+            ? lengthDescriptor.value
+            : undefined;
+        if (typeof length !== "number" ||
+            !Number.isSafeInteger(length) ||
+            length < 0) {
+            throw new TypeError("JSON Schema arrays must have a non-negative integer data length");
+        }
+        if (length > this.limits.maxNodes) {
+            throw new TypeError(`JSON Schema exceeds the maximum node count of ${this.limits.maxNodes}`);
+        }
+        const ownKeys = Reflect.ownKeys(current);
+        if (ownKeys.some((key) => typeof key === "symbol") ||
+            ownKeys.length !== length + 1 ||
+            !ownKeys.includes("length")) {
+            throw new TypeError("JSON Schema arrays must be dense JSON arrays without extra properties");
+        }
+        this.addSerializedBytes(2 + Math.max(0, length - 1));
+        const descriptors = [];
+        for (let index = 0; index < length; index++) {
+            const descriptor = Reflect.getOwnPropertyDescriptor(current, String(index));
+            if (!descriptor || !("value" in descriptor) || descriptor.enumerable !== true) {
+                throw new TypeError("JSON Schema arrays must be dense data-only JSON arrays without accessors");
+            }
+            descriptors.push(descriptor);
+        }
+        const canonical = new Array(length);
+        this.assign(frame, canonical);
+        this.activeAncestors.add(current);
+        this.stack.push({ kind: "exit", value: current });
+        for (let index = descriptors.length - 1; index >= 0; index--) {
+            const descriptor = descriptors[index];
+            if (!descriptor) {
+                throw new TypeError("JSON Schema array snapshot is internally inconsistent");
+            }
+            this.stack.push({
+                kind: "visit",
+                value: descriptor.value,
+                depth: frame.depth + 1,
+                parent: canonical,
+                key: index,
+            });
+        }
+    }
+    visitObject(frame, current) {
+        const prototype = Object.getPrototypeOf(current);
+        if (prototype !== Object.prototype && prototype !== null) {
+            throw new TypeError("JSON Schema objects must be plain JSON objects");
+        }
+        const ownKeys = Reflect.ownKeys(current);
+        if (ownKeys.length > this.limits.maxNodes) {
+            throw new TypeError(`JSON Schema exceeds the maximum node count of ${this.limits.maxNodes}`);
+        }
+        if (ownKeys.some((key) => typeof key === "symbol")) {
+            throw new TypeError("JSON Schema objects must not contain symbol keys");
+        }
+        this.addSerializedBytes(2 + Math.max(0, ownKeys.length - 1));
+        const entries = ownKeys.map((key) => {
+            boundedUtf8Length(key, this.limits.maxKeyBytes, "key");
+            this.addSerializedBytes(serializedJsonTokenByteLength(key) + 1);
+            const descriptor = Object.getOwnPropertyDescriptor(current, key);
+            if (!descriptor || !("value" in descriptor)) {
+                throw new TypeError("JSON Schema objects must be data-only and must not contain accessors");
+            }
+            if (descriptor.enumerable !== true) {
+                throw new TypeError("JSON Schema objects must not contain non-enumerable properties");
+            }
+            return { key, value: descriptor.value };
+        }).sort((left, right) => left.key < right.key ? -1 : left.key > right.key ? 1 : 0);
+        const canonical = {};
+        this.assign(frame, canonical);
+        this.activeAncestors.add(current);
+        this.stack.push({ kind: "exit", value: current });
+        for (let index = entries.length - 1; index >= 0; index--) {
+            const entry = entries[index];
+            if (!entry) {
+                throw new TypeError("JSON Schema object snapshot is internally inconsistent");
+            }
+            this.stack.push({
+                kind: "visit",
+                value: entry.value,
+                depth: frame.depth + 1,
+                parent: canonical,
+                key: entry.key,
+            });
+        }
+    }
+    consumeNode(depth) {
+        if (depth > this.limits.maxDepth) {
+            throw new TypeError(`JSON Schema exceeds the maximum depth of ${this.limits.maxDepth}`);
+        }
+        this.nodeCount++;
+        if (this.nodeCount > this.limits.maxNodes) {
+            throw new TypeError(`JSON Schema exceeds the maximum node count of ${this.limits.maxNodes}`);
+        }
+    }
+    addSerializedBytes(amount) {
+        this.serializedBytes += amount;
+        if (this.serializedBytes > this.limits.maxSerializedBytes) {
+            throw new TypeError(`JSON Schema exceeds the ${this.limits.maxSerializedBytes}-byte serialized limit`);
+        }
+    }
+    assign(frame, canonical) {
+        if (frame.parent === undefined) {
+            this.canonicalRoot = canonical;
+            this.rootAssigned = true;
+            return;
+        }
+        if (Array.isArray(frame.parent)) {
+            frame.parent[frame.key] = canonical;
+            return;
+        }
+        defineOwnDataProperty(frame.parent, frame.key, canonical);
+    }
+}
+function canonicalizeJsonValue(value, limits) {
+    return new JsonSchemaCanonicalizer(limits).canonicalize(value);
+}
+const COMBINATOR_KEYWORDS = new Set(["allOf", "anyOf", "oneOf"]);
+const CODE_GENERATING_MAP_KEYWORDS = new Map([
+    ["properties", 4],
+    ["patternProperties", 8],
+    ["dependencies", 4],
+    ["dependentRequired", 4],
+    ["dependentSchemas", 4],
+]);
+const RETAINED_SCHEMA_MAP_KEYWORDS = new Set(["$defs", "definitions"]);
+function isJsonObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+ * Estimate generated-validator work before Ajv sees a schema. Node and byte
+ * limits alone do not capture wide combinators, large enums, or property maps,
+ * all of which expand generated code and retained compiler state.
+ */
+function estimateCompilationWork(schema) {
+    const stack = [schema];
+    let work = 0;
+    const addWork = (amount) => {
+        work += amount;
+        if (work > JSON_SCHEMA_MAX_COMPILATION_WORK) {
+            throw new TypeError(`JSON Schema exceeds the compilation work limit of ${JSON_SCHEMA_MAX_COMPILATION_WORK}`);
+        }
+    };
+    const addBoundedCollectionWork = (keyword, length, multiplier) => {
+        if (length > JSON_SCHEMA_MAX_COMBINATOR_FANOUT) {
+            throw new TypeError(`JSON Schema ${keyword} exceeds the code-generation collection limit of ${JSON_SCHEMA_MAX_COMBINATOR_FANOUT}`);
+        }
+        addWork(length * multiplier);
+    };
+    while (stack.length > 0) {
+        const value = stack.pop();
+        if (!value || typeof value !== "object")
+            continue;
+        if (Array.isArray(value)) {
+            for (let index = value.length - 1; index >= 0; index--)
+                stack.push(value[index]);
+            continue;
+        }
+        const schemaObject = value;
+        const propertyCount = isJsonObject(schemaObject.properties)
+            ? Object.keys(schemaObject.properties).length
+            : 0;
+        const patternPropertyCount = isJsonObject(schemaObject.patternProperties)
+            ? Object.keys(schemaObject.patternProperties).length
+            : 0;
+        if (propertyCount > 0 && patternPropertyCount > 0) {
+            // In Ajv strict mode every pattern is checked against every named
+            // property during compilation, so account for the cross-product.
+            addWork(propertyCount * patternPropertyCount);
+        }
+        for (const [keyword, keywordValue] of Object.entries(schemaObject)) {
+            addWork(1);
+            if (COMBINATOR_KEYWORDS.has(keyword) && Array.isArray(keywordValue)) {
+                addBoundedCollectionWork(keyword, keywordValue.length, 8);
+            }
+            else if ((keyword === "prefixItems" || keyword === "items") && Array.isArray(keywordValue)) {
+                addBoundedCollectionWork(keyword, keywordValue.length, 2);
+            }
+            else if ((keyword === "enum" || keyword === "required" || keyword === "type") &&
+                Array.isArray(keywordValue)) {
+                addBoundedCollectionWork(keyword, keywordValue.length, keyword === "required" ? 4 : 2);
+            }
+            else if (isJsonObject(keywordValue) && CODE_GENERATING_MAP_KEYWORDS.has(keyword)) {
+                const entryCount = Object.keys(keywordValue).length;
+                addBoundedCollectionWork(keyword, entryCount, CODE_GENERATING_MAP_KEYWORDS.get(keyword));
+                if (keyword === "dependentRequired" || keyword === "dependencies") {
+                    for (const dependencyValue of Object.values(keywordValue)) {
+                        if (Array.isArray(dependencyValue)) {
+                            addBoundedCollectionWork(`${keyword} entry`, dependencyValue.length, 4);
+                        }
+                    }
+                }
+            }
+            else if (isJsonObject(keywordValue) && RETAINED_SCHEMA_MAP_KEYWORDS.has(keyword)) {
+                addWork(Object.keys(keywordValue).length * 2);
+            }
+            else if (keyword === "pattern" && typeof keywordValue === "string") {
+                addWork(Math.ceil(keywordValue.length / 8));
+            }
+            stack.push(keywordValue);
+        }
+    }
+    return work;
+}
+function snapshotJsonSchema(schema) {
+    const snapshot = canonicalizeJsonValue(schema, JSON_SCHEMA_LIMITS);
+    const canonical = snapshot.value;
+    if (canonical === null || typeof canonical !== "object" || Array.isArray(canonical)) {
+        throw new TypeError("JSON Schema root must be a plain object");
+    }
+    const key = JSON.stringify(canonical);
+    if (key === undefined)
+        throw new TypeError("JSON Schema must be JSON serializable");
+    const compilationWork = estimateCompilationWork(canonical);
+    const cacheWeight = snapshot.serializedBytes + snapshot.nodeCount * 64 + compilationWork * 32;
+    return {
+        key,
+        schema: canonical,
+        nodeCount: snapshot.nodeCount,
+        serializedBytes: snapshot.serializedBytes,
+        compilationWork,
+        cacheWeight,
+    };
+}
+function copyValidationIssue(error) {
+    let params;
+    try {
+        params = structuredClone(error.params);
+    }
+    catch {
+        params = { ...error.params };
+    }
+    return {
+        instancePath: error.instancePath,
+        schemaPath: error.schemaPath,
+        keyword: error.keyword,
+        params,
+        ...(error.message === undefined ? {} : { message: error.message }),
+    };
+}
+function validationFailure(errors) {
+    return {
+        success: false,
+        errors: (errors ?? []).map(copyValidationIssue),
+    };
+}
+function validationSuccess(input) {
+    return { success: true, value: input };
+}
+const DATA_ONLY_INPUT_FAILURE = Object.freeze({
+    success: false,
+    errors: Object.freeze([
+        Object.freeze({
+            instancePath: "",
+            schemaPath: "",
+            keyword: "veryfrontDataOnly",
+            params: Object.freeze({}),
+            message: "Input must be a bounded, data-only JSON value",
+        }),
+    ]),
+});
+function snapshotJsonInstance(input) {
+    try {
+        return canonicalizeJsonValue(input, JSON_INSTANCE_LIMITS);
+    }
+    catch {
+        // Accessors, throwing/revoked Proxies, cycles, custom prototypes, and
+        // oversized inputs are ordinary validation failures at this boundary.
+        return undefined;
+    }
+}
+function errorObjectsFromUnknown(error) {
+    if (!error || typeof error !== "object" || !("errors" in error)) {
+        return undefined;
+    }
+    return Array.isArray(error.errors) ? error.errors : undefined;
+}
+function isPromiseLike(value) {
+    return !!value &&
+        (typeof value === "object" || typeof value === "function") &&
+        "then" in value &&
+        typeof value.then === "function";
+}
+function compileJsonSchemaValidator(schema) {
+    const validate = createJsonSchemaCompiler(schema).compile(schemaForCompilation(schema));
+    return (input) => {
+        const inputSnapshot = snapshotJsonInstance(input);
+        if (!inputSnapshot)
+            return DATA_ONLY_INPUT_FAILURE;
+        const acceptedInput = inputSnapshot.value;
+        const outcome = validate(acceptedInput);
+        if (isPromiseLike(outcome)) {
+            return Promise.resolve(outcome).then(() => validationSuccess(acceptedInput), (error) => {
+                const errors = errorObjectsFromUnknown(error);
+                if (errors)
+                    return validationFailure(errors);
+                throw error;
+            });
+        }
+        return outcome ? validationSuccess(acceptedInput) : validationFailure(validate.errors);
+    };
+}
+function createJsonSchemaCompilationCache() {
+    const cache = new Map();
+    let cacheWeight = 0;
+    return (schema) => {
+        const snapshot = snapshotJsonSchema(schema);
+        const cached = cache.get(snapshot.key);
+        if (cached) {
+            cache.delete(snapshot.key);
+            cache.set(snapshot.key, cached);
+            return cached.validator;
+        }
+        const compiled = compileJsonSchemaValidator(snapshot.schema);
+        while (cache.size >= JSON_SCHEMA_VALIDATOR_CACHE_SIZE ||
+            cacheWeight + snapshot.cacheWeight > JSON_SCHEMA_VALIDATOR_CACHE_MAX_WEIGHT) {
+            const oldestKey = cache.keys().next().value;
+            if (oldestKey === undefined)
+                break;
+            const oldest = cache.get(oldestKey);
+            cache.delete(oldestKey);
+            if (oldest)
+                cacheWeight -= oldest.weight;
+        }
+        cache.set(snapshot.key, { validator: compiled, weight: snapshot.cacheWeight });
+        cacheWeight += snapshot.cacheWeight;
+        return compiled;
+    };
+}
 /**
  * Build a zod-backed `SchemaValidator` instance.
  *
- * Stateless — safe to call once at extension setup and pass the returned
- * value to `ctx.provide("SchemaValidator", …)`. Tests that need to register
- * the validator without going through full extension bootstrap can call this
- * factory directly.
+ * Adapter instances snapshot schemas into plain JSON and retain validators in
+ * an entry- and weight-bounded LRU cache. Each unique validator owns an isolated
+ * Ajv compiler, so unrelated `$id` values cannot collide or accumulate in a
+ * process-wide registry. It is therefore safe to call this once at extension setup and pass the returned value to
+ * `ctx.provide("SchemaValidator", …)`. Tests that need to register the
+ * validator without full extension bootstrap can call this factory directly.
  */
 export function createZodAdapter() {
+    const compileJsonSchema = createJsonSchemaCompilationCache();
     return {
         string: () => wrap(z.string()),
         number: () => wrap(z.number()),
@@ -153,6 +686,7 @@ export function createZodAdapter() {
         custom: (check, message) => wrap(z.custom(check, message)),
         coerce,
         validate: (schema, data) => schema.safeParse(data),
+        compileJsonSchema,
         toJsonSchema: (schema) => zodToJsonSchema(toZod(schema)),
         isOptional: (schema) => isOptionalSchema(toZod(schema)),
     };

package/esm/json-schema.d.ts

@@ -1,15 +1,17 @@
 /**
  * Zod-to-JSON-Schema converter used by the `SchemaValidator` adapter.
  *
- * Operates directly on zod's internal `_def` shape (covers both v3 and v4)
- * because zod ships no first-class JSON-Schema export. Confined to
- * `extensions/ext-schema-zod/` so the rest of the codebase never has to import zod
+ * Operates directly on zod's internal `_def` shape to preserve the adapter's
+ * stable v3 and v4 compatibility behavior. It is confined to
+ * `extensions/ext-schema-zod/` so the rest of the codebase never imports zod
  * to learn what a tool's input schema looks like.
  *
  * @module extensions/ext-schema-zod/json-schema
  */
 import type { z } from "zod";
 import type { JsonSchema } from "veryfront/extensions/schema";
+/** Record a literal default without evaluating Zod's possibly dynamic getter. */
+export declare function recordStaticJsonSchemaDefault(schema: z.ZodTypeAny, value: unknown): void;
 export declare function zodToJsonSchema(schema: z.ZodTypeAny): JsonSchema;
 export declare function isOptionalSchema(schema: z.ZodTypeAny): boolean;
 //# sourceMappingURL=json-schema.d.ts.map

package/esm/json-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json-schema.d.ts","sourceRoot":"","sources":["../src/json-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAgD9D,wBAAgB,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,GAAG,UAAU,CAEhE;AAgBD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,GAAG,OAAO,CAE9D"}
+{"version":3,"file":"json-schema.d.ts","sourceRoot":"","sources":["../src/json-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAqO9D,iFAAiF;AACjF,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAOxF;AAmLD,wBAAgB,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,GAAG,UAAU,CAMhE;AAgBD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,GAAG,OAAO,CAE9D"}

package/esm/json-schema.js

@@ -1,21 +1,122 @@
 /**
  * Zod-to-JSON-Schema converter used by the `SchemaValidator` adapter.
  *
- * Operates directly on zod's internal `_def` shape (covers both v3 and v4)
- * because zod ships no first-class JSON-Schema export. Confined to
- * `extensions/ext-schema-zod/` so the rest of the codebase never has to import zod
+ * Operates directly on zod's internal `_def` shape to preserve the adapter's
+ * stable v3 and v4 compatibility behavior. It is confined to
+ * `extensions/ext-schema-zod/` so the rest of the codebase never imports zod
  * to learn what a tool's input schema looks like.
  *
  * @module extensions/ext-schema-zod/json-schema
  */
+const MAX_CONVERSION_DEPTH = 128;
+const MAX_CONVERSION_NODES = 100_000;
+function assertConversionDepth(depth) {
+    if (depth > MAX_CONVERSION_DEPTH) {
+        throw new RangeError(`Zod schema exceeds the maximum conversion depth of ${MAX_CONVERSION_DEPTH}`);
+    }
+}
+const STATIC_DEFAULT_VALUE = Symbol("veryfront.staticJsonSchemaDefault");
 const LITERAL_TYPE_MAP = {
     string: "string",
     number: "number",
     boolean: "boolean",
 };
 function getLiteralType(value) {
+    if (value === null)
+        return "null";
     return LITERAL_TYPE_MAP[typeof value];
 }
+function finiteStringRecordKeys(schema, context) {
+    const activeSchemas = new WeakSet();
+    const keys = [];
+    const stack = [{
+            kind: "visit",
+            schema,
+            depth: context.depth,
+        }];
+    let pendingVisitCount = 1;
+    let visitedNodes = 0;
+    const finish = (result) => {
+        context.nodeCount += visitedNodes;
+        return result;
+    };
+    const assertCapacity = (additionalNodes) => {
+        if (context.nodeCount +
+            visitedNodes +
+            pendingVisitCount +
+            additionalNodes >
+            MAX_CONVERSION_NODES) {
+            throw new RangeError(`Zod schema exceeds the maximum conversion node count of ${MAX_CONVERSION_NODES}`);
+        }
+    };
+    while (stack.length > 0) {
+        const frame = stack.pop();
+        if (!frame)
+            break;
+        if (frame.kind === "exit") {
+            activeSchemas.delete(frame.schema);
+            continue;
+        }
+        pendingVisitCount--;
+        assertConversionDepth(frame.depth);
+        visitedNodes++;
+        if (context.nodeCount + visitedNodes > MAX_CONVERSION_NODES) {
+            throw new RangeError(`Zod schema exceeds the maximum conversion node count of ${MAX_CONVERSION_NODES}`);
+        }
+        if (activeSchemas.has(frame.schema))
+            return finish(undefined);
+        const tag = getTypeTag(frame.schema);
+        const def = getDef(frame.schema);
+        if (tag === "ZodLiteral" || tag === "literal") {
+            const literal = def.value ?? (Array.isArray(def.values) ? def.values[0] : def.values);
+            if (typeof literal !== "string")
+                return finish(undefined);
+            keys.push(literal);
+            continue;
+        }
+        if (tag === "ZodEnum" || tag === "enum") {
+            const rawValues = Array.isArray(def.values)
+                ? def.values
+                : def.entries
+                    ? Object.values(def.entries)
+                    : [];
+            assertCapacity(rawValues.length);
+            for (const value of rawValues) {
+                visitedNodes++;
+                if (typeof value !== "string")
+                    return finish(undefined);
+                keys.push(value);
+            }
+            continue;
+        }
+        if (tag !== "ZodUnion" &&
+            tag !== "ZodDiscriminatedUnion" &&
+            tag !== "union") {
+            return finish(undefined);
+        }
+        const options = def.options ?? [];
+        const optionCount = options instanceof Map ? options.size : options.length;
+        assertCapacity(optionCount);
+        if (optionCount > 0 && frame.depth + 1 > MAX_CONVERSION_DEPTH) {
+            throw new RangeError(`Zod schema exceeds the maximum conversion depth of ${MAX_CONVERSION_DEPTH}`);
+        }
+        const optionArray = options instanceof Map ? Array.from(options.values()) : options;
+        activeSchemas.add(frame.schema);
+        stack.push({ kind: "exit", schema: frame.schema });
+        pendingVisitCount += optionCount;
+        for (let index = optionArray.length - 1; index >= 0; index--) {
+            const option = optionArray[index];
+            if (!option)
+                return finish(undefined);
+            stack.push({
+                kind: "visit",
+                schema: option,
+                depth: frame.depth + 1,
+            });
+        }
+    }
+    return finish(Array.from(new Set(keys)));
+}
 function getDef(schema) {
     return schema._def;
 }
@@ -24,8 +125,217 @@ function getTypeTag(schema) {
     const def = getDef(schema);
     return def.typeName ?? def.type;
 }
+function originatesFromCustomSchema(schema) {
+    const seen = new WeakSet();
+    let current = schema;
+    let depth = 0;
+    while (!seen.has(current)) {
+        assertConversionDepth(depth);
+        seen.add(current);
+        const tag = getTypeTag(current);
+        if (tag === "custom" || tag === "ZodCustom")
+            return true;
+        if (tag !== "pipe" && tag !== "ZodEffects")
+            return false;
+        const def = getDef(current);
+        const input = def.schema ?? def.in;
+        if (!input || input === current)
+            return false;
+        current = input;
+        depth++;
+    }
+    return false;
+}
+function representedPipeSchema(def) {
+    const input = def.schema ?? def.in;
+    return input && originatesFromCustomSchema(input) && def.out ? def.out : input;
+}
+/** Record a literal default without evaluating Zod's possibly dynamic getter. */
+export function recordStaticJsonSchemaDefault(schema, value) {
+    Object.defineProperty(getDef(schema), STATIC_DEFAULT_VALUE, {
+        configurable: true,
+        enumerable: true,
+        value: { value },
+        writable: false,
+    });
+}
+function getStaticJsonSchemaDefault(def) {
+    const marked = def[STATIC_DEFAULT_VALUE];
+    if (!marked || typeof marked !== "object" || !("value" in marked))
+        return undefined;
+    return marked;
+}
+function getCheckDefinitions(def) {
+    return (def.checks ?? []).flatMap((check) => {
+        if (!check || typeof check !== "object")
+            return [];
+        const internal = check._zod?.def;
+        const definition = internal ?? check;
+        return definition && typeof definition === "object" ? [definition] : [];
+    });
+}
+function finiteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function addConjunctiveConstraints(json, keyword, values) {
+    const uniqueValues = Array.from(new Set(values));
+    if (uniqueValues.length === 0)
+        return;
+    if (uniqueValues.length === 1) {
+        json[keyword] = uniqueValues[0];
+        return;
+    }
+    json.allOf = [
+        ...(json.allOf ?? []),
+        ...uniqueValues.map((value) => ({ [keyword]: value })),
+    ];
+}
+const STRING_FORMAT_MAP = {
+    email: "email",
+    url: "uri",
+    uuid: "uuid",
+    datetime: "date-time",
+};
+function convertString(def) {
+    const json = { type: "string" };
+    const patterns = [];
+    const formats = [];
+    for (const check of getCheckDefinitions(def)) {
+        if (check.check === "min_length" && finiteNumber(check.minimum)) {
+            json.minLength = Math.max(json.minLength ?? 0, check.minimum);
+            continue;
+        }
+        if (check.check === "max_length" && finiteNumber(check.maximum)) {
+            json.maxLength = Math.min(json.maxLength ?? Number.POSITIVE_INFINITY, check.maximum);
+            continue;
+        }
+        const format = check.check === "string_format" ? check.format : check.kind;
+        if (format === "min" && finiteNumber(check.value)) {
+            json.minLength = Math.max(json.minLength ?? 0, check.value);
+        }
+        else if (format === "max" && finiteNumber(check.value)) {
+            json.maxLength = Math.min(json.maxLength ?? Number.POSITIVE_INFINITY, check.value);
+        }
+        else if (format === "regex") {
+            const regex = check.pattern ?? check.regex;
+            if (regex && regex.flags.length === 0)
+                patterns.push(regex.source);
+        }
+        else if (format && STRING_FORMAT_MAP[format]) {
+            formats.push(STRING_FORMAT_MAP[format]);
+        }
+    }
+    addConjunctiveConstraints(json, "pattern", patterns);
+    addConjunctiveConstraints(json, "format", formats);
+    return json;
+}
+function tighterLowerBoundary(current, candidate) {
+    if (!current || candidate.value > current.value)
+        return candidate;
+    if (candidate.value < current.value)
+        return current;
+    return { value: current.value, exclusive: current.exclusive || candidate.exclusive };
+}
+function tighterUpperBoundary(current, candidate) {
+    if (!current || candidate.value < current.value)
+        return candidate;
+    if (candidate.value > current.value)
+        return current;
+    return { value: current.value, exclusive: current.exclusive || candidate.exclusive };
+}
+function convertNumber(def) {
+    let integer = false;
+    let lower;
+    let upper;
+    for (const check of getCheckDefinitions(def)) {
+        if ((check.check === "number_format" && check.format === "safeint") ||
+            check.kind === "int") {
+            integer = true;
+            lower = tighterLowerBoundary(lower, {
+                value: -Number.MAX_SAFE_INTEGER,
+                exclusive: false,
+            });
+            upper = tighterUpperBoundary(upper, {
+                value: Number.MAX_SAFE_INTEGER,
+                exclusive: false,
+            });
+            continue;
+        }
+        if (check.check === "greater_than" && finiteNumber(check.value)) {
+            lower = tighterLowerBoundary(lower, {
+                value: check.value,
+                exclusive: check.inclusive !== true,
+            });
+        }
+        else if (check.check === "less_than" && finiteNumber(check.value)) {
+            upper = tighterUpperBoundary(upper, {
+                value: check.value,
+                exclusive: check.inclusive !== true,
+            });
+        }
+        else if (check.kind === "min" && finiteNumber(check.value)) {
+            lower = tighterLowerBoundary(lower, {
+                value: check.value,
+                exclusive: check.inclusive === false,
+            });
+        }
+        else if (check.kind === "max" && finiteNumber(check.value)) {
+            upper = tighterUpperBoundary(upper, {
+                value: check.value,
+                exclusive: check.inclusive === false,
+            });
+        }
+    }
+    const json = { type: integer ? "integer" : "number" };
+    if (lower) {
+        if (lower.exclusive)
+            json.exclusiveMinimum = lower.value;
+        else
+            json.minimum = lower.value;
+    }
+    if (upper) {
+        if (upper.exclusive)
+            json.exclusiveMaximum = upper.value;
+        else
+            json.maximum = upper.value;
+    }
+    return json;
+}
+function arrayLimit(value) {
+    if (finiteNumber(value))
+        return value;
+    if (value && typeof value === "object" && finiteNumber(value.value))
+        return value.value;
+    return undefined;
+}
+function applyArrayLimits(json, def) {
+    const minimums = [];
+    const maximums = [];
+    const legacyMinimum = arrayLimit(def.minLength);
+    const legacyMaximum = arrayLimit(def.maxLength);
+    if (legacyMinimum !== undefined)
+        minimums.push(legacyMinimum);
+    if (legacyMaximum !== undefined)
+        maximums.push(legacyMaximum);
+    for (const check of getCheckDefinitions(def)) {
+        if (check.check === "min_length" && finiteNumber(check.minimum)) {
+            minimums.push(check.minimum);
+        }
+        else if (check.check === "max_length" && finiteNumber(check.maximum)) {
+            maximums.push(check.maximum);
+        }
+    }
+    if (minimums.length > 0)
+        json.minItems = Math.max(...minimums);
+    if (maximums.length > 0)
+        json.maxItems = Math.min(...maximums);
+}
 export function zodToJsonSchema(schema) {
-    return convertSchema(schema, { seen: new WeakSet() });
+    return convertSchema(schema, {
+        seen: new WeakSet(),
+        depth: 0,
+        nodeCount: 0,
+    });
 }
 function convertSchema(schema, context) {
     // Guard against invalid schemas (can happen with different zod instances in npm bundle)
@@ -45,11 +355,18 @@ export function isOptionalSchema(schema) {
 function convert(schema, context) {
     if (context.seen.has(schema))
         return {};
+    assertConversionDepth(context.depth);
+    context.nodeCount += 1;
+    if (context.nodeCount > MAX_CONVERSION_NODES) {
+        throw new RangeError(`Zod schema exceeds the maximum conversion node count of ${MAX_CONVERSION_NODES}`);
+    }
     context.seen.add(schema);
+    context.depth += 1;
     try {
         return convertInner(schema, context);
     }
     finally {
+        context.depth -= 1;
         context.seen.delete(schema);
     }
 }
@@ -59,13 +376,23 @@ function convertInner(schema, context) {
     switch (tag) {
         case "ZodString":
         case "string":
-            return { type: "string" };
+            return convertString(def);
         case "ZodNumber":
         case "number":
-            return { type: "number" };
+            return convertNumber(def);
         case "ZodBoolean":
         case "boolean":
             return { type: "boolean" };
+        case "ZodNull":
+        case "null":
+            return { type: "null" };
+        case "ZodUnknown":
+        case "unknown":
+        case "ZodAny":
+        case "any":
+        case "ZodCustom":
+        case "custom":
+            return {};
         case "ZodBigInt":
         case "bigint":
             return { type: "integer" };
@@ -95,7 +422,12 @@ function convertInner(schema, context) {
             const required = [];
             for (const [key, value] of Object.entries(shape ?? {})) {
                 const zodSchema = value;
-                properties[key] = convertSchema(zodSchema, context);
+                Object.defineProperty(properties, key, {
+                    configurable: true,
+                    enumerable: true,
+                    value: convertSchema(zodSchema, context),
+                    writable: true,
+                });
                 if (!isOptionalSchema(zodSchema))
                     required.push(key);
             }
@@ -111,9 +443,12 @@ function convertInner(schema, context) {
         case "array": {
             // v3: _def.type (item schema), v4: _def.element (item schema)
             const itemType = def.element ?? def.type;
-            if (!itemType || typeof itemType === "string")
-                return { type: "array" };
-            return { type: "array", items: convertSchema(itemType, context) };
+            const json = { type: "array" };
+            if (itemType && typeof itemType !== "string") {
+                json.items = convertSchema(itemType, context);
+            }
+            applyArrayLimits(json, def);
+            return json;
         }
         case "ZodTuple":
         case "tuple": {
@@ -137,7 +472,37 @@ function convertInner(schema, context) {
             const valueSchema = def.valueType ?? def.element;
             if (!valueSchema)
                 return { type: "object" };
-            return { type: "object", additionalProperties: convertSchema(valueSchema, context) };
+            const valueJsonSchema = convertSchema(valueSchema, context);
+            const finiteKeys = def.keyType && finiteStringRecordKeys(def.keyType, context);
+            if (finiteKeys) {
+                const properties = {};
+                for (const key of finiteKeys) {
+                    Object.defineProperty(properties, key, {
+                        configurable: true,
+                        enumerable: true,
+                        value: valueJsonSchema,
+                        writable: true,
+                    });
+                }
+                return {
+                    type: "object",
+                    properties,
+                    required: finiteKeys,
+                    additionalProperties: false,
+                };
+            }
+            const json = {
+                type: "object",
+                additionalProperties: valueJsonSchema,
+            };
+            if (def.keyType) {
+                const propertyNames = convertSchema(def.keyType, context);
+                if (Object.keys(propertyNames).length !== 1 ||
+                    propertyNames.type !== "string") {
+                    json.propertyNames = propertyNames;
+                }
+            }
+            return json;
         }
         case "ZodDefault":
         case "default": {
@@ -145,22 +510,19 @@ function convertInner(schema, context) {
             if (!innerType)
                 return { type: "object" };
             const inner = convertSchema(innerType, context);
-            const defaultValue = typeof def.defaultValue === "function"
-                ? def.defaultValue()
-                : def.defaultValue;
-            if (typeof inner === "object" && !("anyOf" in inner) && defaultValue !== undefined) {
-                inner.default = defaultValue;
-            }
+            const staticDefault = getStaticJsonSchemaDefault(def);
+            if (staticDefault)
+                inner.default = staticDefault.value;
             return inner;
         }
         case "ZodLazy":
         case "lazy":
-            return def.getter ? convert(def.getter(), context) : { type: "object" };
+            return def.getter ? convertSchema(def.getter(), context) : { type: "object" };
         case "ZodEffects":
         case "pipe": {
             // v3: ZodEffects wraps schema in _def.schema
             // v4: pipe wraps in _def.in (input schema)
-            const innerSchema = def.schema ?? def.in;
+            const innerSchema = representedPipeSchema(def);
             return innerSchema ? convert(innerSchema, context) : { type: "object" };
         }
         default:
@@ -184,10 +546,16 @@ function getObjectAdditionalProperties(def, context) {
     return convertSchema(def.catchall, context);
 }
 function unwrapSchema(schema) {
+    const seen = new WeakSet();
     let current = schema;
     let nullable = false;
     let optional = false;
+    let depth = 0;
     while (true) {
+        assertConversionDepth(depth);
+        if (seen.has(current))
+            return { schema: current, nullable, optional };
+        seen.add(current);
         const tag = getTypeTag(current);
         const def = getDef(current);
         switch (tag) {
@@ -195,17 +563,20 @@ function unwrapSchema(schema) {
             case "nullable":
                 nullable = true;
                 current = (def.innerType ?? def.schema);
+                depth++;
                 break;
             case "ZodOptional":
             case "optional":
                 optional = true;
                 current = (def.innerType ?? def.schema);
+                depth++;
                 break;
             case "ZodEffects":
             case "pipe":
-                current = def.schema ?? def.in ?? current;
+                current = representedPipeSchema(def) ?? current;
                 if (current === schema)
                     return { schema: current, nullable, optional };
+                depth++;
                 break;
             default:
                 return { schema: current, nullable, optional };
@@ -213,8 +584,14 @@ function unwrapSchema(schema) {
     }
 }
 function hasDefaultSchema(schema) {
+    const seen = new WeakSet();
     let current = schema;
+    let depth = 0;
     while (true) {
+        assertConversionDepth(depth);
+        if (seen.has(current))
+            return false;
+        seen.add(current);
         const tag = getTypeTag(current);
         const def = getDef(current);
         switch (tag) {
@@ -231,6 +608,7 @@ function hasDefaultSchema(schema) {
                 if (!inner || inner === current)
                     return false;
                 current = inner;
+                depth++;
                 break;
             }
             default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veryfront/ext-schema-zod",
-  "version": "0.1.1186",
+  "version": "0.1.1189",
   "description": "Veryfront first-party extension package for ext-schema-zod",
   "keywords": [
     "veryfront",
@@ -27,7 +27,7 @@
   },
   "scripts": {},
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.3.0"
   },
   "publishConfig": {
     "access": "public"
@@ -42,10 +42,12 @@
     "capabilities": []
   },
   "dependencies": {
+    "ajv": "8.18.0",
+    "ajv-formats": "3.0.1",
     "zod": "4.3.6"
   },
   "peerDependencies": {
-    "veryfront": "^0.1.1186"
+    "veryfront": "^0.1.1189"
   },
   "type": "module",
   "types": "./esm/index.d.ts",