@auto-ai/agent 2.1.97 → 2.1.101

package/tools-runtime/code-tool/node_modules/zod/v4/core/json-schema.d.cts

@@ -0,0 +1,88 @@
+export type Schema = ObjectSchema | ArraySchema | StringSchema | NumberSchema | IntegerSchema | BooleanSchema | NullSchema;
+export type _JSONSchema = boolean | JSONSchema;
+export type JSONSchema = {
+    [k: string]: unknown;
+    $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
+    $id?: string;
+    $anchor?: string;
+    $ref?: string;
+    $dynamicRef?: string;
+    $dynamicAnchor?: string;
+    $vocabulary?: Record<string, boolean>;
+    $comment?: string;
+    $defs?: Record<string, JSONSchema>;
+    type?: "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
+    additionalItems?: _JSONSchema;
+    unevaluatedItems?: _JSONSchema;
+    prefixItems?: _JSONSchema[];
+    items?: _JSONSchema | _JSONSchema[];
+    contains?: _JSONSchema;
+    additionalProperties?: _JSONSchema;
+    unevaluatedProperties?: _JSONSchema;
+    properties?: Record<string, _JSONSchema>;
+    patternProperties?: Record<string, _JSONSchema>;
+    dependentSchemas?: Record<string, _JSONSchema>;
+    propertyNames?: _JSONSchema;
+    if?: _JSONSchema;
+    then?: _JSONSchema;
+    else?: _JSONSchema;
+    allOf?: JSONSchema[];
+    anyOf?: JSONSchema[];
+    oneOf?: JSONSchema[];
+    not?: _JSONSchema;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: number | boolean;
+    minimum?: number;
+    exclusiveMinimum?: number | boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxContains?: number;
+    minContains?: number;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    dependentRequired?: Record<string, string[]>;
+    enum?: Array<string | number | boolean | null>;
+    const?: string | number | boolean | null;
+    id?: string;
+    title?: string;
+    description?: string;
+    default?: unknown;
+    deprecated?: boolean;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    nullable?: boolean;
+    examples?: unknown[];
+    format?: string;
+    contentMediaType?: string;
+    contentEncoding?: string;
+    contentSchema?: JSONSchema;
+    _prefault?: unknown;
+};
+export type BaseSchema = JSONSchema;
+export interface ObjectSchema extends JSONSchema {
+    type: "object";
+}
+export interface ArraySchema extends JSONSchema {
+    type: "array";
+}
+export interface StringSchema extends JSONSchema {
+    type: "string";
+}
+export interface NumberSchema extends JSONSchema {
+    type: "number";
+}
+export interface IntegerSchema extends JSONSchema {
+    type: "integer";
+}
+export interface BooleanSchema extends JSONSchema {
+    type: "boolean";
+}
+export interface NullSchema extends JSONSchema {
+    type: "null";
+}

package/tools-runtime/code-tool/node_modules/zod/v4/core/json-schema.d.ts

