@langchain/core 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/utils/zod-to-json-schema/parsers/union.d.ts

@@ -0,0 +1,25 @@
+import { JsonSchema7Type } from "../parseTypes.js";
+import "zod/v3";
+
+//#region src/utils/zod-to-json-schema/parsers/union.d.ts
+declare const primitiveMappings: {
+  readonly ZodString: "string";
+  readonly ZodNumber: "number";
+  readonly ZodBigInt: "integer";
+  readonly ZodBoolean: "boolean";
+  readonly ZodNull: "null";
+};
+type JsonSchema7Primitive = (typeof primitiveMappings)[keyof typeof primitiveMappings];
+type JsonSchema7UnionType = JsonSchema7PrimitiveUnionType | JsonSchema7AnyOfType;
+type JsonSchema7PrimitiveUnionType = {
+  type: JsonSchema7Primitive | JsonSchema7Primitive[];
+} | {
+  type: JsonSchema7Primitive | JsonSchema7Primitive[];
+  enum: (string | number | bigint | boolean | null)[];
+};
+type JsonSchema7AnyOfType = {
+  anyOf: JsonSchema7Type[];
+};
+//#endregion
+export { JsonSchema7UnionType };
+//# sourceMappingURL=union.d.ts.map

package/dist/utils/zod-to-json-schema/parsers/union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union.d.ts","names":["ZodDiscriminatedUnionDef","ZodUnionDef","JsonSchema7Type","Refs","primitiveMappings","JsonSchema7Primitive","JsonSchema7UnionType","JsonSchema7PrimitiveUnionType","JsonSchema7AnyOfType","parseUnionDef"],"sources":["../../../../src/utils/zod-to-json-schema/parsers/union.d.ts"],"sourcesContent":["import { ZodDiscriminatedUnionDef, ZodUnionDef } from \"zod/v3\";\nimport { JsonSchema7Type } from \"../parseTypes.js\";\nimport { Refs } from \"../Refs.js\";\nexport declare const primitiveMappings: {\n    readonly ZodString: \"string\";\n    readonly ZodNumber: \"number\";\n    readonly ZodBigInt: \"integer\";\n    readonly ZodBoolean: \"boolean\";\n    readonly ZodNull: \"null\";\n};\ntype JsonSchema7Primitive = (typeof primitiveMappings)[keyof typeof primitiveMappings];\nexport type JsonSchema7UnionType = JsonSchema7PrimitiveUnionType | JsonSchema7AnyOfType;\ntype JsonSchema7PrimitiveUnionType = {\n    type: JsonSchema7Primitive | JsonSchema7Primitive[];\n} | {\n    type: JsonSchema7Primitive | JsonSchema7Primitive[];\n    enum: (string | number | bigint | boolean | null)[];\n};\ntype JsonSchema7AnyOfType = {\n    anyOf: JsonSchema7Type[];\n};\nexport declare function parseUnionDef(def: ZodUnionDef | ZodDiscriminatedUnionDef<any, any>, refs: Refs): JsonSchema7PrimitiveUnionType | JsonSchema7AnyOfType | undefined;\nexport {};\n"],"mappings":";;;;cAGqBI;EAAAA,SAAAA,SAAAA,EAMpB,QAAA;EACIC,SAAAA,SAAAA,EAAAA,QAAoB;EAAA,SAAA,SAAA,EAAA,SAAA;EAAA,SAAWD,UAAAA,EAAAA,SAAAA;EAAiB,SAAeA,OAAAA,EAAAA,MAAAA;AAAiB,CAAA;AACrF,KADKC,oBAAAA,GAC2B,CAAA,OADID,iBACJ,CAAA,CAAA,MAAA,OADoCA,iBACpC,CAAA;AAAA,KAApBE,oBAAAA,GAAuBC,6BAAH,GAAmCC,oBAAnC;KAC3BD,6BAAAA,GAD8BA;EAA6B,IAAGC,EAEzDH,oBAFyDG,GAElCH,oBAFkCG,EAAAA;AAAoB,CAAA,GAAA;EAClFD,IAAAA,EAGKF,oBAHLE,GAG4BF,oBAHC,EAAA;EAAA,IAAA,EAAA,CAAA,MAAA,GAAA,MAAA,GAAA,MAAA,GAAA,OAAA,GAAA,IAAA,CAAA,EAAA;CAAA;KAM7BG,oBAAAA,GAL4BH;EAAoB,KAE3CA,EAICH,eAJDG,EAAAA;CAAoB"}

package/dist/utils/zod-to-json-schema/parsers/union.js

@@ -0,0 +1,66 @@
+import { parseDef } from "../parseDef.js";
+
+//#region src/utils/zod-to-json-schema/parsers/union.ts
+const primitiveMappings = {
+	ZodString: "string",
+	ZodNumber: "number",
+	ZodBigInt: "integer",
+	ZodBoolean: "boolean",
+	ZodNull: "null"
+};
+function parseUnionDef(def, refs) {
+	if (refs.target === "openApi3") return asAnyOf(def, refs);
+	const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+	if (options.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {
+		const types = options.reduce((types$1, x) => {
+			const type = primitiveMappings[x._def.typeName];
+			return type && !types$1.includes(type) ? [...types$1, type] : types$1;
+		}, []);
+		return { type: types.length > 1 ? types : types[0] };
+	} else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
+		const types = options.reduce((acc, x) => {
+			const type = typeof x._def.value;
+			switch (type) {
+				case "string":
+				case "number":
+				case "boolean": return [...acc, type];
+				case "bigint": return [...acc, "integer"];
+				case "object":
+					if (x._def.value === null) return [...acc, "null"];
+					return acc;
+				case "symbol":
+				case "undefined":
+				case "function":
+				default: return acc;
+			}
+		}, []);
+		if (types.length === options.length) {
+			const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+			return {
+				type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+				enum: options.reduce((acc, x) => {
+					return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
+				}, [])
+			};
+		}
+	} else if (options.every((x) => x._def.typeName === "ZodEnum")) return {
+		type: "string",
+		enum: options.reduce((acc, x) => [...acc, ...x._def.values.filter((x$1) => !acc.includes(x$1))], [])
+	};
+	return asAnyOf(def, refs);
+}
+const asAnyOf = (def, refs) => {
+	const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef(x._def, {
+		...refs,
+		currentPath: [
+			...refs.currentPath,
+			"anyOf",
+			`${i}`
+		]
+	})).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0));
+	return anyOf.length ? { anyOf } : void 0;
+};
+
+//#endregion
+export { parseUnionDef, primitiveMappings };
+//# sourceMappingURL=union.js.map

