@nullix/zod-mongoose-studio 3.3.2 → 3.3.3

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

@@ -1,11 +1,13 @@
-import { d as defineEventHandler, u as useRuntimeConfig, c as createError, r as readStudioRequest, e as executeStudio, S as StudioExecutionError } from '../../nitro/nitro.mjs';
+import { d as defineEventHandler, u as useRuntimeConfig, c as createError } from '../../nitro/nitro.mjs';
+import vm from 'node:vm';
+import { transformSync } from 'esbuild';
+import util from 'node:util';
+import { parse } from 'acorn';
+import * as zod from 'zod/v4';
+import { z } from 'zod/v4';
+import mongoose from 'mongoose';
+import { r as readStudioRequest } from '../../_/parse-request.mjs';
 import 'node:http';
-import 'node:vm';
-import 'esbuild';
-import 'node:util';
-import 'acorn';
-import 'zod/v4';
-import 'mongoose';
 import 'node:https';
 import 'node:events';
 import 'node:buffer';
@@ -16,6 +18,1596 @@ import 'node:url';
 import '@iconify/utils';
 import 'consola';
 
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(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;
+})();
+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 && typeof result.then === "function") return Promise.resolve(result).then(() => callHooks(hooks2, args, i + 1, task));
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+function serialTaskCaller(hooks2, args, name) {
+  if (hooks2.length > 0) return callHooks(hooks2, args, 0, createTask(name));
+}
+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);
+}
+var Hookable = class {
+  constructor() {
+    __publicField$1(this, "_hooks");
+    __publicField$1(this, "_before");
+    __publicField$1(this, "_after");
+    __publicField$1(this, "_deprecatedHooks");
+    __publicField$1(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();
+}
+const hooks = createHooks();
+function callHookSync(name, ...args) {
+  hooks.callHookWith((callbacks, args2) => {
+    for (const callback of callbacks) {
+      callback(...args2);
+    }
+  }, name, args);
+}
+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;
+}
+function getMongooseMeta(schema) {
+  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;
+}
+function objectStrictness(schema) {
+  var _a, _b, _c, _d;
+  const catchall = (_b = (_a = schema._zod) == null ? void 0 : _a.def) == null ? void 0 : _b.catchall;
+  if (!catchall) return true;
+  return ((_d = (_c = catchall._zod) == null ? void 0 : _c.def) == null ? void 0 : _d.type) === "never" ? "throw" : false;
+}
+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();
+    const result = unwrapZodSchema(
+      // @ts-expect-error Zod v4 schema.unwrap() return type mismatch
+      inner,
+      features,
+      visited
+    );
+    return {
+      schema: result.schema,
+      features: {
+        ...result.features,
+        required: false,
+        isOptional: true,
+        isExactOptional: false,
+        isNonOptional: false
+      }
+    };
+  }
+  if (schema instanceof z.ZodExactOptional) {
+    const result = unwrapZodSchema(schema.unwrap(), features, visited);
+    return {
+      schema: result.schema,
+      features: {
+        ...result.features,
+        required: false,
+        isOptional: true,
+        isExactOptional: true,
+        isNonOptional: false
+      }
+    };
+  }
+  if (schema instanceof z.ZodNonOptional) {
+    const result = unwrapZodSchema(schema.unwrap(), features, visited);
+    return {
+      schema: result.schema,
+      features: {
+        ...result.features,
+        required: true,
+        isOptional: false,
+        isExactOptional: false,
+        isNonOptional: true
+      }
+    };
+  }
+  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 (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);
+    }
+    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;
+    }
+  }
+  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 };
+}
+function prepareForZodValidation(schema, value, mongooseSchema, pathPrefix = "") {
+  var _a;
+  if (value === null || value === void 0) return value;
+  const { schema: unwrapped } = unwrapZodSchema(schema);
+  const def = unwrapped == null ? void 0 : unwrapped._def;
+  if ((def == null ? void 0 : def.type) === "lazy") {
+    return prepareForZodValidation(def.getter(), value, mongooseSchema, pathPrefix);
+  }
+  if ((def == null ? void 0 : def.type) === "object" && typeof value === "object" && !Array.isArray(value)) {
+    const { shape } = unwrapped;
+    const result = { ...value };
+    if (mongooseSchema && !pathPrefix && mongooseSchema.options._id !== false && !Object.hasOwn(shape, "_id")) {
+      delete result._id;
+    }
+    const versionKey = !pathPrefix && (mongooseSchema == null ? void 0 : mongooseSchema.options.versionKey);
+    if (typeof versionKey === "string" && !Object.hasOwn(shape, versionKey)) {
+      delete result[versionKey];
+    }
+    const timestamps = !pathPrefix && (mongooseSchema == null ? void 0 : mongooseSchema.options.timestamps);
+    if (timestamps) {
+      for (const key of ["createdAt", "updatedAt"]) {
+        const configured = typeof timestamps === "object" ? timestamps[key] : void 0;
+        if (configured === false) continue;
+        const fieldName = typeof configured === "string" ? configured : key;
+        if (!Object.hasOwn(shape, fieldName)) delete result[fieldName];
+      }
+    }
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+      if (!Object.hasOwn(result, key)) continue;
+      const path = pathPrefix ? `${pathPrefix}.${key}` : key;
+      const nestedSchema = (_a = mongooseSchema == null ? void 0 : mongooseSchema.path(path)) == null ? void 0 : _a.schema;
+      result[key] = prepareForZodValidation(
+        fieldSchema,
+        result[key],
+        nestedSchema || mongooseSchema,
+        nestedSchema ? "" : path
+      );
+    }
+    return result;
+  }
+  if (Array.isArray(value)) {
+    if ((def == null ? void 0 : def.type) === "array" || (def == null ? void 0 : def.type) === "set") {
+      const element = unwrapped.element || def.valueType;
+      return element ? value.map((item) => prepareForZodValidation(element, item, mongooseSchema, pathPrefix)) : value;
+    }
+    if ((def == null ? void 0 : def.type) === "tuple") {
+      return value.map((item, index) => {
+        var _a2;
+        const element = ((_a2 = def.items) == null ? void 0 : _a2[index]) || def.rest;
+        return element ? prepareForZodValidation(element, item, mongooseSchema, pathPrefix) : item;
+      });
+    }
+  }
+  return value;
+}
+let mongooseInstance = null;
+let isFrontend;
+const setFrontendMode = (enabled) => {
+  console.warn(
+    "[zod-mongoose] setFrontendMode() is deprecated and will be removed in v4. Conditional exports select the appropriate implementation automatically."
+  );
+  isFrontend = enabled;
+};
+const getFrontendMode = () => {
+  if (isFrontend === void 0 || isFrontend === null) {
+    return globalThis.window !== void 0 && globalThis.document !== void 0;
+  }
+  return isFrontend;
+};
+const setMongoose = (m) => {
+  mongooseInstance = m;
+};
+const getMongoose = () => {
+  var _a;
+  if (getFrontendMode()) {
+    return null;
+  }
+  if (mongooseInstance) {
+    return mongooseInstance;
+  }
+  try {
+    if (typeof require !== "undefined") {
+      const m = require("mongoose");
+      if (m && (m.Schema || ((_a = m.default) == null ? void 0 : _a.Schema))) {
+        return m.default || m;
+      }
+      return m;
+    }
+    return null;
+  } catch {
+    if (globalThis.mongoose) {
+      return globalThis.mongoose;
+    }
+    return null;
+  }
+};
+function mapZodChecksToMongoose(checks, mongooseProp) {
+  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;
+    }
+    if (traitSet.has("$ZodCheckMaxLength")) {
+      mongooseProp.maxlength = checkDef.maximum;
+    }
+    if (traitSet.has("$ZodCheckLengthEquals")) {
+      mongooseProp.minlength = checkDef.length;
+      mongooseProp.maxlength = checkDef.length;
+    }
+    if (traitSet.has("$ZodCheckGreaterThan")) {
+      mongooseProp.min = checkDef.value;
+    }
+    if (traitSet.has("$ZodCheckLessThan")) {
+      mongooseProp.max = checkDef.value;
+    }
+    if (traitSet.has("$ZodCheckRegex")) {
+      mongooseProp.match = checkDef.pattern;
+    }
+    if (traitSet.has("$ZodUUID")) {
+      const mongoose = globalThis.mongoose || globalThis.__mongoose;
+      if (mongoose == null ? void 0 : mongoose.Schema.Types.UUID) {
+        mongooseProp.type = mongoose.Schema.Types.UUID;
+      }
+    }
+    if (traitSet.has("$ZodISODateTime") || traitSet.has("$ZodISODate")) {
+      mongooseProp.type = Date;
+    }
+    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;
+      }
+    }
+  }
+  callHookSync("validation:mappers", { checks, mongooseProp });
+}
+function handleObject(unwrapped, mongooseProp, visited, extractMongooseDef2, isField = false) {
+  var _a, _b, _c, _d, _e;
+  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 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 });
+  }
+  let result;
+  const shouldBeSubSchema = isField && mongooseProp.schema !== false;
+  if (isField && mongooseProp.schema === false && !mongooseProp.type && objectStrictness(unwrapped) !== true) {
+    throw new Error(
+      "A strict, loose, or catchall Zod object needs a Mongoose subschema. Remove {schema: false} or provide a Mongoose type override."
+    );
+  }
+  if (shouldBeSubSchema && !mongooseProp.type) {
+    const mongoose = getMongoose();
+    if (mongoose) {
+      const options = typeof mongooseProp.schema === "object" ? mongooseProp.schema : {};
+      const { plugins, ...schemaOptions } = options;
+      const strict = (_b = (_a = schemaOptions.strict) != null ? _a : mongooseProp.strict) != null ? _b : objectStrictness(unwrapped);
+      const minimize = (_d = (_c = schemaOptions.minimize) != null ? _c : mongooseProp.minimize) != null ? _d : objectStrictness(unwrapped) === false ? false : void 0;
+      const subSchema = new mongoose.Schema(objDef, {
+        ...schemaOptions,
+        strict,
+        ...minimize === void 0 ? {} : { minimize }
+      });
+      if (plugins && Array.isArray(plugins)) {
+        for (const plugin of plugins) {
+          subSchema.plugin(plugin);
+        }
+      }
+      mongooseProp.type = subSchema;
+    }
+  }
+  if (mongooseProp.type) {
+    const mongoose = getMongoose();
+    const isSchema = mongoose && (mongooseProp.type instanceof mongoose.Schema || ((_e = mongooseProp.type.constructor) == null ? void 0 : _e.name) === "Schema");
+    if (!isSchema) {
+      Object.assign(mongooseProp, objDef);
+    }
+    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 mongoose = getMongoose();
+  const innerDef = element ? extractMongooseDef2(element, visited) : (mongoose == null ? void 0 : mongoose.Schema.Types.Mixed) || "Mixed";
+  if (!mongooseProp.type) {
+    if (innerDef && typeof innerDef === "object" && innerDef.__isDiscriminatorUnion && mongoose) {
+      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];
+      if (typeof innerDef === "object") {
+        const innerMeta = { ...innerDef };
+        delete innerMeta.type;
+        Object.assign(mongooseProp, innerMeta);
+        mongooseProp.type = [innerType];
+      }
+    }
+  }
+  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;
+    }
+  }
+  callHookSync("schema:record:after", { schema: unwrapped, mongooseProp, innerDef });
+}
+function areDefinitionsEqual(left, right, seen = /* @__PURE__ */ new WeakMap()) {
+  if (left === right) return true;
+  if (left === null || right === null || typeof left !== "object" || typeof right !== "object") {
+    return false;
+  }
+  const mongoose = getMongoose();
+  const leftIsSchema = mongoose && left instanceof mongoose.Schema;
+  const rightIsSchema = mongoose && right instanceof mongoose.Schema;
+  if (leftIsSchema || rightIsSchema) {
+    return Boolean(
+      leftIsSchema && rightIsSchema && areDefinitionsEqual(left.obj, right.obj, seen)
+    );
+  }
+  let seenRight = seen.get(left);
+  if (seenRight == null ? void 0 : seenRight.has(right)) return true;
+  if (!seenRight) {
+    seenRight = /* @__PURE__ */ new WeakSet();
+    seen.set(left, seenRight);
+  }
+  seenRight.add(right);
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => areDefinitionsEqual(value, right[index], seen));
+  }
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  return leftKeys.length === rightKeys.length && leftKeys.every(
+    (key) => Object.prototype.hasOwnProperty.call(right, key) && areDefinitionsEqual(left[key], right[key], seen)
+  );
+}
+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 (Object.keys(meta).length > 0) {
+      Object.assign(existing, mongooseProp);
+    }
+    return existing;
+  }
+  visited.set(schema, mongooseProp);
+  if (features.default !== void 0) {
+    mongooseProp.default = features.default;
+  }
+  if (features.required === false) {
+    mongooseProp.required = false;
+  }
+  if (features.isNullable === true && mongooseProp.required === void 0) {
+    mongooseProp.required = false;
+  }
+  if (features.isNonOptional === true && features.isNullable !== true && mongooseProp.required !== false) {
+    mongooseProp.required = true;
+  }
+  if (features.readOnly === true) {
+    mongooseProp.readOnly = true;
+  }
+  if (isField && features.isExactOptional === true) {
+    const previousSetter = mongooseProp.set;
+    mongooseProp.set = function exactOptionalSetter(value) {
+      if (value === void 0) {
+        throw new TypeError("An exactOptional field cannot be set to undefined");
+      }
+      return typeof previousSetter === "function" ? previousSetter.call(this, value) : value;
+    };
+  }
+  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 previousUnwrapped = schema === unwrapped ? void 0 : visited.get(unwrapped);
+    const result = handleObject(unwrapped, mongooseProp, visited, wrapperFn, isField && !noWrap);
+    visited.set(schema, result);
+    if (schema !== unwrapped) {
+      if (previousUnwrapped === void 0) visited.delete(unwrapped);
+      else visited.set(unwrapped, previousUnwrapped);
+    }
+    callHookSync("converter:after", {
+      schema,
+      mongooseProp: result
+    });
+    if (typeof result === "object" && result !== null && !Array.isArray(result)) {
+      delete result.includeId;
+    }
+    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 mongoose = getMongoose();
+        if (mongoose) {
+          const options = typeof mongooseProp.schema === "object" ? mongooseProp.schema : {};
+          const { plugins, ...schemaOptions } = options;
+          const definition = { ...mongooseProp };
+          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;
+          for (const key of Object.keys(mongooseProp)) {
+            if (key !== "type") delete mongooseProp[key];
+          }
+        }
+      }
+    } 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" || (((_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);
+        }
+      }
+      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 areDefinitionsEqual(def2[key], firstOption[key]);
+          });
+          if (isCommon) {
+            baseDef[key] = firstOption[key];
+            for (const def2 of allOptionDefs) {
+              delete def2[key];
+            }
+          }
+        }
+      }
+      const result = {
+        __isDiscriminatorUnion: true,
+        discriminatorKey,
+        discriminators,
+        baseDef,
+        validate: {
+          validator(_v) {
+            var _a2, _b2;
+            try {
+              const mongoose2 = getMongoose();
+              const doc = mongoose2 && this instanceof mongoose2.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}`
+        }
+      };
+      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 (((_g = getMongoose()) == null ? void 0 : _g.Schema.Types.Union) && unionCtx.isSimpleUnion && options.length > 0 && !unionCtx.isXor) {
+      mongooseProp.type = mongoose.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 (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;
+            }
+          }
+        }
+      }
+      if (isField && unionCtx.isXor) {
+        mongooseProp.type = (mongoose == null ? void 0 : mongoose.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;
+        }
+        Object.assign(mongooseProp, mergedDef);
+        if (isField && Object.prototype.hasOwnProperty.call(mongooseProp, "type") && Object.keys(mongooseProp).length > 1) {
+          const mongooseInstance22 = getMongoose();
+          if (mongooseInstance22) {
+            mongooseProp.type = new mongooseInstance22.Schema(mongooseProp, { _id: false });
+            for (const key of Object.keys(mongooseProp)) {
+              if (key !== "type") delete mongooseProp[key];
+            }
+          }
+        }
+      }
+    } else {
+      mongooseProp.type = (mongoose == null ? void 0 : 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) {
+        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";
+          }
+        };
+      }
+    }
+    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;
+            }
+          }
+          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;
+              }
+            }
+          }
+        }
+      }
+      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;
+    }
+  }
+  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";
+    }
+  }
+  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;
+}
+function modelNameFromCollection(collection) {
+  const singular = collection.replace(/ies$/i, "y").replace(/(ses|xes|zes|ches|shes)$/i, (suffix) => suffix.slice(0, -2)).replace(/s$/i, "");
+  return singular.slice(0, 1).toUpperCase() + singular.slice(1);
+}
+function toMongooseSchema(schema, options) {
+  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, modelName, ...schemaOptions } = options || {};
+  const mergedOptions = {
+    ...unwrapped instanceof z.ZodObject ? { strict: objectStrictness(unwrapped) } : {},
+    ...unwrapped instanceof z.ZodObject && objectStrictness(unwrapped) === false ? { minimize: false } : {},
+    // 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 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."
+    );
+  }
+  let mongooseSchema;
+  if (definition && typeof definition === "object" && definition.__isDiscriminatorUnion) {
+    const baseModelName = modelName || (options == null ? void 0 : options.collection) && modelNameFromCollection(options.collection);
+    if (!baseModelName) {
+      throw new Error(
+        "toMongooseSchema() found a top-level discriminated union. Provide `modelName` or `collection` so discriminator model names can be made unique, for example `{ modelName: 'Activity' }`."
+      );
+    }
+    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)) {
+      const discriminatorModelName = `${baseModelName}_${key}`;
+      if (mongooseSchema.discriminators && mongooseSchema.discriminators[discriminatorModelName]) {
+        continue;
+      }
+      mongooseSchema.discriminator(
+        discriminatorModelName,
+        new mongoose.Schema(dDef, { _id: false }),
+        { value: key }
+      );
+    }
+  } 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);
+  }
+  if (mergedOptions.validateBeforeSave !== false) {
+    mongooseSchema.post("validate", function() {
+      var _a2, _b2, _c, _d;
+      try {
+        schema.parse(prepareForZodValidation(schema, this.toObject(), mongooseSchema));
+      } catch (e) {
+        if (e instanceof z.ZodError) {
+          e.message = JSON.stringify({
+            context: {
+              model: ((_a2 = this.constructor) == null ? void 0 : _a2.modelName) || ((_b2 = this.constructor) == null ? void 0 : _b2.name) || "_unknown_",
+              id: ((_c = this._id) == null ? void 0 : _c.toString()) || ((_d = this.id) == null ? void 0 : _d.toString()) || "_unknown_"
+            },
+            errors: e.issues || e.errors || []
+          });
+        }
+        throw e;
+      }
+    });
+  }
+  if (plugins && Array.isArray(plugins)) {
+    for (const plugin of plugins) {
+      mongooseSchema.plugin(plugin);
+    }
+  }
+  callHookSync("schema:created", {
+    schema,
+    mongooseSchema,
+    options: mergedOptions
+  });
+  return mongooseSchema;
+}
+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);
+    }
+    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 position = z.tuple([z.number(), z.number()]);
+const zPoint = (options) => withMongoose(
+  z.object({
+    type: withMongoose(z.literal("Point"), { type: String, enum: ["Point"], required: true }),
+    coordinates: withMongoose(position, { required: true })
+  }),
+  { schema: { _id: false }, required: true, ...options }
+);
+const zPolygon = (options) => withMongoose(
+  z.object({
+    type: withMongoose(z.literal("Polygon"), { type: String, enum: ["Polygon"], required: true }),
+    coordinates: withMongoose(
+      z.array(
+        z.array(position).refine(
+          (ring) => {
+            var _a, _b, _c, _d;
+            return ring.length >= 4 && ((_a = ring[0]) == null ? void 0 : _a[0]) === ((_b = ring.at(-1)) == null ? void 0 : _b[0]) && ((_c = ring[0]) == null ? void 0 : _c[1]) === ((_d = ring.at(-1)) == null ? void 0 : _d[1]);
+          },
+          "Polygon rings must be closed"
+        )
+      ).refine((rings) => rings.length > 0, "Polygon must have at least one ring"),
+      { required: true }
+    )
+  }),
+  { schema: { _id: false }, required: true, ...options }
+);
+const preprocessFn = (val) => val === null ? void 0 : val;
+const zObjectId = (options) => {
+  var _a;
+  const objectIdSchema = z.custom(
+    (val) => {
+      const mongooseInstance2 = getMongoose();
+      return 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) => {
+      const mongooseInstance2 = getMongoose();
+      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: ((_a = getMongoose()) == null ? void 0 : _a.Schema.Types.ObjectId) || "ObjectId",
+    ...options
+  });
+};
+const zBuffer = (options) => {
+  var _a;
+  return withMongoose(
+    z.preprocess(
+      (val) => {
+        var _a2;
+        const Binary = (_a2 = getMongoose()) == null ? void 0 : _a2.mongo.Binary;
+        return Binary && val instanceof Binary ? Buffer.from(val.value()) : val;
+      },
+      z.custom((val) => val instanceof Uint8Array)
+    ),
+    { type: ((_a = getMongoose()) == null ? void 0 : _a.Schema.Types.Buffer) || "Buffer", ...options }
+  );
+};
+const zRef = (ref, schema, options) => {
+  var _a;
+  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: ((_a = getMongoose()) == null ? void 0 : _a.Schema.Types.ObjectId) || "ObjectId",
+    ref,
+    refSchema: schema,
+    ...options
+  });
+};
+function toStrictModel(name, mongooseSchema) {
+  const m = getMongoose();
+  if (!m) {
+    throw new Error("Mongoose must be installed to use toStrictModel.");
+  }
+  const rawModel = m.model(name, mongooseSchema);
+  return rawModel;
+}
+
+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,
+  objectStrictness: objectStrictness,
+  populateZodSchema: populateZodSchema,
+  setFrontendMode: setFrontendMode,
+  setMongoose: setMongoose,
+  toMongooseSchema: toMongooseSchema,
+  toStrictModel: toStrictModel,
+  unwrapZodSchema: unwrapZodSchema,
+  withMongoose: withMongoose,
+  zBuffer: zBuffer,
+  zObjectId: zObjectId,
+  zPoint: zPoint,
+  zPolygon: zPolygon,
+  zRef: zRef
+}, Symbol.toStringTag, { value: 'Module' }));
+
+function checks(schema) {
+  return (schema._def.checks || []).map((check) => {
+    var _a;
+    return ((_a = check._zod) == null ? void 0 : _a.def) || check.def || {};
+  });
+}
+function sampleString(schema, key) {
+  var _a;
+  const rules = checks(schema);
+  const format = schema._def.format || ((_a = rules.find((rule) => rule.format)) == null ? void 0 : _a.format);
+  if (format === "email" || /email/i.test(key)) return "alex@example.com";
+  if (format === "uuid") return "123e4567-e89b-42d3-a456-426614174000";
+  if (format === "url") return "https://example.com";
+  if (format === "datetime") return "2026-01-01T12:00:00.000Z";
+  if (format === "date") return "2026-01-01";
+  const minimum = Math.max(1, ...rules.filter((rule) => rule.check === "min_length").map((rule) => rule.minimum));
+  const base = /name/i.test(key) ? "Alex Morgan" : /title/i.test(key) ? "Example title" : "example";
+  return base.padEnd(Math.min(minimum, 100), "x");
+}
+function sampleNumber(schema) {
+  const rules = checks(schema);
+  const lower = rules.find((rule) => rule.check === "greater_than");
+  const upper = rules.find((rule) => rule.check === "less_than");
+  const integer = schema._def.type === "int" || rules.some((rule) => rule.check === "number_format" && rule.format === "safeint");
+  const minimum = lower ? Number(lower.value) + (lower.inclusive ? 0 : integer ? 1 : 0.1) : 1;
+  const maximum = upper ? Number(upper.value) - (upper.inclusive ? 0 : integer ? 1 : 0.1) : Infinity;
+  const candidate = Math.min(Math.max(21, minimum), maximum);
+  return integer ? Math.ceil(candidate) : candidate;
+}
+function createExample(schema, key = "value", depth = 0, seen = /* @__PURE__ */ new Set()) {
+  var _a;
+  if (depth > 8 || seen.has(schema)) throw new Error("This recursive schema needs a handwritten example.");
+  const nextSeen = new Set(seen).add(schema);
+  const def = schema._def;
+  const mongooseType = getMongooseMeta(schema).type;
+  if (mongooseType === "ObjectId" || (mongooseType == null ? void 0 : mongooseType.schemaName) === "ObjectId") return "507f1f77bcf86cd799439011";
+  switch (def.type) {
+    case "optional":
+    case "default":
+    case "prefault":
+      return depth === 0 ? createExample(def.innerType, key, depth + 1, nextSeen) : void 0;
+    case "nullable":
+    case "nonoptional":
+    case "readonly":
+    case "catch":
+      return createExample(def.innerType, key, depth + 1, nextSeen);
+    case "pipe":
+      return createExample(def.in, key, depth + 1, nextSeen);
+    case "lazy":
+      return createExample(def.getter(), key, depth + 1, nextSeen);
+    case "object": {
+      const result = {};
+      for (const [field, fieldSchema] of Object.entries(schema.shape || def.shape || {})) {
+        const value = createExample(fieldSchema, field, depth + 1, nextSeen);
+        if (value !== void 0) result[field] = value;
+      }
+      return result;
+    }
+    case "array": {
+      const minimum = Math.max(0, ...checks(schema).filter((rule) => rule.check === "min_length").map((rule) => rule.minimum));
+      return Array.from({ length: Math.min(Math.max(1, minimum), 10) }, () => createExample(def.element, key, depth + 1, nextSeen));
+    }
+    case "tuple":
+      return def.items.map((item) => createExample(item, key, depth + 1, nextSeen));
+    case "string":
+      return sampleString(schema, key);
+    case "number":
+    case "int":
+      return sampleNumber(schema);
+    case "boolean":
+      return true;
+    case "enum":
+      return Object.values(def.entries)[0];
+    case "literal":
+      return (_a = def.values) == null ? void 0 : _a[0];
+    case "union":
+      return createExample(def.options[0], key, depth + 1, nextSeen);
+    case "record":
+      return { example: createExample(def.valueType, key, depth + 1, nextSeen) };
+    case "date":
+      return "2026-01-01T12:00:00.000Z";
+    default:
+      throw new Error(`Automatic examples do not yet support ${def.type || "this schema"}.`);
+  }
+}
+
+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, key + "" , value);
+setMongoose(mongoose);
+class StudioExecutionError extends Error {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "statusCode", 400);
+  }
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message || error.name : String(error);
+}
+function declaredNames(jsCode) {
+  const file = parse(jsCode, { ecmaVersion: "latest", sourceType: "script" });
+  const names = [];
+  for (const statement of file.body) {
+    if (statement.type !== "VariableDeclaration") continue;
+    for (const declaration of statement.declarations) {
+      if (declaration.id.type === "Identifier") names.push(declaration.id.name);
+    }
+  }
+  return names;
+}
+function displayValue(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(value, (_key, item) => {
+    if (typeof item === "bigint") return `${item.toString()}n`;
+    if (typeof item === "undefined") return "[undefined]";
+    if (typeof item === "number" && !Number.isFinite(item)) return String(item);
+    if (typeof item === "object" && item !== null) {
+      if (item instanceof Date) return item.toISOString();
+      if (typeof item.toHexString === "function") return item.toHexString();
+      if (seen.has(item)) return "[Circular]";
+      seen.add(item);
+    }
+    return item;
+  }, 2) || "undefined";
+}
+function formatMongoose(value) {
+  if (typeof value === "function") return value.name || value.toString();
+  if (Array.isArray(value)) return value.map(formatMongoose);
+  if (value !== null && typeof value === "object" && value.constructor === Object) {
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, formatMongoose(entry)]));
+  }
+  return value;
+}
+function executeStudio(body, timeoutMs) {
+  var _a;
+  const sourceCode = body.sourceCode;
+  hooks.removeAllHooks();
+  try {
+    let jsCode;
+    try {
+      jsCode = transformSync(sourceCode, { loader: "ts", format: "cjs", target: "esnext" }).code;
+    } catch (error) {
+      throw new StudioExecutionError(`Compilation error: ${errorMessage(error)}`);
+    }
+    const names = declaredNames(jsCode);
+    const sandboxRequire = (moduleName) => {
+      if (moduleName === "zod" || moduleName === "zod/v4") return zod;
+      if (moduleName === "@nullix/zod-mongoose") return mongooseZod;
+      if (moduleName === "mongoose") return mongoose;
+      throw new Error(`Module "${moduleName}" is unavailable in Studio.`);
+    };
+    const context = vm.createContext({
+      ...mongooseZod,
+      z: zod.z,
+      mongoose,
+      require: sandboxRequire,
+      console: { log: () => {
+      }, warn: () => {
+      }, error: () => {
+      } },
+      __filename: "/sandbox/main.ts",
+      __dirname: "/sandbox"
+    });
+    const captured = names.map((name) => `${JSON.stringify(name)}: typeof ${name} === "undefined" ? undefined : ${name}`).join(",");
+    const script = new vm.Script(`
+      (() => {
+        let exports = {};
+        let module = { exports };
+        ${jsCode}
+        return { exported: module.exports, declared: { ${captured} } };
+      })()
+    `);
+    const result = script.runInContext(context, { timeout: timeoutMs });
+    const choices = /* @__PURE__ */ new Map();
+    for (const [name, value] of Object.entries(result.declared)) {
+      if (value instanceof zod.ZodType && ![...choices.values()].includes(value)) choices.set(name, value);
+    }
+    for (const [name, value] of Object.entries(result.exported || {})) {
+      if (value instanceof zod.ZodType && ![...choices.values()].includes(value)) choices.set(name, value);
+    }
+    const defaultExport = result.exported instanceof zod.ZodType ? result.exported : (_a = result.exported) == null ? void 0 : _a.default;
+    if (defaultExport instanceof zod.ZodType && ![...choices.values()].includes(defaultExport)) choices.set("default", defaultExport);
+    if (!choices.size) throw new Error("Define a Zod schema, such as const UserSchema = z.object({ name: z.string() }).");
+    const selectedSchema = body.selectedSchema && choices.has(body.selectedSchema) ? body.selectedSchema : choices.keys().next().value;
+    const schema = choices.get(selectedSchema);
+    const schemaNames = [...choices.keys()];
+    let example;
+    let exampleError;
+    let inputData = body.inputData;
+    if (body.action === "example") {
+      try {
+        const fixture = result.declared.exampleInput;
+        const generated = fixture !== void 0 ? fixture : createExample(schema);
+        const exampleResult = schema.safeParse(generated);
+        if (!exampleResult.success) throw new Error("The example does not satisfy this schema. Add or update a valid const exampleInput for custom rules.");
+        example = displayValue(generated);
+        inputData = example;
+      } catch (error) {
+        exampleError = errorMessage(error);
+      }
+    }
+    let validation = { status: "empty" };
+    if (typeof inputData !== "string" || !inputData.trim()) {
+      validation = { status: "empty", message: "Add JSON data to try this schema." };
+    } else {
+      let input;
+      let inputValid = false;
+      try {
+        input = JSON.parse(inputData);
+        inputValid = true;
+      } catch (error) {
+        validation = { status: "json-error", message: errorMessage(error) };
+      }
+      if (inputValid) {
+        try {
+          const parsed = schema.safeParse(input);
+          validation = parsed.success ? { status: "valid", parsed: displayValue(parsed.data) } : { status: "invalid", issues: parsed.error.issues.map((issue) => ({ path: issue.path.length ? issue.path.join(".") : "(root)", message: issue.message, code: issue.code })) };
+        } catch (error) {
+          validation = { status: "parse-error", message: `Validation could not run: ${errorMessage(error)}` };
+        }
+      }
+    }
+    let conversion;
+    try {
+      const extracted = extractMongooseDef(schema);
+      const converted = toMongooseSchema(schema, { modelName: "ParsedSchema" });
+      const inspect = (value) => util.inspect(formatMongoose(value), { depth: null, colors: false, showHidden: false });
+      conversion = {
+        definition: inspect(extracted),
+        schemaObj: inspect(converted.obj),
+        schemaTree: inspect(converted.tree),
+        schemaPaths: inspect(converted.paths)
+      };
+    } catch (error) {
+      conversion = { error: errorMessage(error) };
+    }
+    return { schemaNames, selectedSchema, validation, conversion, example, exampleError };
+  } finally {
+    hooks.removeAllHooks();
+  }
+}
+
 const MAX_PENDING_PARSES = 3;
 let parseQueue = Promise.resolve();
 let pendingParses = 0;