@naylence/agent-sdk 0.4.7 → 0.4.9

package/dist/browser/index.js

@@ -5,12 +5,12 @@
 })(this, (function (exports, runtime, factory, core, node) { 'use strict';
 
     // This file is auto-generated during build - do not edit manually
-    // Generated from package.json version: 0.4.7
+    // Generated from package.json version: 0.4.9
     /**
      * The package version, injected at build time.
      * @internal
      */
-    const VERSION = '0.4.7';
+    const VERSION = '0.4.9';
 
     /**
      * AUTO-GENERATED FILE. DO NOT EDIT DIRECTLY.
@@ -395,6 +395,11 @@
     };
     function pick(schema, mask) {
         const currDef = schema._zod.def;
+        const checks = currDef.checks;
+        const hasChecks = checks && checks.length > 0;
+        if (hasChecks) {
+            throw new Error(".pick() cannot be used on object schemas containing refinements");
+        }
         const def = mergeDefs(schema._zod.def, {
             get shape() {
                 const newShape = {};
@@ -415,6 +420,11 @@
     }
     function omit(schema, mask) {
         const currDef = schema._zod.def;
+        const checks = currDef.checks;
+        const hasChecks = checks && checks.length > 0;
+        if (hasChecks) {
+            throw new Error(".omit() cannot be used on object schemas containing refinements");
+        }
         const def = mergeDefs(schema._zod.def, {
             get shape() {
                 const newShape = { ...schema._zod.def.shape };
@@ -440,7 +450,14 @@
         const checks = schema._zod.def.checks;
         const hasChecks = checks && checks.length > 0;
         if (hasChecks) {
-            throw new Error("Object schemas containing refinements cannot be extended. Use `.safeExtend()` instead.");
+            // Only throw if new shape overlaps with existing shape
+            // Use getOwnPropertyDescriptor to check key existence without accessing values
+            const existingShape = schema._zod.def.shape;
+            for (const key in shape) {
+                if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
+                    throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
+                }
+            }
         }
         const def = mergeDefs(schema._zod.def, {
             get shape() {
@@ -448,7 +465,6 @@
                 assignProp(this, "shape", _shape); // self-caching
                 return _shape;
             },
-            checks: [],
         });
         return clone(schema, def);
     }
@@ -456,15 +472,13 @@
         if (!isPlainObject(shape)) {
             throw new Error("Invalid input to safeExtend: expected a plain object");
         }
-        const def = {
-            ...schema._zod.def,
+        const def = mergeDefs(schema._zod.def, {
             get shape() {
                 const _shape = { ...schema._zod.def.shape, ...shape };
                 assignProp(this, "shape", _shape); // self-caching
                 return _shape;
             },
-            checks: schema._zod.def.checks,
-        };
+        });
         return clone(schema, def);
     }
     function merge(a, b) {
@@ -482,6 +496,12 @@
         return clone(a, def);
     }
     function partial(Class, schema, mask) {
+        const currDef = schema._zod.def;
+        const checks = currDef.checks;
+        const hasChecks = checks && checks.length > 0;
+        if (hasChecks) {
+            throw new Error(".partial() cannot be used on object schemas containing refinements");
+        }
         const def = mergeDefs(schema._zod.def, {
             get shape() {
                 const oldShape = schema._zod.def.shape;
@@ -551,7 +571,6 @@
                 assignProp(this, "shape", shape); // self-caching
                 return shape;
             },
-            checks: [],
         });
         return clone(schema, def);
     }
@@ -801,7 +820,8 @@
     const base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
     const base64url = /^[A-Za-z0-9_-]*$/;
     // https://blog.stevenlevithan.com/archives/validate-phone-number#r4-3 (regex sans spaces)
-    const e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
+    // E.164: leading digit must be 1-9; total digits (excluding '+') between 7-15
+    const e164 = /^\+[1-9]\d{6,14}$/;
     // const dateSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
     const dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
     const date$2 = /*@__PURE__*/ new RegExp(`^${dateSource}$`);
@@ -836,7 +856,7 @@
         return new RegExp(`^${regex}$`);
     };
     const integer = /^-?\d+$/;
-    const number$1 = /^-?\d+(?:\.\d+)?/;
+    const number$1 = /^-?\d+(?:\.\d+)?$/;
     const boolean$1 = /^(?:true|false)$/i;
     // regex for string with no uppercase letters
     const lowercase = /^[^A-Z]*$/;
@@ -875,7 +895,7 @@
             payload.issues.push({
                 origin,
                 code: "too_big",
-                maximum: def.value,
+                maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
                 input: payload.value,
                 inclusive: def.inclusive,
                 inst,
@@ -903,7 +923,7 @@
             payload.issues.push({
                 origin,
                 code: "too_small",
-                minimum: def.value,
+                minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
                 input: payload.value,
                 inclusive: def.inclusive,
                 inst,
@@ -991,6 +1011,7 @@
                             note: "Integers must be within the safe integer range.",
                             inst,
                             origin,
+                            inclusive: true,
                             continue: !def.abort,
                         });
                     }
@@ -1003,6 +1024,7 @@
                             note: "Integers must be within the safe integer range.",
                             inst,
                             origin,
+                            inclusive: true,
                             continue: !def.abort,
                         });
                     }