package/dist/utils/zod-to-json-schema/parsers/union.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"union.js","names":["def: ZodUnionDef | ZodDiscriminatedUnionDef<any, any>","refs: Refs","options: readonly ZodTypeAny[]","types: JsonSchema7Primitive[]","types","acc: JsonSchema7Primitive[]","x: { _def: ZodLiteralDef }","acc: string[]","x: string","x"],"sources":["../../../../src/utils/zod-to-json-schema/parsers/union.ts"],"sourcesContent":["import {\n  ZodDiscriminatedUnionDef,\n  ZodLiteralDef,\n  ZodTypeAny,\n  ZodUnionDef,\n} from \"zod/v3\";\nimport { parseDef } from \"../parseDef.js\";\nimport { JsonSchema7Type } from \"../parseTypes.js\";\nimport { Refs } from \"../Refs.js\";\n\nexport const primitiveMappings = {\n  ZodString: \"string\",\n  ZodNumber: \"number\",\n  ZodBigInt: \"integer\",\n  ZodBoolean: \"boolean\",\n  ZodNull: \"null\",\n} as const;\ntype ZodPrimitive = keyof typeof primitiveMappings;\ntype JsonSchema7Primitive =\n  (typeof primitiveMappings)[keyof typeof primitiveMappings];\n\nexport type JsonSchema7UnionType =\n  | JsonSchema7PrimitiveUnionType\n  | JsonSchema7AnyOfType;\n\ntype JsonSchema7PrimitiveUnionType =\n  | {\n      type: JsonSchema7Primitive | JsonSchema7Primitive[];\n    }\n  | {\n      type: JsonSchema7Primitive | JsonSchema7Primitive[];\n      enum: (string | number | bigint | boolean | null)[];\n    };\n\ntype JsonSchema7AnyOfType = {\n  anyOf: JsonSchema7Type[];\n};\n\nexport function parseUnionDef(\n  def: ZodUnionDef | ZodDiscriminatedUnionDef<any, any>,\n  refs: Refs\n): JsonSchema7PrimitiveUnionType | JsonSchema7AnyOfType | undefined {\n  if (refs.target === \"openApi3\") return asAnyOf(def, refs);\n\n  const options: readonly ZodTypeAny[] =\n    def.options instanceof Map ? Array.from(def.options.values()) : def.options;\n\n  // This blocks tries to look ahead a bit to produce nicer looking schemas with type array instead of anyOf.\n  if (\n    options.every(\n      (x) =>\n        x._def.typeName in primitiveMappings &&\n        (!x._def.checks || !x._def.checks.length)\n    )\n  ) {\n    // all types in union are primitive and lack checks, so might as well squash into {type: [...]}\n\n    const types = options.reduce((types: JsonSchema7Primitive[], x) => {\n      const type = primitiveMappings[x._def.typeName as ZodPrimitive]; //Can be safely casted due to row 43\n      return type && !types.includes(type) ? [...types, type] : types;\n    }, []);\n\n    return {\n      type: types.length > 1 ? types : types[0],\n    };\n  } else if (\n    options.every((x) => x._def.typeName === \"ZodLiteral\" && !x.description)\n  ) {\n    // all options literals\n\n    const types = options.reduce(\n      (acc: JsonSchema7Primitive[], x: { _def: ZodLiteralDef }) => {\n        const type = typeof x._def.value;\n        switch (type) {\n          case \"string\":\n          case \"number\":\n          case \"boolean\":\n            return [...acc, type];\n          case \"bigint\":\n            return [...acc, \"integer\" as const];\n          case \"object\":\n            if (x._def.value === null) return [...acc, \"null\" as const];\n            return acc;\n          case \"symbol\":\n          case \"undefined\":\n          case \"function\":\n          default:\n            return acc;\n        }\n      },\n      []\n    );\n\n    if (types.length === options.length) {\n      // all the literals are primitive, as far as null can be considered primitive\n\n      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);\n      return {\n        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],\n        enum: options.reduce((acc, x) => {\n          return acc.includes(x._def.value) ? acc : [...acc, x._def.value];\n        }, [] as (string | number | bigint | boolean | null)[]),\n      };\n    }\n  } else if (options.every((x) => x._def.typeName === \"ZodEnum\")) {\n    return {\n      type: \"string\",\n      enum: options.reduce(\n        (acc: string[], x) => [\n          ...acc,\n          ...x._def.values.filter((x: string) => !acc.includes(x)),\n        ],\n        []\n      ),\n    };\n  }\n\n  return asAnyOf(def, refs);\n}\n\nconst asAnyOf = (\n  def: ZodUnionDef | ZodDiscriminatedUnionDef<any, any>,\n  refs: Refs\n): JsonSchema7PrimitiveUnionType | JsonSchema7AnyOfType | undefined => {\n  const anyOf = (\n    (def.options instanceof Map\n      ? Array.from(def.options.values())\n      : def.options) as any[]\n  )\n    .map((x, i) =>\n      parseDef(x._def, {\n        ...refs,\n        currentPath: [...refs.currentPath, \"anyOf\", `${i}`],\n      })\n    )\n    .filter(\n      (x): x is JsonSchema7Type =>\n        !!x &&\n        (!refs.strictUnions ||\n          (typeof x === \"object\" && Object.keys(x).length > 0))\n    );\n\n  return anyOf.length ? { anyOf } : undefined;\n};\n"],"mappings":";;;AAUA,MAAa,oBAAoB;CAC/B,WAAW;CACX,WAAW;CACX,WAAW;CACX,YAAY;CACZ,SAAS;AACV;AAsBD,SAAgB,cACdA,KACAC,MACkE;AAClE,KAAI,KAAK,WAAW,WAAY,QAAO,QAAQ,KAAK,KAAK;CAEzD,MAAMC,UACJ,IAAI,mBAAmB,MAAM,MAAM,KAAK,IAAI,QAAQ,QAAQ,CAAC,GAAG,IAAI;AAGtE,KACE,QAAQ,MACN,CAAC,MACC,EAAE,KAAK,YAAY,sBAClB,CAAC,EAAE,KAAK,UAAU,CAAC,EAAE,KAAK,OAAO,QACrC,EACD;EAGA,MAAM,QAAQ,QAAQ,OAAO,CAACC,SAA+B,MAAM;GACjE,MAAM,OAAO,kBAAkB,EAAE,KAAK;AACtC,UAAO,QAAQ,CAACC,QAAM,SAAS,KAAK,GAAG,CAAC,GAAGA,SAAO,IAAK,IAAGA;EAC3D,GAAE,CAAE,EAAC;AAEN,SAAO,EACL,MAAM,MAAM,SAAS,IAAI,QAAQ,MAAM,GACxC;CACF,WACC,QAAQ,MAAM,CAAC,MAAM,EAAE,KAAK,aAAa,gBAAgB,CAAC,EAAE,YAAY,EACxE;EAGA,MAAM,QAAQ,QAAQ,OACpB,CAACC,KAA6BC,MAA+B;GAC3D,MAAM,OAAO,OAAO,EAAE,KAAK;AAC3B,WAAQ,MAAR;IACE,KAAK;IACL,KAAK;IACL,KAAK,UACH,QAAO,CAAC,GAAG,KAAK,IAAK;IACvB,KAAK,SACH,QAAO,CAAC,GAAG,KAAK,SAAmB;IACrC,KAAK;AACH,SAAI,EAAE,KAAK,UAAU,KAAM,QAAO,CAAC,GAAG,KAAK,MAAgB;AAC3D,YAAO;IACT,KAAK;IACL,KAAK;IACL,KAAK;IACL,QACE,QAAO;GACV;EACF,GACD,CAAE,EACH;AAED,MAAI,MAAM,WAAW,QAAQ,QAAQ;GAGnC,MAAM,cAAc,MAAM,OAAO,CAAC,GAAG,GAAG,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE;AACjE,UAAO;IACL,MAAM,YAAY,SAAS,IAAI,cAAc,YAAY;IACzD,MAAM,QAAQ,OAAO,CAAC,KAAK,MAAM;AAC/B,YAAO,IAAI,SAAS,EAAE,KAAK,MAAM,GAAG,MAAM,CAAC,GAAG,KAAK,EAAE,KAAK,KAAM;IACjE,GAAE,CAAE,EAAkD;GACxD;EACF;CACF,WAAU,QAAQ,MAAM,CAAC,MAAM,EAAE,KAAK,aAAa,UAAU,CAC5D,QAAO;EACL,MAAM;EACN,MAAM,QAAQ,OACZ,CAACC,KAAe,MAAM,CACpB,GAAG,KACH,GAAG,EAAE,KAAK,OAAO,OAAO,CAACC,QAAc,CAAC,IAAI,SAASC,IAAE,CAAC,AACzD,GACD,CAAE,EACH;CACF;AAGH,QAAO,QAAQ,KAAK,KAAK;AAC1B;AAED,MAAM,UAAU,CACdT,KACAC,SACqE;CACrE,MAAM,SACH,IAAI,mBAAmB,MACpB,MAAM,KAAK,IAAI,QAAQ,QAAQ,CAAC,GAChC,IAAI,SAEP,IAAI,CAAC,GAAG,MACP,SAAS,EAAE,MAAM;EACf,GAAG;EACH,aAAa;GAAC,GAAG,KAAK;GAAa;GAAS,GAAG,GAAG;EAAC;CACpD,EAAC,CACH,CACA,OACC,CAAC,MACC,CAAC,CAAC,MACD,CAAC,KAAK,gBACJ,OAAO,MAAM,YAAY,OAAO,KAAK,EAAE,CAAC,SAAS,GACvD;AAEH,QAAO,MAAM,SAAS,EAAE,MAAO,IAAG;AACnC"}

package/dist/utils/zod-to-json-schema/parsers/unknown.cjs

@@ -0,0 +1,10 @@
+const require_any = require('./any.cjs');
+
+//#region src/utils/zod-to-json-schema/parsers/unknown.ts
+function parseUnknownDef(refs) {
+	return require_any.parseAnyDef(refs);
+}
+
+//#endregion
+exports.parseUnknownDef = parseUnknownDef;
+//# sourceMappingURL=unknown.cjs.map

package/dist/utils/zod-to-json-schema/parsers/unknown.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown.cjs","names":["refs: Refs","parseAnyDef"],"sources":["../../../../src/utils/zod-to-json-schema/parsers/unknown.ts"],"sourcesContent":["import { Refs } from \"../Refs\";\nimport { JsonSchema7AnyType, parseAnyDef } from \"./any.js\";\n\nexport type JsonSchema7UnknownType = JsonSchema7AnyType;\n\nexport function parseUnknownDef(refs: Refs): JsonSchema7UnknownType {\n  return parseAnyDef(refs);\n}\n"],"mappings":";;;AAKA,SAAgB,gBAAgBA,MAAoC;AAClE,QAAOC,wBAAY,KAAK;AACzB"}

package/dist/utils/zod-to-json-schema/parsers/unknown.d.cts

@@ -0,0 +1,7 @@
+import { JsonSchema7AnyType } from "./any.cjs";
+
+//#region src/utils/zod-to-json-schema/parsers/unknown.d.ts
+type JsonSchema7UnknownType = JsonSchema7AnyType;
+//#endregion
+export { JsonSchema7UnknownType };
+//# sourceMappingURL=unknown.d.cts.map

