conductor-oss 0.60.16 → 0.60.18

package/node_modules/yaml/browser/dist/compose/resolve-flow-scalar.js

@@ -142,7 +142,7 @@ function doubleQuotedValue(source, onError) {
                     next = source[++i + 1];
             }
             else if (next === 'x' || next === 'u' || next === 'U') {
-                const length = { x: 2, u: 4, U: 8 }[next];
+                const length = next === 'x' ? 2 : next === 'u' ? 4 : 8;
                 res += parseCharCode(source, i + 1, length, onError);
                 i += length;
             }
@@ -212,12 +212,14 @@ function parseCharCode(source, offset, length, onError) {
     const cc = source.substr(offset, length);
     const ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc);
     const code = ok ? parseInt(cc, 16) : NaN;
-    if (isNaN(code)) {
+    try {
+        return String.fromCodePoint(code);
+    }
+    catch {
         const raw = source.substr(offset - 2, length + 2);
         onError(offset - 2, 'BAD_DQ_ESCAPE', `Invalid escape sequence ${raw}`);
         return raw;
     }
-    return String.fromCodePoint(code);
 }
 
 export { resolveFlowScalar };

package/node_modules/yaml/browser/dist/nodes/Alias.js

@@ -19,6 +19,8 @@ class Alias extends NodeBase {
      * instance of the `source` anchor before this node.
      */
     resolve(doc, ctx) {
+        if (ctx?.maxAliasCount === 0)
+            throw new ReferenceError('Alias resolution is disabled');
         let nodes;
         if (ctx?.aliasResolveCache) {
             nodes = ctx.aliasResolveCache;

package/node_modules/yaml/browser/dist/schema/yaml-1.1/merge.js

@@ -1,4 +1,4 @@
-import { isScalar, isAlias, isSeq, isMap } from '../../nodes/identity.js';
+import { isScalar, isSeq, isAlias, isMap } from '../../nodes/identity.js';
 import { Scalar } from '../../nodes/Scalar.js';
 
 // If the value associated with a merge key is a single mapping node, each of
@@ -26,18 +26,18 @@ const isMergeKey = (ctx, key) => (merge.identify(key) ||
         merge.identify(key.value))) &&
     ctx?.doc.schema.tags.some(tag => tag.tag === merge.tag && tag.default);
 function addMergeToJSMap(ctx, map, value) {
-    value = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;
-    if (isSeq(value))
-        for (const it of value.items)
+    const source = resolveAliasValue(ctx, value);
+    if (isSeq(source))
+        for (const it of source.items)
             mergeValue(ctx, map, it);
-    else if (Array.isArray(value))
-        for (const it of value)
+    else if (Array.isArray(source))
+        for (const it of source)
             mergeValue(ctx, map, it);
     else
-        mergeValue(ctx, map, value);
+        mergeValue(ctx, map, source);
 }
 function mergeValue(ctx, map, value) {
-    const source = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;
+    const source = resolveAliasValue(ctx, value);
     if (!isMap(source))
         throw new Error('Merge sources must be maps or map aliases');
     const srcMap = source.toJSON(null, ctx, Map);
@@ -60,5 +60,8 @@ function mergeValue(ctx, map, value) {
     }
     return map;
 }
+function resolveAliasValue(ctx, value) {
+    return ctx && isAlias(value) ? value.resolve(ctx.doc, ctx) : value;
+}
 
 export { addMergeToJSMap, isMergeKey, merge };

package/node_modules/yaml/browser/dist/stringify/stringifyNumber.js

@@ -8,7 +8,8 @@ function stringifyNumber({ format, minFractionDigits, tag, value }) {
     if (!format &&
         minFractionDigits &&
         (!tag || tag === 'tag:yaml.org,2002:float') &&
-        /^\d/.test(n)) {
+        /^-?\d/.test(n) &&
+        !n.includes('e')) {
         let i = n.indexOf('.');
         if (i < 0) {
             i = n.length;

package/node_modules/yaml/dist/compose/resolve-flow-scalar.js

@@ -144,7 +144,7 @@ function doubleQuotedValue(source, onError) {
                     next = source[++i + 1];
             }
             else if (next === 'x' || next === 'u' || next === 'U') {
-                const length = { x: 2, u: 4, U: 8 }[next];
+                const length = next === 'x' ? 2 : next === 'u' ? 4 : 8;
                 res += parseCharCode(source, i + 1, length, onError);
                 i += length;
             }
@@ -214,12 +214,14 @@ function parseCharCode(source, offset, length, onError) {
     const cc = source.substr(offset, length);
     const ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc);
     const code = ok ? parseInt(cc, 16) : NaN;
-    if (isNaN(code)) {
+    try {
+        return String.fromCodePoint(code);
+    }
+    catch {
         const raw = source.substr(offset - 2, length + 2);
         onError(offset - 2, 'BAD_DQ_ESCAPE', `Invalid escape sequence ${raw}`);
         return raw;
     }
-    return String.fromCodePoint(code);
 }
 
 exports.resolveFlowScalar = resolveFlowScalar;

package/node_modules/yaml/dist/nodes/Alias.js

@@ -21,6 +21,8 @@ class Alias extends Node.NodeBase {
      * instance of the `source` anchor before this node.
      */
     resolve(doc, ctx) {
+        if (ctx?.maxAliasCount === 0)
+            throw new ReferenceError('Alias resolution is disabled');
         let nodes;
         if (ctx?.aliasResolveCache) {
             nodes = ctx.aliasResolveCache;

package/node_modules/yaml/dist/nodes/Scalar.d.ts

@@ -31,7 +31,11 @@ export declare class Scalar<T = unknown> extends NodeBase {
      * The YAML 1.1 schema also supports 'BIN' and 'TIME'
      */
     format?: string;
-    /** If `value` is a number, use this value when stringifying this node. */
+    /**
+     * If `value` is a number that is serialized as a decimal string
+     * (i.e. not using exponential notation),
+     * use this value when stringifying this node.
+     */
     minFractionDigits?: number;
     /** Set during parsing to the source string value */
     source?: string;

package/node_modules/yaml/dist/schema/yaml-1.1/merge.js

@@ -28,18 +28,18 @@ const isMergeKey = (ctx, key) => (merge.identify(key) ||
         merge.identify(key.value))) &&
     ctx?.doc.schema.tags.some(tag => tag.tag === merge.tag && tag.default);
 function addMergeToJSMap(ctx, map, value) {
-    value = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value;
-    if (identity.isSeq(value))
-        for (const it of value.items)
+    const source = resolveAliasValue(ctx, value);
+    if (identity.isSeq(source))
+        for (const it of source.items)
             mergeValue(ctx, map, it);
-    else if (Array.isArray(value))
-        for (const it of value)
+    else if (Array.isArray(source))
+        for (const it of source)
             mergeValue(ctx, map, it);
     else
-        mergeValue(ctx, map, value);
+        mergeValue(ctx, map, source);
 }
 function mergeValue(ctx, map, value) {
-    const source = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value;
+    const source = resolveAliasValue(ctx, value);
     if (!identity.isMap(source))
         throw new Error('Merge sources must be maps or map aliases');
     const srcMap = source.toJSON(null, ctx, Map);
@@ -62,6 +62,9 @@ function mergeValue(ctx, map, value) {
     }
     return map;
 }
+function resolveAliasValue(ctx, value) {
+    return ctx && identity.isAlias(value) ? value.resolve(ctx.doc, ctx) : value;
+}
 
 exports.addMergeToJSMap = addMergeToJSMap;
 exports.isMergeKey = isMergeKey;

package/node_modules/yaml/dist/stringify/stringifyNumber.js

@@ -10,7 +10,8 @@ function stringifyNumber({ format, minFractionDigits, tag, value }) {
     if (!format &&
         minFractionDigits &&
         (!tag || tag === 'tag:yaml.org,2002:float') &&
-        /^\d/.test(n)) {
+        /^-?\d/.test(n) &&
+        !n.includes('e')) {
         let i = n.indexOf('.');
         if (i < 0) {
             i = n.length;

package/node_modules/yaml/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yaml",
-  "version": "2.8.3",
+  "version": "2.8.4",
   "license": "ISC",
   "author": "Eemeli Aro <eemeli@gmail.com>",
   "funding": "https://github.com/sponsors/eemeli",

package/node_modules/zod/README.md

@@ -31,23 +31,6 @@
 <br/>
 <br/>
 
-<h2 align="center">Featured sponsor: Jazz</h2>
-
-<div align="center">
-  <a href="https://jazz.tools/?utm_source=zod">
-    <picture width="85%" >
-      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/garden-co/jazz/938f6767e46cdfded60e50d99bf3b533f4809c68/homepage/homepage/public/Zod%20sponsor%20message.png">
-      <img alt="jazz logo" src="https://raw.githubusercontent.com/garden-co/jazz/938f6767e46cdfded60e50d99bf3b533f4809c68/homepage/homepage/public/Zod%20sponsor%20message.png" width="85%">
-    </picture>
-  </a>
-  <br/>
-  <p><sub>Learn more about <a target="_blank" rel="noopener noreferrer" href="mailto:sponsorship@colinhacks.com">featured sponsorships</a></sub></p>
-</div>
-
-<br/>
-<br/>
-<br/>
-
 ### [Read the docs →](https://zod.dev/api)
 
 <br/>
@@ -169,7 +152,7 @@ if (!result.success) {
 }
 ```
 
-**Note** — If your schema uses certain asynchronous APIs like `async` [refinements](#refine) or [transforms](#transform), you'll need to use the `.safeParseAsync()` method instead.
+**Note** — If your schema uses certain asynchronous APIs like `async` [refinements](https://zod.dev/api#refinements) or [transforms](https://zod.dev/api#transforms), you'll need to use the `.safeParseAsync()` method instead.
 
 ```ts
 const schema = z.string().refine(async (val) => val.length <= 8);

package/node_modules/zod/locales/package.json

@@ -2,5 +2,6 @@
   "type": "module",
   "main": "./index.cjs",
   "module": "./index.js",
-  "types": "./index.d.cts" 
+  "types": "./index.d.cts",
+  "sideEffects": false
 }

package/node_modules/zod/mini/package.json

@@ -2,5 +2,6 @@
   "type": "module",
   "main": "./index.cjs",
   "module": "./index.js",
-  "types": "./index.d.cts" 
+  "types": "./index.d.cts",
+  "sideEffects": false
 }

package/node_modules/zod/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.3.6",
+  "version": "4.4.3",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",

package/node_modules/zod/src/v3/tests/all-errors.test.ts

@@ -16,7 +16,7 @@ type TestFormErrors = z.inferFlattenedErrors<typeof Test>;
 test("default flattened errors type inference", () => {
   type TestTypeErrors = {
     formErrors: string[];
-    fieldErrors: { [P in keyof z.TypeOf<typeof Test>]?: string[] | undefined };
+    fieldErrors: { [P in keyof z.TypeOf<typeof Test>]?: string[] };
   };
 
   util.assertEqual<z.inferFlattenedErrors<typeof Test>, TestTypeErrors>(true);
@@ -28,7 +28,7 @@ test("custom flattened errors type inference", () => {
   type TestTypeErrors = {
     formErrors: ErrorType[];
     fieldErrors: {
-      [P in keyof z.TypeOf<typeof Test>]?: ErrorType[] | undefined;
+      [P in keyof z.TypeOf<typeof Test>]?: ErrorType[];
     };
   };
 
@@ -40,7 +40,7 @@ test("custom flattened errors type inference", () => {
 test("form errors type inference", () => {
   type TestTypeErrors = {
     formErrors: string[];
-    fieldErrors: { [P in keyof z.TypeOf<typeof Test>]?: string[] | undefined };
+    fieldErrors: { [P in keyof z.TypeOf<typeof Test>]?: string[] };
   };
 
   util.assertEqual<z.inferFlattenedErrors<typeof Test>, TestTypeErrors>(true);

package/node_modules/zod/src/v3/tests/object.test.ts

@@ -212,9 +212,9 @@ test("inferred merged object type with optional properties", async () => {
     .object({ a: z.string(), b: z.string().optional() })
     .merge(z.object({ a: z.string().optional(), b: z.string() }));
   type Merged = z.infer<typeof Merged>;
-  util.assertEqual<Merged, { a?: string; b: string }>(true);
+  util.assertEqual<Merged, { a?: string | undefined; b: string }>(true);
   // todo
-  // util.assertEqual<Merged, { a?: string; b: string }>(true);
+  // util.assertEqual<Merged, { a?: string | undefined; b: string }>(true);
 });
 
 test("inferred unioned object type with optional properties", async () => {
@@ -223,7 +223,7 @@ test("inferred unioned object type with optional properties", async () => {
     z.object({ a: z.string().optional(), b: z.string() }),
   ]);
   type Unioned = z.infer<typeof Unioned>;
-  util.assertEqual<Unioned, { a: string; b?: string } | { a?: string; b: string }>(true);
+  util.assertEqual<Unioned, { a: string; b?: string | undefined } | { a?: string | undefined; b: string }>(true);
 });
 
 test("inferred enum type", async () => {
@@ -245,13 +245,13 @@ test("inferred enum type", async () => {
 test("inferred partial object type with optional properties", async () => {
   const Partial = z.object({ a: z.string(), b: z.string().optional() }).partial();
   type Partial = z.infer<typeof Partial>;
-  util.assertEqual<Partial, { a?: string; b?: string }>(true);
+  util.assertEqual<Partial, { a?: string | undefined; b?: string | undefined }>(true);
 });
 
 test("inferred picked object type with optional properties", async () => {
   const Picked = z.object({ a: z.string(), b: z.string().optional() }).pick({ b: true });
   type Picked = z.infer<typeof Picked>;
-  util.assertEqual<Picked, { b?: string }>(true);
+  util.assertEqual<Picked, { b?: string | undefined }>(true);
 });
 
 test("inferred type for unknown/any keys", () => {

package/node_modules/zod/src/v3/tests/partials.test.ts

@@ -21,7 +21,7 @@ test("shallow inference", () => {
     name?: string | undefined;
     age?: number | undefined;
     outer?: { inner: string } | undefined;
-    array?: { asdf: string }[];
+    array?: { asdf: string }[] | undefined;
   };
   util.assertEqual<shallow, correct>(true);
 });
@@ -41,7 +41,7 @@ test("deep partial inference", () => {
   asdf.parse("asdf");
   type deep = z.infer<typeof deep>;
   type correct = {
-    array?: { asdf?: string }[];
+    array?: { asdf?: string | undefined }[] | undefined;
     name?: string | undefined;
     age?: number | undefined;
     outer?: { inner?: string | undefined } | undefined;
@@ -118,7 +118,7 @@ test("deep partial inference", () => {
           asdf?: string | undefined;
         }[]
       | undefined;
-    tuple?: [{ value?: string }] | undefined;
+    tuple?: [{ value?: string | undefined }] | undefined;
   };
   util.assertEqual<expected, partialed>(true);
 });

package/node_modules/zod/src/v4/classic/errors.ts

@@ -61,8 +61,8 @@ const initializer = (inst: ZodError, issues: core.$ZodIssue[]) => {
   //   },
   // });
 };
-export const ZodError: core.$constructor<ZodError> = core.$constructor("ZodError", initializer);
-export const ZodRealError: core.$constructor<ZodError> = core.$constructor("ZodError", initializer, {
+export const ZodError: core.$constructor<ZodError> = /*@__PURE__*/ core.$constructor("ZodError", initializer);
+export const ZodRealError: core.$constructor<ZodError> = /*@__PURE__*/ core.$constructor("ZodError", initializer, {
   Parent: Error,
 });
 

package/node_modules/zod/src/v4/classic/external.ts

@@ -11,6 +11,7 @@ import en from "../locales/en.js";
 config(en());
 
 export type { infer, output, input } from "../core/index.js";
+export type { JSONType } from "../core/util.js";
 export {
   globalRegistry,
   type GlobalMeta,

package/node_modules/zod/src/v4/classic/from-json-schema.ts

@@ -29,7 +29,7 @@ interface ConversionContext {
 }
 
 // Keys that are recognized and handled by the conversion logic
-const RECOGNIZED_KEYS = new Set([
+const RECOGNIZED_KEYS = /*@__PURE__*/ new Set([
   // Schema identification
   "$schema",
   "$ref",
@@ -478,10 +478,10 @@ function convertBaseSchema(schema: JSONSchema.JSONSchema, ctx: ConversionContext
         }
         // Apply minItems/maxItems constraints to tuples
         if (typeof schema.minItems === "number") {
-          zodSchema = (zodSchema as any).check(z.minLength(schema.minItems));
+          zodSchema = zodSchema.check(z.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema = (zodSchema as any).check(z.maxLength(schema.maxItems));
+          zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
         }
       } else if (Array.isArray(items)) {
         // Tuple with items array (draft-7)
@@ -497,10 +497,10 @@ function convertBaseSchema(schema: JSONSchema.JSONSchema, ctx: ConversionContext
         }
         // Apply minItems/maxItems constraints to tuples
         if (typeof schema.minItems === "number") {
-          zodSchema = (zodSchema as any).check(z.minLength(schema.minItems));
+          zodSchema = zodSchema.check(z.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema = (zodSchema as any).check(z.maxLength(schema.maxItems));
+          zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
         }
       } else if (items !== undefined) {
         // Regular array
@@ -509,10 +509,10 @@ function convertBaseSchema(schema: JSONSchema.JSONSchema, ctx: ConversionContext
 
         // Apply constraints
         if (typeof schema.minItems === "number") {
-          arraySchema = (arraySchema as any).min(schema.minItems);
+          arraySchema = arraySchema.min(schema.minItems);
         }
         if (typeof schema.maxItems === "number") {
-          arraySchema = (arraySchema as any).max(schema.maxItems);
+          arraySchema = arraySchema.max(schema.maxItems);
         }
 
         zodSchema = arraySchema;
@@ -527,14 +527,6 @@ function convertBaseSchema(schema: JSONSchema.JSONSchema, ctx: ConversionContext
       throw new Error(`Unsupported type: ${type}`);
   }
 
-  // Apply metadata
-  if (schema.description) {
-    zodSchema = zodSchema.describe(schema.description);
-  }
-  if (schema.default !== undefined) {
-    zodSchema = (zodSchema as any).default(schema.default);
-  }
-
   return zodSchema;
 }
 
@@ -586,10 +578,18 @@ function convertSchema(schema: JSONSchema.JSONSchema | boolean, ctx: ConversionC
     baseSchema = z.readonly(baseSchema);
   }
 
-  // Collect metadata: core schema keywords and unrecognized keys
+  // Apply `default` so it wraps the fully-composed schema. This ensures
+  // `parse(undefined) -> default` works regardless of which branch of
+  // `convertBaseSchema` produced the inner schema (enum/const/not/typed/etc.).
+  if (schema.default !== undefined) {
+    baseSchema = baseSchema.default(schema.default);
+  }
+
+  // Collect non-description annotation metadata into the user-supplied
+  // registry. Description is handled separately below via `.describe()` to
+  // preserve the contract that `schema.description` reads from globalRegistry.
   const extraMeta: Record<string, unknown> = {};
 
-  // Core schema keywords that should be captured as metadata
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
   for (const key of coreMetadataKeys) {
     if (key in schema) {
@@ -597,7 +597,6 @@ function convertSchema(schema: JSONSchema.JSONSchema | boolean, ctx: ConversionC
     }
   }
 
-  // Content keywords - store as metadata
   const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
   for (const key of contentMetadataKeys) {
     if (key in schema) {
@@ -605,7 +604,6 @@ function convertSchema(schema: JSONSchema.JSONSchema | boolean, ctx: ConversionC
     }
   }
 
-  // Unrecognized keys (custom metadata)
   for (const key of Object.keys(schema)) {
     if (!RECOGNIZED_KEYS.has(key)) {
       extraMeta[key] = schema[key];
@@ -616,6 +614,13 @@ function convertSchema(schema: JSONSchema.JSONSchema | boolean, ctx: ConversionC
     ctx.registry.add(baseSchema, extraMeta);
   }
 
+  // Apply description last. `.describe()` clones the schema and sets
+  // `_zod.parent` on the clone, so registry lookups on the returned reference
+  // still resolve `extraMeta` via parent inheritance.
+  if (schema.description) {
+    baseSchema = baseSchema.describe(schema.description);
+  }
+
   return baseSchema;
 }
 
@@ -627,17 +632,28 @@ export function fromJSONSchema(schema: JSONSchema.JSONSchema | boolean, params?:
     return schema ? z.any() : z.never();
   }
 
-  const version = detectVersion(schema, params?.defaultTarget);
-  const defs = (schema.$defs || schema.definitions || {}) as Record<string, JSONSchema.JSONSchema>;
+  // Normalize input via a JSON round-trip. This guarantees the converter
+  // walks a plain, finite, JSON-valid object graph: cyclic inputs fail here,
+  // getter/Proxy-based properties are materialized into static values, and
+  // class instances collapse to plain objects.
+  let normalized: JSONSchema.JSONSchema;
+  try {
+    normalized = JSON.parse(JSON.stringify(schema));
+  } catch {
+    throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
+  }
+
+  const version = detectVersion(normalized, params?.defaultTarget);
+  const defs = (normalized.$defs || normalized.definitions || {}) as Record<string, JSONSchema.JSONSchema>;
 
   const ctx: ConversionContext = {
     version,
     defs,
     refs: new Map(),
     processing: new Set(),
-    rootSchema: schema,
+    rootSchema: normalized,
     registry: params?.registry ?? globalRegistry,
   };
 
-  return convertSchema(schema, ctx);
+  return convertSchema(normalized, ctx);
 }

package/node_modules/zod/src/v4/classic/parse.ts

@@ -10,14 +10,14 @@ export const parse: <T extends core.$ZodType>(
   value: unknown,
   _ctx?: core.ParseContext<core.$ZodIssue>,
   _params?: { callee?: core.util.AnyFunc; Err?: core.$ZodErrorClass }
-) => core.output<T> = /* @__PURE__ */ core._parse(ZodRealError) as any;
+) => core.output<T> = /* @__PURE__ */ core._parse(ZodRealError);
 
 export const parseAsync: <T extends core.$ZodType>(
   schema: T,
   value: unknown,
   _ctx?: core.ParseContext<core.$ZodIssue>,
   _params?: { callee?: core.util.AnyFunc; Err?: core.$ZodErrorClass }
-) => Promise<core.output<T>> = /* @__PURE__ */ core._parseAsync(ZodRealError) as any;
+) => Promise<core.output<T>> = /* @__PURE__ */ core._parseAsync(ZodRealError);
 
 export const safeParse: <T extends core.$ZodType>(
   schema: T,
@@ -37,25 +37,25 @@ export const encode: <T extends core.$ZodType>(
   schema: T,
   value: core.output<T>,
   _ctx?: core.ParseContext<core.$ZodIssue>
-) => core.input<T> = /* @__PURE__ */ core._encode(ZodRealError) as any;
+) => core.input<T> = /* @__PURE__ */ core._encode(ZodRealError);
 
 export const decode: <T extends core.$ZodType>(
   schema: T,
   value: core.input<T>,
   _ctx?: core.ParseContext<core.$ZodIssue>
-) => core.output<T> = /* @__PURE__ */ core._decode(ZodRealError) as any;
+) => core.output<T> = /* @__PURE__ */ core._decode(ZodRealError);
 
 export const encodeAsync: <T extends core.$ZodType>(
   schema: T,
   value: core.output<T>,
   _ctx?: core.ParseContext<core.$ZodIssue>
-) => Promise<core.input<T>> = /* @__PURE__ */ core._encodeAsync(ZodRealError) as any;
+) => Promise<core.input<T>> = /* @__PURE__ */ core._encodeAsync(ZodRealError);
 
 export const decodeAsync: <T extends core.$ZodType>(
   schema: T,
   value: core.input<T>,
   _ctx?: core.ParseContext<core.$ZodIssue>
-) => Promise<core.output<T>> = /* @__PURE__ */ core._decodeAsync(ZodRealError) as any;
+) => Promise<core.output<T>> = /* @__PURE__ */ core._decodeAsync(ZodRealError);
 
 export const safeEncode: <T extends core.$ZodType>(
   schema: T,