@@ -1026,7 +1048,9 @@
                     input,
                     code: "too_big",
                     maximum,
+                    inclusive: true,
                     inst,
+                    continue: !def.abort,
                 });
             }
         };
@@ -1289,8 +1313,8 @@
 
     const version = {
         major: 4,
-        minor: 2,
-        patch: 1,
+        minor: 3,
+        patch: 6,
     };
 
     const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
@@ -1400,7 +1424,8 @@
                 return runChecks(result, checks, ctx);
             };
         }
-        inst["~standard"] = {
+        // Lazy initialize ~standard to avoid creating objects for every schema
+        defineLazy(inst, "~standard", () => ({
             validate: (value) => {
                 try {
                     const r = safeParse$1(inst, value);
@@ -1412,7 +1437,7 @@
             },
             vendor: "zod",
             version: 1,
-        };
+        }));
     });
     const $ZodString = /*@__PURE__*/ $constructor("$ZodString", (inst, def) => {
         $ZodType.init(inst, def);
@@ -1865,8 +1890,12 @@
             return payload; //handleArrayResultsAsync(parseResults, final);
         };
     });
-    function handlePropertyResult(result, final, key, input) {
+    function handlePropertyResult(result, final, key, input, isOptionalOut) {
         if (result.issues.length) {
+            // For optional-out schemas, ignore errors on absent keys
+            if (isOptionalOut && !(key in input)) {
+                return;
+            }
             final.issues.push(...prefixIssues(key, result.issues));
         }
         if (result.value === undefined) {
@@ -1900,6 +1929,7 @@
         const keySet = def.keySet;
         const _catchall = def.catchall._zod;
         const t = _catchall.def.type;
+        const isOptionalOut = _catchall.optout === "optional";
         for (const key in input) {
             if (keySet.has(key))
                 continue;
@@ -1909,10 +1939,10 @@
             }
             const r = _catchall.run({ value: input[key], issues: [] }, ctx);
             if (r instanceof Promise) {
-                proms.push(r.then((r) => handlePropertyResult(r, payload, key, input)));
+                proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, isOptionalOut)));
             }
             else {
-                handlePropertyResult(r, payload, key, input);
+                handlePropertyResult(r, payload, key, input, isOptionalOut);
             }
         }
         if (unrecognized.length) {
@@ -1980,12 +2010,13 @@
             const shape = value.shape;
             for (const key of value.keys) {
                 const el = shape[key];
+                const isOptionalOut = el._zod.optout === "optional";
                 const r = el._zod.run({ value: input[key], issues: [] }, ctx);
                 if (r instanceof Promise) {
-                    proms.push(r.then((r) => handlePropertyResult(r, payload, key, input)));
+                    proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, isOptionalOut)));
                 }
                 else {
-                    handlePropertyResult(r, payload, key, input);
+                    handlePropertyResult(r, payload, key, input, isOptionalOut);
                 }
             }
             if (!catchall) {
@@ -2017,8 +2048,33 @@
             for (const key of normalized.keys) {
                 const id = ids[key];
                 const k = esc(key);
+                const schema = shape[key];
+                const isOptionalOut = schema?._zod?.optout === "optional";
                 doc.write(`const ${id} = ${parseStr(key)};`);
-                doc.write(`
+                if (isOptionalOut) {
+                    // For optional-out schemas, ignore errors on absent keys
+                    doc.write(`
+        if (${id}.issues.length) {
+          if (${k} in input) {
+            payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+              ...iss,
+              path: iss.path ? [${k}, ...iss.path] : [${k}]
+            })));
+          }
+        }
+        
+        if (${id}.value === undefined) {
+          if (${k} in input) {
+            newResult[${k}] = undefined;
+          }
+        } else {
+          newResult[${k}] = ${id}.value;
+        }
+        
+      `);
+                }
+                else {
+                    doc.write(`
         if (${id}.issues.length) {
           payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
             ...iss,
@@ -2026,7 +2082,6 @@
           })));
         }
         