package/dist/utils/zod-to-json-schema/parsers/unknown.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown.d.cts","names":["Refs","JsonSchema7AnyType","JsonSchema7UnknownType","parseUnknownDef"],"sources":["../../../../src/utils/zod-to-json-schema/parsers/unknown.d.ts"],"sourcesContent":["import { Refs } from \"../Refs\";\nimport { JsonSchema7AnyType } from \"./any.js\";\nexport type JsonSchema7UnknownType = JsonSchema7AnyType;\nexport declare function parseUnknownDef(refs: Refs): JsonSchema7UnknownType;\n"],"mappings":";;;KAEYE,sBAAAA,GAAyBD"}

package/dist/utils/zod-to-json-schema/parsers/unknown.d.ts

@@ -0,0 +1,7 @@
+import { JsonSchema7AnyType } from "./any.js";
+
+//#region src/utils/zod-to-json-schema/parsers/unknown.d.ts
+type JsonSchema7UnknownType = JsonSchema7AnyType;
+//#endregion
+export { JsonSchema7UnknownType };
+//# sourceMappingURL=unknown.d.ts.map

package/dist/utils/zod-to-json-schema/parsers/unknown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown.d.ts","names":["Refs","JsonSchema7AnyType","JsonSchema7UnknownType","parseUnknownDef"],"sources":["../../../../src/utils/zod-to-json-schema/parsers/unknown.d.ts"],"sourcesContent":["import { Refs } from \"../Refs\";\nimport { JsonSchema7AnyType } from \"./any.js\";\nexport type JsonSchema7UnknownType = JsonSchema7AnyType;\nexport declare function parseUnknownDef(refs: Refs): JsonSchema7UnknownType;\n"],"mappings":";;;KAEYE,sBAAAA,GAAyBD"}

package/dist/utils/zod-to-json-schema/parsers/unknown.js

@@ -0,0 +1,10 @@
+import { parseAnyDef } from "./any.js";
+
+//#region src/utils/zod-to-json-schema/parsers/unknown.ts
+function parseUnknownDef(refs) {
+	return parseAnyDef(refs);
+}
+
+//#endregion
+export { parseUnknownDef };
+//# sourceMappingURL=unknown.js.map

package/dist/utils/zod-to-json-schema/parsers/unknown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown.js","names":["refs: Refs"],"sources":["../../../../src/utils/zod-to-json-schema/parsers/unknown.ts"],"sourcesContent":["import { Refs } from \"../Refs\";\nimport { JsonSchema7AnyType, parseAnyDef } from \"./any.js\";\n\nexport type JsonSchema7UnknownType = JsonSchema7AnyType;\n\nexport function parseUnknownDef(refs: Refs): JsonSchema7UnknownType {\n  return parseAnyDef(refs);\n}\n"],"mappings":";;;AAKA,SAAgB,gBAAgBA,MAAoC;AAClE,QAAO,YAAY,KAAK;AACzB"}

package/dist/utils/zod-to-json-schema/selectParser.cjs