@@ -0,0 +1,88 @@
+export type Schema = ObjectSchema | ArraySchema | StringSchema | NumberSchema | IntegerSchema | BooleanSchema | NullSchema;
+export type _JSONSchema = boolean | JSONSchema;
+export type JSONSchema = {
+    [k: string]: unknown;
+    $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
+    $id?: string;
+    $anchor?: string;
+    $ref?: string;
+    $dynamicRef?: string;
+    $dynamicAnchor?: string;
+    $vocabulary?: Record<string, boolean>;
+    $comment?: string;
+    $defs?: Record<string, JSONSchema>;
+    type?: "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
+    additionalItems?: _JSONSchema;
+    unevaluatedItems?: _JSONSchema;
+    prefixItems?: _JSONSchema[];
+    items?: _JSONSchema | _JSONSchema[];
+    contains?: _JSONSchema;
+    additionalProperties?: _JSONSchema;
+    unevaluatedProperties?: _JSONSchema;
+    properties?: Record<string, _JSONSchema>;
+    patternProperties?: Record<string, _JSONSchema>;
+    dependentSchemas?: Record<string, _JSONSchema>;
+    propertyNames?: _JSONSchema;
+    if?: _JSONSchema;
+    then?: _JSONSchema;
+    else?: _JSONSchema;
+    allOf?: JSONSchema[];
+    anyOf?: JSONSchema[];
+    oneOf?: JSONSchema[];
+    not?: _JSONSchema;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: number | boolean;
+    minimum?: number;
+    exclusiveMinimum?: number | boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxContains?: number;
+    minContains?: number;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    dependentRequired?: Record<string, string[]>;
+    enum?: Array<string | number | boolean | null>;
+    const?: string | number | boolean | null;
+    id?: string;
+    title?: string;
+    description?: string;
+    default?: unknown;
+    deprecated?: boolean;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    nullable?: boolean;
+    examples?: unknown[];
+    format?: string;
+    contentMediaType?: string;
+    contentEncoding?: string;
+    contentSchema?: JSONSchema;
+    _prefault?: unknown;
+};
+export type BaseSchema = JSONSchema;
+export interface ObjectSchema extends JSONSchema {
+    type: "object";
+}
+export interface ArraySchema extends JSONSchema {
+    type: "array";
+}
+export interface StringSchema extends JSONSchema {
+    type: "string";
+}
+export interface NumberSchema extends JSONSchema {
+    type: "number";
+}
+export interface IntegerSchema extends JSONSchema {
+    type: "integer";
+}
+export interface BooleanSchema extends JSONSchema {
+    type: "boolean";
+}
+export interface NullSchema extends JSONSchema {
+    type: "null";
+}

package/tools-runtime/code-tool/node_modules/zod/v4/core/json-schema.js

@@ -0,0 +1 @@
+export {};

package/tools-runtime/code-tool/node_modules/zod/v4/core/package.json

@@ -0,0 +1,7 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts",
+  "sideEffects": false
+}

