@vellumai/cli 0.10.5 → 0.10.6-dev.202607062124.26c976d

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/v4/core/schemas.d.ts

@@ -23,13 +23,8 @@ export interface ParseContextInternal<T extends errors.$ZodIssueBase = never> ex
 export interface ParsePayload<T = unknown> {
     value: T;
     issues: errors.$ZodRawIssue[];
-    /** A way to mark a whole payload as aborted. Used in codecs/pipes. */
+    /** A may to mark a whole payload as aborted. Used in codecs/pipes. */
     aborted?: boolean;
-    /** @internal Marks a value as a fallback that an outer wrapper (e.g.
-     * $ZodOptional) may override with its own interpretation when input was
-     * undefined. Set by $ZodCatch when catchValue substitutes and by every
-     * $ZodTransform invocation. */
-    fallback?: boolean | undefined;
 }
 export type CheckFn<T> = (input: ParsePayload<T>) => util.MaybeAsync<void>;
 export interface $ZodTypeDef {
@@ -187,33 +182,13 @@ export interface $ZodNanoID extends $ZodType {
     _zod: $ZodNanoIDInternals;
 }
 export declare const $ZodNanoID: core.$constructor<$ZodNanoID>;
-/**
- * @deprecated CUID v1 is deprecated by its authors due to information leakage
- * (timestamps embedded in the id). Use {@link $ZodCUID2} instead.
- * See https://github.com/paralleldrive/cuid.
- */
 export interface $ZodCUIDDef extends $ZodStringFormatDef<"cuid"> {
 }
-/**
- * @deprecated CUID v1 is deprecated by its authors due to information leakage
- * (timestamps embedded in the id). Use {@link $ZodCUID2} instead.
- * See https://github.com/paralleldrive/cuid.
- */
 export interface $ZodCUIDInternals extends $ZodStringFormatInternals<"cuid"> {
 }
-/**
- * @deprecated CUID v1 is deprecated by its authors due to information leakage
- * (timestamps embedded in the id). Use {@link $ZodCUID2} instead.
- * See https://github.com/paralleldrive/cuid.
- */
 export interface $ZodCUID extends $ZodType {
     _zod: $ZodCUIDInternals;
 }
-/**
- * @deprecated CUID v1 is deprecated by its authors due to information leakage
- * (timestamps embedded in the id). Use {@link $ZodCUID2} instead.
- * See https://github.com/paralleldrive/cuid.
- */
 export declare const $ZodCUID: core.$constructor<$ZodCUID>;
 export interface $ZodCUID2Def extends $ZodStringFormatDef<"cuid2"> {
 }
@@ -1035,19 +1010,6 @@ export interface $ZodCodec<A extends SomeType = $ZodType, B extends SomeType = $
     _zod: $ZodCodecInternals<A, B>;
 }
 export declare const $ZodCodec: core.$constructor<$ZodCodec>;
-export interface $ZodPreprocessDef<B extends SomeType = $ZodType> extends $ZodPipeDef<$ZodTransform, B> {
-    in: $ZodTransform;
-    out: B;
-}
-export interface $ZodPreprocessInternals<B extends SomeType = $ZodType> extends $ZodPipeInternals<$ZodTransform, B> {
-    def: $ZodPreprocessDef<B>;
-    optin: B["_zod"]["optin"];
-    optout: B["_zod"]["optout"];
-}
-export interface $ZodPreprocess<B extends SomeType = $ZodType> extends $ZodPipe<$ZodTransform, B> {
-    _zod: $ZodPreprocessInternals<B>;
-}
-export declare const $ZodPreprocess: core.$constructor<$ZodPreprocess>;
 export interface $ZodReadonlyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "readonly";
     innerType: T;

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/v4/core/schemas.js