@@ -0,0 +1,81 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_any = require('./parsers/any.cjs');
+const require_array = require('./parsers/array.cjs');
+const require_bigint = require('./parsers/bigint.cjs');
+const require_boolean = require('./parsers/boolean.cjs');
+const require_branded = require('./parsers/branded.cjs');
+const require_catch = require('./parsers/catch.cjs');
+const require_date = require('./parsers/date.cjs');
+const require_default = require('./parsers/default.cjs');
+const require_effects = require('./parsers/effects.cjs');
+const require_enum = require('./parsers/enum.cjs');
+const require_intersection = require('./parsers/intersection.cjs');
+const require_literal = require('./parsers/literal.cjs');
+const require_string = require('./parsers/string.cjs');
+const require_record = require('./parsers/record.cjs');
+const require_map = require('./parsers/map.cjs');
+const require_nativeEnum = require('./parsers/nativeEnum.cjs');
+const require_never = require('./parsers/never.cjs');
+const require_null = require('./parsers/null.cjs');
+const require_union = require('./parsers/union.cjs');
+const require_nullable = require('./parsers/nullable.cjs');
+const require_number = require('./parsers/number.cjs');
+const require_object = require('./parsers/object.cjs');
+const require_optional = require('./parsers/optional.cjs');
+const require_pipeline = require('./parsers/pipeline.cjs');
+const require_promise = require('./parsers/promise.cjs');
+const require_set = require('./parsers/set.cjs');
+const require_tuple = require('./parsers/tuple.cjs');
+const require_undefined = require('./parsers/undefined.cjs');
+const require_unknown = require('./parsers/unknown.cjs');
+const require_readonly = require('./parsers/readonly.cjs');
+const zod_v3 = require_rolldown_runtime.__toESM(require("zod/v3"));
+
+//#region src/utils/zod-to-json-schema/selectParser.ts
+const selectParser = (def, typeName, refs) => {
+	switch (typeName) {
+		case zod_v3.ZodFirstPartyTypeKind.ZodString: return require_string.parseStringDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodNumber: return require_number.parseNumberDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodObject: return require_object.parseObjectDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodBigInt: return require_bigint.parseBigintDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodBoolean: return require_boolean.parseBooleanDef();
+		case zod_v3.ZodFirstPartyTypeKind.ZodDate: return require_date.parseDateDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodUndefined: return require_undefined.parseUndefinedDef(refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodNull: return require_null.parseNullDef(refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodArray: return require_array.parseArrayDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodUnion:
+		case zod_v3.ZodFirstPartyTypeKind.ZodDiscriminatedUnion: return require_union.parseUnionDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodIntersection: return require_intersection.parseIntersectionDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodTuple: return require_tuple.parseTupleDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodRecord: return require_record.parseRecordDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodLiteral: return require_literal.parseLiteralDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodEnum: return require_enum.parseEnumDef(def);
+		case zod_v3.ZodFirstPartyTypeKind.ZodNativeEnum: return require_nativeEnum.parseNativeEnumDef(def);
+		case zod_v3.ZodFirstPartyTypeKind.ZodNullable: return require_nullable.parseNullableDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodOptional: return require_optional.parseOptionalDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodMap: return require_map.parseMapDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodSet: return require_set.parseSetDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodLazy: return () => def.getter()._def;
+		case zod_v3.ZodFirstPartyTypeKind.ZodPromise: return require_promise.parsePromiseDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodNaN:
+		case zod_v3.ZodFirstPartyTypeKind.ZodNever: return require_never.parseNeverDef(refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodEffects: return require_effects.parseEffectsDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodAny: return require_any.parseAnyDef(refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodUnknown: return require_unknown.parseUnknownDef(refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodDefault: return require_default.parseDefaultDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodBranded: return require_branded.parseBrandedDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodReadonly: return require_readonly.parseReadonlyDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodCatch: return require_catch.parseCatchDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodPipeline: return require_pipeline.parsePipelineDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodFunction:
+		case zod_v3.ZodFirstPartyTypeKind.ZodVoid:
+		case zod_v3.ZodFirstPartyTypeKind.ZodSymbol: return void 0;
+		default:
+ /* c8 ignore next */
+		return ((_) => void 0)(typeName);
+	}
+};
+
+//#endregion
+exports.selectParser = selectParser;
+//# sourceMappingURL=selectParser.cjs.map

package/dist/utils/zod-to-json-schema/selectParser.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectParser.cjs","names":["def: any","typeName: ZodFirstPartyTypeKind","refs: Refs","ZodFirstPartyTypeKind","parseStringDef","parseNumberDef","parseObjectDef","parseBigintDef","parseBooleanDef","parseDateDef","parseUndefinedDef","parseNullDef","parseArrayDef","parseUnionDef","parseIntersectionDef","parseTupleDef","parseRecordDef","parseLiteralDef","parseEnumDef","parseNativeEnumDef","parseNullableDef","parseOptionalDef","parseMapDef","parseSetDef","parsePromiseDef","parseNeverDef","parseEffectsDef","parseAnyDef","parseUnknownDef","parseDefaultDef","parseBrandedDef","parseReadonlyDef","parseCatchDef","parsePipelineDef","_: never"],"sources":["../../../src/utils/zod-to-json-schema/selectParser.ts"],"sourcesContent":["import { ZodFirstPartyTypeKind } from \"zod/v3\";\nimport { parseAnyDef } from \"./parsers/any.js\";\nimport { parseArrayDef } from \"./parsers/array.js\";\nimport { parseBigintDef } from \"./parsers/bigint.js\";\nimport { parseBooleanDef } from \"./parsers/boolean.js\";\nimport { parseBrandedDef } from \"./parsers/branded.js\";\nimport { parseCatchDef } from \"./parsers/catch.js\";\nimport { parseDateDef } from \"./parsers/date.js\";\nimport { parseDefaultDef } from \"./parsers/default.js\";\nimport { parseEffectsDef } from \"./parsers/effects.js\";\nimport { parseEnumDef } from \"./parsers/enum.js\";\nimport { parseIntersectionDef } from \"./parsers/intersection.js\";\nimport { parseLiteralDef } from \"./parsers/literal.js\";\nimport { parseMapDef } from \"./parsers/map.js\";\nimport { parseNativeEnumDef } from \"./parsers/nativeEnum.js\";\nimport { parseNeverDef } from \"./parsers/never.js\";\nimport { parseNullDef } from \"./parsers/null.js\";\nimport { parseNullableDef } from \"./parsers/nullable.js\";\nimport { parseNumberDef } from \"./parsers/number.js\";\nimport { parseObjectDef } from \"./parsers/object.js\";\nimport { parseOptionalDef } from \"./parsers/optional.js\";\nimport { parsePipelineDef } from \"./parsers/pipeline.js\";\nimport { parsePromiseDef } from \"./parsers/promise.js\";\nimport { parseRecordDef } from \"./parsers/record.js\";\nimport { parseSetDef } from \"./parsers/set.js\";\nimport { parseStringDef } from \"./parsers/string.js\";\nimport { parseTupleDef } from \"./parsers/tuple.js\";\nimport { parseUndefinedDef } from \"./parsers/undefined.js\";\nimport { parseUnionDef } from \"./parsers/union.js\";\nimport { parseUnknownDef } from \"./parsers/unknown.js\";\nimport { Refs } from \"./Refs.js\";\nimport { parseReadonlyDef } from \"./parsers/readonly.js\";\nimport { JsonSchema7Type } from \"./parseTypes.js\";\n\nexport type InnerDefGetter = () => any;\n\nexport const selectParser = (\n  def: any,\n  typeName: ZodFirstPartyTypeKind,\n  refs: Refs\n): JsonSchema7Type | undefined | InnerDefGetter => {\n  switch (typeName) {\n    case ZodFirstPartyTypeKind.ZodString:\n      return parseStringDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodNumber:\n      return parseNumberDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodObject:\n      return parseObjectDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodBigInt:\n      return parseBigintDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodBoolean:\n      return parseBooleanDef();\n    case ZodFirstPartyTypeKind.ZodDate:\n      return parseDateDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodUndefined:\n      return parseUndefinedDef(refs);\n    case ZodFirstPartyTypeKind.ZodNull:\n      return parseNullDef(refs);\n    case ZodFirstPartyTypeKind.ZodArray:\n      return parseArrayDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodUnion:\n    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:\n      return parseUnionDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodIntersection:\n      return parseIntersectionDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodTuple:\n      return parseTupleDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodRecord:\n      return parseRecordDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodLiteral:\n      return parseLiteralDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodEnum:\n      return parseEnumDef(def);\n    case ZodFirstPartyTypeKind.ZodNativeEnum:\n      return parseNativeEnumDef(def);\n    case ZodFirstPartyTypeKind.ZodNullable:\n      return parseNullableDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodOptional:\n      return parseOptionalDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodMap:\n      return parseMapDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodSet:\n      return parseSetDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodLazy:\n      return () => (def as any).getter()._def;\n    case ZodFirstPartyTypeKind.ZodPromise:\n      return parsePromiseDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodNaN:\n    case ZodFirstPartyTypeKind.ZodNever:\n      return parseNeverDef(refs);\n    case ZodFirstPartyTypeKind.ZodEffects:\n      return parseEffectsDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodAny:\n      return parseAnyDef(refs);\n    case ZodFirstPartyTypeKind.ZodUnknown:\n      return parseUnknownDef(refs);\n    case ZodFirstPartyTypeKind.ZodDefault:\n      return parseDefaultDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodBranded:\n      return parseBrandedDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodReadonly:\n      return parseReadonlyDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodCatch:\n      return parseCatchDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodPipeline:\n      return parsePipelineDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodFunction:\n    case ZodFirstPartyTypeKind.ZodVoid:\n    case ZodFirstPartyTypeKind.ZodSymbol:\n      return undefined;\n    default:\n      /* c8 ignore next */\n      return ((_: never) => undefined)(typeName);\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,MAAa,eAAe,CAC1BA,KACAC,UACAC,SACiD;AACjD,SAAQ,UAAR;EACE,KAAKC,6BAAsB,UACzB,QAAOC,8BAAe,KAAK,KAAK;EAClC,KAAKD,6BAAsB,UACzB,QAAOE,8BAAe,KAAK,KAAK;EAClC,KAAKF,6BAAsB,UACzB,QAAOG,8BAAe,KAAK,KAAK;EAClC,KAAKH,6BAAsB,UACzB,QAAOI,8BAAe,KAAK,KAAK;EAClC,KAAKJ,6BAAsB,WACzB,QAAOK,iCAAiB;EAC1B,KAAKL,6BAAsB,QACzB,QAAOM,0BAAa,KAAK,KAAK;EAChC,KAAKN,6BAAsB,aACzB,QAAOO,oCAAkB,KAAK;EAChC,KAAKP,6BAAsB,QACzB,QAAOQ,0BAAa,KAAK;EAC3B,KAAKR,6BAAsB,SACzB,QAAOS,4BAAc,KAAK,KAAK;EACjC,KAAKT,6BAAsB;EAC3B,KAAKA,6BAAsB,sBACzB,QAAOU,4BAAc,KAAK,KAAK;EACjC,KAAKV,6BAAsB,gBACzB,QAAOW,0CAAqB,KAAK,KAAK;EACxC,KAAKX,6BAAsB,SACzB,QAAOY,4BAAc,KAAK,KAAK;EACjC,KAAKZ,6BAAsB,UACzB,QAAOa,8BAAe,KAAK,KAAK;EAClC,KAAKb,6BAAsB,WACzB,QAAOc,gCAAgB,KAAK,KAAK;EACnC,KAAKd,6BAAsB,QACzB,QAAOe,0BAAa,IAAI;EAC1B,KAAKf,6BAAsB,cACzB,QAAOgB,sCAAmB,IAAI;EAChC,KAAKhB,6BAAsB,YACzB,QAAOiB,kCAAiB,KAAK,KAAK;EACpC,KAAKjB,6BAAsB,YACzB,QAAOkB,kCAAiB,KAAK,KAAK;EACpC,KAAKlB,6BAAsB,OACzB,QAAOmB,wBAAY,KAAK,KAAK;EAC/B,KAAKnB,6BAAsB,OACzB,QAAOoB,wBAAY,KAAK,KAAK;EAC/B,KAAKpB,6BAAsB,QACzB,QAAO,MAAO,IAAY,QAAQ,CAAC;EACrC,KAAKA,6BAAsB,WACzB,QAAOqB,gCAAgB,KAAK,KAAK;EACnC,KAAKrB,6BAAsB;EAC3B,KAAKA,6BAAsB,SACzB,QAAOsB,4BAAc,KAAK;EAC5B,KAAKtB,6BAAsB,WACzB,QAAOuB,gCAAgB,KAAK,KAAK;EACnC,KAAKvB,6BAAsB,OACzB,QAAOwB,wBAAY,KAAK;EAC1B,KAAKxB,6BAAsB,WACzB,QAAOyB,gCAAgB,KAAK;EAC9B,KAAKzB,6BAAsB,WACzB,QAAO0B,gCAAgB,KAAK,KAAK;EACnC,KAAK1B,6BAAsB,WACzB,QAAO2B,gCAAgB,KAAK,KAAK;EACnC,KAAK3B,6BAAsB,YACzB,QAAO4B,kCAAiB,KAAK,KAAK;EACpC,KAAK5B,6BAAsB,SACzB,QAAO6B,4BAAc,KAAK,KAAK;EACjC,KAAK7B,6BAAsB,YACzB,QAAO8B,kCAAiB,KAAK,KAAK;EACpC,KAAK9B,6BAAsB;EAC3B,KAAKA,6BAAsB;EAC3B,KAAKA,6BAAsB,UACzB,QAAO;EACT;;AAEE,UAAQ,CAAC+B,MAAa,QAAW,SAAS;CAC7C;AACF"}

package/dist/utils/zod-to-json-schema/selectParser.js

@@ -0,0 +1,80 @@
+import { parseAnyDef } from "./parsers/any.js";
+import { parseArrayDef } from "./parsers/array.js";
+import { parseBigintDef } from "./parsers/bigint.js";
+import { parseBooleanDef } from "./parsers/boolean.js";
+import { parseBrandedDef } from "./parsers/branded.js";
+import { parseCatchDef } from "./parsers/catch.js";
+import { parseDateDef } from "./parsers/date.js";
+import { parseDefaultDef } from "./parsers/default.js";
+import { parseEffectsDef } from "./parsers/effects.js";
+import { parseEnumDef } from "./parsers/enum.js";
+import { parseIntersectionDef } from "./parsers/intersection.js";
+import { parseLiteralDef } from "./parsers/literal.js";
+import { parseStringDef } from "./parsers/string.js";
+import { parseRecordDef } from "./parsers/record.js";
+import { parseMapDef } from "./parsers/map.js";
+import { parseNativeEnumDef } from "./parsers/nativeEnum.js";
+import { parseNeverDef } from "./parsers/never.js";
+import { parseNullDef } from "./parsers/null.js";
+import { parseUnionDef } from "./parsers/union.js";
+import { parseNullableDef } from "./parsers/nullable.js";
+import { parseNumberDef } from "./parsers/number.js";
+import { parseObjectDef } from "./parsers/object.js";
+import { parseOptionalDef } from "./parsers/optional.js";
+import { parsePipelineDef } from "./parsers/pipeline.js";
+import { parsePromiseDef } from "./parsers/promise.js";
+import { parseSetDef } from "./parsers/set.js";
+import { parseTupleDef } from "./parsers/tuple.js";
+import { parseUndefinedDef } from "./parsers/undefined.js";
+import { parseUnknownDef } from "./parsers/unknown.js";
+import { parseReadonlyDef } from "./parsers/readonly.js";
+import { ZodFirstPartyTypeKind } from "zod/v3";
+
+//#region src/utils/zod-to-json-schema/selectParser.ts
+const selectParser = (def, typeName, refs) => {
+	switch (typeName) {
+		case ZodFirstPartyTypeKind.ZodString: return parseStringDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodNumber: return parseNumberDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodObject: return parseObjectDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodBigInt: return parseBigintDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodBoolean: return parseBooleanDef();
+		case ZodFirstPartyTypeKind.ZodDate: return parseDateDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodUndefined: return parseUndefinedDef(refs);
+		case ZodFirstPartyTypeKind.ZodNull: return parseNullDef(refs);
+		case ZodFirstPartyTypeKind.ZodArray: return parseArrayDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodUnion:
+		case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: return parseUnionDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodIntersection: return parseIntersectionDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodTuple: return parseTupleDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodRecord: return parseRecordDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodLiteral: return parseLiteralDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodEnum: return parseEnumDef(def);
+		case ZodFirstPartyTypeKind.ZodNativeEnum: return parseNativeEnumDef(def);
+		case ZodFirstPartyTypeKind.ZodNullable: return parseNullableDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodOptional: return parseOptionalDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodMap: return parseMapDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodSet: return parseSetDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodLazy: return () => def.getter()._def;
+		case ZodFirstPartyTypeKind.ZodPromise: return parsePromiseDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodNaN:
+		case ZodFirstPartyTypeKind.ZodNever: return parseNeverDef(refs);
+		case ZodFirstPartyTypeKind.ZodEffects: return parseEffectsDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodAny: return parseAnyDef(refs);
+		case ZodFirstPartyTypeKind.ZodUnknown: return parseUnknownDef(refs);
+		case ZodFirstPartyTypeKind.ZodDefault: return parseDefaultDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodBranded: return parseBrandedDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodReadonly: return parseReadonlyDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodCatch: return parseCatchDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodPipeline: return parsePipelineDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodFunction:
+		case ZodFirstPartyTypeKind.ZodVoid:
+		case ZodFirstPartyTypeKind.ZodSymbol: return void 0;
+		default:
+ /* c8 ignore next */
+		return ((_) => void 0)(typeName);
+	}
+};
+
+//#endregion
+export { selectParser };
+//# sourceMappingURL=selectParser.js.map

package/dist/utils/zod-to-json-schema/selectParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectParser.js","names":["def: any","typeName: ZodFirstPartyTypeKind","refs: Refs","_: never"],"sources":["../../../src/utils/zod-to-json-schema/selectParser.ts"],"sourcesContent":["import { ZodFirstPartyTypeKind } from \"zod/v3\";\nimport { parseAnyDef } from \"./parsers/any.js\";\nimport { parseArrayDef } from \"./parsers/array.js\";\nimport { parseBigintDef } from \"./parsers/bigint.js\";\nimport { parseBooleanDef } from \"./parsers/boolean.js\";\nimport { parseBrandedDef } from \"./parsers/branded.js\";\nimport { parseCatchDef } from \"./parsers/catch.js\";\nimport { parseDateDef } from \"./parsers/date.js\";\nimport { parseDefaultDef } from \"./parsers/default.js\";\nimport { parseEffectsDef } from \"./parsers/effects.js\";\nimport { parseEnumDef } from \"./parsers/enum.js\";\nimport { parseIntersectionDef } from \"./parsers/intersection.js\";\nimport { parseLiteralDef } from \"./parsers/literal.js\";\nimport { parseMapDef } from \"./parsers/map.js\";\nimport { parseNativeEnumDef } from \"./parsers/nativeEnum.js\";\nimport { parseNeverDef } from \"./parsers/never.js\";\nimport { parseNullDef } from \"./parsers/null.js\";\nimport { parseNullableDef } from \"./parsers/nullable.js\";\nimport { parseNumberDef } from \"./parsers/number.js\";\nimport { parseObjectDef } from \"./parsers/object.js\";\nimport { parseOptionalDef } from \"./parsers/optional.js\";\nimport { parsePipelineDef } from \"./parsers/pipeline.js\";\nimport { parsePromiseDef } from \"./parsers/promise.js\";\nimport { parseRecordDef } from \"./parsers/record.js\";\nimport { parseSetDef } from \"./parsers/set.js\";\nimport { parseStringDef } from \"./parsers/string.js\";\nimport { parseTupleDef } from \"./parsers/tuple.js\";\nimport { parseUndefinedDef } from \"./parsers/undefined.js\";\nimport { parseUnionDef } from \"./parsers/union.js\";\nimport { parseUnknownDef } from \"./parsers/unknown.js\";\nimport { Refs } from \"./Refs.js\";\nimport { parseReadonlyDef } from \"./parsers/readonly.js\";\nimport { JsonSchema7Type } from \"./parseTypes.js\";\n\nexport type InnerDefGetter = () => any;\n\nexport const selectParser = (\n  def: any,\n  typeName: ZodFirstPartyTypeKind,\n  refs: Refs\n): JsonSchema7Type | undefined | InnerDefGetter => {\n  switch (typeName) {\n    case ZodFirstPartyTypeKind.ZodString:\n      return parseStringDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodNumber:\n      return parseNumberDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodObject:\n      return parseObjectDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodBigInt:\n      return parseBigintDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodBoolean:\n      return parseBooleanDef();\n    case ZodFirstPartyTypeKind.ZodDate:\n      return parseDateDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodUndefined:\n      return parseUndefinedDef(refs);\n    case ZodFirstPartyTypeKind.ZodNull:\n      return parseNullDef(refs);\n    case ZodFirstPartyTypeKind.ZodArray:\n      return parseArrayDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodUnion:\n    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:\n      return parseUnionDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodIntersection:\n      return parseIntersectionDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodTuple:\n      return parseTupleDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodRecord:\n      return parseRecordDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodLiteral:\n      return parseLiteralDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodEnum:\n      return parseEnumDef(def);\n    case ZodFirstPartyTypeKind.ZodNativeEnum:\n      return parseNativeEnumDef(def);\n    case ZodFirstPartyTypeKind.ZodNullable:\n      return parseNullableDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodOptional:\n      return parseOptionalDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodMap:\n      return parseMapDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodSet:\n      return parseSetDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodLazy:\n      return () => (def as any).getter()._def;\n    case ZodFirstPartyTypeKind.ZodPromise:\n      return parsePromiseDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodNaN:\n    case ZodFirstPartyTypeKind.ZodNever:\n      return parseNeverDef(refs);\n    case ZodFirstPartyTypeKind.ZodEffects:\n      return parseEffectsDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodAny:\n      return parseAnyDef(refs);\n    case ZodFirstPartyTypeKind.ZodUnknown:\n      return parseUnknownDef(refs);\n    case ZodFirstPartyTypeKind.ZodDefault:\n      return parseDefaultDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodBranded:\n      return parseBrandedDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodReadonly:\n      return parseReadonlyDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodCatch:\n      return parseCatchDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodPipeline:\n      return parsePipelineDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodFunction:\n    case ZodFirstPartyTypeKind.ZodVoid:\n    case ZodFirstPartyTypeKind.ZodSymbol:\n      return undefined;\n    default:\n      /* c8 ignore next */\n      return ((_: never) => undefined)(typeName);\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,MAAa,eAAe,CAC1BA,KACAC,UACAC,SACiD;AACjD,SAAQ,UAAR;EACE,KAAK,sBAAsB,UACzB,QAAO,eAAe,KAAK,KAAK;EAClC,KAAK,sBAAsB,UACzB,QAAO,eAAe,KAAK,KAAK;EAClC,KAAK,sBAAsB,UACzB,QAAO,eAAe,KAAK,KAAK;EAClC,KAAK,sBAAsB,UACzB,QAAO,eAAe,KAAK,KAAK;EAClC,KAAK,sBAAsB,WACzB,QAAO,iBAAiB;EAC1B,KAAK,sBAAsB,QACzB,QAAO,aAAa,KAAK,KAAK;EAChC,KAAK,sBAAsB,aACzB,QAAO,kBAAkB,KAAK;EAChC,KAAK,sBAAsB,QACzB,QAAO,aAAa,KAAK;EAC3B,KAAK,sBAAsB,SACzB,QAAO,cAAc,KAAK,KAAK;EACjC,KAAK,sBAAsB;EAC3B,KAAK,sBAAsB,sBACzB,QAAO,cAAc,KAAK,KAAK;EACjC,KAAK,sBAAsB,gBACzB,QAAO,qBAAqB,KAAK,KAAK;EACxC,KAAK,sBAAsB,SACzB,QAAO,cAAc,KAAK,KAAK;EACjC,KAAK,sBAAsB,UACzB,QAAO,eAAe,KAAK,KAAK;EAClC,KAAK,sBAAsB,WACzB,QAAO,gBAAgB,KAAK,KAAK;EACnC,KAAK,sBAAsB,QACzB,QAAO,aAAa,IAAI;EAC1B,KAAK,sBAAsB,cACzB,QAAO,mBAAmB,IAAI;EAChC,KAAK,sBAAsB,YACzB,QAAO,iBAAiB,KAAK,KAAK;EACpC,KAAK,sBAAsB,YACzB,QAAO,iBAAiB,KAAK,KAAK;EACpC,KAAK,sBAAsB,OACzB,QAAO,YAAY,KAAK,KAAK;EAC/B,KAAK,sBAAsB,OACzB,QAAO,YAAY,KAAK,KAAK;EAC/B,KAAK,sBAAsB,QACzB,QAAO,MAAO,IAAY,QAAQ,CAAC;EACrC,KAAK,sBAAsB,WACzB,QAAO,gBAAgB,KAAK,KAAK;EACnC,KAAK,sBAAsB;EAC3B,KAAK,sBAAsB,SACzB,QAAO,cAAc,KAAK;EAC5B,KAAK,sBAAsB,WACzB,QAAO,gBAAgB,KAAK,KAAK;EACnC,KAAK,sBAAsB,OACzB,QAAO,YAAY,KAAK;EAC1B,KAAK,sBAAsB,WACzB,QAAO,gBAAgB,KAAK;EAC9B,KAAK,sBAAsB,WACzB,QAAO,gBAAgB,KAAK,KAAK;EACnC,KAAK,sBAAsB,WACzB,QAAO,gBAAgB,KAAK,KAAK;EACnC,KAAK,sBAAsB,YACzB,QAAO,iBAAiB,KAAK,KAAK;EACpC,KAAK,sBAAsB,SACzB,QAAO,cAAc,KAAK,KAAK;EACjC,KAAK,sBAAsB,YACzB,QAAO,iBAAiB,KAAK,KAAK;EACpC,KAAK,sBAAsB;EAC3B,KAAK,sBAAsB;EAC3B,KAAK,sBAAsB,UACzB,QAAO;EACT;;AAEE,UAAQ,CAACC,MAAa,QAAW,SAAS;CAC7C;AACF"}

package/dist/utils/zod-to-json-schema/zodToJsonSchema.cjs

@@ -0,0 +1,70 @@
+const require_Refs = require('./Refs.cjs');
+const require_any = require('./parsers/any.cjs');
+const require_parseDef = require('./parseDef.cjs');
+
+//#region src/utils/zod-to-json-schema/zodToJsonSchema.ts
+const zodToJsonSchema = (schema, options) => {
+	const refs = require_Refs.getRefs(options);
+	let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name$1, schema$1]) => ({
+		...acc,
+		[name$1]: require_parseDef.parseDef(schema$1._def, {
+			...refs,
+			currentPath: [
+				...refs.basePath,
+				refs.definitionPath,
+				name$1
+			]
+		}, true) ?? require_any.parseAnyDef(refs)
+	}), {}) : void 0;
+	const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
+	const main = require_parseDef.parseDef(schema._def, name === void 0 ? refs : {
+		...refs,
+		currentPath: [
+			...refs.basePath,
+			refs.definitionPath,
+			name
+		]
+	}, false) ?? require_any.parseAnyDef(refs);
+	const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
+	if (title !== void 0) main.title = title;
+	if (refs.flags.hasReferencedOpenAiAnyType) {
+		if (!definitions) definitions = {};
+		if (!definitions[refs.openAiAnyTypeName]) definitions[refs.openAiAnyTypeName] = {
+			type: [
+				"string",
+				"number",
+				"integer",
+				"boolean",
+				"array",
+				"null"
+			],
+			items: { $ref: refs.$refStrategy === "relative" ? "1" : [
+				...refs.basePath,
+				refs.definitionPath,
+				refs.openAiAnyTypeName
+			].join("/") }
+		};
+	}
+	const combined = name === void 0 ? definitions ? {
+		...main,
+		[refs.definitionPath]: definitions
+	} : main : {
+		$ref: [
+			...refs.$refStrategy === "relative" ? [] : refs.basePath,
+			refs.definitionPath,
+			name
+		].join("/"),
+		[refs.definitionPath]: {
+			...definitions,
+			[name]: main
+		}
+	};
+	if (refs.target === "jsonSchema7") combined.$schema = "http://json-schema.org/draft-07/schema#";
+	else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
+	if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
+	return combined;
+};
+
+//#endregion
+exports.zodToJsonSchema = zodToJsonSchema;
+//# sourceMappingURL=zodToJsonSchema.cjs.map

