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

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/core/tests/record-constructor.test.ts

@@ -65,61 +65,3 @@ test("record should work with different key types and constructor field", () =>
   const result = enumSchema.parse({ constructor: "value1", key: "value2" });
   expect(result).toEqual({ constructor: "value1", key: "value2" });
 });
-
-test("record should skip non-enumerable own properties", () => {
-  const schema = z.record(z.string(), z.string());
-
-  const input = { key: "value" };
-  Object.defineProperty(input, "~standard", {
-    value: { validate: () => {}, vendor: "zod", version: 1 },
-    enumerable: false,
-    writable: false,
-    configurable: false,
-  });
-
-  const result = schema.safeParse(input);
-  expect(result.success).toBe(true);
-  if (result.success) {
-    expect(result.data).toEqual({ key: "value" });
-    expect("~standard" in result.data).toBe(false);
-  }
-});
-
-test("record fails on enumerable invalid values even when non-enumerable properties are present", () => {
-  const schema = z.record(z.string(), z.string());
-
-  const input = { key: "value", bad: 123 };
-  Object.defineProperty(input, "hidden", {
-    value: "should be ignored",
-    enumerable: false,
-  });
-
-  const result = schema.safeParse(input);
-  expect(result.success).toBe(false);
-});
-
-test("record validates enumerable Symbol keys and skips non-enumerable Symbol keys", () => {
-  const enumerableSym = Symbol.for("included");
-  const nonEnumerableSym = Symbol.for("hidden");
-  const schema = z.record(z.symbol(), z.string());
-
-  const input: Record<symbol, unknown> = { [enumerableSym]: "value" };
-  Object.defineProperty(input, nonEnumerableSym, {
-    value: 123,
-    enumerable: false,
-  });
-
-  const result = schema.safeParse(input);
-  expect(result.success).toBe(true);
-  if (result.success) {
-    expect(result.data[enumerableSym]).toBe("value");
-    expect(Object.prototype.hasOwnProperty.call(result.data, nonEnumerableSym)).toBe(false);
-  }
-});
-
-test("z.json() accepts z.toJSONSchema() output (issue #5714)", () => {
-  const schema = z.object({ name: z.string() });
-  const jsonSchema = z.toJSONSchema(schema);
-
-  expect(z.json().safeParse(jsonSchema).success).toBe(true);
-});

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

@@ -205,7 +205,7 @@ export function process<T extends schemas.$ZodType>(
   }
 
   // set prefault as default
-  if (ctx.io === "input" && "_prefault" in result.schema) result.schema.default ??= result.schema._prefault;
+  if (ctx.io === "input" && result.schema._prefault) result.schema.default ??= result.schema._prefault;
   delete result.schema._prefault;
 
   // pulling fresh from ctx.seen in case it was overwritten
@@ -471,19 +471,11 @@ export function finalize<T extends schemas.$ZodType>(
 
   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: JSONSchema.BaseSchema["$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;
     }
   }
@@ -561,7 +553,6 @@ function isTransforming(
     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);
   }
 

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

@@ -1,5 +1,4 @@
 import type * as checks from "./checks.js";
-import { globalConfig } from "./core.js";
 import type { $ZodConfig } from "./core.js";
 import type * as errors from "./errors.js";
 import type * as schemas from "./schemas.js";
@@ -246,15 +245,23 @@ export function cleanRegex(source: string): string {
 }
 
 export function floatSafeRemainder(val: number, step: number): number {
-  const ratio = val / step;
-  const roundedRatio = Math.round(ratio);
-  // Use a relative epsilon scaled to the magnitude of the result
-  const tolerance = Number.EPSILON * Math.max(Math.abs(ratio), 1);
-  if (Math.abs(ratio - roundedRatio) < tolerance) return 0;
-  return ratio - roundedRatio;
+  const valDecCount = (val.toString().split(".")[1] || "").length;
+  const stepString = step.toString();
+  let stepDecCount = (stepString.split(".")[1] || "").length;
+  if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
+    const match = stepString.match(/\d?e-(\d?)/);
+    if (match?.[1]) {
+      stepDecCount = Number.parseInt(match[1]);
+    }
+  }
+
+  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
+  const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
+  const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
+  return (valInt % stepInt) / 10 ** decCount;
 }
 