-        
         if (${id}.value === undefined) {
           if (${k} in input) {
             newResult[${k}] = undefined;
@@ -2036,6 +2091,7 @@
         }
         
       `);
+                }
             }
             doc.write(`payload.value = newResult;`);
             doc.write(`return payload;`);
@@ -2271,11 +2327,38 @@
         return { valid: false, mergeErrorPath: [] };
     }
     function handleIntersectionResults(result, left, right) {
-        if (left.issues.length) {
-            result.issues.push(...left.issues);
+        // Track which side(s) report each key as unrecognized
+        const unrecKeys = new Map();
+        let unrecIssue;
+        for (const iss of left.issues) {
+            if (iss.code === "unrecognized_keys") {
+                unrecIssue ?? (unrecIssue = iss);
+                for (const k of iss.keys) {
+                    if (!unrecKeys.has(k))
+                        unrecKeys.set(k, {});
+                    unrecKeys.get(k).l = true;
+                }
+            }
+            else {
+                result.issues.push(iss);
+            }
+        }
+        for (const iss of right.issues) {
+            if (iss.code === "unrecognized_keys") {
+                for (const k of iss.keys) {
+                    if (!unrecKeys.has(k))
+                        unrecKeys.set(k, {});
+                    unrecKeys.get(k).r = true;
+                }
+            }
+            else {
+                result.issues.push(iss);
+            }
         }
-        if (right.issues.length) {
-            result.issues.push(...right.issues);
+        // Report only keys unrecognized by BOTH sides
+        const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
+        if (bothKeys.length && unrecIssue) {
+            result.issues.push({ ...unrecIssue, keys: bothKeys });
         }
         if (aborted(result))
             return result;
@@ -2345,10 +2428,22 @@
                 for (const key of Reflect.ownKeys(input)) {
                     if (key === "__proto__")
                         continue;
-                    const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+                    let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
                     if (keyResult instanceof Promise) {
                         throw new Error("Async schemas not supported in object keys currently");
                     }
+                    // Numeric string fallback: if key is a numeric string and failed, retry with Number(key)
+                    // This handles z.number(), z.literal([1, 2, 3]), and unions containing numeric literals
+                    const checkNumericKey = typeof key === "string" && number$1.test(key) && keyResult.issues.length;
+                    if (checkNumericKey) {
+                        const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
+                        if (retryResult instanceof Promise) {
+                            throw new Error("Async schemas not supported in object keys currently");
+                        }
+                        if (retryResult.issues.length === 0) {
+                            keyResult = retryResult;
+                        }
+                    }
                     if (keyResult.issues.length) {
                         if (def.mode === "loose") {
                             // Pass through unchanged
@@ -2488,6 +2583,17 @@
             return def.innerType._zod.run(payload, ctx);
         };
     });
+    const $ZodExactOptional = /*@__PURE__*/ $constructor("$ZodExactOptional", (inst, def) => {
+        // Call parent init - inherits optin/optout = "optional"
+        $ZodOptional.init(inst, def);
+        // Override values/pattern to NOT add undefined
+        defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+        defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern);
+        // Override parse to just delegate (no undefined handling)
+        inst._zod.parse = (payload, ctx) => {
+            return def.innerType._zod.run(payload, ctx);
+        };
+    });
     const $ZodNullable = /*@__PURE__*/ $constructor("$ZodNullable", (inst, def) => {
         $ZodType.init(inst, def);
         defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
@@ -2710,9 +2816,6 @@
             const meta = _meta[0];
             this._map.set(schema, meta);
             if (meta && typeof meta === "object" && "id" in meta) {
-                if (this._idmap.has(meta.id)) {
-                    throw new Error(`ID ${meta.id} already exists in the registry`);
-                }
                 this._idmap.set(meta.id, schema);
             }
             return this;
@@ -2753,12 +2856,14 @@
     (_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
     const globalRegistry = globalThis.__zod_globalRegistry;
 
+    // @__NO_SIDE_EFFECTS__
     function _string(Class, params) {
         return new Class({
             type: "string",
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _email(Class, params) {
         return new Class({
             type: "string",
@@ -2768,6 +2873,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _guid(Class, params) {
         return new Class({
             type: "string",
@@ -2777,6 +2883,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _uuid(Class, params) {
         return new Class({
             type: "string",
@@ -2786,6 +2893,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _uuidv4(Class, params) {
         return new Class({
             type: "string",
@@ -2796,6 +2904,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _uuidv6(Class, params) {
         return new Class({
             type: "string",
@@ -2806,6 +2915,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _uuidv7(Class, params) {
         return new Class({
             type: "string",
@@ -2816,6 +2926,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _url(Class, params) {
         return new Class({
             type: "string",
@@ -2825,6 +2936,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _emoji(Class, params) {
         return new Class({
             type: "string",
@@ -2834,6 +2946,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _nanoid(Class, params) {
         return new Class({
             type: "string",
@@ -2843,6 +2956,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _cuid(Class, params) {
         return new Class({
             type: "string",
@@ -2852,6 +2966,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _cuid2(Class, params) {
         return new Class({
             type: "string",
@@ -2861,6 +2976,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _ulid(Class, params) {
         return new Class({
             type: "string",
@@ -2870,6 +2986,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _xid(Class, params) {
         return new Class({
             type: "string",
@@ -2879,6 +2996,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _ksuid(Class, params) {
         return new Class({
             type: "string",
@@ -2888,6 +3006,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _ipv4(Class, params) {
         return new Class({
             type: "string",
@@ -2897,6 +3016,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _ipv6(Class, params) {
         return new Class({
             type: "string",
@@ -2906,6 +3026,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _cidrv4(Class, params) {
         return new Class({
             type: "string",
@@ -2915,6 +3036,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _cidrv6(Class, params) {
         return new Class({
             type: "string",
@@ -2924,6 +3046,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _base64(Class, params) {
         return new Class({
             type: "string",
@@ -2933,6 +3056,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _base64url(Class, params) {
         return new Class({
             type: "string",
@@ -2942,6 +3066,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _e164(Class, params) {
         return new Class({
             type: "string",
@@ -2951,6 +3076,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _jwt(Class, params) {
         return new Class({
             type: "string",
@@ -2960,6 +3086,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _isoDateTime(Class, params) {
         return new Class({
             type: "string",
@@ -2971,6 +3098,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _isoDate(Class, params) {
         return new Class({
             type: "string",
@@ -2979,6 +3107,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _isoTime(Class, params) {
         return new Class({
             type: "string",
@@ -2988,6 +3117,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _isoDuration(Class, params) {
         return new Class({
             type: "string",
@@ -2996,6 +3126,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _number(Class, params) {
         return new Class({
             type: "number",
@@ -3003,6 +3134,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _int(Class, params) {
         return new Class({
             type: "number",
@@ -3012,34 +3144,40 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _boolean(Class, params) {
         return new Class({
             type: "boolean",
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _any(Class) {
         return new Class({
             type: "any",
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _unknown(Class) {
         return new Class({
             type: "unknown",
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _never(Class, params) {
         return new Class({
             type: "never",
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _date(Class, params) {
         return new Class({
             type: "date",
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _lt(value, params) {
         return new $ZodCheckLessThan({
             check: "less_than",
@@ -3048,6 +3186,7 @@
             inclusive: false,
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _lte(value, params) {
         return new $ZodCheckLessThan({
             check: "less_than",
@@ -3056,6 +3195,7 @@
             inclusive: true,
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _gt(value, params) {
         return new $ZodCheckGreaterThan({
             check: "greater_than",
@@ -3064,6 +3204,7 @@
             inclusive: false,
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _gte(value, params) {
         return new $ZodCheckGreaterThan({
             check: "greater_than",
@@ -3072,6 +3213,7 @@
             inclusive: true,
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _multipleOf(value, params) {
         return new $ZodCheckMultipleOf({
             check: "multiple_of",
@@ -3079,6 +3221,7 @@
             value,
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _maxLength(maximum, params) {
         const ch = new $ZodCheckMaxLength({
             check: "max_length",
@@ -3087,6 +3230,7 @@
         });
         return ch;
     }
+    // @__NO_SIDE_EFFECTS__
     function _minLength(minimum, params) {
         return new $ZodCheckMinLength({
             check: "min_length",
@@ -3094,6 +3238,7 @@
             minimum,
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _length(length, params) {
         return new $ZodCheckLengthEquals({
             check: "length_equals",
@@ -3101,6 +3246,7 @@
             length,
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _regex(pattern, params) {
         return new $ZodCheckRegex({
             check: "string_format",
@@ -3109,6 +3255,7 @@
             pattern,
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _lowercase(params) {
         return new $ZodCheckLowerCase({
             check: "string_format",
@@ -3116,6 +3263,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _uppercase(params) {
         return new $ZodCheckUpperCase({
             check: "string_format",
@@ -3123,6 +3271,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _includes(includes, params) {
         return new $ZodCheckIncludes({
             check: "string_format",
@@ -3131,6 +3280,7 @@
             includes,
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _startsWith(prefix, params) {
         return new $ZodCheckStartsWith({
             check: "string_format",
@@ -3139,6 +3289,7 @@
             prefix,
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _endsWith(suffix, params) {
         return new $ZodCheckEndsWith({
             check: "string_format",
@@ -3147,6 +3298,7 @@
             suffix,
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _overwrite(tx) {
         return new $ZodCheckOverwrite({
             check: "overwrite",
@@ -3154,25 +3306,31 @@
         });
     }
     // normalize
+    // @__NO_SIDE_EFFECTS__
     function _normalize(form) {
         return _overwrite((input) => input.normalize(form));
     }
     // trim
+    // @__NO_SIDE_EFFECTS__
     function _trim() {
         return _overwrite((input) => input.trim());
     }
     // toLowerCase
+    // @__NO_SIDE_EFFECTS__
     function _toLowerCase() {
         return _overwrite((input) => input.toLowerCase());
     }
     // toUpperCase
+    // @__NO_SIDE_EFFECTS__
     function _toUpperCase() {
         return _overwrite((input) => input.toUpperCase());
     }
     // slugify
+    // @__NO_SIDE_EFFECTS__
     function _slugify() {
         return _overwrite((input) => slugify(input));
     }
+    // @__NO_SIDE_EFFECTS__
     function _array(Class, element, params) {
         return new Class({
             type: "array",
@@ -3184,6 +3342,7 @@
         });
     }
     // same as _custom but defaults to abort:false
+    // @__NO_SIDE_EFFECTS__
     function _refine(Class, fn, _params) {
         const schema = new Class({
             type: "custom",
@@ -3193,6 +3352,7 @@
         });
         return schema;
     }
+    // @__NO_SIDE_EFFECTS__
     function _superRefine(fn) {
         const ch = _check((payload) => {
             payload.addIssue = (issue$1) => {
@@ -3215,6 +3375,7 @@
         });
         return ch;
     }
+    // @__NO_SIDE_EFFECTS__
     function _check(fn, params) {
         const ch = new $ZodCheck({
             check: "custom",
@@ -3281,14 +3442,7 @@
                 schemaPath: [..._params.schemaPath, schema],
                 path: _params.path,
             };
-            const parent = schema._zod.parent;
-            if (parent) {
-                // schema was cloned from another schema
-                result.ref = parent;
-                process$1(parent, ctx, params);
-                ctx.seen.get(parent).isParent = true;
-            }
-            else if (schema._zod.processJSONSchema) {
+            if (schema._zod.processJSONSchema) {
                 schema._zod.processJSONSchema(ctx, result.schema, params);
             }
             else {
@@ -3299,6 +3453,14 @@
                 }
                 processor(schema, ctx, _json, params);
             }
+            const parent = schema._zod.parent;
+            if (parent) {
+                // Also set ref if processor didn't (for inheritance)
+                if (!result.ref)
+                    result.ref = parent;
+                process$1(parent, ctx, params);
+                ctx.seen.get(parent).isParent = true;
+            }
         }
         // metadata
         const meta = ctx.metadataRegistry.get(schema);
@@ -3324,6 +3486,18 @@
         const root = ctx.seen.get(schema);
         if (!root)
             throw new Error("Unprocessed schema. This is a bug in Zod.");
+        // Track ids to detect duplicates across different schemas
+        const idToSchema = new Map();
+        for (const entry of ctx.seen.entries()) {
+            const id = ctx.metadataRegistry.get(entry[0])?.id;
+            if (id) {
+                const existing = idToSchema.get(id);
+                if (existing && existing !== entry[0]) {
+                    throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
+                }
+                idToSchema.set(id, entry[0]);
+            }
+        }
         // returns a ref to the schema
         // defId will be empty if the ref points to an external schema (or #)
         const makeURI = (entry) => {
@@ -3425,43 +3599,84 @@
         }
     }
     function finalize(ctx, schema) {
-        //
-        // iterate over seen map;
         const root = ctx.seen.get(schema);
         if (!root)
             throw new Error("Unprocessed schema. This is a bug in Zod.");
-        // flatten _refs
+        // flatten refs - inherit properties from parent schemas
         const flattenRef = (zodSchema) => {
             const seen = ctx.seen.get(zodSchema);
+            // already processed
+            if (seen.ref === null)
+                return;
             const schema = seen.def ?? seen.schema;
             const _cached = { ...schema };
-            // already seen
-            if (seen.ref === null) {
-                return;
-            }
-            // flatten ref if defined
             const ref = seen.ref;
-            seen.ref = null; // prevent recursion
+            seen.ref = null; // prevent infinite recursion
             if (ref) {
                 flattenRef(ref);
+                const refSeen = ctx.seen.get(ref);
+                const refSchema = refSeen.schema;
                 // merge referenced schema into current
-                const refSchema = ctx.seen.get(ref).schema;
                 if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
+                    // older drafts can't combine $ref with other properties
                     schema.allOf = schema.allOf ?? [];
                     schema.allOf.push(refSchema);
                 }
                 else {
                     Object.assign(schema, refSchema);
-                    Object.assign(schema, _cached); // prevent overwriting any fields in the original schema
+                }
+                // restore child's own properties (child wins)
+                Object.assign(schema, _cached);
+                const isParentRef = zodSchema._zod.parent === ref;
+                // For parent chain, child is a refinement - remove parent-only properties
+                if (isParentRef) {
+                    for (const key in schema) {
+                        if (key === "$ref" || key === "allOf")
+                            continue;
+                        if (!(key in _cached)) {
+                            delete schema[key];
+                        }
+                    }
+                }
+                // When ref was extracted to $defs, remove properties that match the definition
+                if (refSchema.$ref && refSeen.def) {
+                    for (const key in schema) {
+                        if (key === "$ref" || key === "allOf")
+                            continue;
+                        if (key in refSeen.def && JSON.stringify(schema[key]) === JSON.stringify(refSeen.def[key])) {
+                            delete schema[key];
+                        }
+                    }
+                }
+            }
+            // If parent was extracted (has $ref), propagate $ref to this schema
+            // This handles cases like: readonly().meta({id}).describe()
+            // where processor sets ref to innerType but parent should be referenced
+            const parent = zodSchema._zod.parent;
+            if (parent && parent !== ref) {
+                // Ensure parent is processed first so its def has inherited properties
+                flattenRef(parent);
+                const parentSeen = ctx.seen.get(parent);
+                if (parentSeen?.schema.$ref) {
+                    schema.$ref = parentSeen.schema.$ref;
+                    // De-duplicate with parent's definition
+                    if (parentSeen.def) {
+                        for (const key in schema) {
+                            if (key === "$ref" || key === "allOf")
+                                continue;
+                            if (key in parentSeen.def && JSON.stringify(schema[key]) === JSON.stringify(parentSeen.def[key])) {
+                                delete schema[key];
+                            }
+                        }
+                    }
                 }
             }
             // execute overrides
-            if (!seen.isParent)
-                ctx.override({
-                    zodSchema: zodSchema,
-                    jsonSchema: schema,
-                    path: seen.path ?? [],
-                });
+            ctx.override({
+                zodSchema: zodSchema,
+                jsonSchema: schema,
+                path: seen.path ?? [],
+            });
         };
         for (const entry of [...ctx.seen.entries()].reverse()) {
             flattenRef(entry[0]);
@@ -3514,8 +3729,8 @@
                 value: {
                     ...schema["~standard"],
                     jsonSchema: {
-                        input: createStandardJSONSchemaMethod(schema, "input"),
-                        output: createStandardJSONSchemaMethod(schema, "output"),
+                        input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
+                        output: createStandardJSONSchemaMethod(schema, "output", ctx.processors),
                     },
                 },
                 enumerable: false,
@@ -3594,9 +3809,9 @@
         extractDefs(ctx, schema);
         return finalize(ctx, schema);
     };
-    const createStandardJSONSchemaMethod = (schema, io) => (params) => {
+    const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
         const { libraryOptions, target } = params ?? {};
-        const ctx = initializeContext({ ...(libraryOptions ?? {}), target, io, processors: {} });
+        const ctx = initializeContext({ ...(libraryOptions ?? {}), target, io, processors });
         process$1(schema, ctx);
         extractDefs(ctx, schema);
         return finalize(ctx, schema);
@@ -3624,6 +3839,11 @@
             json.format = formatMap[format] ?? format;
             if (json.format === "")
                 delete json.format; // empty format is not valid
+            // JSON Schema format: "time" requires a full time with offset or Z
+            // z.iso.time() does not include timezone information, so format: "time" should never be used
+            if (format === "time") {
+                delete json.format;
+            }
         }
         if (contentEncoding)
             json.contentEncoding = contentEncoding;
@@ -3862,16 +4082,44 @@
         const json = _json;
         const def = schema._zod.def;
         json.type = "object";
-        if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-            json.propertyNames = process$1(def.keyType, ctx, {
+        // For looseRecord with regex patterns, use patternProperties
+        // This correctly represents "only validate keys matching the pattern" semantics
+        // and composes well with allOf (intersections)
+        const keyType = def.keyType;
+        const keyBag = keyType._zod.bag;
+        const patterns = keyBag?.patterns;
+        if (def.mode === "loose" && patterns && patterns.size > 0) {
+            // Use patternProperties for looseRecord with regex patterns
+            const valueSchema = process$1(def.valueType, ctx, {
                 ...params,
-                path: [...params.path, "propertyNames"],
+                path: [...params.path, "patternProperties", "*"],
             });
+            json.patternProperties = {};
+            for (const pattern of patterns) {
+                json.patternProperties[pattern.source] = valueSchema;
+            }
+        }
+        else {
+            // Default behavior: use propertyNames + additionalProperties
+            if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
+                json.propertyNames = process$1(def.keyType, ctx, {
+                    ...params,
+                    path: [...params.path, "propertyNames"],
+                });
+            }
+            json.additionalProperties = process$1(def.valueType, ctx, {
+                ...params,
+                path: [...params.path, "additionalProperties"],
+            });
+        }
+        // Add required for keys with discrete values (enum, literal, etc.)
+        const keyValues = keyType._zod.values;
+        if (keyValues) {
+            const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
+            if (validKeyValues.length > 0) {
+                json.required = validKeyValues;
+            }
         }
-        json.additionalProperties = process$1(def.valueType, ctx, {
-            ...params,
-            path: [...params.path, "additionalProperties"],
-        });
     };
     const nullableProcessor = (schema, ctx, json, params) => {
         const def = schema._zod.def;
@@ -4049,8 +4297,11 @@
                     ...(def.checks ?? []),
                     ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch),
                 ],
-            }));
+            }), {
+                parent: true,
+            });
         };
+        inst.with = inst.check;
         inst.clone = (def, params) => clone(inst, def, params);
         inst.brand = () => inst;
         inst.register = ((reg, meta) => {
@@ -4078,6 +4329,7 @@
         inst.overwrite = (fn) => inst.check(_overwrite(fn));
         // wrappers
         inst.optional = () => optional(inst);
+        inst.exactOptional = () => exactOptional(inst);
         inst.nullable = () => nullable(inst);
         inst.nullish = () => optional(nullable(inst));
         inst.nonoptional = (params) => nonoptional(inst, params);
@@ -4114,6 +4366,7 @@
         // helpers
         inst.isOptional = () => inst.safeParse(undefined).success;
         inst.isNullable = () => inst.safeParse(null).success;
+        inst.apply = (fn) => fn(inst);
         return inst;
     });
     /** @internal */
@@ -4595,6 +4848,18 @@
             innerType: innerType,
         });
     }
+    const ZodExactOptional = /*@__PURE__*/ $constructor("ZodExactOptional", (inst, def) => {
+        $ZodExactOptional.init(inst, def);
+        ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
+        inst.unwrap = () => inst._zod.def.innerType;
+    });
+    function exactOptional(innerType) {
+        return new ZodExactOptional({
+            type: "optional",
+            innerType: innerType,
+        });
+    }
     const ZodNullable = /*@__PURE__*/ $constructor("ZodNullable", (inst, def) => {
         $ZodNullable.init(inst, def);
         ZodType.init(inst, def);