package/dist/utils/zod-to-json-schema/zodToJsonSchema.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"zodToJsonSchema.cjs","names":["schema: ZodSchema<any>","options?: Partial<Options<Target>> | string","getRefs","acc: { [key: string]: JsonSchema7Type }","name","schema","parseDef","parseAnyDef","combined: ReturnType<typeof zodToJsonSchema<Target>>"],"sources":["../../../src/utils/zod-to-json-schema/zodToJsonSchema.ts"],"sourcesContent":["import { ZodSchema } from \"zod/v3\";\nimport { Options, Targets } from \"./Options.js\";\nimport { parseDef } from \"./parseDef.js\";\nimport { JsonSchema7Type } from \"./parseTypes.js\";\nimport { getRefs } from \"./Refs.js\";\nimport { parseAnyDef } from \"./parsers/any.js\";\n\nconst zodToJsonSchema = <Target extends Targets = \"jsonSchema7\">(\n  schema: ZodSchema<any>,\n  options?: Partial<Options<Target>> | string\n): (Target extends \"jsonSchema7\" ? JsonSchema7Type : object) & {\n  $schema?: string;\n  definitions?: {\n    [key: string]: Target extends \"jsonSchema7\"\n      ? JsonSchema7Type\n      : Target extends \"jsonSchema2019-09\"\n      ? JsonSchema7Type\n      : object;\n  };\n} => {\n  const refs = getRefs(options);\n\n  let definitions =\n    typeof options === \"object\" && options.definitions\n      ? Object.entries(options.definitions).reduce(\n          (acc: { [key: string]: JsonSchema7Type }, [name, schema]) => ({\n            ...acc,\n            [name]:\n              parseDef(\n                schema._def,\n                {\n                  ...refs,\n                  currentPath: [...refs.basePath, refs.definitionPath, name],\n                },\n                true\n              ) ?? parseAnyDef(refs),\n          }),\n          {}\n        )\n      : undefined;\n\n  const name =\n    typeof options === \"string\"\n      ? options\n      : options?.nameStrategy === \"title\"\n      ? undefined\n      : options?.name;\n\n  const main =\n    parseDef(\n      schema._def,\n      name === undefined\n        ? refs\n        : {\n            ...refs,\n            currentPath: [...refs.basePath, refs.definitionPath, name],\n          },\n      false\n    ) ?? (parseAnyDef(refs) as JsonSchema7Type);\n\n  const title =\n    typeof options === \"object\" &&\n    options.name !== undefined &&\n    options.nameStrategy === \"title\"\n      ? options.name\n      : undefined;\n\n  if (title !== undefined) {\n    main.title = title;\n  }\n\n  if (refs.flags.hasReferencedOpenAiAnyType) {\n    if (!definitions) {\n      definitions = {};\n    }\n\n    if (!definitions[refs.openAiAnyTypeName]) {\n      definitions[refs.openAiAnyTypeName] = {\n        // Skipping \"object\" as no properties can be defined and additionalProperties must be \"false\"\n        type: [\"string\", \"number\", \"integer\", \"boolean\", \"array\", \"null\"],\n        items: {\n          $ref:\n            refs.$refStrategy === \"relative\"\n              ? \"1\"\n              : [\n                  ...refs.basePath,\n                  refs.definitionPath,\n                  refs.openAiAnyTypeName,\n                ].join(\"/\"),\n        },\n      } as JsonSchema7Type;\n    }\n  }\n\n  const combined: ReturnType<typeof zodToJsonSchema<Target>> =\n    name === undefined\n      ? definitions\n        ? {\n            ...main,\n            [refs.definitionPath]: definitions,\n          }\n        : main\n      : {\n          $ref: [\n            ...(refs.$refStrategy === \"relative\" ? [] : refs.basePath),\n            refs.definitionPath,\n            name,\n          ].join(\"/\"),\n          [refs.definitionPath]: {\n            ...definitions,\n            [name]: main,\n          },\n        };\n\n  if (refs.target === \"jsonSchema7\") {\n    combined.$schema = \"http://json-schema.org/draft-07/schema#\";\n  } else if (refs.target === \"jsonSchema2019-09\" || refs.target === \"openAi\") {\n    combined.$schema = \"https://json-schema.org/draft/2019-09/schema#\";\n  }\n\n  if (\n    refs.target === \"openAi\" &&\n    (\"anyOf\" in combined ||\n      \"oneOf\" in combined ||\n      \"allOf\" in combined ||\n      (\"type\" in combined && Array.isArray(combined.type)))\n  ) {\n    console.warn(\n      \"Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.\"\n    );\n  }\n\n  return combined;\n};\n\nexport { zodToJsonSchema };\n"],"mappings":";;;;;AAOA,MAAM,kBAAkB,CACtBA,QACAC,YAUG;CACH,MAAM,OAAOC,qBAAQ,QAAQ;CAE7B,IAAI,cACF,OAAO,YAAY,YAAY,QAAQ,cACnC,OAAO,QAAQ,QAAQ,YAAY,CAAC,OAClC,CAACC,KAAyC,CAACC,QAAMC,SAAO,MAAM;EAC5D,GAAG;GACFD,SACCE,0BACED,SAAO,MACP;GACE,GAAG;GACH,aAAa;IAAC,GAAG,KAAK;IAAU,KAAK;IAAgBD;GAAK;EAC3D,GACD,KACD,IAAIG,wBAAY,KAAK;CACzB,IACD,CAAE,EACH,GACD;CAEN,MAAM,OACJ,OAAO,YAAY,WACf,UACA,SAAS,iBAAiB,UAC1B,SACA,SAAS;CAEf,MAAM,OACJD,0BACE,OAAO,MACP,SAAS,SACL,OACA;EACE,GAAG;EACH,aAAa;GAAC,GAAG,KAAK;GAAU,KAAK;GAAgB;EAAK;CAC3D,GACL,MACD,IAAKC,wBAAY,KAAK;CAEzB,MAAM,QACJ,OAAO,YAAY,YACnB,QAAQ,SAAS,UACjB,QAAQ,iBAAiB,UACrB,QAAQ,OACR;AAEN,KAAI,UAAU,QACZ,KAAK,QAAQ;AAGf,KAAI,KAAK,MAAM,4BAA4B;AACzC,MAAI,CAAC,aACH,cAAc,CAAE;AAGlB,MAAI,CAAC,YAAY,KAAK,oBACpB,YAAY,KAAK,qBAAqB;GAEpC,MAAM;IAAC;IAAU;IAAU;IAAW;IAAW;IAAS;GAAO;GACjE,OAAO,EACL,MACE,KAAK,iBAAiB,aAClB,MACA;IACE,GAAG,KAAK;IACR,KAAK;IACL,KAAK;GACN,EAAC,KAAK,IAAI,CAClB;EACF;CAEJ;CAED,MAAMC,WACJ,SAAS,SACL,cACE;EACE,GAAG;GACF,KAAK,iBAAiB;CACxB,IACD,OACF;EACE,MAAM;GACJ,GAAI,KAAK,iBAAiB,aAAa,CAAE,IAAG,KAAK;GACjD,KAAK;GACL;EACD,EAAC,KAAK,IAAI;GACV,KAAK,iBAAiB;GACrB,GAAG;IACF,OAAO;EACT;CACF;AAEP,KAAI,KAAK,WAAW,eAClB,SAAS,UAAU;UACV,KAAK,WAAW,uBAAuB,KAAK,WAAW,UAChE,SAAS,UAAU;AAGrB,KACE,KAAK,WAAW,aACf,WAAW,YACV,WAAW,YACX,WAAW,YACV,UAAU,YAAY,MAAM,QAAQ,SAAS,KAAK,GAErD,QAAQ,KACN,uGACD;AAGH,QAAO;AACR"}