@@ -35,8 +35,6 @@ export const $ZodType = /*@__PURE__*/ core.$constructor("$ZodType", (inst, def)
             let asyncResult;
             for (const ch of checks) {
                 if (ch._zod.def.when) {
-                    if (util.explicitlyAborted(payload))
-                        continue;
                     const shouldRun = ch._zod.def.when(payload);
                     if (!shouldRun)
                         continue;
@@ -190,21 +188,6 @@ export const $ZodURL = /*@__PURE__*/ core.$constructor("$ZodURL", (inst, def) =>
         try {
             // Trim whitespace from input
             const trimmed = payload.value.trim();
-            // When normalize is off, require :// for http/https URLs
-            // This prevents strings like "http:example.com" or "https:/path" from being silently accepted
-            if (!def.normalize && def.protocol?.source === regexes.httpProtocol.source) {
-                if (!/^https?:\/\//i.test(trimmed)) {
-                    payload.issues.push({
-                        code: "invalid_format",
-                        format: "url",
-                        note: "Invalid URL format",
-                        input: payload.value,
-                        inst,
-                        continue: !def.abort,
-                    });
-                    return;
-                }
-            }
             // @ts-ignore
             const url = new URL(trimmed);
             if (def.hostname) {
@@ -265,11 +248,6 @@ export const $ZodNanoID = /*@__PURE__*/ core.$constructor("$ZodNanoID", (inst, d
     def.pattern ?? (def.pattern = regexes.nanoid);
     $ZodStringFormat.init(inst, def);
 });
-/**
- * @deprecated CUID v1 is deprecated by its authors due to information leakage
- * (timestamps embedded in the id). Use {@link $ZodCUID2} instead.
- * See https://github.com/paralleldrive/cuid.
- */
 export const $ZodCUID = /*@__PURE__*/ core.$constructor("$ZodCUID", (inst, def) => {
     def.pattern ?? (def.pattern = regexes.cuid);
     $ZodStringFormat.init(inst, def);
@@ -375,9 +353,6 @@ export const $ZodCIDRv6 = /*@__PURE__*/ core.$constructor("$ZodCIDRv6", (inst, d
 export function isValidBase64(data) {
     if (data === "")
         return true;
-    // atob ignores whitespace, so reject it up front.
-    if (/\s/.test(data))
-        return false;
     if (data.length % 4 !== 0)
         return false;
     try {
@@ -582,6 +557,8 @@ export const $ZodUndefined = /*@__PURE__*/ core.$constructor("$ZodUndefined", (i
     $ZodType.init(inst, def);
     inst._zod.pattern = regexes.undefined;
     inst._zod.values = new Set([undefined]);
+    inst._zod.optin = "optional";
+    inst._zod.optout = "optional";
     inst._zod.parse = (payload, _ctx) => {
         const input = payload.value;
         if (typeof input === "undefined")
@@ -711,28 +688,16 @@ export const $ZodArray = /*@__PURE__*/ core.$constructor("$ZodArray", (inst, def
         return payload; //handleArrayResultsAsync(parseResults, final);
     };
 });
-function handlePropertyResult(result, final, key, input, isOptionalIn, isOptionalOut) {
-    const isPresent = key in input;
+function handlePropertyResult(result, final, key, input, isOptionalOut) {
     if (result.issues.length) {
-        // For optional-in/out schemas, ignore errors on absent keys.
-        if (isOptionalIn && isOptionalOut && !isPresent) {
+        // For optional-out schemas, ignore errors on absent keys
+        if (isOptionalOut && !(key in input)) {
             return;
         }
         final.issues.push(...util.prefixIssues(key, result.issues));
     }
-    if (!isPresent && !isOptionalIn) {
-        if (!result.issues.length) {
-            final.issues.push({
-                code: "invalid_type",
-                expected: "nonoptional",
-                input: undefined,
-                path: [key],
-            });
-        }
-        return;
-    }
     if (result.value === undefined) {
-        if (isPresent) {
+        if (key in input) {
             final.value[key] = undefined;
         }
     }
@@ -758,16 +723,12 @@ function normalizeDef(def) {
 }
 function handleCatchall(proms, input, payload, ctx, def, inst) {
     const unrecognized = [];
+    // iterate over input keys
     const keySet = def.keySet;
     const _catchall = def.catchall._zod;
     const t = _catchall.def.type;
-    const isOptionalIn = _catchall.optin === "optional";
     const isOptionalOut = _catchall.optout === "optional";
     for (const key in input) {
-        // skip __proto__ so it can't replace the result prototype via the
-        // assignment setter on the plain {} we build into
-        if (key === "__proto__")
-            continue;
         if (keySet.has(key))
             continue;
         if (t === "never") {
@@ -776,10 +737,10 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
         }
         const r = _catchall.run({ value: input[key], issues: [] }, ctx);
         if (r instanceof Promise) {
-            proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut)));
+            proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, isOptionalOut)));
         }
         else {
-            handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
+            handlePropertyResult(r, payload, key, input, isOptionalOut);
         }
     }
     if (unrecognized.length) {
@@ -847,14 +808,13 @@ export const $ZodObject = /*@__PURE__*/ core.$constructor("$ZodObject", (inst, d
         const shape = value.shape;
         for (const key of value.keys) {
             const el = shape[key];
-            const isOptionalIn = el._zod.optin === "optional";
             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, isOptionalIn, isOptionalOut)));
+                proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, isOptionalOut)));
             }
             else {
-                handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
+                handlePropertyResult(r, payload, key, input, isOptionalOut);
             }
         }
         if (!catchall) {
@@ -887,11 +847,10 @@ export const $ZodObjectJIT = /*@__PURE__*/ core.$constructor("$ZodObjectJIT", (i
             const id = ids[key];
             const k = util.esc(key);
             const schema = shape[key];
-            const isOptionalIn = schema?._zod?.optin === "optional";
             const isOptionalOut = schema?._zod?.optout === "optional";
             doc.write(`const ${id} = ${parseStr(key)};`);
-            if (isOptionalIn && isOptionalOut) {
-                // For optional-in/out schemas, ignore errors on absent keys
+            if (isOptionalOut) {
+                // For optional-out schemas, ignore errors on absent keys
                 doc.write(`
         if (${id}.issues.length) {
           if (${k} in input) {
@@ -910,34 +869,6 @@ export const $ZodObjectJIT = /*@__PURE__*/ core.$constructor("$ZodObjectJIT", (i
           newResult[${k}] = ${id}.value;
         }
         
-      `);
-            }
-            else if (!isOptionalIn) {
-                doc.write(`
-        const ${id}_present = ${k} in input;
-        if (${id}.issues.length) {
-          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
-            ...iss,
-            path: iss.path ? [${k}, ...iss.path] : [${k}]
-          })));
-        }
-        if (!${id}_present && !${id}.issues.length) {
-          payload.issues.push({
-            code: "invalid_type",
-            expected: "nonoptional",
-            input: undefined,
-            path: [${k}]
-          });
-        }
-
-        if (${id}_present) {
-          if (${id}.value === undefined) {
-            newResult[${k}] = undefined;
-          } else {
-            newResult[${k}] = ${id}.value;
-          }
-        }
-
       `);
             }
             else {
@@ -1033,9 +964,10 @@ export const $ZodUnion = /*@__PURE__*/ core.$constructor("$ZodUnion", (inst, def
         }
         return undefined;
     });
-    const first = def.options.length === 1 ? def.options[0]._zod.run : null;
+    const single = def.options.length === 1;
+    const first = def.options[0]._zod.run;
     inst._zod.parse = (payload, ctx) => {
-        if (first) {
+        if (single) {
             return first(payload, ctx);
         }
         let async = false;
@@ -1092,9 +1024,10 @@ function handleExclusiveUnionResults(results, final, inst, ctx) {
 export const $ZodXor = /*@__PURE__*/ core.$constructor("$ZodXor", (inst, def) => {
     $ZodUnion.init(inst, def);
     def.inclusive = false;
-    const first = def.options.length === 1 ? def.options[0]._zod.run : null;
+    const single = def.options.length === 1;
+    const first = def.options[0]._zod.run;
     inst._zod.parse = (payload, ctx) => {
-        if (first) {
+        if (single) {
             return first(payload, ctx);
         }
         let async = false;
@@ -1172,11 +1105,7 @@ core.$constructor("$ZodDiscriminatedUnion", (inst, def) => {
         if (opt) {
             return opt._zod.run(payload, ctx);
         }
-        // Fall back to union matching when the fast discriminator path fails:
-        // - explicitly enabled via unionFallback, or
-        // - during backward direction (encode), since codec-based discriminators
-        //   have different values in forward vs backward directions
-        if (def.unionFallback || ctx.direction === "backward") {
+        if (def.unionFallback) {
             return _super(payload, ctx);
         }
         // no matching discriminator
@@ -1185,7 +1114,6 @@ core.$constructor("$ZodDiscriminatedUnion", (inst, def) => {
             errors: [],
             note: "No matching discriminator",
             discriminator: def.discriminator,
-            options: Array.from(disc.value.keys()),
             input,
             path: [def.discriminator],
             inst,
@@ -1313,112 +1241,67 @@ export const $ZodTuple = /*@__PURE__*/ core.$constructor("$ZodTuple", (inst, def
         }
         payload.value = [];
         const proms = [];
-        const optinStart = getTupleOptStart(items, "optin");
-        const optoutStart = getTupleOptStart(items, "optout");
+        const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
+        const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex;
         if (!def.rest) {
-            if (input.length < optinStart) {
+            const tooBig = input.length > items.length;
+            const tooSmall = input.length < optStart - 1;
+            if (tooBig || tooSmall) {
                 payload.issues.push({
-                    code: "too_small",
-                    minimum: optinStart,
-                    inclusive: true,
+                    ...(tooBig
+                        ? { code: "too_big", maximum: items.length, inclusive: true }
+                        : { code: "too_small", minimum: items.length }),
                     input,
                     inst,
                     origin: "array",
                 });
                 return payload;
             }
-            if (input.length > items.length) {
-                payload.issues.push({
-                    code: "too_big",
-                    maximum: items.length,
-                    inclusive: true,
-                    input,
-                    inst,
-                    origin: "array",
-                });
-            }
         }
-        // Run every item in parallel, collecting results into an indexed
-        // array. The post-processing in `handleTupleResults` walks them in
-        // order so it can decide whether an absent optional-output error can
-        // truncate the tail or must be reported to preserve required output.
-        const itemResults = new Array(items.length);
-        for (let i = 0; i < items.length; i++) {
-            const r = items[i]._zod.run({ value: input[i], issues: [] }, ctx);
-            if (r instanceof Promise) {
-                proms.push(r.then((rr) => {
-                    itemResults[i] = rr;
-                }));
+        let i = -1;
+        for (const item of items) {
+            i++;
+            if (i >= input.length)
+                if (i >= optStart)
+                    continue;
+            const result = item._zod.run({
+                value: input[i],
+                issues: [],
+            }, ctx);
+            if (result instanceof Promise) {
+                proms.push(result.then((result) => handleTupleResult(result, payload, i)));
             }
             else {
-                itemResults[i] = r;
+                handleTupleResult(result, payload, i);
             }
         }
         if (def.rest) {
-            let i = items.length - 1;
             const rest = input.slice(items.length);
             for (const el of rest) {
                 i++;
-                const result = def.rest._zod.run({ value: el, issues: [] }, ctx);
+                const result = def.rest._zod.run({
+                    value: el,
+                    issues: [],
+                }, ctx);
                 if (result instanceof Promise) {
-                    proms.push(result.then((r) => handleTupleResult(r, payload, i)));
+                    proms.push(result.then((result) => handleTupleResult(result, payload, i)));
                 }
                 else {
                     handleTupleResult(result, payload, i);
                 }
             }
         }
-        if (proms.length) {
-            return Promise.all(proms).then(() => handleTupleResults(itemResults, payload, items, input, optoutStart));
-        }
-        return handleTupleResults(itemResults, payload, items, input, optoutStart);
+        if (proms.length)
+            return Promise.all(proms).then(() => payload);
+        return payload;
     };
 });
-function getTupleOptStart(items, key) {
-    for (let i = items.length - 1; i >= 0; i--) {
-        if (items[i]._zod[key] !== "optional")
-            return i + 1;
-    }
-    return 0;
-}
 function handleTupleResult(result, final, index) {
     if (result.issues.length) {
         final.issues.push(...util.prefixIssues(index, result.issues));
     }
     final.value[index] = result.value;
 }
-function handleTupleResults(itemResults, final, items, input, optoutStart) {
-    // Walk results in order. Mirror $ZodObject's swallow-on-absent-optional
-    // rule, but only after `optoutStart`: the first index where the output
-    // tuple tail can be absent.
-    for (let i = 0; i < items.length; i++) {
-        const r = itemResults[i];
-        const isPresent = i < input.length;
-        if (r.issues.length) {
-            if (!isPresent && i >= optoutStart) {
-                final.value.length = i;
-                break;
-            }
-            final.issues.push(...util.prefixIssues(i, r.issues));
-        }
-        final.value[i] = r.value;
-    }
-    // Drop trailing slots that produced `undefined` for absent input
-    // (the array analog of an absent optional key on an object). The
-    // `i >= input.length` floor is critical: an explicit `undefined`
-    // *inside* the input must be preserved even when the schema is
-    // optional-out (e.g. `z.string().or(z.undefined())` accepting an
-    // explicit undefined value).
-    for (let i = final.value.length - 1; i >= input.length; i--) {
-        if (items[i]._zod.optout === "optional" && final.value[i] === undefined) {
-            final.value.length = i;
-        }
-        else {
-            break;
-        }
-    }
-    return final;
-}
 export const $ZodRecord = /*@__PURE__*/ core.$constructor("$ZodRecord", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.parse = (payload, ctx) => {
@@ -1440,36 +1323,20 @@ export const $ZodRecord = /*@__PURE__*/ core.$constructor("$ZodRecord", (inst, d
             for (const key of values) {
                 if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
                     recordKeys.add(typeof key === "number" ? key.toString() : key);
-                    const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
-                    if (keyResult instanceof Promise) {
-                        throw new Error("Async schemas not supported in object keys currently");
-                    }
-                    if (keyResult.issues.length) {
-                        payload.issues.push({
-                            code: "invalid_key",
-                            origin: "record",
-                            issues: keyResult.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),
-                            input: key,
-                            path: [key],
-                            inst,
-                        });
-                        continue;
-                    }
-                    const outKey = keyResult.value;
                     const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
                     if (result instanceof Promise) {
                         proms.push(result.then((result) => {
                             if (result.issues.length) {
                                 payload.issues.push(...util.prefixIssues(key, result.issues));
                             }
-                            payload.value[outKey] = result.value;
+                            payload.value[key] = result.value;
                         }));
                     }
                     else {
                         if (result.issues.length) {
                             payload.issues.push(...util.prefixIssues(key, result.issues));
                         }
-                        payload.value[outKey] = result.value;
+                        payload.value[key] = result.value;
                     }
                 }
             }
@@ -1491,12 +1358,9 @@ export const $ZodRecord = /*@__PURE__*/ core.$constructor("$ZodRecord", (inst, d
         }
         else {
             payload.value = {};
-            // Reflect.ownKeys for Symbol-key support; filter non-enumerable to match z.object()
             for (const key of Reflect.ownKeys(input)) {
                 if (key === "__proto__")
                     continue;
-                if (!Object.prototype.propertyIsEnumerable.call(input, key))
-                    continue;
                 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");
@@ -1717,7 +1581,6 @@ export const $ZodFile = /*@__PURE__*/ core.$constructor("$ZodFile", (inst, def)
 });
 export const $ZodTransform = /*@__PURE__*/ core.$constructor("$ZodTransform", (inst, def) => {
     $ZodType.init(inst, def);
-    inst._zod.optin = "optional";
     inst._zod.parse = (payload, ctx) => {
         if (ctx.direction === "backward") {
             throw new core.$ZodEncodeError(inst.constructor.name);
@@ -1727,7 +1590,6 @@ export const $ZodTransform = /*@__PURE__*/ core.$constructor("$ZodTransform", (i
             const output = _out instanceof Promise ? _out : Promise.resolve(_out);
             return output.then((output) => {
                 payload.value = output;
-                payload.fallback = true;
                 return payload;
             });
         }
@@ -1735,12 +1597,11 @@ export const $ZodTransform = /*@__PURE__*/ core.$constructor("$ZodTransform", (i
             throw new core.$ZodAsyncError();
         }
         payload.value = _out;
-        payload.fallback = true;
         return payload;
     };
 });
 function handleOptionalResult(result, input) {
-    if (input === undefined && (result.issues.length || result.fallback)) {
+    if (result.issues.length && input === undefined) {
         return { issues: [], value: undefined };
     }
     return result;
@@ -1758,11 +1619,10 @@ export const $ZodOptional = /*@__PURE__*/ core.$constructor("$ZodOptional", (ins
     });
     inst._zod.parse = (payload, ctx) => {
         if (def.innerType._zod.optin === "optional") {
-            const input = payload.value;
             const result = def.innerType._zod.run(payload, ctx);
             if (result instanceof Promise)
-                return result.then((r) => handleOptionalResult(r, input));
-            return handleOptionalResult(result, input);
+                return result.then((r) => handleOptionalResult(r, payload.value));
+            return handleOptionalResult(result, payload.value);
         }
         if (payload.value === undefined) {
             return payload;
@@ -1889,7 +1749,7 @@ export const $ZodSuccess = /*@__PURE__*/ core.$constructor("$ZodSuccess", (inst,
 });
 export const $ZodCatch = /*@__PURE__*/ core.$constructor("$ZodCatch", (inst, def) => {
     $ZodType.init(inst, def);
-    inst._zod.optin = "optional";
+    util.defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
     util.defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
     util.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
     inst._zod.parse = (payload, ctx) => {
@@ -1910,7 +1770,6 @@ export const $ZodCatch = /*@__PURE__*/ core.$constructor("$ZodCatch", (inst, def
                         input: payload.value,
                     });
                     payload.issues = [];
-                    payload.fallback = true;
                 }
                 return payload;
             });
@@ -1925,7 +1784,6 @@ export const $ZodCatch = /*@__PURE__*/ core.$constructor("$ZodCatch", (inst, def
                 input: payload.value,
             });
             payload.issues = [];
-            payload.fallback = true;
         }
         return payload;
     };
@@ -1972,7 +1830,7 @@ function handlePipeResult(left, next, ctx) {
         left.aborted = true;
         return left;
     }
-    return next._zod.run({ value: left.value, issues: left.issues, fallback: left.fallback }, ctx);
+    return next._zod.run({ value: left.value, issues: left.issues }, ctx);
 }
 export const $ZodCodec = /*@__PURE__*/ core.$constructor("$ZodCodec", (inst, def) => {
     $ZodType.init(inst, def);
@@ -2028,9 +1886,6 @@ function handleCodecTxResult(left, value, nextSchema, ctx) {
     }
     return nextSchema._zod.run({ value, issues: left.issues }, ctx);
 }
-export const $ZodPreprocess = /*@__PURE__*/ core.$constructor("$ZodPreprocess", (inst, def) => {
-    $ZodPipe.init(inst, def);
-});
 export const $ZodReadonly = /*@__PURE__*/ core.$constructor("$ZodReadonly", (inst, def) => {
     $ZodType.init(inst, def);
     util.defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
@@ -2188,15 +2043,14 @@ export const $ZodPromise = /*@__PURE__*/ core.$constructor("$ZodPromise", (inst,
 });
 export const $ZodLazy = /*@__PURE__*/ core.$constructor("$ZodLazy", (inst, def) => {
     $ZodType.init(inst, def);
-    // Cache the resolved inner type on the shared `def` so all clones of this
-    // lazy (e.g. via `.describe()`/`.meta()`) share the same inner instance,
-    // preserving identity for cycle detection on recursive schemas.
-    util.defineLazy(inst._zod, "innerType", () => {
-        const d = def;
-        if (!d._cachedInner)
-            d._cachedInner = def.getter();
-        return d._cachedInner;
-    });
+    // let _innerType!: any;
+    // util.defineLazy(def, "getter", () => {
+    //   if (!_innerType) {
+    //     _innerType = def.getter();
+    //   }
+    //   return () => _innerType;
+    // });
+    util.defineLazy(inst._zod, "innerType", () => def.getter());
     util.defineLazy(inst._zod, "pattern", () => inst._zod.innerType?._zod?.pattern);
     util.defineLazy(inst._zod, "propValues", () => inst._zod.innerType?._zod?.propValues);
     util.defineLazy(inst._zod, "optin", () => inst._zod.innerType?._zod?.optin ?? undefined);

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/v4/core/to-json-schema.cjs

@@ -93,7 +93,7 @@ function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
         delete result.schema.default;
     }
     // set prefault as default
-    if (ctx.io === "input" && "_prefault" in result.schema)
+    if (ctx.io === "input" && result.schema._prefault)
         (_a = result.schema).default ?? (_a.default = result.schema._prefault);
     delete result.schema._prefault;
     // pulling fresh from ctx.seen in case it was overwritten
@@ -325,20 +325,11 @@ function finalize(ctx, schema) {
         result.$id = ctx.external.uri(id);
     }
     Object.assign(result, root.def ?? root.schema);
-    // The `id` in `.meta()` is a Zod-specific registration tag used to extract
-    // schemas into $defs — it is not user-facing JSON Schema metadata. Strip it
-    // from the output body where it would otherwise leak. The id is preserved
-    // implicitly via the $defs key (and via $ref paths).
-    const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
-    if (rootMetaId !== undefined && result.id === rootMetaId)
-        delete result.id;
     // build defs object
     const defs = ctx.external?.defs ?? {};
     for (const entry of ctx.seen.entries()) {
         const seen = entry[1];
         if (seen.def && seen.defId) {
-            if (seen.def.id === seen.defId)
-                delete seen.def.id;
             defs[seen.defId] = seen.def;
         }
     }
@@ -407,8 +398,6 @@ function isTransforming(_schema, _ctx) {
         return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
     }
     if (def.type === "pipe") {
-        if (_schema._zod.traits.has("$ZodCodec"))
-            return true;
         return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
     }
     if (def.type === "object") {