package/tools-runtime/code-tool/node_modules/zod/v4/core/parse.cjs

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeDecodeAsync = exports._safeDecodeAsync = exports.safeEncodeAsync = exports._safeEncodeAsync = exports.safeDecode = exports._safeDecode = exports.safeEncode = exports._safeEncode = exports.decodeAsync = exports._decodeAsync = exports.encodeAsync = exports._encodeAsync = exports.decode = exports._decode = exports.encode = exports._encode = exports.safeParseAsync = exports._safeParseAsync = exports.safeParse = exports._safeParse = exports.parseAsync = exports._parseAsync = exports.parse = exports._parse = void 0;
+const core = __importStar(require("./core.cjs"));
+const errors = __importStar(require("./errors.cjs"));
+const util = __importStar(require("./util.cjs"));
+const _parse = (_Err) => (schema, value, _ctx, _params) => {
+    const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
+    const result = schema._zod.run({ value, issues: [] }, ctx);
+    if (result instanceof Promise) {
+        throw new core.$ZodAsyncError();
+    }
+    if (result.issues.length) {
+        const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
+        util.captureStackTrace(e, _params?.callee);
+        throw e;
+    }
+    return result.value;
+};
+exports._parse = _parse;
+exports.parse = (0, exports._parse)(errors.$ZodRealError);
+const _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
+    const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
+    let result = schema._zod.run({ value, issues: [] }, ctx);
+    if (result instanceof Promise)
+        result = await result;
+    if (result.issues.length) {
+        const e = new (params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
+        util.captureStackTrace(e, params?.callee);
+        throw e;
+    }
+    return result.value;
+};
+exports._parseAsync = _parseAsync;
+exports.parseAsync = (0, exports._parseAsync)(errors.$ZodRealError);
+const _safeParse = (_Err) => (schema, value, _ctx) => {
+    const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
+    const result = schema._zod.run({ value, issues: [] }, ctx);
+    if (result instanceof Promise) {
+        throw new core.$ZodAsyncError();
+    }
+    return result.issues.length
+        ? {
+            success: false,
+            error: new (_Err ?? errors.$ZodError)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
+        }
+        : { success: true, data: result.value };
+};
+exports._safeParse = _safeParse;
+exports.safeParse = (0, exports._safeParse)(errors.$ZodRealError);
+const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
+    const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
+    let result = schema._zod.run({ value, issues: [] }, ctx);
+    if (result instanceof Promise)
+        result = await result;
+    return result.issues.length
+        ? {
+            success: false,
+            error: new _Err(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
+        }
+        : { success: true, data: result.value };
+};
+exports._safeParseAsync = _safeParseAsync;
+exports.safeParseAsync = (0, exports._safeParseAsync)(errors.$ZodRealError);
+const _encode = (_Err) => (schema, value, _ctx) => {
+    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
+    return (0, exports._parse)(_Err)(schema, value, ctx);
+};
+exports._encode = _encode;
+exports.encode = (0, exports._encode)(errors.$ZodRealError);
+const _decode = (_Err) => (schema, value, _ctx) => {
+    return (0, exports._parse)(_Err)(schema, value, _ctx);
+};
+exports._decode = _decode;
+exports.decode = (0, exports._decode)(errors.$ZodRealError);
+const _encodeAsync = (_Err) => async (schema, value, _ctx) => {
+    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
+    return (0, exports._parseAsync)(_Err)(schema, value, ctx);
+};
+exports._encodeAsync = _encodeAsync;
+exports.encodeAsync = (0, exports._encodeAsync)(errors.$ZodRealError);
+const _decodeAsync = (_Err) => async (schema, value, _ctx) => {
+    return (0, exports._parseAsync)(_Err)(schema, value, _ctx);
+};
+exports._decodeAsync = _decodeAsync;
+exports.decodeAsync = (0, exports._decodeAsync)(errors.$ZodRealError);
+const _safeEncode = (_Err) => (schema, value, _ctx) => {
+    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
+    return (0, exports._safeParse)(_Err)(schema, value, ctx);
+};
+exports._safeEncode = _safeEncode;
+exports.safeEncode = (0, exports._safeEncode)(errors.$ZodRealError);
+const _safeDecode = (_Err) => (schema, value, _ctx) => {
+    return (0, exports._safeParse)(_Err)(schema, value, _ctx);
+};
+exports._safeDecode = _safeDecode;
+exports.safeDecode = (0, exports._safeDecode)(errors.$ZodRealError);
+const _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
+    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
+    return (0, exports._safeParseAsync)(_Err)(schema, value, ctx);
+};
+exports._safeEncodeAsync = _safeEncodeAsync;
+exports.safeEncodeAsync = (0, exports._safeEncodeAsync)(errors.$ZodRealError);
+const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
+    return (0, exports._safeParseAsync)(_Err)(schema, value, _ctx);
+};
+exports._safeDecodeAsync = _safeDecodeAsync;
+exports.safeDecodeAsync = (0, exports._safeDecodeAsync)(errors.$ZodRealError);

package/tools-runtime/code-tool/node_modules/zod/v4/core/parse.d.cts