package/dist/utils/zod-to-json-schema/zodToJsonSchema.js

@@ -0,0 +1,70 @@
+import { getRefs } from "./Refs.js";
+import { parseAnyDef } from "./parsers/any.js";
+import { parseDef } from "./parseDef.js";
+
+//#region src/utils/zod-to-json-schema/zodToJsonSchema.ts
+const zodToJsonSchema = (schema, options) => {
+	const refs = getRefs(options);
+	let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name$1, schema$1]) => ({
+		...acc,
+		[name$1]: parseDef(schema$1._def, {
+			...refs,
+			currentPath: [
+				...refs.basePath,
+				refs.definitionPath,
+				name$1
+			]
+		}, true) ?? parseAnyDef(refs)
+	}), {}) : void 0;
+	const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
+	const main = parseDef(schema._def, name === void 0 ? refs : {
+		...refs,
+		currentPath: [
+			...refs.basePath,
+			refs.definitionPath,
+			name
+		]
+	}, false) ?? parseAnyDef(refs);
+	const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
+	if (title !== void 0) main.title = title;
+	if (refs.flags.hasReferencedOpenAiAnyType) {
+		if (!definitions) definitions = {};
+		if (!definitions[refs.openAiAnyTypeName]) definitions[refs.openAiAnyTypeName] = {
+			type: [
+				"string",
+				"number",
+				"integer",
+				"boolean",
+				"array",
+				"null"
+			],
+			items: { $ref: refs.$refStrategy === "relative" ? "1" : [
+				...refs.basePath,
+				refs.definitionPath,
+				refs.openAiAnyTypeName
+			].join("/") }
+		};
+	}
+	const combined = name === void 0 ? definitions ? {
+		...main,
+		[refs.definitionPath]: definitions
+	} : main : {
+		$ref: [
+			...refs.$refStrategy === "relative" ? [] : refs.basePath,
+			refs.definitionPath,
+			name
+		].join("/"),
+		[refs.definitionPath]: {
+			...definitions,
+			[name]: main
+		}
+	};
+	if (refs.target === "jsonSchema7") combined.$schema = "http://json-schema.org/draft-07/schema#";
+	else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
+	if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
+	return combined;
+};
+
+//#endregion
+export { zodToJsonSchema };
+//# sourceMappingURL=zodToJsonSchema.js.map

