@nullix/zod-mongoose-studio 3.2.0 → 3.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nullix/zod-mongoose-studio",
-  "version": "3.2.0",
+  "version": "3.3.1",
   "description": "Monaco-powered TypeScript playground for @nullix/zod-mongoose",
   "main": "./nuxt.config.ts",
   "bin": {
@@ -39,12 +39,13 @@
     "provenance": true
   },
   "dependencies": {
+    "acorn": "8.16.0",
     "esbuild": "0.28.0",
     "get-port-please": "3.2.0",
     "mongoose": "9.6.3",
     "open": "11.0.0",
     "zod": "4.3.6",
-    "@nullix/zod-mongoose": "3.2.0"
+    "@nullix/zod-mongoose": "3.3.1"
   },
   "devDependencies": {
     "@nuxt/ui": "4.6.0",
@@ -61,6 +62,7 @@
     "dev": "nuxt dev -p 34003",
     "generate": "nuxt generate",
     "preview": "nuxt preview",
+    "test": "node --experimental-strip-types --test test/*.test.ts",
     "postinstall": "nuxt prepare"
   }
 }

package/server/api/editor-types.get.ts

@@ -0,0 +1,28 @@
+import { readdir, readFile } from "node:fs/promises";
+import { dirname, join, relative } from "node:path";
+import { createRequire } from "node:module";
+import { setHeader } from "h3";
+
+const require = createRequire(import.meta.url);
+const zodRoot = dirname(dirname(require.resolve("zod/v4")));
+let cachedTypes: Promise<Record<string, string>> | undefined;
+
+async function collect(directory: string, files: Record<string, string>) {
+  for (const entry of await readdir(directory, { withFileTypes: true })) {
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) await collect(path, files);
+    else if (entry.name.endsWith(".d.ts")) {
+      files[`file:///node_modules/zod/${relative(zodRoot, path).replaceAll("\\", "/")}`] = await readFile(path, "utf8");
+    }
+  }
+}
+
+export default defineEventHandler((event) => {
+  setHeader(event, "Cache-Control", "public, max-age=3600");
+  cachedTypes ||= (async () => {
+    const files: Record<string, string> = {};
+    await collect(join(zodRoot, "v4"), files);
+    return files;
+  })();
+  return cachedTypes;
+});

package/server/api/parse.post.ts

@@ -1,187 +1,29 @@
-import { defineEventHandler, readBody, createError } from "h3";
-import vm from "node:vm";
-import { transformSync } from "esbuild";
-import util from "node:util";
-import { fileURLToPath } from "node:url";
-import { dirname } from "node:path";
+import { defineEventHandler, createError } from "h3";
+import { executeStudio, StudioExecutionError } from "../utils/studio-execution";
+import { readStudioRequest } from "../utils/parse-request";
 
-import * as zod from "zod";
-import * as mongoose from "mongoose";
-import * as mongooseZod from "@nullix/zod-mongoose";
-
-// Initialize Mongoose in ESM environment
-mongooseZod.setMongoose(mongoose.default || mongoose);
-
-// Shim __filename and __dirname for ESM environments (Nitro)
-let _filename = "/sandbox/main.ts";
-let _dirname = "/sandbox";
-
-try {
-  _filename = fileURLToPath(import.meta.url);
-  _dirname = dirname(_filename);
-} catch {
-  // Fallback if import.meta.url is not available or valid in the current context
-}
-
-// The converter exposes a module-level Hookable instance. User code can add
-// hooks to it, so parse requests must not overlap and must always clean it up
-// before the next request starts.
+const MAX_PENDING_PARSES = 3;
 let parseQueue = Promise.resolve();
+let pendingParses = 0;
 