@@ -0,0 +1,49 @@
+import * as core from "./core.cjs";
+import * as errors from "./errors.cjs";
+import type * as schemas from "./schemas.cjs";
+import * as util from "./util.cjs";
+export type $ZodErrorClass = {
+    new (issues: errors.$ZodIssue[]): errors.$ZodError;
+};
+export type $Parse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: {
+    callee?: util.AnyFunc;
+    Err?: $ZodErrorClass;
+}) => core.output<T>;
+export declare const _parse: (_Err: $ZodErrorClass) => $Parse;
+export declare const parse: $Parse;
+export type $ParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: {
+    callee?: util.AnyFunc;
+    Err?: $ZodErrorClass;
+}) => Promise<core.output<T>>;
+export declare const _parseAsync: (_Err: $ZodErrorClass) => $ParseAsync;
+export declare const parseAsync: $ParseAsync;
+export type $SafeParse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;
+export declare const _safeParse: (_Err: $ZodErrorClass) => $SafeParse;
+export declare const safeParse: $SafeParse;
+export type $SafeParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;
+export declare const _safeParseAsync: (_Err: $ZodErrorClass) => $SafeParseAsync;
+export declare const safeParseAsync: $SafeParseAsync;
+export type $Encode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => core.input<T>;
+export declare const _encode: (_Err: $ZodErrorClass) => $Encode;
+export declare const encode: $Encode;
+export type $Decode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => core.output<T>;
+export declare const _decode: (_Err: $ZodErrorClass) => $Decode;
+export declare const decode: $Decode;
+export type $EncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<core.input<T>>;
+export declare const _encodeAsync: (_Err: $ZodErrorClass) => $EncodeAsync;
+export declare const encodeAsync: $EncodeAsync;
+export type $DecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<core.output<T>>;
+export declare const _decodeAsync: (_Err: $ZodErrorClass) => $DecodeAsync;
+export declare const decodeAsync: $DecodeAsync;
+export type $SafeEncode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.input<T>>;
+export declare const _safeEncode: (_Err: $ZodErrorClass) => $SafeEncode;
+export declare const safeEncode: $SafeEncode;
+export type $SafeDecode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;
+export declare const _safeDecode: (_Err: $ZodErrorClass) => $SafeDecode;
+export declare const safeDecode: $SafeDecode;
+export type $SafeEncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.input<T>>>;
+export declare const _safeEncodeAsync: (_Err: $ZodErrorClass) => $SafeEncodeAsync;
+export declare const safeEncodeAsync: $SafeEncodeAsync;
+export type $SafeDecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;
+export declare const _safeDecodeAsync: (_Err: $ZodErrorClass) => $SafeDecodeAsync;
+export declare const safeDecodeAsync: $SafeDecodeAsync;

package/tools-runtime/code-tool/node_modules/zod/v4/core/parse.d.ts

@@ -0,0 +1,49 @@
+import * as core from "./core.js";
+import * as errors from "./errors.js";
+import type * as schemas from "./schemas.js";
+import * as util from "./util.js";
+export type $ZodErrorClass = {
+    new (issues: errors.$ZodIssue[]): errors.$ZodError;
+};
+export type $Parse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: {
+    callee?: util.AnyFunc;
+    Err?: $ZodErrorClass;
+}) => core.output<T>;
+export declare const _parse: (_Err: $ZodErrorClass) => $Parse;
+export declare const parse: $Parse;
+export type $ParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: {
+    callee?: util.AnyFunc;
+    Err?: $ZodErrorClass;
+}) => Promise<core.output<T>>;
+export declare const _parseAsync: (_Err: $ZodErrorClass) => $ParseAsync;
+export declare const parseAsync: $ParseAsync;
+export type $SafeParse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;
+export declare const _safeParse: (_Err: $ZodErrorClass) => $SafeParse;
+export declare const safeParse: $SafeParse;
+export type $SafeParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;
+export declare const _safeParseAsync: (_Err: $ZodErrorClass) => $SafeParseAsync;
+export declare const safeParseAsync: $SafeParseAsync;
+export type $Encode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => core.input<T>;
+export declare const _encode: (_Err: $ZodErrorClass) => $Encode;
+export declare const encode: $Encode;
+export type $Decode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => core.output<T>;
+export declare const _decode: (_Err: $ZodErrorClass) => $Decode;
+export declare const decode: $Decode;
+export type $EncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<core.input<T>>;
+export declare const _encodeAsync: (_Err: $ZodErrorClass) => $EncodeAsync;
+export declare const encodeAsync: $EncodeAsync;
+export type $DecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<core.output<T>>;
+export declare const _decodeAsync: (_Err: $ZodErrorClass) => $DecodeAsync;
+export declare const decodeAsync: $DecodeAsync;
+export type $SafeEncode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.input<T>>;
+export declare const _safeEncode: (_Err: $ZodErrorClass) => $SafeEncode;
+export declare const safeEncode: $SafeEncode;
+export type $SafeDecode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;
+export declare const _safeDecode: (_Err: $ZodErrorClass) => $SafeDecode;
+export declare const safeDecode: $SafeDecode;
+export type $SafeEncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.input<T>>>;
+export declare const _safeEncodeAsync: (_Err: $ZodErrorClass) => $SafeEncodeAsync;
+export declare const safeEncodeAsync: $SafeEncodeAsync;
+export type $SafeDecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;
+export declare const _safeDecodeAsync: (_Err: $ZodErrorClass) => $SafeDecodeAsync;
+export declare const safeDecodeAsync: $SafeDecodeAsync;