package/dist/utils/zod-to-json-schema/zodToJsonSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zodToJsonSchema.js","names":["schema: ZodSchema<any>","options?: Partial<Options<Target>> | string","acc: { [key: string]: JsonSchema7Type }","name","schema","combined: ReturnType<typeof zodToJsonSchema<Target>>"],"sources":["../../../src/utils/zod-to-json-schema/zodToJsonSchema.ts"],"sourcesContent":["import { ZodSchema } from \"zod/v3\";\nimport { Options, Targets } from \"./Options.js\";\nimport { parseDef } from \"./parseDef.js\";\nimport { JsonSchema7Type } from \"./parseTypes.js\";\nimport { getRefs } from \"./Refs.js\";\nimport { parseAnyDef } from \"./parsers/any.js\";\n\nconst zodToJsonSchema = <Target extends Targets = \"jsonSchema7\">(\n  schema: ZodSchema<any>,\n  options?: Partial<Options<Target>> | string\n): (Target extends \"jsonSchema7\" ? JsonSchema7Type : object) & {\n  $schema?: string;\n  definitions?: {\n    [key: string]: Target extends \"jsonSchema7\"\n      ? JsonSchema7Type\n      : Target extends \"jsonSchema2019-09\"\n      ? JsonSchema7Type\n      : object;\n  };\n} => {\n  const refs = getRefs(options);\n\n  let definitions =\n    typeof options === \"object\" && options.definitions\n      ? Object.entries(options.definitions).reduce(\n          (acc: { [key: string]: JsonSchema7Type }, [name, schema]) => ({\n            ...acc,\n            [name]:\n              parseDef(\n                schema._def,\n                {\n                  ...refs,\n                  currentPath: [...refs.basePath, refs.definitionPath, name],\n                },\n                true\n              ) ?? parseAnyDef(refs),\n          }),\n          {}\n        )\n      : undefined;\n\n  const name =\n    typeof options === \"string\"\n      ? options\n      : options?.nameStrategy === \"title\"\n      ? undefined\n      : options?.name;\n\n  const main =\n    parseDef(\n      schema._def,\n      name === undefined\n        ? refs\n        : {\n            ...refs,\n            currentPath: [...refs.basePath, refs.definitionPath, name],\n          },\n      false\n    ) ?? (parseAnyDef(refs) as JsonSchema7Type);\n\n  const title =\n    typeof options === \"object\" &&\n    options.name !== undefined &&\n    options.nameStrategy === \"title\"\n      ? options.name\n      : undefined;\n\n  if (title !== undefined) {\n    main.title = title;\n  }\n\n  if (refs.flags.hasReferencedOpenAiAnyType) {\n    if (!definitions) {\n      definitions = {};\n    }\n\n    if (!definitions[refs.openAiAnyTypeName]) {\n      definitions[refs.openAiAnyTypeName] = {\n        // Skipping \"object\" as no properties can be defined and additionalProperties must be \"false\"\n        type: [\"string\", \"number\", \"integer\", \"boolean\", \"array\", \"null\"],\n        items: {\n          $ref:\n            refs.$refStrategy === \"relative\"\n              ? \"1\"\n              : [\n                  ...refs.basePath,\n                  refs.definitionPath,\n                  refs.openAiAnyTypeName,\n                ].join(\"/\"),\n        },\n      } as JsonSchema7Type;\n    }\n  }\n\n  const combined: ReturnType<typeof zodToJsonSchema<Target>> =\n    name === undefined\n      ? definitions\n        ? {\n            ...main,\n            [refs.definitionPath]: definitions,\n          }\n        : main\n      : {\n          $ref: [\n            ...(refs.$refStrategy === \"relative\" ? [] : refs.basePath),\n            refs.definitionPath,\n            name,\n          ].join(\"/\"),\n          [refs.definitionPath]: {\n            ...definitions,\n            [name]: main,\n          },\n        };\n\n  if (refs.target === \"jsonSchema7\") {\n    combined.$schema = \"http://json-schema.org/draft-07/schema#\";\n  } else if (refs.target === \"jsonSchema2019-09\" || refs.target === \"openAi\") {\n    combined.$schema = \"https://json-schema.org/draft/2019-09/schema#\";\n  }\n\n  if (\n    refs.target === \"openAi\" &&\n    (\"anyOf\" in combined ||\n      \"oneOf\" in combined ||\n      \"allOf\" in combined ||\n      (\"type\" in combined && Array.isArray(combined.type)))\n  ) {\n    console.warn(\n      \"Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.\"\n    );\n  }\n\n  return combined;\n};\n\nexport { zodToJsonSchema };\n"],"mappings":";;;;;AAOA,MAAM,kBAAkB,CACtBA,QACAC,YAUG;CACH,MAAM,OAAO,QAAQ,QAAQ;CAE7B,IAAI,cACF,OAAO,YAAY,YAAY,QAAQ,cACnC,OAAO,QAAQ,QAAQ,YAAY,CAAC,OAClC,CAACC,KAAyC,CAACC,QAAMC,SAAO,MAAM;EAC5D,GAAG;GACFD,SACC,SACEC,SAAO,MACP;GACE,GAAG;GACH,aAAa;IAAC,GAAG,KAAK;IAAU,KAAK;IAAgBD;GAAK;EAC3D,GACD,KACD,IAAI,YAAY,KAAK;CACzB,IACD,CAAE,EACH,GACD;CAEN,MAAM,OACJ,OAAO,YAAY,WACf,UACA,SAAS,iBAAiB,UAC1B,SACA,SAAS;CAEf,MAAM,OACJ,SACE,OAAO,MACP,SAAS,SACL,OACA;EACE,GAAG;EACH,aAAa;GAAC,GAAG,KAAK;GAAU,KAAK;GAAgB;EAAK;CAC3D,GACL,MACD,IAAK,YAAY,KAAK;CAEzB,MAAM,QACJ,OAAO,YAAY,YACnB,QAAQ,SAAS,UACjB,QAAQ,iBAAiB,UACrB,QAAQ,OACR;AAEN,KAAI,UAAU,QACZ,KAAK,QAAQ;AAGf,KAAI,KAAK,MAAM,4BAA4B;AACzC,MAAI,CAAC,aACH,cAAc,CAAE;AAGlB,MAAI,CAAC,YAAY,KAAK,oBACpB,YAAY,KAAK,qBAAqB;GAEpC,MAAM;IAAC;IAAU;IAAU;IAAW;IAAW;IAAS;GAAO;GACjE,OAAO,EACL,MACE,KAAK,iBAAiB,aAClB,MACA;IACE,GAAG,KAAK;IACR,KAAK;IACL,KAAK;GACN,EAAC,KAAK,IAAI,CAClB;EACF;CAEJ;CAED,MAAME,WACJ,SAAS,SACL,cACE;EACE,GAAG;GACF,KAAK,iBAAiB;CACxB,IACD,OACF;EACE,MAAM;GACJ,GAAI,KAAK,iBAAiB,aAAa,CAAE,IAAG,KAAK;GACjD,KAAK;GACL;EACD,EAAC,KAAK,IAAI;GACV,KAAK,iBAAiB;GACrB,GAAG;IACF,OAAO;EACT;CACF;AAEP,KAAI,KAAK,WAAW,eAClB,SAAS,UAAU;UACV,KAAK,WAAW,uBAAuB,KAAK,WAAW,UAChE,SAAS,UAAU;AAGrB,KACE,KAAK,WAAW,aACf,WAAW,YACV,WAAW,YACX,WAAW,YACV,UAAU,YAAY,MAAM,QAAQ,SAAS,KAAK,GAErD,QAAQ,KACN,uGACD;AAGH,QAAO;AACR"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.4",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -26,23 +26,15 @@
     "p-queue": "^6.6.2",
     "p-retry": "4",
     "uuid": "^10.0.0",
