@nullix/zod-mongoose-studio 2.4.0 → 2.4.1

package/.output/server/chunks/routes/api/parse.post.mjs

@@ -5,8 +5,9 @@ import util from 'node:util';
 import { fileURLToPath } from 'node:url';
 import { dirname } from 'node:path';
 import * as zod from 'zod';
-import * as mongoose$1 from 'mongoose';
-import * as v4$1 from 'zod/v4';
+import * as mongoose from 'mongoose';
+import mongoose__default from 'mongoose';
+import { z } from 'zod/v4';
 import 'node:http';
 import 'node:https';
 import 'node:events';
@@ -16,1395 +17,1113 @@ import 'node:crypto';
 import '@iconify/utils';
 import 'consola';
 
-function _mergeNamespaces(n, m) {
-	for (var i = 0; i < m.length; i++) {
-		const e = m[i];
-		if (typeof e !== 'string' && !Array.isArray(e)) { for (const k in e) {
-			if (k !== 'default' && !(k in n)) {
-				const d = Object.getOwnPropertyDescriptor(e, k);
-				if (d) {
-					Object.defineProperty(n, k, d.get ? d : {
-						enumerable: true,
-						get: function () { return e[k]; }
-					});
-				}
-			}
-		} }
-	}
-	return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: 'Module' }));
-}
-
-function getDefaultExportFromNamespaceIfNotNamed (n) {
-	return n && Object.prototype.hasOwnProperty.call(n, 'default') && Object.keys(n).length === 1 ? n['default'] : n;
-}
-
-var dist = {};
-
-const require$$0 = /*@__PURE__*/getDefaultExportFromNamespaceIfNotNamed(v4$1);
-
-const require$$1 = /*@__PURE__*/getDefaultExportFromNamespaceIfNotNamed(mongoose$1);
-
-var v4 = require$$0;
-var mongoose = require$$1;
-
-//#region src/utils.ts
-function flatHooks(configHooks, hooks = {}, parentName) {
-	for (const key in configHooks) {
-		const subHook = configHooks[key];
-		const name = parentName ? `${parentName}:${key}` : key;
-		if (typeof subHook === "object" && subHook !== null) flatHooks(subHook, hooks, name);
-		else if (typeof subHook === "function") hooks[name] = subHook;
-	}
-	return hooks;
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+function flatHooks(configHooks, hooks2 = {}, parentName) {
+  for (const key in configHooks) {
+    const subHook = configHooks[key];
+    const name = parentName ? `${parentName}:${key}` : key;
+    if (typeof subHook === "object" && subHook !== null) flatHooks(subHook, hooks2, name);
+    else if (typeof subHook === "function") hooks2[name] = subHook;
+  }
+  return hooks2;
 }
 const createTask = /* @__PURE__ */ (() => {
-	if (console.createTask) return console.createTask;
-	const defaultTask = { run: (fn) => fn() };
-	return () => defaultTask;
+  if (console.createTask) return console.createTask;
+  const defaultTask = { run: (fn) => fn() };
+  return () => defaultTask;
 })();
-function callHooks(hooks, args, startIndex, task) {
-	for (let i = startIndex; i < hooks.length; i += 1) try {
-		const result = task ? task.run(() => hooks[i](...args)) : hooks[i](...args);
-		if (result instanceof Promise) return result.then(() => callHooks(hooks, args, i + 1, task));
-	} catch (error) {
-		return Promise.reject(error);
-	}
+function callHooks(hooks2, args, startIndex, task) {
+  for (let i = startIndex; i < hooks2.length; i += 1) try {
+    const result = task ? task.run(() => hooks2[i](...args)) : hooks2[i](...args);
+    if (result instanceof Promise) return result.then(() => callHooks(hooks2, args, i + 1, task));
+  } catch (error) {
+    return Promise.reject(error);
+  }
 }
-function serialTaskCaller(hooks, args, name) {
-	if (hooks.length > 0) return callHooks(hooks, args, 0, createTask(name));
+function serialTaskCaller(hooks2, args, name) {
+  if (hooks2.length > 0) return callHooks(hooks2, args, 0, createTask(name));
 }
-function parallelTaskCaller(hooks, args, name) {
-	if (hooks.length > 0) {
-		const task = createTask(name);
-		return Promise.all(hooks.map((hook) => task.run(() => hook(...args))));
-	}
+function parallelTaskCaller(hooks2, args, name) {
+  if (hooks2.length > 0) {
+    const task = createTask(name);
+    return Promise.all(hooks2.map((hook) => task.run(() => hook(...args))));
+  }
 }
 function callEachWith(callbacks, arg0) {
-	for (const callback of [...callbacks]) callback(arg0);
+  for (const callback of [...callbacks]) callback(arg0);
 }
-//#endregion
-//#region src/hookable.ts
 var Hookable = class {
-	_hooks;
-	_before;
-	_after;
-	_deprecatedHooks;
-	_deprecatedMessages;
-	constructor() {
-		this._hooks = {};
-		this._before = void 0;
-		this._after = void 0;
-		this._deprecatedMessages = void 0;
-		this._deprecatedHooks = {};
-		this.hook = this.hook.bind(this);
-		this.callHook = this.callHook.bind(this);
-		this.callHookWith = this.callHookWith.bind(this);
-	}
-	hook(name, function_, options = {}) {
-		if (!name || typeof function_ !== "function") return () => {};
-		const originalName = name;
-		let dep;
-		while (this._deprecatedHooks[name]) {
-			dep = this._deprecatedHooks[name];
-			name = dep.to;
-		}
-		if (dep && !options.allowDeprecated) {
-			let message = dep.message;
-			if (!message) message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
-			if (!this._deprecatedMessages) this._deprecatedMessages = /* @__PURE__ */ new Set();
-			if (!this._deprecatedMessages.has(message)) {
-				console.warn(message);
-				this._deprecatedMessages.add(message);
-			}
-		}
-		if (!function_.name) try {
-			Object.defineProperty(function_, "name", {
-				get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
-				configurable: true
-			});
-		} catch {}
-		this._hooks[name] = this._hooks[name] || [];
-		this._hooks[name].push(function_);
-		return () => {
-			if (function_) {
-				this.removeHook(name, function_);
-				function_ = void 0;
-			}
-		};
-	}
-	hookOnce(name, function_) {
-		let _unreg;
-		let _function = (...arguments_) => {
-			if (typeof _unreg === "function") _unreg();
-			_unreg = void 0;
-			_function = void 0;
-			return function_(...arguments_);
-		};
-		_unreg = this.hook(name, _function);
-		return _unreg;
-	}
-	removeHook(name, function_) {
-		const hooks = this._hooks[name];
-		if (hooks) {
-			const index = hooks.indexOf(function_);
-			if (index !== -1) hooks.splice(index, 1);
-			if (hooks.length === 0) this._hooks[name] = void 0;
-		}
-	}
-	clearHook(name) {
-		this._hooks[name] = void 0;
-	}
-	deprecateHook(name, deprecated) {
-		this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
-		const _hooks = this._hooks[name] || [];
-		this._hooks[name] = void 0;
-		for (const hook of _hooks) this.hook(name, hook);
-	}
-	deprecateHooks(deprecatedHooks) {
-		for (const name in deprecatedHooks) this.deprecateHook(name, deprecatedHooks[name]);
-	}
-	addHooks(configHooks) {
-		const hooks = flatHooks(configHooks);
-		const removeFns = Object.keys(hooks).map((key) => this.hook(key, hooks[key]));
-		return () => {
-			for (const unreg of removeFns) unreg();
-			removeFns.length = 0;
-		};
-	}
-	removeHooks(configHooks) {
-		const hooks = flatHooks(configHooks);
-		for (const key in hooks) this.removeHook(key, hooks[key]);
-	}
-	removeAllHooks() {
-		this._hooks = {};
-	}
-	callHook(name, ...args) {
-		return this.callHookWith(serialTaskCaller, name, args);
-	}
-	callHookParallel(name, ...args) {
-		return this.callHookWith(parallelTaskCaller, name, args);
-	}
-	callHookWith(caller, name, args) {
-		const event = this._before || this._after ? {
-			name,
-			args,
-			context: {}
-		} : void 0;
-		if (this._before) callEachWith(this._before, event);
-		const result = caller(this._hooks[name] ? [...this._hooks[name]] : [], args, name);
-		if (result instanceof Promise) return result.finally(() => {
-			if (this._after && event) callEachWith(this._after, event);
-		});
-		if (this._after && event) callEachWith(this._after, event);
-		return result;
-	}
-	beforeEach(function_) {
-		this._before = this._before || [];
-		this._before.push(function_);
-		return () => {
-			if (this._before !== void 0) {
-				const index = this._before.indexOf(function_);
-				if (index !== -1) this._before.splice(index, 1);
-			}
-		};
-	}
-	afterEach(function_) {
-		this._after = this._after || [];
-		this._after.push(function_);
-		return () => {
-			if (this._after !== void 0) {
-				const index = this._after.indexOf(function_);
-				if (index !== -1) this._after.splice(index, 1);
-			}
-		};
-	}
+  constructor() {
+    __publicField(this, "_hooks");
+    __publicField(this, "_before");
+    __publicField(this, "_after");
+    __publicField(this, "_deprecatedHooks");
+    __publicField(this, "_deprecatedMessages");
+    this._hooks = {};
+    this._before = void 0;
+    this._after = void 0;
+    this._deprecatedMessages = void 0;
+    this._deprecatedHooks = {};
+    this.hook = this.hook.bind(this);
+    this.callHook = this.callHook.bind(this);
+    this.callHookWith = this.callHookWith.bind(this);
+  }
+  hook(name, function_, options = {}) {
+    if (!name || typeof function_ !== "function") return () => {
+    };
+    const originalName = name;
+    let dep;
+    while (this._deprecatedHooks[name]) {
+      dep = this._deprecatedHooks[name];
+      name = dep.to;
+    }
+    if (dep && !options.allowDeprecated) {
+      let message = dep.message;
+      if (!message) message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
+      if (!this._deprecatedMessages) this._deprecatedMessages = /* @__PURE__ */ new Set();
+      if (!this._deprecatedMessages.has(message)) {
+        console.warn(message);
+        this._deprecatedMessages.add(message);
+      }
+    }
+    if (!function_.name) try {
+      Object.defineProperty(function_, "name", {
+        get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
+        configurable: true
+      });
+    } catch {
+    }
+    this._hooks[name] = this._hooks[name] || [];
+    this._hooks[name].push(function_);
+    return () => {
+      if (function_) {
+        this.removeHook(name, function_);
+        function_ = void 0;
+      }
+    };
+  }
+  hookOnce(name, function_) {
+    let _unreg;
+    let _function = (...arguments_) => {
+      if (typeof _unreg === "function") _unreg();
+      _unreg = void 0;
+      _function = void 0;
+      return function_(...arguments_);
+    };
+    _unreg = this.hook(name, _function);
+    return _unreg;
+  }
+  removeHook(name, function_) {
+    const hooks2 = this._hooks[name];
+    if (hooks2) {
+      const index = hooks2.indexOf(function_);
+      if (index !== -1) hooks2.splice(index, 1);
+      if (hooks2.length === 0) this._hooks[name] = void 0;
+    }
+  }
+  clearHook(name) {
+    this._hooks[name] = void 0;
+  }
+  deprecateHook(name, deprecated) {
+    this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
+    const _hooks = this._hooks[name] || [];
+    this._hooks[name] = void 0;
+    for (const hook of _hooks) this.hook(name, hook);
+  }
+  deprecateHooks(deprecatedHooks) {
+    for (const name in deprecatedHooks) this.deprecateHook(name, deprecatedHooks[name]);
+  }
+  addHooks(configHooks) {
+    const hooks2 = flatHooks(configHooks);
+    const removeFns = Object.keys(hooks2).map((key) => this.hook(key, hooks2[key]));
+    return () => {
+      for (const unreg of removeFns) unreg();
+      removeFns.length = 0;
+    };
+  }
+  removeHooks(configHooks) {
+    const hooks2 = flatHooks(configHooks);
+    for (const key in hooks2) this.removeHook(key, hooks2[key]);
+  }
+  removeAllHooks() {
+    this._hooks = {};
+  }
+  callHook(name, ...args) {
+    return this.callHookWith(serialTaskCaller, name, args);
+  }
+  callHookParallel(name, ...args) {
+    return this.callHookWith(parallelTaskCaller, name, args);
+  }
+  callHookWith(caller, name, args) {
+    const event = this._before || this._after ? {
+      name,
+      args,
+      context: {}
+    } : void 0;
+    if (this._before) callEachWith(this._before, event);
+    const result = caller(this._hooks[name] ? [...this._hooks[name]] : [], args, name);
+    if (result instanceof Promise) return result.finally(() => {
+      if (this._after && event) callEachWith(this._after, event);
+    });
+    if (this._after && event) callEachWith(this._after, event);
+    return result;
+  }
+  beforeEach(function_) {
+    this._before = this._before || [];
+    this._before.push(function_);
+    return () => {
+      if (this._before !== void 0) {
+        const index = this._before.indexOf(function_);
+        if (index !== -1) this._before.splice(index, 1);
+      }
+    };
+  }
+  afterEach(function_) {
+    this._after = this._after || [];
+    this._after.push(function_);
+    return () => {
+      if (this._after !== void 0) {
+        const index = this._after.indexOf(function_);
+        if (index !== -1) this._after.splice(index, 1);
+      }
+    };
+  }
 };
 function createHooks() {
-	return new Hookable();
+  return new Hookable();
 }
-
 const hooks = createHooks();
-/**
- * Synchronous hook caller for Hookable.
- */
 function callHookSync(name, ...args) {
-    hooks.callHookWith((callbacks, args) => {
-        for (const callback of callbacks) {
-            callback(...args);
-        }
-    }, name, args);
+  hooks.callHookWith((callbacks, args2) => {
+    for (const callback of callbacks) {
+      callback(...args2);
+    }
+  }, name, args);
 }
-
-/**
- * This securely stores our Mongoose metadata alongside the Zod schema instances
- * without polluting the actual validation logic.
- */
-const mongooseRegistry = v4.z.registry();
-/**
- * A clean wrapper to attach Mongoose metadata to any Zod schema.
- */
+const mongooseRegistry = z.registry();
 function withMongoose(schema, meta = {}) {
-    callHookSync('registry:get:before', { schema });
-    const existing = mongooseRegistry.get(schema) || {};
-    callHookSync('registry:get', { schema, meta: existing });
-    const merged = { ...existing, ...meta };
-    callHookSync('registry:add', { schema, meta: merged });
-    mongooseRegistry.add(schema, merged);
-    callHookSync('registry:added', { schema, meta: merged });
-    return schema;
+  callHookSync("registry:get:before", { schema });
+  const existing = mongooseRegistry.get(schema) || {};
+  callHookSync("registry:get", { schema, meta: existing });
+  const merged = { ...existing, ...meta };
+  callHookSync("registry:add", { schema, meta: merged });
+  mongooseRegistry.add(schema, merged);
+  callHookSync("registry:added", { schema, meta: merged });
+  return schema;
 }
-/**
- * Recursively collect Mongoose metadata from a Zod schema and its wrappers.
- */
 function getMongooseMeta(schema) {
-    const def = schema._def;
-    if (!def)
-        return {};
-    let meta = mongooseRegistry.get(schema) || {};
-    // If it has an inner type (Optional, Nullable, Default, etc.), collect from it too
-    if (def.innerType) {
-        meta = { ...getMongooseMeta(def.innerType), ...meta };
-    }
-    else if (def.schema) {
-        meta = { ...getMongooseMeta(def.schema), ...meta };
-    }
-    // Handle pipes (like z.codec)
-    if (def.type === 'pipe') {
-        // Collect from both 'in' and 'out' parts, preferring metadata from 'out' if it exists,
-        // but the pipe itself usually holds the metadata we want.
-        meta = { ...getMongooseMeta(def.in), ...getMongooseMeta(def.out), ...meta };
-    }
-    return meta;
+  const def = schema._def;
+  if (!def)
+    return {};
+  let meta = mongooseRegistry.get(schema) || {};
+  if (def.innerType) {
+    meta = { ...getMongooseMeta(def.innerType), ...meta };
+  } else if (def.schema) {
+    meta = { ...getMongooseMeta(def.schema), ...meta };
+  }
+  if (def.type === "pipe") {
+    meta = { ...getMongooseMeta(def.in), ...getMongooseMeta(def.out), ...meta };
+  }
+  return meta;
 }
-
-/**
- * Recursively unwrap Zod schemas (Optional, Nullable, Default, Effects, Pipelines)
- * using Zod's public API and internal _def.type identifiers.
- */
-function unwrapZodSchema(schema, 
-// eslint-disable-next-line unicorn/no-object-as-default-parameter
-features = { required: true }, visited = new Set()) {
-    if (!schema)
-        return { schema, features };
-    if (visited.has(schema))
-        return { schema, features };
-    const def = schema._def;
-    if (!def)
-        return { schema, features };
-    // Skip visited check for wrappers to allow deep unwrapping
-    if (!(schema instanceof v4.z.ZodOptional) &&
-        !(schema instanceof v4.z.ZodNullable) &&
-        !(schema instanceof v4.z.ZodDefault) &&
-        def.type !== 'pipe') {
-        visited.add(schema);
-    }
-    if (schema instanceof v4.z.ZodOptional) {
-        const inner = schema.unwrap();
-        return unwrapZodSchema(
-        // @ts-expect-error Zod v4 schema.unwrap() return type mismatch
-        inner, {
-            ...features,
-            required: false,
-            isOptional: true,
-        }, visited);
-    }
-    if (schema instanceof v4.z.ZodNullable) {
-        return unwrapZodSchema(
-        // @ts-expect-error Zod v4 schema.unwrap() return type mismatch
-        schema.unwrap(), {
-            ...features,
-            isNullable: true,
-        }, visited);
-    }
-    if (schema instanceof v4.z.ZodDefault) {
-        const defaultValue = typeof def.defaultValue === 'function' ? def.defaultValue() : def.defaultValue;
-        return unwrapZodSchema(def.innerType, {
-            ...features,
-            default: defaultValue,
-        }, visited);
-    }
-    const { type } = def;
-    // In Zod v4, transform, preprocess, and refine are often implemented as pipes.
-    // For transform: in = schema, out = transformation
-    // For preprocess: in = preprocessing, out = schema
-    if (type === 'pipe') {
-        const inType = def.in?._def?.type;
-        const outType = def.out?._def?.type;
-        if (inType === 'transform') {
-            // It's a preprocess (in is transformation, out is schema)
-            return unwrapZodSchema(def.out, features, visited);
-        }
-        if (outType === 'transform' || outType === 'refinement') {
-            // It's a transform or refine (in is schema, out is logic)
-            // We should still collect transformations from the 'out' part
-            const transformFeatures = { ...features };
-            const outDef = def.out?._def;
-            const effects = outDef?.effects || outDef?.transformations || (outType === 'transform' ? [outDef] : []);
-            if (effects && Array.isArray(effects)) {
-                transformFeatures.transformations = [
-                    ...(transformFeatures.transformations || []),
-                    ...effects,
-                ];
-            }
-            return unwrapZodSchema(def.in, transformFeatures, visited);
-        }
-        // Default pipe behavior (extract the output part)
-        return unwrapZodSchema(def.out, features, visited);
-    }
-    if (type === 'transform' ||
-        type === 'preprocess' ||
-        type === 'refinement' ||
-        type === 'effects') {
-        const transformFeatures = { ...features };
-        const effects = def.effects || def.transformations || (def.type === 'transform' || type === 'transform' ? [def] : []);
-        if (effects && Array.isArray(effects)) {
-            transformFeatures.transformations = [
-                ...(transformFeatures.transformations || []),
-                ...effects,
-            ];
-        }
-        const inner = def.schema || def.innerType;
-        if (inner) {
-            const result = unwrapZodSchema(inner, transformFeatures, visited);
-            return result;
-        }
+function unwrapZodSchema(schema, features = { required: true }, visited = /* @__PURE__ */ new Set()) {
+  var _a, _b, _c, _d, _e;
+  if (!schema)
+    return { schema, features };
+  if (visited.has(schema))
+    return { schema, features };
+  const def = schema._def;
+  if (!def)
+    return { schema, features };
+  if (!(schema instanceof z.ZodOptional) && !(schema instanceof z.ZodNullable) && !(schema instanceof z.ZodDefault) && def.type !== "pipe") {
+    visited.add(schema);
+  }
+  if (schema instanceof z.ZodOptional) {
+    const inner = schema.unwrap();
+    return unwrapZodSchema(
+      // @ts-expect-error Zod v4 schema.unwrap() return type mismatch
+      inner,
+      {
+        ...features,
+        required: false,
+        isOptional: true
+      },
+      visited
+    );
+  }
+  if (schema instanceof z.ZodNullable) {
+    return unwrapZodSchema(
+      // @ts-expect-error Zod v4 schema.unwrap() return type mismatch
+      schema.unwrap(),
+      {
+        ...features,
+        isNullable: true
+      },
+      visited
+    );
+  }
+  if (schema instanceof z.ZodDefault) {
+    const defaultValue = typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
+    return unwrapZodSchema(def.innerType, {
+      ...features,
+      default: defaultValue
+    }, visited);
+  }
+  const { type } = def;
+  if (type === "pipe") {
+    const inType = (_b = (_a = def.in) == null ? void 0 : _a._def) == null ? void 0 : _b.type;
+    const outType = (_d = (_c = def.out) == null ? void 0 : _c._def) == null ? void 0 : _d.type;
+    if (inType === "transform") {
+      return unwrapZodSchema(def.out, features, visited);
     }
-    if (type === 'lazy') {
-        // For lazy types, we need to be careful with infinite recursion.
-        // If we've already seen this specific lazy schema in this unwrapping chain,
-        // we return it as is to stop recursion.
-        // NOTE: In Zod v4, getter() might return different objects each time if not careful.
-        return { schema, features };
+    if (outType === "transform" || outType === "refinement") {
+      const transformFeatures = { ...features };
+      const outDef = (_e = def.out) == null ? void 0 : _e._def;
+      const effects = (outDef == null ? void 0 : outDef.effects) || (outDef == null ? void 0 : outDef.transformations) || (outType === "transform" ? [outDef] : []);
+      if (effects && Array.isArray(effects)) {
+        transformFeatures.transformations = [
+          ...transformFeatures.transformations || [],
+          ...effects
+        ];
+      }
+      return unwrapZodSchema(def.in, transformFeatures, visited);
     }
-    if (type === 'branded' || type === 'readonly') {
-        return unwrapZodSchema(schema.unwrap(), {
-            ...features,
-            ...(type === 'readonly' ? { readOnly: true } : {}),
-        }, visited);
+    return unwrapZodSchema(def.out, features, visited);
+  }
+  if (type === "transform" || type === "preprocess" || type === "refinement" || type === "effects") {
+    const transformFeatures = { ...features };
+    const effects = def.effects || def.transformations || (def.type === "transform" || type === "transform" ? [def] : []);
+    if (effects && Array.isArray(effects)) {
+      transformFeatures.transformations = [
+        ...transformFeatures.transformations || [],
+        ...effects
+      ];
     }
-    // Extract checks if present
-    if (def.checks && Array.isArray(def.checks)) {
-        features.checks = [...(features.checks || []), ...def.checks];
+    const inner = def.schema || def.innerType;
+    if (inner) {
+      const result = unwrapZodSchema(inner, transformFeatures, visited);
+      return result;
     }
+  }
+  if (type === "lazy") {
     return { schema, features };
+  }
+  if (type === "branded" || type === "readonly") {
+    return unwrapZodSchema(schema.unwrap(), {
+      ...features,
+      ...type === "readonly" ? { readOnly: true } : {}
+    }, visited);
+  }
+  if (def.checks && Array.isArray(def.checks)) {
+    features.checks = [...features.checks || [], ...def.checks];
+  }
+  return { schema, features };
 }
-
 let mongooseInstance = null;
-/**
- * Manually set the Mongoose instance.
- * Useful in ESM environments where automatic detection via require() might fail.
- */
 const setMongoose = (m) => {
-    mongooseInstance = m;
+  mongooseInstance = m;
 };
-// Helper to get mongoose instance safely
 const getMongoose = () => {
-    if (mongooseInstance) {
-        return mongooseInstance;
-    }
-    try {
-        // eslint-disable-next-line global-require
-        const m = require('mongoose');
-        if (m && (m.Schema || m.default?.Schema)) {
-            return m.default || m;
-        }
-        return m;
+  var _a;
+  if (mongooseInstance) {
+    return mongooseInstance;
+  }
+  try {
+    const m = require("mongoose");
+    if (m && (m.Schema || ((_a = m.default) == null ? void 0 : _a.Schema))) {
+      return m.default || m;
     }
-    catch {
-        // Try to see if mongoose is globally available (e.g. in some environments)
-        if (globalThis.mongoose) {
-            return globalThis.mongoose;
-        }
-        return null;
+    return m;
+  } catch {
+    if (globalThis.mongoose) {
+      return globalThis.mongoose;
     }
+    return null;
+  }
 };
 let isFrontend = false;
-/**
- * Enable or disable frontend mode.
- * In frontend mode, specialized types like ObjectId and Buffer fall back to
- * simpler representations (strings/arrays) and do not depend on Mongoose.
- */
 const setFrontendMode = (enabled) => {
-    isFrontend = enabled;
+  isFrontend = enabled;
 };
 const getFrontendMode = () => {
-    // Try to auto-detect if not explicitly set
-    // This is a simple heuristic: check for window/document
-    if (isFrontend === undefined || isFrontend === null) {
-        return globalThis.window !== undefined && globalThis.document !== undefined;
-    }
-    return isFrontend;
+  if (isFrontend === void 0 || isFrontend === null) {
+    return globalThis.window !== void 0 && globalThis.document !== void 0;
+  }
+  return isFrontend;
 };
-
-/**
- * Helper to map Zod checks (min, max, regex, etc.) to Mongoose Schema properties.
- */
 function mapZodChecksToMongoose(checks, mongooseProp) {
-    if (!checks || !Array.isArray(checks))
-        return;
-    for (const check of checks) {
-        const traitSet = check._zod?.traits;
-        const checkDef = check._zod?.def;
-        if (!traitSet || !checkDef)
-            continue;
-        // String Lengths
-        if (traitSet.has('$ZodCheckMinLength')) {
-            mongooseProp.minlength = checkDef.minimum;
-        }
-        if (traitSet.has('$ZodCheckMaxLength')) {
-            mongooseProp.maxlength = checkDef.maximum;
-        }
-        if (traitSet.has('$ZodCheckLengthEquals')) {
-            mongooseProp.minlength = checkDef.length;
-            mongooseProp.maxlength = checkDef.length;
-        }
-        // Numbers and Dates Comparisons
-        if (traitSet.has('$ZodCheckGreaterThan')) {
-            mongooseProp.min = checkDef.value;
-        }
-        if (traitSet.has('$ZodCheckLessThan')) {
-            mongooseProp.max = checkDef.value;
-        }
-        // Regex / Match
-        if (traitSet.has('$ZodCheckRegex')) {
-            mongooseProp.match = checkDef.pattern;
-        }
-        // UUID
-        if (traitSet.has('$ZodUUID')) {
-            const mongoose = globalThis.mongoose || globalThis.__mongoose;
-            if (mongoose?.Schema.Types.UUID) {
-                mongooseProp.type = mongoose.Schema.Types.UUID;
-            }
-        }
-        // ISO Formats
-        if (traitSet.has('$ZodISODateTime') || traitSet.has('$ZodISODate')) {
-            mongooseProp.type = Date;
-        }
-        // String Transforms (trim, lowercase, uppercase)
-        if (traitSet.has('$ZodCheckOverwrite') && typeof checkDef.tx === 'function') {
-            const txStr = checkDef.tx.toString();
-            if (txStr.includes('.trim()')) {
-                mongooseProp.trim = true;
-            }
-            else if (txStr.includes('.toLowerCase()')) {
-                mongooseProp.lowercase = true;
-            }
-            else if (txStr.includes('.toUpperCase()')) {
-                mongooseProp.uppercase = true;
-            }
-        }
+  var _a, _b;
+  if (!checks || !Array.isArray(checks))
+    return;
+  for (const check of checks) {
+    const traitSet = (_a = check._zod) == null ? void 0 : _a.traits;
+    const checkDef = (_b = check._zod) == null ? void 0 : _b.def;
+    if (!traitSet || !checkDef)
+      continue;
+    if (traitSet.has("$ZodCheckMinLength")) {
+      mongooseProp.minlength = checkDef.minimum;
     }
-    callHookSync('validation:mappers', { checks, mongooseProp });
-}
-
-/**
- * Handles ZodObject conversion to Mongoose Schema definition.
- */
-function handleObject(unwrapped, mongooseProp, visited, extractMongooseDef, isField = false) {
-    callHookSync('schema:object:before', { schema: unwrapped, mongooseProp, visited });
-    const { shape } = unwrapped;
-    const objDef = {};
-    // We must ensure recursive calls see the current object to break cycles.
-    const placeholder = mongooseProp.type ? mongooseProp : objDef;
-    visited.set(unwrapped, placeholder);
-    // eslint-disable-next-line no-restricted-syntax
-    for (const key in shape) {
-        if (!Object.prototype.hasOwnProperty.call(shape, key))
-            continue;
-        // Skip automatic _id mapping unless explicitly requested
-        if (key === '_id') {
-            const idMeta = mongooseRegistry.get(shape[key]) || {};
-            const unwrappedId = unwrapZodSchema(shape[key]).schema;
-            const unwrappedIdMeta = mongooseRegistry.get(unwrappedId) || {};
-            if (idMeta.includeId !== true &&
-                unwrappedIdMeta.includeId !== true &&
-                mongooseProp.includeId !== true) {
-                continue;
-            }
-        }
-        const def = extractMongooseDef(shape[key], visited);
-        if (def && typeof def === 'object' && def.__isDiscriminatorUnion) {
-            const mongoose = getMongoose();
-            if (mongoose) {
-                const baseSchema = new mongoose.Schema(def.baseDef, {
-                    discriminatorKey: def.discriminatorKey,
-                    _id: false,
-                });
-                const discriminators = {};
-                for (const [dKey, dDef] of Object.entries(def.discriminators)) {
-                    discriminators[dKey] = new mongoose.Schema(dDef, { _id: false });
-                }
-                objDef[key] = {
-                    type: baseSchema,
-                    discriminators,
-                };
-            }
-            else {
-                objDef[key] = def;
-            }
-        }
-        else if (typeof def === 'object' && def !== null && !Array.isArray(def)) {
-            const { includeId, ...cleanDef } = def;
-            objDef[key] = cleanDef;
-        }
-        else {
-            objDef[key] = def;
-        }
-        callHookSync('schema:object:field', { key, schema: shape[key], objDef, visited });
+    if (traitSet.has("$ZodCheckMaxLength")) {
+      mongooseProp.maxlength = checkDef.maximum;
     }
-    // If the developer didn't provide a strict Mongoose type override, return the shape
-    let result;
-    // Handle explicit or default subschema request
-    const shouldBeSubSchema = isField && mongooseProp.schema !== false;
-    if (shouldBeSubSchema && !mongooseProp.type) {
-        const mongoose = getMongoose();
-        if (mongoose) {
-            const options = typeof mongooseProp.schema === 'object' ? mongooseProp.schema : {};
-            const { plugins, ...schemaOptions } = options;
-            const subSchema = new mongoose.Schema(objDef, schemaOptions);
-            if (plugins && Array.isArray(plugins)) {
-                for (const plugin of plugins) {
-                    subSchema.plugin(plugin);
-                }
-            }
-            mongooseProp.type = subSchema;
-        }
+    if (traitSet.has("$ZodCheckLengthEquals")) {
+      mongooseProp.minlength = checkDef.length;
+      mongooseProp.maxlength = checkDef.length;
     }
-    if (mongooseProp.type) {
-        const mongoose = getMongoose();
-        const isSchema = mongoose && (mongooseProp.type instanceof mongoose.Schema || mongooseProp.type.constructor?.name === 'Schema');
-        // If there is a type override, merge the object definition into the result unless it's a Schema
-        if (!isSchema) {
-            Object.assign(mongooseProp, objDef);
-        }
-        result = mongooseProp;
+    if (traitSet.has("$ZodCheckGreaterThan")) {
+      mongooseProp.min = checkDef.value;
     }
-    else {
-        Object.assign(mongooseProp, objDef);
-        const topLevelOptions = new Set([
-            'collection',
-            'versionKey',
-            'timestamps',
-            'discriminatorKey',
-            'strict',
-            'id',
-            '_id',
-            'minimize',
-            'validateBeforeSave',
-            'schema',
-        ]);
-        const hasFieldMetadata = Object.keys(mongooseProp).some((k) => {
-            if (Object.prototype.hasOwnProperty.call(objDef, k))
-                return false;
-            if (topLevelOptions.has(k))
-                return false;
-            if (k === 'required' && mongooseProp[k] === false)
-                return false;
-            return true;
-        });
-        result = hasFieldMetadata ? mongooseProp : objDef;
+    if (traitSet.has("$ZodCheckLessThan")) {
+      mongooseProp.max = checkDef.value;
     }
-    callHookSync('schema:object:after', { schema: unwrapped, mongooseProp, objDef, result });
-    return result;
-}
-/**
- * Handles ZodArray, ZodSet, and ZodTuple conversion.
- */
-function handleArray(unwrapped, mongooseProp, visited, extractMongooseDef) {
-    callHookSync('schema:array:before', { schema: unwrapped, mongooseProp, visited });
-    const element = unwrapped.element ||
-        unwrapped._def.valueType ||
-        unwrapped._def.rest ||
-        unwrapped._def.items?.[0];
-    const mongoose = getMongoose();
-    const innerDef = element
-        ? extractMongooseDef(element, visited)
-        : mongoose?.Schema.Types.Mixed || 'Mixed';
-    // If no explicit type override, wrap the inner definition in an array
-    if (!mongooseProp.type) {
-        if (innerDef && typeof innerDef === 'object' && innerDef.__isDiscriminatorUnion && mongoose) {
-            // const baseSchema =
-            // new mongoose.Schema(innerDef.baseDef, {
-            //   discriminatorKey: innerDef.discriminatorKey,
-            //   _id: false,
-            // });
-            const discriminators = {};
-            for (const [dKey, dDef] of Object.entries(innerDef.discriminators)) {
-                discriminators[dKey] = new mongoose.Schema(dDef, { _id: false });
-            }
-            mongooseProp.type = [
-                new mongoose.Schema({}, {
-                    discriminatorKey: innerDef.discriminatorKey,
-                    _id: false,
-                }),
-            ];
-            mongooseProp.discriminators = discriminators;
-        }
-        else {
-            const innerType = innerDef.type || innerDef;
-            mongooseProp.type = [innerType];
-            // Transfer any metadata from the inner type (like 'ref') to the array definition
-            if (typeof innerDef === 'object') {
-                // eslint-disable-next-line sonarjs/no-unused-vars
-                const { type: _extractedType, ...innerMeta } = innerDef;
-                Object.assign(mongooseProp, innerMeta);
-                mongooseProp.type = [innerType]; // Restore type as array
-            }
-        }
+    if (traitSet.has("$ZodCheckRegex")) {
+      mongooseProp.match = checkDef.pattern;
     }
-    callHookSync('schema:array:after', { schema: unwrapped, mongooseProp, innerDef });
-}
-/**
- * Handles ZodRecord and ZodMap conversion.
- */
-function handleRecord(unwrapped, mongooseProp, visited, extractMongooseDef) {
-    callHookSync('schema:record:before', { schema: unwrapped, mongooseProp, visited });
-    const type = unwrapped._def?.type;
-    const isMap = type === 'map';
-    const valueType = unwrapped.valueType ||
-        unwrapped.valueSchema ||
-        unwrapped._def.valueType ||
-        unwrapped._def.valueSchema ||
-        unwrapped._def.innerType; // For some Zod versions
-    let innerDef;
-    if (!mongooseProp.type || mongooseProp.type === Map || mongooseProp.type === Object) {
-        // z.record() maps to a POJO (Object/Mixed), while z.map() maps to a Mongoose Map
-        mongooseProp.type = isMap ? Map : Object;
-        const finalValueType = valueType || unwrapped.valueSchema || unwrapped._def?.valueSchema;
-        if (finalValueType) {
-            innerDef = extractMongooseDef(finalValueType, visited);
-            mongooseProp.of = innerDef.type || innerDef;
-        }
+    if (traitSet.has("$ZodUUID")) {
+      const mongoose2 = globalThis.mongoose || globalThis.__mongoose;
+      if (mongoose2 == null ? void 0 : mongoose2.Schema.Types.UUID) {
+        mongooseProp.type = mongoose2.Schema.Types.UUID;
+      }
     }
-    callHookSync('schema:record:after', { schema: unwrapped, mongooseProp, innerDef });
-}
-
-/**
- * THE CONVERTER (Safe AST Walker)
- * We extract the Zod type and merge it with any registered Mongoose metadata.
- */
-function extractMongooseDef(schema, visited = new Map(), isField = false, noWrap = false) {
-    // Only call converter:before at the very beginning of a run
-    if (visited.size === 0) {
-        callHookSync('converter:before', { schema: schema, visited });
+    if (traitSet.has("$ZodISODateTime") || traitSet.has("$ZodISODate")) {
+      mongooseProp.type = Date;
     }
-    callHookSync('converter:start', { schema: schema, visited });
-    const { schema: unwrapped, features } = unwrapZodSchema(schema);
-    // Pull any explicitly registered Mongoose metadata (including from wrappers)
-    const meta = mongooseRegistry.get(schema) || {};
-    const mongooseProp = getMongooseMeta(schema);
-    callHookSync('converter:unwrapped', {
-        schema: schema,
-        unwrapped,
-        features,
-        meta: mongooseProp,
-        mongooseProp: mongooseProp,
-    });
-    if (features.isOptional === true && mongooseProp.type && mongooseProp.required !== true) {
-        mongooseProp.required = false;
+    if (traitSet.has("$ZodCheckOverwrite") && typeof checkDef.tx === "function") {
+      const txStr = checkDef.tx.toString();
+      if (txStr.includes(".trim()")) {
+        mongooseProp.trim = true;
+      } else if (txStr.includes(".toLowerCase()")) {
+        mongooseProp.lowercase = true;
+      } else if (txStr.includes(".toUpperCase()")) {
+        mongooseProp.uppercase = true;
+      }
     }
-    if (visited.has(schema)) {
-        const existing = visited.get(schema);
-        if (existing === mongooseProp) {
-            return existing;
-        }
-        // console.log('Visited CACHE for', (unwrapped as any)._def.type, existing);
-        if (Object.keys(meta).length > 0) {
-            Object.assign(existing, mongooseProp);
+  }
+  callHookSync("validation:mappers", { checks, mongooseProp });
+}
+function handleObject(unwrapped, mongooseProp, visited, extractMongooseDef2, isField = false) {
+  var _a;
+  callHookSync("schema:object:before", { schema: unwrapped, mongooseProp, visited });
+  const { shape } = unwrapped;
+  const objDef = {};
+  const placeholder = mongooseProp.type ? mongooseProp : objDef;
+  visited.set(unwrapped, placeholder);
+  for (const key in shape) {
+    if (!Object.prototype.hasOwnProperty.call(shape, key))
+      continue;
+    if (key === "_id") {
+      const idMeta = mongooseRegistry.get(shape[key]) || {};
+      const unwrappedId = unwrapZodSchema(shape[key]).schema;
+      const unwrappedIdMeta = mongooseRegistry.get(unwrappedId) || {};
+      if (idMeta.includeId !== true && unwrappedIdMeta.includeId !== true && mongooseProp.includeId !== true) {
+        continue;
+      }
+    }
+    const def = extractMongooseDef2(shape[key], visited);
+    if (def && typeof def === "object" && def.__isDiscriminatorUnion) {
+      const mongoose2 = getMongoose();
+      if (mongoose2) {
+        const baseSchema = new mongoose2.Schema(def.baseDef, {
+          discriminatorKey: def.discriminatorKey,
+          _id: false
+        });
+        const discriminators = {};
+        for (const [dKey, dDef] of Object.entries(def.discriminators)) {
+          discriminators[dKey] = new mongoose2.Schema(dDef, { _id: false });
         }
-        return existing;
+        objDef[key] = {
+          type: baseSchema,
+          discriminators
+        };
+      } else {
+        objDef[key] = def;
+      }
+    } else if (typeof def === "object" && def !== null && !Array.isArray(def)) {
+      const { includeId, ...cleanDef } = def;
+      objDef[key] = cleanDef;
+    } else {
+      objDef[key] = def;
     }
-    visited.set(schema, mongooseProp);
-    // console.log('Visited set for', (unwrapped as any)._def.type, mongooseProp);
-    if (features.default !== undefined) {
-        mongooseProp.default = features.default;
+    callHookSync("schema:object:field", { key, schema: shape[key], objDef, visited });
+  }
+  let result;
+  const shouldBeSubSchema = isField && mongooseProp.schema !== false;
+  if (shouldBeSubSchema && !mongooseProp.type) {
+    const mongoose2 = getMongoose();
+    if (mongoose2) {
+      const options = typeof mongooseProp.schema === "object" ? mongooseProp.schema : {};
+      const { plugins, ...schemaOptions } = options;
+      const subSchema = new mongoose2.Schema(objDef, schemaOptions);
+      if (plugins && Array.isArray(plugins)) {
+        for (const plugin of plugins) {
+          subSchema.plugin(plugin);
+        }
+      }
+      mongooseProp.type = subSchema;
     }
-    if (features.required === false) {
-        mongooseProp.required = false;
+  }
+  if (mongooseProp.type) {
+    const mongoose2 = getMongoose();
+    const isSchema = mongoose2 && (mongooseProp.type instanceof mongoose2.Schema || ((_a = mongooseProp.type.constructor) == null ? void 0 : _a.name) === "Schema");
+    if (!isSchema) {
+      Object.assign(mongooseProp, objDef);
     }
-    if (features.readOnly === true) {
-        mongooseProp.readOnly = true;
+    result = mongooseProp;
+  } else {
+    Object.assign(mongooseProp, objDef);
+    const topLevelOptions = /* @__PURE__ */ new Set([
+      "collection",
+      "versionKey",
+      "timestamps",
+      "discriminatorKey",
+      "strict",
+      "id",
+      "_id",
+      "minimize",
+      "validateBeforeSave",
+      "schema"
+    ]);
+    const hasFieldMetadata = Object.keys(mongooseProp).some((k) => {
+      if (Object.prototype.hasOwnProperty.call(objDef, k))
+        return false;
+      if (topLevelOptions.has(k))
+        return false;
+      if (k === "required" && mongooseProp[k] === false)
+        return false;
+      return true;
+    });
+    result = hasFieldMetadata ? mongooseProp : objDef;
+  }
+  callHookSync("schema:object:after", { schema: unwrapped, mongooseProp, objDef, result });
+  return result;
+}
+function handleArray(unwrapped, mongooseProp, visited, extractMongooseDef2) {
+  var _a;
+  callHookSync("schema:array:before", { schema: unwrapped, mongooseProp, visited });
+  const element = unwrapped.element || unwrapped._def.valueType || unwrapped._def.rest || ((_a = unwrapped._def.items) == null ? void 0 : _a[0]);
+  const mongoose2 = getMongoose();
+  const innerDef = element ? extractMongooseDef2(element, visited) : (mongoose2 == null ? void 0 : mongoose2.Schema.Types.Mixed) || "Mixed";
+  if (!mongooseProp.type) {
+    if (innerDef && typeof innerDef === "object" && innerDef.__isDiscriminatorUnion && mongoose2) {
+      const discriminators = {};
+      for (const [dKey, dDef] of Object.entries(innerDef.discriminators)) {
+        discriminators[dKey] = new mongoose2.Schema(dDef, { _id: false });
+      }
+      mongooseProp.type = [
+        new mongoose2.Schema({}, {
+          discriminatorKey: innerDef.discriminatorKey,
+          _id: false
+        })
+      ];
+      mongooseProp.discriminators = discriminators;
+    } else {
+      const innerType = innerDef.type || innerDef;
+      mongooseProp.type = [innerType];
+      if (typeof innerDef === "object") {
+        const { type: _extractedType, ...innerMeta } = innerDef;
+        Object.assign(mongooseProp, innerMeta);
+        mongooseProp.type = [innerType];
+      }
     }
-    // Map Zod checks to Mongoose options
-    mapZodChecksToMongoose(features.checks, mongooseProp);
-    const def = unwrapped._def;
-    if (!def) {
-        callHookSync('converter:after', {
-            schema: schema,
-            mongooseProp,
-        });
-        return mongooseProp;
+  }
+  callHookSync("schema:array:after", { schema: unwrapped, mongooseProp, innerDef });
+}
+function handleRecord(unwrapped, mongooseProp, visited, extractMongooseDef2) {
+  var _a, _b;
+  callHookSync("schema:record:before", { schema: unwrapped, mongooseProp, visited });
+  const type = (_a = unwrapped._def) == null ? void 0 : _a.type;
+  const isMap = type === "map";
+  const valueType = unwrapped.valueType || unwrapped.valueSchema || unwrapped._def.valueType || unwrapped._def.valueSchema || unwrapped._def.innerType;
+  let innerDef;
+  if (!mongooseProp.type || mongooseProp.type === Map || mongooseProp.type === Object) {
+    mongooseProp.type = isMap ? Map : Object;
+    const finalValueType = valueType || unwrapped.valueSchema || ((_b = unwrapped._def) == null ? void 0 : _b.valueSchema);
+    if (finalValueType) {
+      innerDef = extractMongooseDef2(finalValueType, visited);
+      mongooseProp.of = innerDef.type || innerDef;
     }
-    const { type } = def;
-    callHookSync('converter:node', {
-        schema: unwrapped,
-        mongooseProp,
-        type,
-    });
-    // Handle recursion and specific types via separate handlers
-    if (type === 'object') {
-        const wrapperFn = (s, v) => extractMongooseDef(s, v, true);
-        const result = handleObject(unwrapped, mongooseProp, visited, wrapperFn, isField && !noWrap);
-        callHookSync('converter:after', {
-            schema: schema,
-            mongooseProp: result,
-        });
-        if (typeof result === 'object' && result !== null && !Array.isArray(result)) {
-            delete result.includeId;
-        }
-        return result;
+  }
+  callHookSync("schema:record:after", { schema: unwrapped, mongooseProp, innerDef });
+}
+function extractMongooseDef(schema, visited = /* @__PURE__ */ new Map(), isField = false, noWrap = false) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  if (visited.size === 0) {
+    callHookSync("converter:before", { schema, visited });
+  }
+  callHookSync("converter:start", { schema, visited });
+  const { schema: unwrapped, features } = unwrapZodSchema(schema);
+  const meta = mongooseRegistry.get(schema) || {};
+  const mongooseProp = getMongooseMeta(schema);
+  callHookSync("converter:unwrapped", {
+    schema,
+    unwrapped,
+    features,
+    meta: mongooseProp,
+    mongooseProp
+  });
+  if (features.isOptional === true && mongooseProp.type && mongooseProp.required !== true) {
+    mongooseProp.required = false;
+  }
+  if (visited.has(schema)) {
+    const existing = visited.get(schema);
+    if (existing === mongooseProp) {
+      return existing;
     }
-    if (type === 'array' || type === 'set' || type === 'tuple') {
-        handleArray(unwrapped, mongooseProp, visited, (s, v) => extractMongooseDef(s, v, true));
+    if (Object.keys(meta).length > 0) {
+      Object.assign(existing, mongooseProp);
     }
-    if (type === 'record' || type === 'map') {
-        handleRecord(unwrapped, mongooseProp, visited, (s, v) => extractMongooseDef(s, v, true));
+    return existing;
+  }
+  visited.set(schema, mongooseProp);
+  if (features.default !== void 0) {
+    mongooseProp.default = features.default;
+  }
+  if (features.required === false) {
+    mongooseProp.required = false;
+  }
+  if (features.readOnly === true) {
+    mongooseProp.readOnly = true;
+  }
+  mapZodChecksToMongoose(features.checks, mongooseProp);
+  const def = unwrapped._def;
+  if (!def) {
+    callHookSync("converter:after", {
+      schema,
+      mongooseProp
+    });
+    return mongooseProp;
+  }
+  const { type } = def;
+  callHookSync("converter:node", {
+    schema: unwrapped,
+    mongooseProp,
+    type
+  });
+  if (type === "object") {
+    const wrapperFn = (s, v) => extractMongooseDef(s, v, true);
+    const result = handleObject(unwrapped, mongooseProp, visited, wrapperFn, isField && !noWrap);
+    callHookSync("converter:after", {
+      schema,
+      mongooseProp: result
+    });
+    if (typeof result === "object" && result !== null && !Array.isArray(result)) {
+      delete result.includeId;
     }
-    // Handle Intersections
-    if (type === 'intersection') {
-        const left = extractMongooseDef(unwrapped._def.left, visited, isField, true);
-        const right = extractMongooseDef(unwrapped._def.right, visited, isField, true);
-        if (typeof left === 'object' && typeof right === 'object') {
-            Object.assign(mongooseProp, left, right);
-            if (isField && !noWrap && mongooseProp.schema !== false && !mongooseProp.type) {
-                const mongoose = getMongoose();
-                if (mongoose) {
-                    const options = typeof mongooseProp.schema === 'object' ? mongooseProp.schema : {};
-                    const { plugins, ...schemaOptions } = options;
-                    const definition = { ...mongooseProp };
-                    // Remove metadata fields that shouldn't be in the schema definition if they are top-level
-                    delete definition.schema;
-                    const subSchema = new mongoose.Schema(definition, schemaOptions);
-                    if (plugins && Array.isArray(plugins)) {
-                        for (const plugin of plugins) {
-                            subSchema.plugin(plugin);
-                        }
-                    }
-                    mongooseProp.type = subSchema;
-                    // Clear other fields since they are now in subSchema
-                    for (const key of Object.keys(mongooseProp)) {
-                        if (key !== 'type')
-                            delete mongooseProp[key];
-                    }
-                }
+    return result;
+  }
+  if (type === "array" || type === "set" || type === "tuple") {
+    handleArray(unwrapped, mongooseProp, visited, (s, v) => extractMongooseDef(s, v, true));
+  }
+  if (type === "record" || type === "map") {
+    handleRecord(unwrapped, mongooseProp, visited, (s, v) => extractMongooseDef(s, v, true));
+  }
+  if (type === "intersection") {
+    const left = extractMongooseDef(unwrapped._def.left, visited, isField, true);
+    const right = extractMongooseDef(unwrapped._def.right, visited, isField, true);
+    if (typeof left === "object" && typeof right === "object") {
+      Object.assign(mongooseProp, left, right);
+      if (isField && !noWrap && mongooseProp.schema !== false && !mongooseProp.type) {
+        const mongoose2 = getMongoose();
+        if (mongoose2) {
+          const options = typeof mongooseProp.schema === "object" ? mongooseProp.schema : {};
+          const { plugins, ...schemaOptions } = options;
+          const definition = { ...mongooseProp };
+          delete definition.schema;
+          const subSchema = new mongoose2.Schema(definition, schemaOptions);
+          if (plugins && Array.isArray(plugins)) {
+            for (const plugin of plugins) {
+              subSchema.plugin(plugin);
             }
+          }
+          mongooseProp.type = subSchema;
+          for (const key of Object.keys(mongooseProp)) {
+            if (key !== "type")
+              delete mongooseProp[key];
+          }
         }
-        else if (!mongooseProp.type) {
-            mongooseProp.type = getMongoose()?.Schema.Types.Mixed || 'Mixed';
-        }
+      }
+    } else if (!mongooseProp.type) {
+      mongooseProp.type = ((_a = getMongoose()) == null ? void 0 : _a.Schema.Types.Mixed) || "Mixed";
     }
-    if ((type === 'union' ||
-        type === 'discriminatedunion' ||
-        type === 'discriminated_union' ||
-        type === 'xor') &&
-        !mongooseProp.type) {
-        const mongoose = getMongoose();
-        const options = unwrapped.options || unwrapped._def.options;
-        const discriminatorKey = unwrapped._def.discriminator;
-        const unionCtx = {
-            isSimpleUnion: false,
-            isObjectUnion: false,
-            isXor: type === 'xor' ||
-                ((unwrapped._def?.inclusive === false ||
-                    schema._def?.inclusive === false) &&
-                    !discriminatorKey &&
-                    !schema._def?.discriminator),
-        };
-        if (Array.isArray(options) && options.length > 0) {
-            unionCtx.isSimpleUnion = options.every((opt) => {
-                const { type } = unwrapZodSchema(opt).schema._def;
-                return ['string', 'number', 'boolean', 'date', 'bigint', 'literal'].includes(type);
-            });
-            unionCtx.isObjectUnion = options.every((opt) => {
-                const { type } = unwrapZodSchema(opt).schema._def;
-                return type === 'object';
-            });
-        }
-        callHookSync('schema:union:before', { schema: unwrapped, mongooseProp, ctx: unionCtx });
-        if (discriminatorKey && unionCtx.isObjectUnion) {
-            const discriminators = {};
-            const allOptionDefs = [];
-            for (const option of options) {
-                const { schema: unwrappedOpt } = unwrapZodSchema(option);
-                const { shape } = unwrappedOpt._def;
-                const discriminatorProp = shape[discriminatorKey];
-                // Support both ZodLiteral and ZodOptional/ZodDefault/ZodNullable wrapped literals
-                const { schema: unwrappedDisc } = unwrapZodSchema(discriminatorProp);
-                const discriminatorValue = unwrappedDisc._def.value ?? unwrappedDisc._def.values?.[0];
-                // Use a fresh Map for each option to avoid cross-contamination of visited nodes
-                const optionDef = extractMongooseDef(option, new Map(), true, true);
-                if (optionDef && typeof optionDef === 'object' && !Array.isArray(optionDef)) {
-                    const cleanOptionDef = { ...optionDef };
-                    delete cleanOptionDef[discriminatorKey];
-                    discriminators[discriminatorValue] = cleanOptionDef;
-                    allOptionDefs.push(cleanOptionDef);
-                }
-            }
-            // Identify common fields present in ALL options to move to baseDef
-            const baseDef = {};
-            if (allOptionDefs.length > 0) {
-                const firstOption = allOptionDefs[0];
-                for (const key of Object.keys(firstOption)) {
-                    const isCommon = allOptionDefs.every((def) => {
-                        if (!(key in def))
-                            return false;
-                        // Simple check for equality of definitions (can be improved)
-                        return JSON.stringify(def[key]) === JSON.stringify(firstOption[key]);
-                    });
-                    if (isCommon) {
-                        baseDef[key] = firstOption[key];
-                        // Remove from discriminators to avoid duplication
-                        for (const def of allOptionDefs) {
-                            delete def[key];
-                        }
-                    }
-                }
-            }
-            const result = {
-                __isDiscriminatorUnion: true,
-                discriminatorKey,
-                discriminators,
-                baseDef,
-                validate: {
-                    validator(_v) {
-                        try {
-                            // Ensure we include the discriminator key in the object being validated
-                            const mongoose = getMongoose();
-                            const doc = mongoose && this instanceof mongoose.Document ? this.toObject() : this || {};
-                            schema.parse(doc);
-                            return true;
-                        }
-                        catch (err) {
-                            const message = err?.errors?.[0]?.message || err.message;
-                            if (this && typeof this.invalidate === 'function') {
-                                this.invalidate(discriminatorKey, `Zod validation failed: ${message}`);
-                            }
-                            return false;
-                        }
-                    },
-                    message: (props) => `Validation failed for ${props.path}`,
-                },
-            };
-            // If this is wrapped in a meta object, ensure we return the result properly
-            if (mongooseProp && typeof mongooseProp === 'object' && !Array.isArray(mongooseProp)) {
-                Object.assign(mongooseProp, result);
-                callHookSync('schema:union:after', {
-                    schema: unwrapped,
-                    mongooseProp,
-                    ctx: unionCtx,
-                });
-                return mongooseProp;
-            }
-            callHookSync('schema:union:after', {
-                schema: unwrapped,
-                mongooseProp: result,
-                ctx: unionCtx,
-            });
-            return result;
-        }
-        if (getMongoose()?.Schema.Types.Union &&
-            unionCtx.isSimpleUnion &&
-            options.length > 0 &&
-            !unionCtx.isXor) {
-            mongooseProp.type = mongoose.Schema.Types.Union;
-            mongooseProp.of = options.map((opt) => {
-                const def = extractMongooseDef(opt, visited, true, true);
-                return def.type || def;
-            });
+  }
+  if ((type === "union" || type === "discriminatedunion" || type === "discriminated_union" || type === "xor") && !mongooseProp.type) {
+    const mongoose2 = getMongoose();
+    const options = unwrapped.options || unwrapped._def.options;
+    const discriminatorKey = unwrapped._def.discriminator;
+    const unionCtx = {
+      isSimpleUnion: false,
+      isObjectUnion: false,
+      isXor: type === "xor" || (((_b = unwrapped._def) == null ? void 0 : _b.inclusive) === false || ((_c = schema._def) == null ? void 0 : _c.inclusive) === false) && !discriminatorKey && !((_d = schema._def) == null ? void 0 : _d.discriminator)
+    };
+    if (Array.isArray(options) && options.length > 0) {
+      unionCtx.isSimpleUnion = options.every((opt) => {
+        const { type: type2 } = unwrapZodSchema(opt).schema._def;
+        return ["string", "number", "boolean", "date", "bigint", "literal"].includes(type2);
+      });
+      unionCtx.isObjectUnion = options.every((opt) => {
+        const { type: type2 } = unwrapZodSchema(opt).schema._def;
+        return type2 === "object";
+      });
+    }
+    callHookSync("schema:union:before", { schema: unwrapped, mongooseProp, ctx: unionCtx });
+    if (discriminatorKey && unionCtx.isObjectUnion) {
+      const discriminators = {};
+      const allOptionDefs = [];
+      for (const option of options) {
+        const { schema: unwrappedOpt } = unwrapZodSchema(option);
+        const { shape } = unwrappedOpt._def;
+        const discriminatorProp = shape[discriminatorKey];
+        const { schema: unwrappedDisc } = unwrapZodSchema(discriminatorProp);
+        const discriminatorValue = (_f = unwrappedDisc._def.value) != null ? _f : (_e = unwrappedDisc._def.values) == null ? void 0 : _e[0];
+        const optionDef = extractMongooseDef(option, /* @__PURE__ */ new Map(), true, true);
+        if (optionDef && typeof optionDef === "object" && !Array.isArray(optionDef)) {
+          const cleanOptionDef = { ...optionDef };
+          delete cleanOptionDef[discriminatorKey];
+          discriminators[discriminatorValue] = cleanOptionDef;
+          allOptionDefs.push(cleanOptionDef);
         }
-        else if (unionCtx.isObjectUnion && options.length > 0) {
-            // Merge all object properties into a single schema object
-            const mergedDef = {};
-            for (const opt of options) {
-                const def = extractMongooseDef(opt, new Map(), true, true);
-                if (typeof def === 'object' && def !== null) {
-                    for (const [key, prop] of Object.entries(def)) {
-                        if (typeof prop === 'object' && prop !== null && !Array.isArray(prop)) {
-                            prop.required = false;
-                        }
-                        if (mergedDef[key] &&
-                            typeof mergedDef[key] === 'object' &&
-                            typeof prop === 'object' &&
-                            !Array.isArray(mergedDef[key]) &&
-                            !Array.isArray(prop)) {
-                            const existingType = mergedDef[key].type ||
-                                mergedDef[key].instance ||
-                                (typeof mergedDef[key] === 'function' ? mergedDef[key] : null);
-                            const newType = prop.type ||
-                                prop.instance ||
-                                (typeof prop === 'function' ? prop : null);
-                            const isMixed = (t) => !t ||
-                                t === 'Mixed' ||
-                                t === 'SchemaMixed' ||
-                                t?.name === 'Mixed' ||
-                                t?.instance === 'Mixed' ||
-                                t?.name === 'SchemaMixed' ||
-                                t?.instance === 'SchemaMixed' ||
-                                (getMongoose()?.Schema.Types.Mixed &&
-                                    (t === getMongoose()?.Schema.Types.Mixed ||
-                                        t?.instance === 'Mixed' ||
-                                        t?.instance === 'SchemaMixed'));
-                            if (isMixed(existingType) && !isMixed(newType)) {
-                                mergedDef[key] = prop;
-                            }
-                            else if (!isMixed(existingType) && isMixed(newType)) ;
-                            else {
-                                Object.assign(mergedDef[key], prop);
-                            }
-                        }
-                        else if (!mergedDef[key] ||
-                            typeof mergedDef[key] !== 'object' ||
-                            Array.isArray(mergedDef[key])) {
-                            mergedDef[key] = prop;
-                        }
-                    }
-                }
-            }
-            if (isField && unionCtx.isXor) {
-                // For nested XOR, always use Mixed with validator to ensure mutual exclusivity
-                mongooseProp.type = mongoose?.Schema.Types.Mixed || 'Mixed';
-                mongooseProp.validate = {
-                    validator(v) {
-                        try {
-                            schema.parse(v);
-                            return true;
-                        }
-                        catch {
-                            return false;
-                        }
-                    },
-                    message: 'XOR validation failed',
-                };
-            }
-            else {
-                // For root or other object unions, merge properties
-                if (!mongooseProp.type ||
-                    mongooseProp.type === (getMongoose()?.Schema.Types.Mixed || 'Mixed')) {
-                    delete mongooseProp.type;
-                }
-                Object.assign(mongooseProp, mergedDef);
-                // If the object contains a 'type' property, Mongoose might misinterpret it as a field definition.
-                // We can hint that it's a nested object by using a Schema if 'type' is present along with other fields.
-                if (isField &&
-                    Object.prototype.hasOwnProperty.call(mongooseProp, 'type') &&
-                    Object.keys(mongooseProp).length > 1) {
-                    const mongooseInstance = getMongoose();
-                    if (mongooseInstance) {
-                        mongooseProp.type = new mongooseInstance.Schema(mongooseProp, { _id: false });
-                        for (const key of Object.keys(mongooseProp)) {
-                            if (key !== 'type')
-                                delete mongooseProp[key];
-                        }
-                    }
-                }
+      }
+      const baseDef = {};
+      if (allOptionDefs.length > 0) {
+        const firstOption = allOptionDefs[0];
+        for (const key of Object.keys(firstOption)) {
+          const isCommon = allOptionDefs.every((def2) => {
+            if (!(key in def2))
+              return false;
+            return JSON.stringify(def2[key]) === JSON.stringify(firstOption[key]);
+          });
+          if (isCommon) {
+            baseDef[key] = firstOption[key];
+            for (const def2 of allOptionDefs) {
+              delete def2[key];
             }
+          }
         }
-        else {
-            mongooseProp.type = mongoose?.Schema.Types.Mixed || 'Mixed';
-            if (isField &&
-                (type === 'xor' ||
-                    type === 'discriminated_union' ||
-                    type === 'discriminatedunion' ||
-                    type === 'union') &&
-                !mongooseProp.ref && // Skip Zod validation for populated fields
-                !Array.isArray(mongooseProp.type) && // Skip Zod validation for arrays
-                mongooseProp.type !== Map && // Skip Zod validation for maps
-                !mongooseProp.of // Skip Zod validation for collections
-            ) {
-                mongooseProp.validate = {
-                    validator(v) {
-                        try {
-                            schema.parse(v);
-                            return true;
-                        }
-                        catch (err) {
-                            return false;
-                        }
-                    },
-                    message: (props) => {
-                        if (unionCtx.isXor)
-                            return 'XOR validation failed';
-                        try {
-                            schema.parse(props.value);
-                        }
-                        catch (err) {
-                            return `Union validation failed: ${err.message}`;
-                        }
-                        return 'Union validation failed';
-                    },
-                };
+      }
+      const result = {
+        __isDiscriminatorUnion: true,
+        discriminatorKey,
+        discriminators,
+        baseDef,
+        validate: {
+          validator(_v) {
+            var _a2, _b2;
+            try {
+              const mongoose3 = getMongoose();
+              const doc = mongoose3 && this instanceof mongoose3.Document ? this.toObject() : this || {};
+              schema.parse(doc);
+              return true;
+            } catch (err) {
+              const message = ((_b2 = (_a2 = err == null ? void 0 : err.errors) == null ? void 0 : _a2[0]) == null ? void 0 : _b2.message) || err.message;
+              if (this && typeof this.invalidate === "function") {
+                this.invalidate(discriminatorKey, `Zod validation failed: ${message}`);
+              }
+              return false;
             }
+          },
+          message: (props) => `Validation failed for ${props.path}`
         }
-        callHookSync('schema:union:after', {
-            schema: unwrapped,
-            mongooseProp,
-            ctx: unionCtx,
+      };
+      if (mongooseProp && typeof mongooseProp === "object" && !Array.isArray(mongooseProp)) {
+        Object.assign(mongooseProp, result);
+        callHookSync("schema:union:after", {
+          schema: unwrapped,
+          mongooseProp,
+          ctx: unionCtx
         });
+        return mongooseProp;
+      }
+      callHookSync("schema:union:after", {
+        schema: unwrapped,
+        mongooseProp: result,
+        ctx: unionCtx
+      });
+      return result;
     }
-    if (type === 'literal' && !mongooseProp.type) {
-        mongooseProp.type = getMongoose()?.Schema.Types.Mixed || 'Mixed';
-    }
-    // Handle Primitives
-    switch (type) {
-        case 'string':
-        case 'number':
-        case 'boolean':
-        case 'date':
-        case 'bigint':
-        case 'stringbool':
-        case 'boolstring':
-        case 'booleanstring': {
-            if (!mongooseProp.type) {
-                if (type === 'bigint') {
-                    mongooseProp.type = typeof BigInt === 'undefined' ? Number : BigInt;
-                }
-                else {
-                    const typeMap = {
-                        string: String,
-                        number: Number,
-                        boolean: Boolean,
-                        date: Date,
-                        stringbool: Boolean,
-                        boolstring: Boolean,
-                        booleanstring: Boolean,
-                    };
-                    mongooseProp.type = typeMap[type];
-                    // Clever inference: If a transform occurred (which we know if the Zod type
-                    // is different from the default value type), prefer the default's type.
-                    if (mongooseProp.default !== undefined) {
-                        const defaultType = typeof mongooseProp.default;
-                        if (defaultType === 'boolean' && type !== 'boolean') {
-                            mongooseProp.type = Boolean;
-                        }
-                        else if (defaultType === 'number' && type !== 'number') {
-                            mongooseProp.type = Number;
-                        }
-                        else if (defaultType === 'string' && type !== 'string') {
-                            mongooseProp.type = String;
-                        }
-                        else if (mongooseProp.default instanceof Date && type !== 'date') {
-                            mongooseProp.type = Date;
-                        }
-                    }
-                    // Even cleverer: Check transformations for clues (e.g., stringbool, boolstring)
-                    if (mongooseProp.type === String && features.transformations) {
-                        for (const tx of features.transformations) {
-                            const txStr = tx.transform?.toString() || tx.toString();
-                            if (txStr.includes('stringbool') || txStr.includes('boolstring') || txStr.includes('booleanstring')) {
-                                mongooseProp.type = Boolean;
-                                break;
-                            }
-                            if (txStr.includes('=== "true"') || txStr.includes('=== \'true\'')) {
-                                mongooseProp.type = Boolean;
-                                break;
-                            }
-                        }
-                    }
-                }
+    if (((_g = getMongoose()) == null ? void 0 : _g.Schema.Types.Union) && unionCtx.isSimpleUnion && options.length > 0 && !unionCtx.isXor) {
+      mongooseProp.type = mongoose2.Schema.Types.Union;
+      mongooseProp.of = options.map((opt) => {
+        const def2 = extractMongooseDef(opt, visited, true, true);
+        return def2.type || def2;
+      });
+    } else if (unionCtx.isObjectUnion && options.length > 0) {
+      const mergedDef = {};
+      for (const opt of options) {
+        const def2 = extractMongooseDef(opt, /* @__PURE__ */ new Map(), true, true);
+        if (typeof def2 === "object" && def2 !== null) {
+          for (const [key, prop] of Object.entries(def2)) {
+            if (typeof prop === "object" && prop !== null && !Array.isArray(prop)) {
+              prop.required = false;
             }
-            if (mongooseProp.required !== false)
-                mongooseProp.required = true;
-            break;
-        }
-        case 'enum':
-        case 'nativeenum':
-        case 'native_enum': {
-            if (!mongooseProp.type)
-                mongooseProp.type = String;
-            mongooseProp.enum =
-                type === 'enum'
-                    ? unwrapped.options || def.values
-                    : Object.values(unwrapped.enum || def.values);
-            if (mongooseProp.required !== false)
-                mongooseProp.required = true;
-            break;
+            if (mergedDef[key] && typeof mergedDef[key] === "object" && typeof prop === "object" && !Array.isArray(mergedDef[key]) && !Array.isArray(prop)) {
+              const existingType = mergedDef[key].type || mergedDef[key].instance || (typeof mergedDef[key] === "function" ? mergedDef[key] : null);
+              const newType = prop.type || prop.instance || (typeof prop === "function" ? prop : null);
+              const isMixed = (t) => {
+                var _a2, _b2;
+                return !t || t === "Mixed" || t === "SchemaMixed" || (t == null ? void 0 : t.name) === "Mixed" || (t == null ? void 0 : t.instance) === "Mixed" || (t == null ? void 0 : t.name) === "SchemaMixed" || (t == null ? void 0 : t.instance) === "SchemaMixed" || ((_a2 = getMongoose()) == null ? void 0 : _a2.Schema.Types.Mixed) && (t === ((_b2 = getMongoose()) == null ? void 0 : _b2.Schema.Types.Mixed) || (t == null ? void 0 : t.instance) === "Mixed" || (t == null ? void 0 : t.instance) === "SchemaMixed");
+              };
+              if (isMixed(existingType) && !isMixed(newType)) {
+                mergedDef[key] = prop;
+              } else if (!isMixed(existingType) && isMixed(newType)) ;
+              else {
+                Object.assign(mergedDef[key], prop);
+              }
+            } else if (!mergedDef[key] || typeof mergedDef[key] !== "object" || Array.isArray(mergedDef[key])) {
+              mergedDef[key] = prop;
+            }
+          }
         }
-        // Do nothing
-    }
-    // Handle Specialized Types (Buffer, ObjectId)
-    const mongooseInstance = getMongoose();
-    if (type === 'any' || type === 'unknown' || type === 'custom') {
-        const cls = def.cls || unwrapped.cls;
-        if (cls === Buffer || (typeof Uint8Array !== 'undefined' && cls === Uint8Array)) {
-            if (!mongooseProp.type)
-                mongooseProp.type = mongooseInstance?.Schema.Types.Buffer || 'Buffer';
+      }
+      if (isField && unionCtx.isXor) {
+        mongooseProp.type = (mongoose2 == null ? void 0 : mongoose2.Schema.Types.Mixed) || "Mixed";
+        mongooseProp.validate = {
+          validator(v) {
+            try {
+              schema.parse(v);
+              return true;
+            } catch {
+              return false;
+            }
+          },
+          message: "XOR validation failed"
+        };
+      } else {
+        if (!mongooseProp.type || mongooseProp.type === (((_h = getMongoose()) == null ? void 0 : _h.Schema.Types.Mixed) || "Mixed")) {
+          delete mongooseProp.type;
         }
-        else if ((cls?.name === 'ObjectId' || (mongooseInstance && cls === mongooseInstance.Types.ObjectId)) &&
-            !mongooseProp.type) {
-            mongooseProp.type = mongooseInstance?.Schema.Types.ObjectId || 'ObjectId';
+        Object.assign(mongooseProp, mergedDef);
+        if (isField && Object.prototype.hasOwnProperty.call(mongooseProp, "type") && Object.keys(mongooseProp).length > 1) {
+          const mongooseInstance3 = getMongoose();
+          if (mongooseInstance3) {
+            mongooseProp.type = new mongooseInstance3.Schema(mongooseProp, { _id: false });
+            for (const key of Object.keys(mongooseProp)) {
+              if (key !== "type")
+                delete mongooseProp[key];
+            }
+          }
         }
+      }
+    } else {
+      mongooseProp.type = (mongoose2 == null ? void 0 : mongoose2.Schema.Types.Mixed) || "Mixed";
+      if (isField && (type === "xor" || type === "discriminated_union" || type === "discriminatedunion" || type === "union") && !mongooseProp.ref && // Skip Zod validation for populated fields
+      !Array.isArray(mongooseProp.type) && // Skip Zod validation for arrays
+      mongooseProp.type !== Map && // Skip Zod validation for maps
+      !mongooseProp.of) {
+        mongooseProp.validate = {
+          validator(v) {
+            try {
+              schema.parse(v);
+              return true;
+            } catch (err) {
+              return false;
+            }
+          },
+          message: (props) => {
+            if (unionCtx.isXor)
+              return "XOR validation failed";
+            try {
+              schema.parse(props.value);
+            } catch (err) {
+              return `Union validation failed: ${err.message}`;
+            }
+            return "Union validation failed";
+          }
+        };
+      }
     }
-    // Handle Lazy (Recursion Support)
-    if (type === 'lazy') {
-        const inner = def.getter();
-        const result = extractMongooseDef(inner, visited, isField);
-        if (Object.keys(meta).length > 0 && result !== mongooseProp) {
-            if (typeof result === 'object' && !Array.isArray(result)) {
-                Object.assign(mongooseProp, result);
+    callHookSync("schema:union:after", {
+      schema: unwrapped,
+      mongooseProp,
+      ctx: unionCtx
+    });
+  }
+  if (type === "literal" && !mongooseProp.type) {
+    mongooseProp.type = ((_i = getMongoose()) == null ? void 0 : _i.Schema.Types.Mixed) || "Mixed";
+  }
+  switch (type) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "date":
+    case "bigint":
+    case "stringbool":
+    case "boolstring":
+    case "booleanstring": {
+      if (!mongooseProp.type) {
+        if (type === "bigint") {
+          mongooseProp.type = typeof BigInt === "undefined" ? Number : BigInt;
+        } else {
+          const typeMap = {
+            string: String,
+            number: Number,
+            boolean: Boolean,
+            date: Date,
+            stringbool: Boolean,
+            boolstring: Boolean,
+            booleanstring: Boolean
+          };
+          mongooseProp.type = typeMap[type];
+          if (mongooseProp.default !== void 0) {
+            const defaultType = typeof mongooseProp.default;
+            if (defaultType === "boolean" && type !== "boolean") {
+              mongooseProp.type = Boolean;
+            } else if (defaultType === "number" && type !== "number") {
+              mongooseProp.type = Number;
+            } else if (defaultType === "string" && type !== "string") {
+              mongooseProp.type = String;
+            } else if (mongooseProp.default instanceof Date && type !== "date") {
+              mongooseProp.type = Date;
             }
-            else {
-                mongooseProp.type = result.type || result;
+          }
+          if (mongooseProp.type === String && features.transformations) {
+            for (const tx of features.transformations) {
+              const txStr = ((_j = tx.transform) == null ? void 0 : _j.toString()) || tx.toString();
+              if (txStr.includes("stringbool") || txStr.includes("boolstring") || txStr.includes("booleanstring")) {
+                mongooseProp.type = Boolean;
+                break;
+              }
+              if (txStr.includes('=== "true"') || txStr.includes("=== 'true'")) {
+                mongooseProp.type = Boolean;
+                break;
+              }
             }
-            return mongooseProp;
+          }
         }
-        return result;
+      }
+      if (mongooseProp.required !== false)
+        mongooseProp.required = true;
+      break;
     }
-    // Fallback for z.any() or unhandled types
-    if (!mongooseProp.type && type !== 'object') {
-        mongooseProp.type = getMongoose()?.Schema.Types.Mixed || 'Mixed';
+    case "enum":
+    case "nativeenum":
+    case "native_enum": {
+      if (!mongooseProp.type)
+        mongooseProp.type = String;
+      mongooseProp.enum = type === "enum" ? unwrapped.options || def.values : Object.values(unwrapped.enum || def.values);
+      if (mongooseProp.required !== false)
+        mongooseProp.required = true;
+      break;
     }
-    callHookSync('converter:after', {
-        schema: schema,
-        mongooseProp,
-    });
-    if (typeof mongooseProp === 'object' && mongooseProp !== null && !Array.isArray(mongooseProp)) {
-        delete mongooseProp.includeId;
+  }
+  const mongooseInstance2 = getMongoose();
+  if (type === "any" || type === "unknown" || type === "custom") {
+    const cls = def.cls || unwrapped.cls;
+    if (cls === Buffer || typeof Uint8Array !== "undefined" && cls === Uint8Array) {
+      if (!mongooseProp.type)
+        mongooseProp.type = (mongooseInstance2 == null ? void 0 : mongooseInstance2.Schema.Types.Buffer) || "Buffer";
+    } else if (((cls == null ? void 0 : cls.name) === "ObjectId" || mongooseInstance2 && cls === mongooseInstance2.Types.ObjectId) && !mongooseProp.type) {
+      mongooseProp.type = (mongooseInstance2 == null ? void 0 : mongooseInstance2.Schema.Types.ObjectId) || "ObjectId";
     }
-    return mongooseProp;
+  }
+  if (type === "lazy") {
+    const inner = def.getter();
+    const result = extractMongooseDef(inner, visited, isField);
+    if (Object.keys(meta).length > 0 && result !== mongooseProp) {
+      if (typeof result === "object" && !Array.isArray(result)) {
+        Object.assign(mongooseProp, result);
+      } else {
+        mongooseProp.type = result.type || result;
+      }
+      return mongooseProp;
+    }
+    return result;
+  }
+  if (!mongooseProp.type && type !== "object") {
+    mongooseProp.type = ((_k = getMongoose()) == null ? void 0 : _k.Schema.Types.Mixed) || "Mixed";
+  }
+  callHookSync("converter:after", {
+    schema,
+    mongooseProp
+  });
+  if (typeof mongooseProp === "object" && mongooseProp !== null && !Array.isArray(mongooseProp)) {
+    delete mongooseProp.includeId;
+  }
+  return mongooseProp;
 }
-
-/**
- * Converts a Zod schema to a Mongoose Schema instance.
- */
 function toMongooseSchema(schema, options) {
-    const { schema: unwrapped } = unwrapZodSchema(schema);
-    const meta = mongooseRegistry.get(schema) ||
-        mongooseRegistry.get(unwrapped) ||
-        schema.meta?.() ||
-        unwrapped.meta?.() ||
-        {};
-    const { plugins, ...schemaOptions } = options || {};
-    const mergedOptions = {
-        // Also merge other schema options from meta if they exist
-        ...(meta.collection ? { collection: meta.collection } : {}),
-        // eslint-disable-next-line unicorn/no-negated-condition
-        ...(meta.strict !== undefined ? { strict: meta.strict } : {}),
-        // eslint-disable-next-line unicorn/no-negated-condition
-        ...(meta.minimize !== undefined ? { minimize: meta.minimize } : {}),
-        // eslint-disable-next-line unicorn/no-negated-condition
-        ...(meta.validateBeforeSave !== undefined ? { validateBeforeSave: meta.validateBeforeSave } : {}),
-        // eslint-disable-next-line unicorn/no-negated-condition
-        ...(meta.versionKey !== undefined ? { versionKey: meta.versionKey } : {}),
-        ...(meta.id === undefined ? {} : { id: meta.id }),
-        ...(meta._id === undefined ? {} : { _id: meta._id }),
-        ...(meta.timestamps ? { timestamps: meta.timestamps } : {}),
-        ...(meta.discriminatorKey ? { discriminatorKey: meta.discriminatorKey } : {}),
-        ...schemaOptions,
-    };
-    let definition = extractMongooseDef(schema, new Map(), false);
-    const mongoose = getMongoose();
-    if (!mongoose) {
-        throw new Error('Mongoose must be installed to use toMongooseSchema. If you are in an ESM environment, ensure mongoose is loaded.');
+  var _a, _b;
+  const { schema: unwrapped } = unwrapZodSchema(schema);
+  const meta = mongooseRegistry.get(schema) || mongooseRegistry.get(unwrapped) || ((_a = schema.meta) == null ? void 0 : _a.call(schema)) || ((_b = unwrapped.meta) == null ? void 0 : _b.call(unwrapped)) || {};
+  const { plugins, ...schemaOptions } = options || {};
+  const mergedOptions = {
+    // Also merge other schema options from meta if they exist
+    ...meta.collection ? { collection: meta.collection } : {},
+    // eslint-disable-next-line unicorn/no-negated-condition
+    ...meta.strict !== void 0 ? { strict: meta.strict } : {},
+    // eslint-disable-next-line unicorn/no-negated-condition
+    ...meta.minimize !== void 0 ? { minimize: meta.minimize } : {},
+    // eslint-disable-next-line unicorn/no-negated-condition
+    ...meta.validateBeforeSave !== void 0 ? { validateBeforeSave: meta.validateBeforeSave } : {},
+    // eslint-disable-next-line unicorn/no-negated-condition
+    ...meta.versionKey !== void 0 ? { versionKey: meta.versionKey } : {},
+    ...meta.id === void 0 ? {} : { id: meta.id },
+    ...meta._id === void 0 ? {} : { _id: meta._id },
+    ...meta.timestamps ? { timestamps: meta.timestamps } : {},
+    ...meta.discriminatorKey ? { discriminatorKey: meta.discriminatorKey } : {},
+    ...schemaOptions
+  };
+  let definition = extractMongooseDef(schema, /* @__PURE__ */ new Map(), false);
+  const mongoose2 = getMongoose();
+  if (!mongoose2) {
+    throw new Error("Mongoose must be installed to use toMongooseSchema. If you are in an ESM environment, ensure mongoose is loaded.");
+  }
+  let mongooseSchema;
+  if (definition && typeof definition === "object" && definition.__isDiscriminatorUnion) {
+    const { discriminatorKey, discriminators, baseDef, validate } = definition;
+    mongooseSchema = new mongoose2.Schema(baseDef, {
+      ...mergedOptions,
+      discriminatorKey
+    });
+    if (validate) {
+      if (!mongooseSchema.path(discriminatorKey)) {
+        mongooseSchema.add({ [discriminatorKey]: { type: String } });
+      }
+      mongooseSchema.path(discriminatorKey).validate(validate);
     }
-    let mongooseSchema;
-    if (definition && typeof definition === 'object' && definition.__isDiscriminatorUnion) {
-        const { discriminatorKey, discriminators, baseDef, validate } = definition;
-        mongooseSchema = new mongoose.Schema(baseDef, {
-            ...mergedOptions,
-            discriminatorKey,
-        });
-        if (validate) {
-            if (!mongooseSchema.path(discriminatorKey)) {
-                mongooseSchema.add({ [discriminatorKey]: { type: String } });
-            }
-            mongooseSchema.path(discriminatorKey).validate(validate);
-        }
-        for (const [key, dDef] of Object.entries(discriminators)) {
-            if (mongooseSchema.discriminators && mongooseSchema.discriminators[key]) {
-                continue;
-            }
-            mongooseSchema.discriminator(key, new mongoose.Schema(dDef, { _id: false }));
-        }
+    for (const [key, dDef] of Object.entries(discriminators)) {
+      if (mongooseSchema.discriminators && mongooseSchema.discriminators[key]) {
+        continue;
+      }
+      mongooseSchema.discriminator(key, new mongoose2.Schema(dDef, { _id: false }));
     }
-    else {
-        // Strip internal includeId metadata that might have leaked into the definition
-        if (typeof definition === 'object' && definition !== null) {
-            // If it's a top-level object, it might have metadata fields directly
-            const { includeId, ...cleanDefinition } = definition;
-            definition = cleanDefinition;
-            // Also clean any top-level field definitions
-            for (const value of Object.values(definition)) {
-                if (value && typeof value === 'object' && !Array.isArray(value)) {
-                    delete value.includeId;
-                }
-            }
+  } else {
+    if (typeof definition === "object" && definition !== null) {
+      const { includeId, ...cleanDefinition } = definition;
+      definition = cleanDefinition;
+      for (const value of Object.values(definition)) {
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+          delete value.includeId;
         }
-        mongooseSchema = new mongoose.Schema(definition, mergedOptions);
+      }
     }
-    // Apply plugins if provided in options
-    if (plugins && Array.isArray(plugins)) {
-        for (const plugin of plugins) {
-            mongooseSchema.plugin(plugin);
-        }
+    mongooseSchema = new mongoose2.Schema(definition, mergedOptions);
+  }
+  if (plugins && Array.isArray(plugins)) {
+    for (const plugin of plugins) {
+      mongooseSchema.plugin(plugin);
     }
-    // Call schema:created hook
-    callHookSync('schema:created', {
-        schema,
-        mongooseSchema,
-        options: mergedOptions,
-    });
-    return mongooseSchema;
+  }
+  callHookSync("schema:created", {
+    schema,
+    mongooseSchema,
+    options: mergedOptions
+  });
+  return mongooseSchema;
 }
-
-// ============================================================================
-// 2. PRIMITIVE TYPES (ObjectId & Buffer)
-// ============================================================================
-const preprocessFn = (val) => (val === null ? undefined : val);
-const zObjectId = (options) => {
-    const isFrontend = getFrontendMode();
-    if (isFrontend) {
-        return withMongoose(v4.z.preprocess(preprocessFn, v4.z.string().regex(/^[\dA-Fa-f]{24}$/, 'Invalid ObjectId')), { type: 'ObjectId', ...options });
+function populateZodSchema(schema, keys) {
+  const { shape } = schema;
+  const newShape = { ...shape };
+  const keysToPopulate = keys || Object.keys(shape);
+  const populateField = (field) => {
+    const meta = getMongooseMeta(field);
+    const { schema: unwrapped, features } = unwrapZodSchema(field);
+    let result = field;
+    if (meta == null ? void 0 : meta.refSchema) {
+      result = meta.refSchema;
+    } else if (unwrapped instanceof z.ZodArray) {
+      const populatedInner = populateField(unwrapped.element);
+      if (populatedInner !== unwrapped.element) {
+        result = z.array(populatedInner);
+      }
+    } else if (unwrapped instanceof z.ZodObject) {
+      result = populateZodSchema(unwrapped);
     }
-    const mongooseInstance = getMongoose();
-    return withMongoose(v4.z.preprocess(preprocessFn, v4.z.custom((val) => (mongooseInstance && val instanceof mongooseInstance.Types.ObjectId) ||
-        (typeof val === 'string' && /^[\dA-Fa-f]{24}$/.test(val)))), { type: mongooseInstance?.Schema.Types.ObjectId || 'ObjectId', ...options });
+    if (result !== field && result !== unwrapped) {
+      if (features.isOptional && !(result instanceof z.ZodOptional))
+        result = result.optional();
+      if (features.isNullable && !(result instanceof z.ZodNullable))
+        result = result.nullable();
+      if (features.default !== void 0 && !(result instanceof z.ZodDefault))
+        result = result.default(features.default);
+    }
+    return result;
+  };
+  for (const key of keysToPopulate) {
+    newShape[key] = populateField(shape[key]);
+  }
+  return z.object(newShape);
+}
+const genTimestampsSchema = (createdAtField = "createdAt", updatedAtField = "updatedAt") => {
+  if (createdAtField != null && updatedAtField != null && createdAtField === updatedAtField) {
+    throw new Error("`createdAt` and `updatedAt` fields must be different");
+  }
+  const shape = {};
+  if (createdAtField != null)
+    shape[createdAtField] = z.date().default(() => /* @__PURE__ */ new Date());
+  if (updatedAtField != null)
+    shape[updatedAtField] = z.date().default(() => /* @__PURE__ */ new Date());
+  return shape;
+};
+const bufferMongooseGetter = (value) => value != null && value._bsontype === "Binary" ? value.buffer : value;
+const preprocessFn = (val) => val === null ? void 0 : val;
+const zObjectId = (options) => {
+  const mongooseInstance2 = getMongoose();
+  const objectIdSchema = z.custom((val) => mongooseInstance2 && val instanceof mongooseInstance2.Types.ObjectId);
+  const baseUnion = z.preprocess(preprocessFn, z.union([objectIdSchema, z.string().regex(/^[\dA-Fa-f]{24}$/, "Invalid ObjectId")]));
+  const inputSchema = z.codec(baseUnion, objectIdSchema, {
+    decode: (val) => {
+      if (!mongooseInstance2)
+        return val;
+      if (val instanceof mongooseInstance2.Types.ObjectId) {
+        return val;
+      }
+      return new mongooseInstance2.Types.ObjectId(val);
+    },
+    encode: (val) => val.toString()
+  });
+  return withMongoose(inputSchema, {
+    type: (mongooseInstance2 == null ? void 0 : mongooseInstance2.Schema.Types.ObjectId) || "ObjectId",
+    ...options
+  });
 };
 const zBuffer = (options) => {
-    if (getFrontendMode()) {
-        return withMongoose(v4.z.instanceof(Uint8Array), { type: 'Buffer', ...options });
-    }
-    const mongooseInstance = getMongoose();
-    return withMongoose(v4.z.custom((val) => (mongooseInstance && val instanceof Buffer) || val instanceof Uint8Array), { type: mongooseInstance?.Schema.Types.Buffer || 'Buffer', ...options });
+  const mongooseInstance2 = getMongoose();
+  return withMongoose(z.custom((val) => mongooseInstance2 && val instanceof Buffer || val instanceof Uint8Array), { type: (mongooseInstance2 == null ? void 0 : mongooseInstance2.Schema.Types.Buffer) || "Buffer", ...options });
 };
-// ============================================================================
-// 3. REF SCHEMAS & DYNAMIC POPULATION
-// ============================================================================
 const zRef = (ref, schema, options) => {
-    const isFrontend = getFrontendMode();
-    const mongooseInstance = getMongoose();
-    const objectIdSchema = zObjectId();
-    const base = v4.z.codec(v4.z.union([objectIdSchema, schema]), objectIdSchema, {
-        decode: (val) => (typeof val === 'object' && val !== null && '_id' in val ? val._id : val),
-        encode: (val) => val,
-    });
-    const result = withMongoose(base, {
-        type: isFrontend ? 'ObjectId' : mongooseInstance?.Schema.Types.ObjectId || 'ObjectId',
-        ref,
-        refSchema: schema,
-        ...options,
-    });
-    return result;
-};
-function populateZodSchema(schema, keys) {
-    const { shape } = schema;
-    const newShape = { ...shape };
-    const keysToPopulate = keys || Object.keys(shape);
-    const populateField = (field) => {
-        const meta = getMongooseMeta(field);
-        const { schema: unwrapped, features } = unwrapZodSchema(field);
-        let result = field;
-        if (meta?.refSchema) {
-            result = meta.refSchema;
-        }
-        else if (unwrapped instanceof v4.z.ZodArray) {
-            const populatedInner = populateField(unwrapped.element);
-            if (populatedInner !== unwrapped.element) {
-                result = v4.z.array(populatedInner);
-            }
-        }
-        else if (unwrapped instanceof v4.z.ZodObject) {
-            result = populateZodSchema(unwrapped);
-        }
-        if (result !== field && result !== unwrapped) {
-            if (features.isOptional && !(result instanceof v4.z.ZodOptional))
-                result = result.optional();
-            if (features.isNullable && !(result instanceof v4.z.ZodNullable))
-                result = result.nullable();
-            if (features.default !== undefined && !(result instanceof v4.z.ZodDefault))
-                result = result.default(features.default);
-        }
-        return result;
-    };
-    for (const key of keysToPopulate) {
-        newShape[key] = populateField(shape[key]);
-    }
-    return v4.z.object(newShape);
-}
-// ============================================================================
-// 4. TIMESTAMPS & OUTPUT FORMATTING
-// ============================================================================
-const DateFieldZod = () => v4.z.date().default(() => new Date());
-const genTimestampsSchema = (createdAtField = 'createdAt', updatedAtField = 'updatedAt') => {
-    if (createdAtField != null &&
-        updatedAtField != null &&
-        createdAtField === updatedAtField) {
-        throw new Error('`createdAt` and `updatedAt` fields must be different');
-    }
-    const shape = {};
-    if (createdAtField != null)
-        shape[createdAtField] = withMongoose(DateFieldZod(), { immutable: true, index: true });
-    if (updatedAtField != null)
-        shape[updatedAtField] = withMongoose(DateFieldZod(), { index: true });
-    return shape;
+  const mongooseInstance2 = getMongoose();
+  const objectIdSchema = zObjectId();
+  const base = z.codec(z.union([objectIdSchema, schema]), objectIdSchema, {
+    decode: (val) => typeof val === "object" && val !== null && "_id" in val ? val._id : val,
+    encode: (val) => val
+  });
+  return withMongoose(base, {
+    type: (mongooseInstance2 == null ? void 0 : mongooseInstance2.Schema.Types.ObjectId) || "ObjectId",
+    ref,
+    refSchema: schema,
+    ...options
+  });
 };
-const bufferMongooseGetter = (value) => value != null && value._bsontype === 'Binary' ? value.buffer : value;
-
-// ============================================================================
-// 6. INITIALIZATION RUNTIME COMPONENT
-// ============================================================================
-/**
- * Converts a standard Mongoose model into a `StrictModel` with advanced type-safe population.
- *
- * @template UserInferredType The Zod-inferred type of the document (e.g. `z.infer<typeof Schema>`).
- * @param name The model name to register or retrieve from Mongoose.
- * @param mongooseSchema The Mongoose schema instance.
- * @returns A `StrictModel` instance with enhanced type safety for population.
- *
- * @example
- * ```typescript
- * const PostModel = toStrictModel<Post>('Post', postSchema);
- * const post = await PostModel.findOne().populate('author').exec();
- * // post.author is now fully typed
- * ```
- */
 function toStrictModel(name, mongooseSchema) {
-    const rawModel = mongoose.model(name, mongooseSchema);
-    return rawModel;
+  const rawModel = mongoose__default.model(name, mongooseSchema);
+  return rawModel;
 }
 
-var bufferMongooseGetter_1 = dist.bufferMongooseGetter = bufferMongooseGetter;
-var callHookSync_1 = dist.callHookSync = callHookSync;
-var extractMongooseDef_1 = dist.extractMongooseDef = extractMongooseDef;
-var genTimestampsSchema_1 = dist.genTimestampsSchema = genTimestampsSchema;
-var getFrontendMode_1 = dist.getFrontendMode = getFrontendMode;
-var getMongoose_1 = dist.getMongoose = getMongoose;
-var getMongooseMeta_1 = dist.getMongooseMeta = getMongooseMeta;
-var hooks_1 = dist.hooks = hooks;
-var mongooseRegistry_1 = dist.mongooseRegistry = mongooseRegistry;
-var populateZodSchema_1 = dist.populateZodSchema = populateZodSchema;
-var setFrontendMode_1 = dist.setFrontendMode = setFrontendMode;
-var setMongoose_1 = dist.setMongoose = setMongoose;
-var toMongooseSchema_1 = dist.toMongooseSchema = toMongooseSchema;
-var toStrictModel_1 = dist.toStrictModel = toStrictModel;
-var withMongoose_1 = dist.withMongoose = withMongoose;
-var zBuffer_1 = dist.zBuffer = zBuffer;
-var zObjectId_1 = dist.zObjectId = zObjectId;
-var zRef_1 = dist.zRef = zRef;
-
-const mongooseZod = /*#__PURE__*/_mergeNamespaces({
-	__proto__: null,
-	bufferMongooseGetter: bufferMongooseGetter_1,
-	callHookSync: callHookSync_1,
-	default: dist,
-	extractMongooseDef: extractMongooseDef_1,
-	genTimestampsSchema: genTimestampsSchema_1,
-	getFrontendMode: getFrontendMode_1,
-	getMongoose: getMongoose_1,
-	getMongooseMeta: getMongooseMeta_1,
-	hooks: hooks_1,
-	mongooseRegistry: mongooseRegistry_1,
-	populateZodSchema: populateZodSchema_1,
-	setFrontendMode: setFrontendMode_1,
-	setMongoose: setMongoose_1,
-	toMongooseSchema: toMongooseSchema_1,
-	toStrictModel: toStrictModel_1,
-	withMongoose: withMongoose_1,
-	zBuffer: zBuffer_1,
-	zObjectId: zObjectId_1,
-	zRef: zRef_1
-}, [dist]);
+const mongooseZod = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    bufferMongooseGetter: bufferMongooseGetter,
+    callHookSync: callHookSync,
+    extractMongooseDef: extractMongooseDef,
+    genTimestampsSchema: genTimestampsSchema,
+    getFrontendMode: getFrontendMode,
+    getMongoose: getMongoose,
+    getMongooseMeta: getMongooseMeta,
+    hooks: hooks,
+    mongooseRegistry: mongooseRegistry,
+    populateZodSchema: populateZodSchema,
+    setFrontendMode: setFrontendMode,
+    setMongoose: setMongoose,
+    toMongooseSchema: toMongooseSchema,
+    toStrictModel: toStrictModel,
+    withMongoose: withMongoose,
+    zBuffer: zBuffer,
+    zObjectId: zObjectId,
+    zRef: zRef
+}, Symbol.toStringTag, { value: 'Module' }));
 
-setMongoose_1(mongoose$1.default || mongoose$1);
+setMongoose(mongoose.default || mongoose);
 let _filename = "/sandbox/main.ts";
 let _dirname = "/sandbox";
 try {
@@ -1447,7 +1166,7 @@ const parse_post = defineEventHandler(async (event) => {
   const sandboxRequire = (moduleName) => {
     if (moduleName === "zod" || moduleName === "zod/v4") return zod;
     if (moduleName === "@nullix/zod-mongoose") return mongooseZod;
-    if (moduleName === "mongoose") return mongoose$1.default || mongoose$1;
+    if (moduleName === "mongoose") return mongoose.default || mongoose;
     throw new Error(`Security Exception: Module "${moduleName}" is blocked.`);
   };
   const sandbox = {
@@ -1478,8 +1197,8 @@ const parse_post = defineEventHandler(async (event) => {
     if (!schema || !schema._def) {
       throw new Error("You must `export default` a valid Zod schema.");
     }
-    const extractedDef = extractMongooseDef_1(schema);
-    const mongooseSchema = toMongooseSchema_1(schema);
+    const extractedDef = extractMongooseDef(schema);
+    const mongooseSchema = toMongooseSchema(schema);
     const formatOpts = { depth: null, showHidden: false, colors: false };
     const formatValue = (val) => {
       if (typeof val === "function") {