-async function acquireParseLock(): Promise<() => void> {
+async function acquireLocalLock(): Promise<() => void> {
+  if (pendingParses >= MAX_PENDING_PARSES) throw createError({ statusCode: 503, message: "Studio is busy. Try again shortly." });
+  pendingParses++;
   const previous = parseQueue;
   let release!: () => void;
-
-  parseQueue = new Promise<void>((resolve) => {
-    release = resolve;
-  });
-
+  parseQueue = new Promise<void>((resolve) => { release = () => { pendingParses--; resolve(); }; });
   await previous;
   return release;
 }
 
-function getErrorMessage(error: unknown): string {
-  if (error instanceof Error) return error.message || error.name;
-  return String(error);
-}
-
-// @ts-ignore
-if (typeof __filename === "undefined") {
-  // @ts-ignore
-  globalThis.__filename = _filename;
-}
-// @ts-ignore
-if (typeof __dirname === "undefined") {
-  // @ts-ignore
-  globalThis.__dirname = _dirname;
-}
-
 export default defineEventHandler(async (event) => {
-  const config = useRuntimeConfig(event);
-  const isDocsMode = config.public.isDocsMode;
-  const { sourceCode } = await readBody(event);
-
-  if (!sourceCode) {
-    throw createError({ statusCode: 400, message: "Missing sourceCode" });
-  }
-
-  const releaseParseLock = await acquireParseLock();
-
-  // 1. Transpile exactly what the user wrote
-  try {
-    // A user hook can throw before the converter has completed. Since hooks are
-    // global within the server process, cleanup must happen for both success and
-    // failure, otherwise the user's hook would affect every later visitor.
-    mongooseZod.hooks.removeAllHooks();
-
-    let jsCode: string;
-    try {
-      jsCode = transformSync(sourceCode, {
-        loader: "ts",
-        format: "cjs",
-        target: "esnext",
-        // Provide these globals during transpilation just in case
-        define: {
-          __filename: '"/sandbox/main.ts"',
-          __dirname: '"/sandbox"',
-        },
-      }).code;
-    } catch (error: unknown) {
-      throw createError({
-        statusCode: 400,
-        message: `Compilation Error: ${getErrorMessage(error)}`,
-      });
-    }
-    // 2. Map imports securely
-    const sandboxRequire = (moduleName: string) => {
-      if (moduleName === "zod" || moduleName === "zod/v4") return zod;
-      if (moduleName === "@nullix/zod-mongoose") return mongooseZod;
-      if (moduleName === "mongoose") return mongoose.default || mongoose;
-      throw new Error(`Security Exception: Module "${moduleName}" is blocked.`);
-    };
-
-    const sandbox = {
-      require: sandboxRequire,
-      console: { log: () => {}, warn: () => {}, error: () => {} },
-      __filename: "/sandbox/main.ts",
-      __dirname: "/sandbox",
-    };
-    const context = vm.createContext(sandbox);
-
-    const script = new vm.Script(`
-      ((__filename, __dirname) => {
-        let exports = {};
-        let module = { exports };
-
-        ${jsCode}
-
-        return module.exports;
-      })("/sandbox/main.ts", "/sandbox");
-    `);
-
-    // 3. Execute code and grab the default export
-    const rawExport = script.runInContext(context, {
-      timeout: isDocsMode ? 1000 : 5000,
-    });
-
-    const schema = rawExport.default || rawExport;
-
-    if (!schema || !schema._def) {
-      throw new Error("You must `export default` a valid Zod schema.");
-    }
-
-    // 4. Run BOTH functions on the user's schema
-    const extractedDef = mongooseZod.extractMongooseDef(schema);
-    const mongooseSchema = mongooseZod.toMongooseSchema(schema, { modelName: 'ParsedSchema' });
-
-    // Format the outputs nicely
-    const formatOpts = { depth: null, showHidden: false, colors: false };
-
-    // Mongoose schemas are massive class instances, so we extract the raw .obj definition to display
-    const formatValue = (val: any): any => {
-      if (typeof val === "function") {
-        return val.name || val.toString();
-      }
-      if (Array.isArray(val)) {
-        return val.map(formatValue);
-      }
-      if (
-        val !== null &&
-        typeof val === "object" &&
-        val.constructor === Object
-      ) {
-        const formatted: any = {};
-        for (const key in val) {
-          formatted[key] = formatValue(val[key]);
-        }
-        return formatted;
-      }
-      return val;
-    };
-
-    const formattedDef = formatValue(extractedDef);
-    // schemaObj is a Mongoose Schema instance, we only care about its .obj for display
-    const formattedSchema = formatValue(mongooseSchema.obj);
-    // @ts-ignore
-    const formattedTree = formatValue(mongooseSchema.tree);
-    // @ts-ignore
-    const formattedPaths = formatValue(mongooseSchema.paths);
-
-    return {
-      definition: util.inspect(formattedDef, formatOpts),
-      schemaObj: util.inspect(formattedSchema, formatOpts),
-      schemaTree: util.inspect(formattedTree, formatOpts),
-      schemaPaths: util.inspect(formattedPaths, formatOpts),
-    };
-  } catch (err: any) {
-    const message = getErrorMessage(err);
-    const isCompilationError = err?.statusCode === 400;
-    throw createError({
-      statusCode: isCompilationError ? 400 : 500,
-      message: isCompilationError ? message : `Execution Error: ${message}`,
-    });
-  } finally {
-    mongooseZod.hooks.removeAllHooks();
-    releaseParseLock();
+  if (useRuntimeConfig(event).public.isDocsMode) {
+    throw createError({ statusCode: 403, message: "Local Studio execution is unavailable in docs mode." });
   }
+  const body = await readStudioRequest(event);
+  const release = await acquireLocalLock();
+  try { return executeStudio(body, 5000); }
+  catch (error: any) {
+    throw createError({ statusCode: error instanceof StudioExecutionError ? 400 : 500, message: error?.message || "Studio execution failed." });
+  } finally { release(); }
 });

package/server/api/studio/run.post.ts

@@ -0,0 +1,17 @@
+import { createError, defineEventHandler } from "h3";
+import { readStudioRequest } from "../../utils/parse-request";
+import { runInContainer } from "../../utils/runner-client";
+
+export default defineEventHandler(async (event) => {
+  if (!useRuntimeConfig(event).public.isDocsMode) {
+    throw createError({ statusCode: 403, message: "Use the local Studio endpoint in CLI mode." });
+  }
+  const socketPath = process.env.STUDIO_RUNNER_SOCKET;
+  if (!socketPath) throw createError({ statusCode: 503, message: "Studio runner is not configured." });
+  const body = await readStudioRequest(event);
+  try { return await runInContainer(body, socketPath); }
+  catch (error: any) {
+    if (error?.statusCode) throw error;
+    throw createError({ statusCode: 503, message: "Studio runner is unavailable. Try again shortly." });
+  }
+});

package/server/middleware/security.ts

@@ -1,14 +1,25 @@
-import { defineEventHandler, createError, getRequestIP } from "h3";
+import { defineEventHandler, createError, getHeader, getRequestIP, setHeader } from "h3";
 
 // Simple in-memory rate limiting map: IP -> array of timestamps
 const rateLimitMap = new Map<string, number[]>();
-const RATE_LIMIT = 2; // 2 requests
+const RATE_LIMIT = 8; // Allow quick edits and shortcut runs without throttling normal use.
 const TIME_WINDOW = 1000; // per 1 second (1000ms)
+const GLOBAL_RATE_LIMIT = 20;
+let globalWindowStart = 0;
+let globalRequests = 0;
 
 export default defineEventHandler((event) => {
-  const isDocsMode = process.env.DOCS_MODE === "true";
+  const isDocsMode = useRuntimeConfig(event).public.isDocsMode;
   const path = event.path;
 
+  if (!isDocsMode && path.startsWith("/api/")) {
+    const host = getHeader(event, "host") || "";
+    const origin = getHeader(event, "origin");
+    const localHost = /^(localhost|127\.0\.0\.1)(:\d+)?$/.test(host);
+    const localOrigin = !origin || /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin);
+    if (!localHost || !localOrigin) throw createError({ statusCode: 403, message: "Local Studio accepts only loopback requests." });
+  }
+
   // 1. Environment Check: Disable local resolving in Docs mode
   if (isDocsMode && path.startsWith("/api/resolve")) {
     throw createError({
@@ -17,8 +28,8 @@ export default defineEventHandler((event) => {
     });
   }
 
-  // 2. Rate Limiting for Parse endpoint in Docs Mode
-  if (isDocsMode && path.startsWith("/api/parse")) {
+  // 2. Rate limiting for the parse endpoint in Docs Mode
+  if (isDocsMode && path === "/api/studio/run") {
     const ip = getRequestIP(event) || "unknown";
     const now = Date.now();
 
@@ -27,14 +38,25 @@ export default defineEventHandler((event) => {
     // Filter timestamps within the current window
     const recentRequests = timestamps.filter((t) => now - t < TIME_WINDOW);
 
-    if (recentRequests.length >= RATE_LIMIT) {
+    if (now - globalWindowStart >= TIME_WINDOW) {
+      globalWindowStart = now;
+      globalRequests = 0;
+    }
+    if (rateLimitMap.size > 1024) {
+      for (const [key, entries] of rateLimitMap) {
+        if (entries.every((time) => now - time >= TIME_WINDOW)) rateLimitMap.delete(key);
+      }
+    }
+    if (recentRequests.length >= RATE_LIMIT || globalRequests >= GLOBAL_RATE_LIMIT || (rateLimitMap.size >= 1024 && !rateLimitMap.has(ip))) {
+      setHeader(event, "Retry-After", 1);
       throw createError({
         statusCode: 429,
-        message: "Too Many Requests. Limit is 2 requests per second.",
+        message: "Too many runs. Wait a moment and try again.",
       });
     }
 
     recentRequests.push(now);
     rateLimitMap.set(ip, recentRequests);
+    globalRequests++;
   }
 });

package/server/utils/example-data.ts

@@ -0,0 +1,80 @@
+import type { ZodType } from "zod/v4";
+import { getMongooseMeta } from "@nullix/zod-mongoose";
+
+type Schema = ZodType & { _def: Record<string, any> };
+
+function checks(schema: Schema): Record<string, any>[] {
+  return (schema._def.checks || []).map((check: any) => check._zod?.def || check.def || {});
+}
+
+function sampleString(schema: Schema, key: string): string {
+  const rules = checks(schema);
+  const format = schema._def.format || rules.find((rule) => rule.format)?.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: Schema): number {
+  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;
+}
+
+export function createExample(schema: Schema, key = "value", depth = 0, seen = new Set<Schema>()): unknown {
+  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 as any;
+  if (mongooseType === "ObjectId" || mongooseType?.schemaName === "ObjectId") return "507f1f77bcf86cd799439011";
+
+  switch (def.type) {
+    case "optional":
+    case "default":
+    case "prefault":
+      return depth === 0 ? createExample(def.innerType, key, depth + 1, nextSeen) : undefined;
+    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: Record<string, unknown> = {};
+      for (const [field, fieldSchema] of Object.entries((schema as any).shape || def.shape || {})) {
+        const value = createExample(fieldSchema as Schema, field, depth + 1, nextSeen);
+        if (value !== undefined) 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: Schema) => 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 def.values?.[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"}.`);
+  }
+}

package/server/utils/parse-request.ts

@@ -0,0 +1,28 @@
+import { createError } from "h3";
+import type { H3Event } from "h3";
+import type { ParseBody } from "./studio-execution";
+
+const MAX_BODY_BYTES = 160_000;
+
+export async function readStudioRequest(event: H3Event): Promise<ParseBody> {
+  const chunks: Buffer[] = [];
+  let size = 0;
+  for await (const chunk of event.node.req) {
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += bytes.length;
+    if (size > MAX_BODY_BYTES) throw createError({ statusCode: 413, message: "Studio input is too large." });
+    chunks.push(bytes);
+  }
+  let body: ParseBody;
+  try { body = JSON.parse(Buffer.concat(chunks).toString("utf8")); }
+  catch { throw createError({ statusCode: 400, message: "Invalid JSON request." }); }
+  if (typeof body?.sourceCode !== "string" || !body.sourceCode.trim()) {
+    throw createError({ statusCode: 400, message: "Add a Zod schema to the editor first." });
+  }
+  if (body.sourceCode.length > 50_000 || typeof body.inputData !== "string" || body.inputData.length > 100_000 ||
+      (body.selectedSchema !== undefined && typeof body.selectedSchema !== "string") ||
+      (body.action !== undefined && body.action !== "run" && body.action !== "example")) {
+    throw createError({ statusCode: 400, message: "Invalid or oversized Studio input." });
+  }
+  return body;
+}

package/server/utils/runner-client.ts

@@ -0,0 +1,40 @@
+import { createError } from "h3";
+import { request } from "node:http";
+import type { ParseBody } from "./studio-execution";
+
+const MAX_RESPONSE_BYTES = 1_000_000;
+
+export function runInContainer(body: ParseBody, socketPath: string): Promise<unknown> {
+  const payload = JSON.stringify(body);
+  return new Promise((resolve, reject) => {
+    const req = request({
+      socketPath,
+      path: "/run",
+      method: "POST",
+      headers: { "content-type": "application/json", "content-length": Buffer.byteLength(payload) },
+    }, (res) => {
+      const chunks: Buffer[] = [];
+      let size = 0;
+      res.on("data", (chunk: Buffer) => {
+        size += chunk.length;
+        if (size > MAX_RESPONSE_BYTES) {
+          req.destroy(new Error("Studio result is too large."));
+          return;
+        }
+        chunks.push(chunk);
+      });
+      res.on("end", () => {
+        try {
+          const result = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+          if (res.statusCode !== 200) {
+            reject(createError({ statusCode: res.statusCode === 400 ? 400 : res.statusCode === 504 ? 504 : 503, message: result.error || "Studio runner failed." }));
+          } else resolve(result);
+        } catch { reject(createError({ statusCode: 502, message: "Invalid response from Studio runner." })); }
+      });
+      res.on("error", reject);
+    });
+    req.setTimeout(5000, () => req.destroy(new Error("Studio runner timed out.")));
+    req.on("error", reject);
+    req.end(payload);
+  });
+}

package/server/utils/studio-execution.ts

@@ -0,0 +1,176 @@
+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 mongoose from "mongoose";
+import * as mongooseZod from "@nullix/zod-mongoose";
+import { createExample } from "./example-data";
+
+mongooseZod.setMongoose(mongoose);
+
+export class StudioExecutionError extends Error {
+  statusCode = 400;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message || error.name : String(error);
+}
+
+function declaredNames(jsCode: string): string[] {
+  const file = parse(jsCode, { ecmaVersion: "latest", sourceType: "script" });
+  const names: string[] = [];
+  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: unknown): string {
+  const seen = new WeakSet<object>();
+  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: any): any {
+  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;
+}
+
+export type ParseBody = {
+  sourceCode?: string;
+  inputData?: string;
+  selectedSchema?: string;
+  action?: "run" | "example";
+};
+
+export function executeStudio(body: ParseBody, timeoutMs: number) {
+  const sourceCode = body.sourceCode!;
+  mongooseZod.hooks.removeAllHooks();
+  try {
+    let jsCode: string;
+    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: string) => {
+      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 = new Map<string, zod.ZodType>();
+    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 : result.exported?.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 as string;
+    const schema = choices.get(selectedSchema)!;
+    const schemaNames = [...choices.keys()];
+
+    let example: string | undefined;
+    let exampleError: string | undefined;
+    let inputData = body.inputData;
+    if (body.action === "example") {
+      try {
+        const fixture = result.declared.exampleInput;
+        const generated = fixture !== undefined ? fixture : createExample(schema as any);
+        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: "valid" | "invalid" | "json-error" | "parse-error" | "empty"; parsed?: string; issues?: { path: string; message: string; code: string }[]; message?: string } = { status: "empty" };
+    if (typeof inputData !== "string" || !inputData.trim()) {
+      validation = { status: "empty", message: "Add JSON data to try this schema." };
+    } else {
+      let input: unknown;
+      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: { definition?: string; schemaObj?: string; schemaTree?: string; schemaPaths?: string; error?: string };
+    try {
+      const extracted = mongooseZod.extractMongooseDef(schema);
+      const converted = mongooseZod.toMongooseSchema(schema, { modelName: "ParsedSchema" });
+      const inspect = (value: unknown) => util.inspect(formatMongoose(value), { depth: null, colors: false, showHidden: false });
+      conversion = {
+        definition: inspect(extracted),
+        schemaObj: inspect(converted.obj),
+        schemaTree: inspect((converted as any).tree),
+        schemaPaths: inspect((converted as any).paths),
+      };
+    } catch (error) {
+      conversion = { error: errorMessage(error) };
+    }
+
+    return { schemaNames, selectedSchema, validation, conversion, example, exampleError };
+  } finally {
+    mongooseZod.hooks.removeAllHooks();
+  }
+}