-    "zod": "^3.25.32",
-    "zod-to-json-schema": "^3.22.3"
+    "zod": "^3.25.76 || ^4"
   },
   "devDependencies": {
     "@types/decamelize": "^1.2.0",
     "@types/mustache": "^4",
     "@types/uuid": "^10.0.0",
-    "@typescript-eslint/eslint-plugin": "^6.12.0",
-    "@typescript-eslint/parser": "^6.12.0",
     "dotenv": "^17.2.1",
     "dpdm": "^3.14.0",
-    "eslint": "^8.33.0",
-    "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-prettier": "^8.6.0",
-    "eslint-plugin-import": "^2.27.5",
-    "eslint-plugin-no-instanceof": "^1.0.1",
-    "eslint-plugin-prettier": "^4.2.1",
+    "eslint": "^9.34.0",
     "ml-matrix": "^6.10.4",
     "prettier": "^2.8.3",
     "release-it": "^19.0.4",
@@ -50,7 +42,8 @@
     "rimraf": "^5.0.1",
     "typescript": "~5.8.3",
     "vitest": "^3.2.4",
-    "web-streams-polyfill": "^4.0.0"
+    "web-streams-polyfill": "^4.0.0",
+    "@langchain/eslint": "0.1.0"
   },
   "publishConfig": {
     "access": "public"
@@ -653,28 +646,6 @@
       },
       "input": "./src/utils/hash.ts"
     },
-    "./utils/hash/insecure": {
-      "require": {
-        "types": "./dist/utils/js-sha1/hash.d.cts",
-        "default": "./dist/utils/js-sha1/hash.cjs"
-      },
-      "import": {
-        "types": "./dist/utils/js-sha1/hash.d.ts",
-        "default": "./dist/utils/js-sha1/hash.js"
-      },
-      "input": "./src/utils/js-sha1/hash.ts"
-    },
-    "./utils/hash/sha256": {
-      "require": {
-        "types": "./dist/utils/js-sha256/hash.d.cts",
-        "default": "./dist/utils/js-sha256/hash.cjs"
-      },
-      "import": {
-        "types": "./dist/utils/js-sha256/hash.d.ts",
-        "default": "./dist/utils/js-sha256/hash.js"
-      },
-      "input": "./src/utils/js-sha256/hash.ts"
-    },
     "./utils/json_patch": {
       "require": {
         "types": "./dist/utils/json_patch.d.cts",
@@ -771,8 +742,8 @@
   "scripts": {
     "build": "pnpm --filter @langchain/build compile @langchain/core",
     "clean": "rm -rf .turbo dist/",
-    "lint:eslint": "NODE_OPTIONS=--max-old-space-size=4096 eslint --cache --ext .ts,.js src/",
-    "lint:dpdm": "dpdm --skip-dynamic-imports circular --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts --transform",
+    "lint:eslint": "eslint --cache src/",
+    "lint:dpdm": "dpdm --skip-dynamic-imports circular --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts --exclude \"(node_modules|src/utils/zod-to-json-schema)\" --transform",
     "lint": "pnpm lint:eslint && pnpm lint:dpdm",
     "lint:fix": "pnpm lint:eslint --fix && pnpm lint:dpdm",
     "release": "release-it --only-version --config .release-it.json",