-const EVALUATING = /* @__PURE__*/ Symbol("evaluating");
+const EVALUATING = Symbol("evaluating");
 
 export function defineLazy<T, K extends keyof T>(object: T, key: K, getter: () => T[K]): void {
   let value: T[K] | typeof EVALUATING | undefined = undefined;
@@ -361,13 +368,7 @@ export function isObject(data: any): data is Record<PropertyKey, unknown> {
   return typeof data === "object" && data !== null && !Array.isArray(data);
 }
 
-export const allowsEval: { value: boolean } = /* @__PURE__*/ cached(() => {
-  // Skip the probe under `jitless`: strict CSPs report the caught `new Function`
-  // as a `securitypolicyviolation` even though the throw is swallowed.
-  if (globalConfig.jitless) {
-    return false;
-  }
-
+export const allowsEval: { value: boolean } = cached(() => {
   // @ts-ignore
   if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
     return false;
@@ -406,8 +407,6 @@ export function isPlainObject(o: any): o is Record<PropertyKey, unknown> {
 export function shallowClone(o: any): any {
   if (isPlainObject(o)) return { ...o };
   if (Array.isArray(o)) return [...o];
-  if (o instanceof Map) return new Map(o);
-  if (o instanceof Set) return new Set(o);
   return o;
 }
 
@@ -476,15 +475,8 @@ export const getParsedType = (data: any): ParsedTypes => {
   }
 };
 
-export const propertyKeyTypes: Set<string> = /* @__PURE__*/ new Set(["string", "number", "symbol"]);
-export const primitiveTypes: Set<string> = /* @__PURE__*/ new Set([
-  "string",
-  "number",
-  "bigint",
-  "boolean",
-  "symbol",
-  "undefined",
-]);
+export const propertyKeyTypes: Set<string> = new Set(["string", "number", "symbol"]);
+export const primitiveTypes: Set<string> = new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
 export function escapeRegex(str: string): string {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -699,9 +691,6 @@ export function safeExtend(schema: schemas.$ZodObject, shape: schemas.$ZodShape)
 }
 
 export function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any {
-  if (a._zod.def.checks?.length) {
-    throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
-  }
   const def = mergeDefs(a._zod.def, {
     get shape() {
       const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
@@ -711,7 +700,7 @@ export function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any {
     get catchall() {
       return b._zod.def.catchall;
     },
-    checks: b._zod.def.checks ?? [],
+    checks: [], // delete existing checks
   });
 
   return clone(a, def) as any;
@@ -822,18 +811,6 @@ export function aborted(x: schemas.ParsePayload, startIndex = 0): boolean {
   return false;
 }
 
-// Checks for explicit abort (continue === false), as opposed to implicit abort (continue === undefined).
-// Used to respect `abort: true` in .refine() even for checks that have a `when` function.
-export function explicitlyAborted(x: schemas.ParsePayload, startIndex = 0): boolean {
-  if (x.aborted === true) return true;
-  for (let i = startIndex; i < x.issues.length; i++) {
-    if (x.issues[i]?.continue === false) {
-      return true;
-    }
-  }
-  return false;
-}
-
 export function prefixIssues(path: PropertyKey, issues: errors.$ZodRawIssue[]): errors.$ZodRawIssue[] {
   return issues.map((iss) => {
     (iss as any).path ??= [];
@@ -851,21 +828,27 @@ export function finalizeIssue(
   ctx: schemas.ParseContextInternal | undefined,
   config: $ZodConfig
 ): errors.$ZodIssue {
-  const message = iss.message
-    ? iss.message
-    : (unwrapMessage(iss.inst?._zod.def?.error?.(iss as never)) ??
+  const full = { ...iss, path: iss.path ?? [] } as errors.$ZodIssue;
+
+  // for backwards compatibility
+  if (!iss.message) {
+    const message =
+      unwrapMessage(iss.inst?._zod.def?.error?.(iss as never)) ??
       unwrapMessage(ctx?.error?.(iss as never)) ??
       unwrapMessage(config.customError?.(iss)) ??
       unwrapMessage(config.localeError?.(iss)) ??
-      "Invalid input");
+      "Invalid input";
+    (full as any).message = message;
+  }
 
-  const { inst: _inst, continue: _continue, input: _input, ...rest } = iss as any;
-  rest.path ??= [];
-  rest.message = message;
-  if (ctx?.reportInput) {
-    rest.input = _input;
+  // delete (full as any).def;
+  delete (full as any).inst;
+  delete (full as any).continue;
+  if (!ctx?.reportInput) {
+    delete (full as any).input;
   }
-  return rest;
+
+  return full;
 }
 
 export function getSizableOrigin(input: any): "set" | "map" | "file" | "unknown" {

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

@@ -1,5 +1,5 @@
 export const version = {
   major: 4,
-  minor: 4,
-  patch: 3 as number,
+  minor: 3,
+  patch: 6 as number,
 } as const;

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/locales/en.ts

@@ -103,10 +103,6 @@ const error: () => errors.$ZodErrorMap = () => {
       case "invalid_key":
         return `Invalid key in ${issue.origin}`;
       case "invalid_union":
-        if (issue.options && Array.isArray(issue.options) && issue.options.length > 0) {
-          const opts = issue.options.map((o) => `'${o}'`).join(" | ");
-          return `Invalid discriminator value. Expected ${opts}`;
-        }
         return "Invalid input";
       case "invalid_element":
         return `Invalid value in ${issue.origin}`;

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/locales/fr.ts

@@ -50,27 +50,9 @@ const error: () => errors.$ZodErrorMap = () => {
   const TypeDictionary: {
     [k in errors.$ZodInvalidTypeExpected | (string & {})]?: string;
   } = {
-    string: "chaîne",
+    nan: "NaN",
     number: "nombre",
-    int: "entier",
-    boolean: "booléen",
-    bigint: "grand entier",
-    symbol: "symbole",
-    undefined: "indéfini",
-    null: "null",
-    never: "jamais",
-    void: "vide",
-    date: "date",
     array: "tableau",
-    object: "objet",
-    tuple: "tuple",
-    record: "enregistrement",
-    map: "carte",
-    set: "ensemble",
-    file: "fichier",
-    nonoptional: "non-optionnel",
-    nan: "NaN",
-    function: "fonction",
   };
 
   return (issue) => {
@@ -91,15 +73,17 @@ const error: () => errors.$ZodErrorMap = () => {
         const adj = issue.inclusive ? "<=" : "<";
         const sizing = getSizing(issue.origin);
         if (sizing)
-          return `Trop grand : ${TypeDictionary[issue.origin] ?? "valeur"} doit ${sizing.verb} ${adj}${issue.maximum.toString()} ${sizing.unit ?? "élément(s)"}`;
-        return `Trop grand : ${TypeDictionary[issue.origin] ?? "valeur"} doit être ${adj}${issue.maximum.toString()}`;
+          return `Trop grand : ${issue.origin ?? "valeur"} doit ${sizing.verb} ${adj}${issue.maximum.toString()} ${sizing.unit ?? "élément(s)"}`;
+        return `Trop grand : ${issue.origin ?? "valeur"} doit être ${adj}${issue.maximum.toString()}`;
       }
       case "too_small": {
         const adj = issue.inclusive ? ">=" : ">";
         const sizing = getSizing(issue.origin);
-        if (sizing)
-          return `Trop petit : ${TypeDictionary[issue.origin] ?? "valeur"} doit ${sizing.verb} ${adj}${issue.minimum.toString()} ${sizing.unit}`;
-        return `Trop petit : ${TypeDictionary[issue.origin] ?? "valeur"} doit être ${adj}${issue.minimum.toString()}`;
+        if (sizing) {
+          return `Trop petit : ${issue.origin} doit ${sizing.verb} ${adj}${issue.minimum.toString()} ${sizing.unit}`;
+        }
+
+        return `Trop petit : ${issue.origin} doit être ${adj}${issue.minimum.toString()}`;
       }
       case "invalid_format": {
         const _issue = issue as errors.$ZodStringFormatIssues;

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/locales/index.ts

@@ -6,7 +6,6 @@ export { default as ca } from "./ca.js";
 export { default as cs } from "./cs.js";
 export { default as da } from "./da.js";
 export { default as de } from "./de.js";
-export { default as el } from "./el.js";
 export { default as en } from "./en.js";
 export { default as eo } from "./eo.js";
 export { default as es } from "./es.js";
@@ -15,7 +14,6 @@ export { default as fi } from "./fi.js";
 export { default as fr } from "./fr.js";
 export { default as frCA } from "./fr-CA.js";
 export { default as he } from "./he.js";
-export { default as hr } from "./hr.js";
 export { default as hu } from "./hu.js";
 export { default as hy } from "./hy.js";
 export { default as id } from "./id.js";
@@ -35,7 +33,6 @@ export { default as ota } from "./ota.js";
 export { default as ps } from "./ps.js";
 export { default as pl } from "./pl.js";
 export { default as pt } from "./pt.js";
-export { default as ro } from "./ro.js";
 export { default as ru } from "./ru.js";
 export { default as sl } from "./sl.js";
 export { default as sv } from "./sv.js";

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/locales/it.ts

@@ -91,7 +91,7 @@ const error: () => errors.$ZodErrorMap = () => {
         if (_issue.format === "ends_with") return `Stringa non valida: deve terminare con "${_issue.suffix}"`;
         if (_issue.format === "includes") return `Stringa non valida: deve includere "${_issue.includes}"`;
         if (_issue.format === "regex") return `Stringa non valida: deve corrispondere al pattern ${_issue.pattern}`;
-        return `Input non valido: ${FormatDictionary[_issue.format] ?? issue.format}`;
+        return `Invalid ${FormatDictionary[_issue.format] ?? issue.format}`;
       }
       case "not_multiple_of":
         return `Numero non valido: deve essere un multiplo di ${issue.divisor}`;

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/locales/ka.ts

@@ -39,9 +39,9 @@ const error: () => errors.$ZodErrorMap = () => {
     ipv6: "IPv6 მისამართი",
     cidrv4: "IPv4 დიაპაზონი",
     cidrv6: "IPv6 დიაპაზონი",
-    base64: "base64-კოდირებული ველი",
-    base64url: "base64url-კოდირებული ველი",
-    json_string: "JSON ველი",
+    base64: "base64-კოდირებული სტრინგი",
+    base64url: "base64url-კოდირებული სტრინგი",
+    json_string: "JSON სტრინგი",
     e164: "E.164 ნომერი",
     jwt: "JWT",
     template_literal: "შეყვანა",
@@ -52,7 +52,7 @@ const error: () => errors.$ZodErrorMap = () => {
   } = {
     nan: "NaN",
     number: "რიცხვი",
-    string: "ველი",
+    string: "სტრინგი",
     boolean: "ბულეანი",
     function: "ფუნქცია",
     array: "მასივი",
@@ -93,11 +93,11 @@ const error: () => errors.$ZodErrorMap = () => {
       case "invalid_format": {
         const _issue = issue as errors.$ZodStringFormatIssues;
         if (_issue.format === "starts_with") {
-          return `არასწორი ველი: უნდა იწყებოდეს "${_issue.prefix}"-ით`;
+          return `არასწორი სტრინგი: უნდა იწყებოდეს "${_issue.prefix}"-ით`;
         }
-        if (_issue.format === "ends_with") return `არასწორი ველი: უნდა მთავრდებოდეს "${_issue.suffix}"-ით`;
-        if (_issue.format === "includes") return `არასწორი ველი: უნდა შეიცავდეს "${_issue.includes}"-ს`;
-        if (_issue.format === "regex") return `არასწორი ველი: უნდა შეესაბამებოდეს შაბლონს ${_issue.pattern}`;
+        if (_issue.format === "ends_with") return `არასწორი სტრინგი: უნდა მთავრდებოდეს "${_issue.suffix}"-ით`;
+        if (_issue.format === "includes") return `არასწორი სტრინგი: უნდა შეიცავდეს "${_issue.includes}"-ს`;
+        if (_issue.format === "regex") return `არასწორი სტრინგი: უნდა შეესაბამებოდეს შაბლონს ${_issue.pattern}`;
         return `არასწორი ${FormatDictionary[_issue.format] ?? issue.format}`;
       }
       case "not_multiple_of":

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/locales/uz.ts

@@ -8,7 +8,6 @@ const error: () => errors.$ZodErrorMap = () => {
     file: { unit: "bayt", verb: "bo‘lishi kerak" },
     array: { unit: "element", verb: "bo‘lishi kerak" },
     set: { unit: "element", verb: "bo‘lishi kerak" },
-    map: { unit: "yozuv", verb: "bo‘lishi kerak" },
   };
 
   function getSizing(origin: string): { unit: string; verb: string } | null {

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/mini/external.ts

@@ -4,7 +4,6 @@ export * from "./schemas.js";
 export * from "./checks.js";
 
 export type { infer, output, input } from "../core/index.js";
-export type { JSONType } from "../core/util.js";
 export {
   globalRegistry,
   registry,

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

@@ -60,11 +60,7 @@ export const ZodMiniType: core.$constructor<ZodMiniType> = /*@__PURE__*/ core.$c
           checks: [
             ...(def.checks ?? []),
             ...checks.map((ch) =>
-              typeof ch === "function"
-                ? {
-                    _zod: { check: ch, def: { check: "custom" }, onattach: [] },
-                  }
-                : ch
+              typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch
             ),
           ],
         },
@@ -204,7 +200,7 @@ export function url(params?: string | core.$ZodURLParams): ZodMiniURL {
 // @__NO_SIDE_EFFECTS__
 export function httpUrl(params?: string | Omit<core.$ZodURLParams, "protocol" | "hostname">): ZodMiniURL {
   return core._url(ZodMiniURL, {
-    protocol: core.regexes.httpProtocol,
+    protocol: /^https?$/,
     hostname: core.regexes.domain,
     ...util.normalizeParams(params),
   });
@@ -245,19 +241,9 @@ export function nanoid(params?: string | core.$ZodNanoIDParams): ZodMiniNanoID {
 }
 
 // ZodMiniCUID
-/**
- * @deprecated CUID v1 is deprecated by its authors due to information leakage
- * (timestamps embedded in the id). Use {@link ZodMiniCUID2} instead.
- * See https://github.com/paralleldrive/cuid.
- */
 export interface ZodMiniCUID extends _ZodMiniString<core.$ZodCUIDInternals> {
   // _zod: core.$ZodCUIDInternals;
 }
-/**
- * @deprecated CUID v1 is deprecated by its authors due to information leakage
- * (timestamps embedded in the id). Use {@link ZodMiniCUID2} instead.
- * See https://github.com/paralleldrive/cuid.
- */
 export const ZodMiniCUID: core.$constructor<ZodMiniCUID> = /*@__PURE__*/ core.$constructor(
   "ZodMiniCUID",
   (inst, def) => {
@@ -266,13 +252,6 @@ export const ZodMiniCUID: core.$constructor<ZodMiniCUID> = /*@__PURE__*/ core.$c
   }
 );
 
-/**
- * Validates a CUID v1 string.
- *
- * @deprecated CUID v1 is deprecated by its authors due to information leakage
- * (timestamps embedded in the id). Use {@link cuid2 | `z.cuid2()`} instead.
- * See https://github.com/paralleldrive/cuid.
- */
 // @__NO_SIDE_EFFECTS__
 export function cuid(params?: string | core.$ZodCUIDParams): ZodMiniCUID {
   return core._cuid(ZodMiniCUID, params);
@@ -854,7 +833,7 @@ export const ZodMiniObject: core.$constructor<ZodMiniObject> = /*@__PURE__*/ cor
 export function object<T extends core.$ZodLooseShape = Record<never, SomeType>>(
   shape?: T,
   params?: string | core.$ZodObjectParams
-): ZodMiniObject<util.Writeable<T>, core.$strip> {
+): ZodMiniObject<T, core.$strip> {
   const def: core.$ZodObjectDef = {
     type: "object",
     shape: shape ?? {},
@@ -868,7 +847,7 @@ export function object<T extends core.$ZodLooseShape = Record<never, SomeType>>(
 export function strictObject<T extends core.$ZodLooseShape>(
   shape: T,
   params?: string | core.$ZodObjectParams
-): ZodMiniObject<util.Writeable<T>, core.$strict> {
+): ZodMiniObject<T, core.$strict> {
   return new ZodMiniObject({
     type: "object",
     shape,
@@ -882,7 +861,7 @@ export function strictObject<T extends core.$ZodLooseShape>(
 export function looseObject<T extends core.$ZodLooseShape>(
   shape: T,
   params?: string | core.$ZodObjectParams
-): ZodMiniObject<util.Writeable<T>, core.$loose> {
+): ZodMiniObject<T, core.$loose> {
   return new ZodMiniObject({
     type: "object",
     shape,
@@ -896,7 +875,7 @@ export function looseObject<T extends core.$ZodLooseShape>(
 export function extend<T extends ZodMiniObject, U extends core.$ZodLooseShape>(
   schema: T,
   shape: U
-): ZodMiniObject<util.Extend<T["shape"], util.Writeable<U>>, T["_zod"]["config"]> {
+): ZodMiniObject<util.Extend<T["shape"], U>, T["_zod"]["config"]> {
   return util.extend(schema, shape);
 }
 
@@ -914,7 +893,7 @@ export type SafeExtendShape<Base extends core.$ZodShape, Ext extends core.$ZodLo
 export function safeExtend<T extends ZodMiniObject, U extends core.$ZodLooseShape>(
   schema: T,
   shape: SafeExtendShape<T["shape"], U>
-): ZodMiniObject<util.Extend<T["shape"], util.Writeable<U>>, T["_zod"]["config"]> {
+): ZodMiniObject<util.Extend<T["shape"], U>, T["_zod"]["config"]> {
   return util.safeExtend(schema, shape as any);
 }
 
@@ -951,7 +930,7 @@ export function partial<T extends ZodMiniObject>(
   schema: T
 ): ZodMiniObject<
   {
-    -readonly [k in keyof T["shape"]]: ZodMiniOptional<T["shape"][k]>;
+    [k in keyof T["shape"]]: ZodMiniOptional<T["shape"][k]>;
   },
   T["_zod"]["config"]
 >;
@@ -961,7 +940,7 @@ export function partial<T extends ZodMiniObject, M extends util.Mask<keyof T["sh
   mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>
 ): ZodMiniObject<
   {
-    -readonly [k in keyof T["shape"]]: k extends keyof M ? ZodMiniOptional<T["shape"][k]> : T["shape"][k];
+    [k in keyof T["shape"]]: k extends keyof M ? ZodMiniOptional<T["shape"][k]> : T["shape"][k];
   },
   T["_zod"]["config"]
 >;
@@ -986,7 +965,7 @@ export function required<T extends ZodMiniObject>(
   schema: T
 ): ZodMiniObject<
   {
-    -readonly [k in keyof T["shape"]]: ZodMiniNonOptional<T["shape"][k]>;
+    [k in keyof T["shape"]]: ZodMiniNonOptional<T["shape"][k]>;
   },
   T["_zod"]["config"]
 >;
@@ -1083,7 +1062,7 @@ export const ZodMiniDiscriminatedUnion: core.$constructor<ZodMiniDiscriminatedUn
 
 // @__NO_SIDE_EFFECTS__
 export function discriminatedUnion<
-  Types extends readonly [core.$ZodTypeDiscriminable<Disc>, ...core.$ZodTypeDiscriminable<Disc>[]],
+  Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]],
   Disc extends string,
 >(
   discriminator: Disc,
@@ -1183,15 +1162,6 @@ export function record<Key extends core.$ZodRecordKey, Value extends SomeType>(
   valueType: Value,
   params?: string | core.$ZodRecordParams
 ): ZodMiniRecord<Key, Value> {
-  // v3-compat: z.record(valueType, params?) — defaults keyType to z.string()
-  if (!valueType || !(valueType as any)._zod) {
-    return new ZodMiniRecord({
-      type: "record",
-      keyType: string() as any,
-      valueType: keyType as any as core.$ZodType,
-      ...util.normalizeParams(valueType as string | core.$ZodRecordParams | undefined),
-    }) as any;
-  }
   return new ZodMiniRecord({
     type: "record",
     keyType,
@@ -1655,17 +1625,14 @@ export function codec<const A extends SomeType, B extends core.SomeType = core.$
   }) as any;
 }
 
-// @__NO_SIDE_EFFECTS__
-export function invertCodec<A extends SomeType, B extends SomeType>(codec: ZodMiniCodec<A, B>): ZodMiniCodec<B, A> {
-  const def = codec._zod.def;
-  return new ZodMiniCodec({
-    type: "pipe",
-    in: def.out as any,
-    out: def.in as any,
-    transform: def.reverseTransform as any,
-    reverseTransform: def.transform as any,
-  }) as any;
-}
+// /** @deprecated Use `z.pipe()` and `z.transform()` instead. */
+// export function preprocess<A, U extends core.$ZodType>(
+//   fn: (arg: unknown, ctx: core.ParsePayload) => A,
+//   schema: U,
+//   params?: ZodPreprocessParams
+// ): ZodPipe<ZodTransform<A, unknown>, U> {
+//   return pipe(transform(fn as any, params), schema as any, params);
+// }
 
 // ZodMiniReadonly
 export interface ZodMiniReadonly<T extends SomeType = core.$ZodType>
@@ -1803,10 +1770,9 @@ export function refine<T>(
 // superRefine
 // @__NO_SIDE_EFFECTS__
 export function superRefine<T>(
-  fn: (arg: T, payload: core.$RefinementCtx<T>) => void | Promise<void>,
-  params?: core.$ZodSuperRefineParams
+  fn: (arg: T, payload: core.$RefinementCtx<T>) => void | Promise<void>
 ): core.$ZodCheck<T> {
-  return core._superRefine(fn, params);
+  return core._superRefine(fn);
 }
 
 // Re-export describe and meta from core
@@ -1931,7 +1897,10 @@ export function _function<const Out extends core.$ZodFunctionOut = core.$ZodFunc
 export function _function<
   In extends core.$ZodFunctionIn = core.$ZodFunctionIn,
   Out extends core.$ZodFunctionOut = core.$ZodFunctionOut,
->(params?: { input: In; output: Out }): ZodMiniFunction<In, Out>;
+>(params?: {
+  input: In;
+  output: Out;
+}): ZodMiniFunction<In, Out>;
 // @__NO_SIDE_EFFECTS__
 export function _function(params?: {
   output?: core.$ZodFunctionOut;

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/mini/tests/codec.test.ts

@@ -527,22 +527,3 @@ test("codec type enforcement - complex types", () => {
     }
   );
 });
-
-test("invertCodec", () => {
-  const inverted = z.invertCodec(isoDateCodec);
-
-  type InvIn = z.input<typeof inverted>;
-  type InvOut = z.output<typeof inverted>;
-  expectTypeOf<InvIn>().toEqualTypeOf<Date>();
-  expectTypeOf<InvOut>().toEqualTypeOf<string>();
-
-  const testDate = new Date("2024-01-15T10:30:00.000Z");
-  expect(z.decode(inverted, testDate)).toBe("2024-01-15T10:30:00.000Z");
-
-  const encoded = z.encode(inverted, "2024-01-15T10:30:00.000Z");
-  expect(encoded).toBeInstanceOf(Date);
-  expect(encoded.toISOString()).toBe("2024-01-15T10:30:00.000Z");
-
-  const doubleInverted = z.invertCodec(z.invertCodec(isoDateCodec));
-  expect(z.decode(doubleInverted, "2024-01-15T10:30:00.000Z")).toBeInstanceOf(Date);
-});