package/tools-runtime/code-tool/node_modules/zod/v4/core/parse.js

@@ -0,0 +1,93 @@
+import * as core from "./core.js";
+import * as errors from "./errors.js";
+import * as util from "./util.js";
+export const _parse = (_Err) => (schema, value, _ctx, _params) => {
+    const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
+    const result = schema._zod.run({ value, issues: [] }, ctx);
+    if (result instanceof Promise) {
+        throw new core.$ZodAsyncError();
+    }
+    if (result.issues.length) {
+        const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
+        util.captureStackTrace(e, _params?.callee);
+        throw e;
+    }
+    return result.value;
+};
+export const parse = /* @__PURE__*/ _parse(errors.$ZodRealError);
+export const _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
+    const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
+    let result = schema._zod.run({ value, issues: [] }, ctx);
+    if (result instanceof Promise)
+        result = await result;
+    if (result.issues.length) {
+        const e = new (params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
+        util.captureStackTrace(e, params?.callee);
+        throw e;
+    }
+    return result.value;
+};
+export const parseAsync = /* @__PURE__*/ _parseAsync(errors.$ZodRealError);
+export const _safeParse = (_Err) => (schema, value, _ctx) => {
+    const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
+    const result = schema._zod.run({ value, issues: [] }, ctx);
+    if (result instanceof Promise) {
+        throw new core.$ZodAsyncError();
+    }
+    return result.issues.length
+        ? {
+            success: false,
+            error: new (_Err ?? errors.$ZodError)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
+        }
+        : { success: true, data: result.value };
+};
+export const safeParse = /* @__PURE__*/ _safeParse(errors.$ZodRealError);
+export const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
+    const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
+    let result = schema._zod.run({ value, issues: [] }, ctx);
+    if (result instanceof Promise)
+        result = await result;
+    return result.issues.length
+        ? {
+            success: false,
+            error: new _Err(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
+        }
+        : { success: true, data: result.value };
+};
+export const safeParseAsync = /* @__PURE__*/ _safeParseAsync(errors.$ZodRealError);
+export const _encode = (_Err) => (schema, value, _ctx) => {
+    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
+    return _parse(_Err)(schema, value, ctx);
+};
+export const encode = /* @__PURE__*/ _encode(errors.$ZodRealError);
+export const _decode = (_Err) => (schema, value, _ctx) => {
+    return _parse(_Err)(schema, value, _ctx);
+};
+export const decode = /* @__PURE__*/ _decode(errors.$ZodRealError);
+export const _encodeAsync = (_Err) => async (schema, value, _ctx) => {
+    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
+    return _parseAsync(_Err)(schema, value, ctx);
+};
+export const encodeAsync = /* @__PURE__*/ _encodeAsync(errors.$ZodRealError);
+export const _decodeAsync = (_Err) => async (schema, value, _ctx) => {
+    return _parseAsync(_Err)(schema, value, _ctx);
+};
+export const decodeAsync = /* @__PURE__*/ _decodeAsync(errors.$ZodRealError);
+export const _safeEncode = (_Err) => (schema, value, _ctx) => {
+    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
+    return _safeParse(_Err)(schema, value, ctx);
+};
+export const safeEncode = /* @__PURE__*/ _safeEncode(errors.$ZodRealError);
+export const _safeDecode = (_Err) => (schema, value, _ctx) => {
+    return _safeParse(_Err)(schema, value, _ctx);
+};
+export const safeDecode = /* @__PURE__*/ _safeDecode(errors.$ZodRealError);
+export const _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
+    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
+    return _safeParseAsync(_Err)(schema, value, ctx);
+};
+export const safeEncodeAsync = /* @__PURE__*/ _safeEncodeAsync(errors.$ZodRealError);
+export const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
+    return _safeParseAsync(_Err)(schema, value, _ctx);
+};
+export const safeDecodeAsync = /* @__PURE__*/ _safeDecodeAsync(errors.$ZodRealError);