@opentabs-dev/opentabs-plugin-hack2hire 0.0.109 → 0.0.111

package/dist/adapter.iife.js

@@ -6,465 +6,6 @@
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
-  // node_modules/@opentabs-dev/shared/dist/error.js
-  var toErrorMessage = (err2) => err2 instanceof Error ? err2.message : String(err2);
-
-  // node_modules/@opentabs-dev/plugin-sdk/dist/errors.js
-  var ToolError = class _ToolError extends Error {
-    code;
-    /** Whether this error is retryable (defaults to false). */
-    retryable;
-    /** Suggested delay before retrying, in milliseconds. */
-    retryAfterMs;
-    /** Error category for structured error classification. */
-    category;
-    constructor(message, code, opts) {
-      super(message);
-      this.code = code;
-      this.name = "ToolError";
-      this.retryable = opts?.retryable ?? false;
-      this.retryAfterMs = opts?.retryAfterMs;
-      this.category = opts?.category;
-    }
-    /** Authentication or authorization error (not retryable). Accepts an optional domain-specific code. */
-    static auth(message, code) {
-      return new _ToolError(message, code ?? "AUTH_ERROR", { category: "auth", retryable: false });
-    }
-    /** Resource not found (not retryable). Accepts an optional domain-specific code. */
-    static notFound(message, code) {
-      return new _ToolError(message, code ?? "NOT_FOUND", { category: "not_found", retryable: false });
-    }
-    /** Rate limited (retryable). Accepts an optional retry delay in milliseconds and an optional domain-specific code. */
-    static rateLimited(message, retryAfterMs, code) {
-      return new _ToolError(message, code ?? "RATE_LIMITED", { category: "rate_limit", retryable: true, retryAfterMs });
-    }
-    /** Input validation error (not retryable). Accepts an optional domain-specific code. */
-    static validation(message, code) {
-      return new _ToolError(message, code ?? "VALIDATION_ERROR", { category: "validation", retryable: false });
-    }
-    /** Operation timed out (retryable). Accepts an optional domain-specific code. */
-    static timeout(message, code) {
-      return new _ToolError(message, code ?? "TIMEOUT", { category: "timeout", retryable: true });
-    }
-    /** Internal/unexpected error (not retryable). Accepts an optional domain-specific code. */
-    static internal(message, code) {
-      return new _ToolError(message, code ?? "INTERNAL_ERROR", { category: "internal", retryable: false });
-    }
-  };
-
-  // node_modules/@opentabs-dev/plugin-sdk/dist/fetch.js
-  var MAX_ERROR_BODY_LENGTH = 512;
-  var httpStatusToToolError = (response, message) => {
-    const status = response.status;
-    if (status === 401 || status === 403) {
-      return ToolError.auth(message);
-    }
-    if (status === 404) {
-      return ToolError.notFound(message);
-    }
-    if (status === 429) {
-      const retryAfter = response.headers.get("Retry-After");
-      const retryAfterMs = retryAfter !== null ? parseRetryAfterMs(retryAfter) : void 0;
-      return ToolError.rateLimited(message, retryAfterMs);
-    }
-    if (status === 400 || status === 422) {
-      return ToolError.validation(message);
-    }
-    if (status === 408) {
-      return ToolError.timeout(message);
-    }
-    if (status >= 500) {
-      const TRANSIENT_5XX = /* @__PURE__ */ new Set([500, 502, 503, 504]);
-      const retryable = TRANSIENT_5XX.has(status);
-      const retryAfter = status === 503 ? response.headers.get("Retry-After") : null;
-      const retryAfterMs = retryAfter !== null ? parseRetryAfterMs(retryAfter) : void 0;
-      return new ToolError(message, "http_error", { category: "internal", retryable, retryAfterMs });
-    }
-    if (status >= 400 && status < 500) {
-      return new ToolError(message, "http_error", { retryable: false });
-    }
-    return new ToolError(message, "http_error", { category: "internal" });
-  };
-  var parseRetryAfterMs = (value) => {
-    const seconds = Number(value);
-    if (!Number.isNaN(seconds) && seconds >= 0) {
-      return seconds * 1e3;
-    }
-    const date5 = Date.parse(value);
-    if (!Number.isNaN(date5)) {
-      const ms = date5 - Date.now();
-      return ms > 0 ? ms : void 0;
-    }
-    return void 0;
-  };
-  var buildQueryString = (params) => {
-    const searchParams = new URLSearchParams();
-    for (const [key, value] of Object.entries(params)) {
-      if (value === void 0)
-        continue;
-      if (Array.isArray(value)) {
-        for (const item of value) {
-          searchParams.append(key, String(item));
-        }
-      } else {
-        searchParams.append(key, String(value));
-      }
-    }
-    return searchParams.toString();
-  };
-  var fetchFromPage = async (url2, init) => {
-    const { timeout = 3e4, signal, ...rest } = init ?? {};
-    const timeoutSignal = AbortSignal.timeout(timeout);
-    const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
-    let response;
-    try {
-      response = await fetch(url2, {
-        credentials: "include",
-        ...rest,
-        signal: combinedSignal
-      });
-    } catch (error51) {
-      if (error51 instanceof DOMException && error51.name === "TimeoutError") {
-        throw ToolError.timeout(`fetchFromPage: request timed out after ${timeout}ms for ${url2}`);
-      }
-      if (combinedSignal.aborted) {
-        throw new ToolError(`fetchFromPage: request aborted for ${url2}`, "aborted");
-      }
-      throw new ToolError(`fetchFromPage: network error for ${url2}: ${toErrorMessage(error51)}`, "network_error", {
-        category: "internal",
-        retryable: true
-      });
-    }
-    if (!response.ok) {
-      const rawText = await response.text().catch(() => response.statusText);
-      const errorText = rawText.length > MAX_ERROR_BODY_LENGTH ? `${rawText.slice(0, MAX_ERROR_BODY_LENGTH)}\u2026` : rawText;
-      const msg = `fetchFromPage: HTTP ${response.status} for ${url2}: ${errorText}`;
-      throw httpStatusToToolError(response, msg);
-    }
-    return response;
-  };
-
-  // node_modules/@opentabs-dev/plugin-sdk/dist/timing.js
-  var waitUntil = (predicate, opts) => {
-    const interval = opts?.interval ?? 200;
-    const timeout = opts?.timeout ?? 1e4;
-    const signal = opts?.signal;
-    const abortReason = () => signal?.reason instanceof Error ? signal.reason : new Error("waitUntil: aborted");
-    if (signal?.aborted)
-      return Promise.reject(abortReason());
-    return new Promise((resolve, reject) => {
-      let settled = false;
-      let poller;
-      let lastPredicateError;
-      const isSettled = () => settled;
-      const cleanup = () => {
-        settled = true;
-        clearTimeout(timer);
-        clearTimeout(poller);
-        signal?.removeEventListener("abort", onAbort);
-      };
-      const onAbort = () => {
-        if (isSettled())
-          return;
-        cleanup();
-        reject(abortReason());
-      };
-      signal?.addEventListener("abort", onAbort, { once: true });
-      const timer = setTimeout(() => {
-        if (isSettled())
-          return;
-        cleanup();
-        const errorContext = lastPredicateError instanceof Error ? `: predicate last threw \u2014 ${lastPredicateError.message}` : "";
-        reject(new Error(`waitUntil: timed out after ${timeout}ms waiting for predicate to return true${errorContext}`));
-      }, timeout);
-      const check2 = async () => {
-        if (isSettled())
-          return;
-        try {
-          const result = await predicate();
-          if (result) {
-            cleanup();
-            resolve();
-            return;
-          }
-        } catch (err2) {
-          lastPredicateError = err2;
-        }
-        if (!isSettled()) {
-          poller = setTimeout(() => void check2(), interval);
-        }
-      };
-      void check2();
-    });
-  };
-
-  // node_modules/@opentabs-dev/plugin-sdk/dist/log.js
-  var MAX_DATA_LENGTH = 10;
-  var MAX_STRING_LENGTH = 4096;
-  var MAX_SERIALIZED_SIZE = 64 * 1024;
-  var safeSerializeArg = (value) => {
-    try {
-      if (value === null || value === void 0)
-        return value;
-      const type = typeof value;
-      if (type === "boolean" || type === "number")
-        return value;
-      if (type === "string") {
-        return value.length > MAX_STRING_LENGTH ? `${value.slice(0, MAX_STRING_LENGTH)}\u2026` : value;
-      }
-      if (type === "function")
-        return `[Function: ${value.name || "anonymous"}]`;
-      if (type === "symbol")
-        return `[Symbol: ${value.description ?? ""}]`;
-      if (type === "bigint")
-        return `[BigInt: ${value.toString()}]`;
-      if (typeof value.nodeType === "number" && typeof value.nodeName === "string") {
-        try {
-          const node = value;
-          let classStr = "";
-          if (typeof node.className === "string") {
-            classStr = node.className ? `.${node.className.split(" ")[0] ?? ""}` : "";
-          } else if (node.className !== null && typeof node.className === "object") {
-            const baseVal = node.className.baseVal;
-            if (typeof baseVal === "string") {
-              classStr = baseVal ? `.${baseVal.split(" ")[0] ?? ""}` : "";
-            }
-          }
-          return `[${node.nodeName}${node.id ? `#${node.id}` : ""}${classStr}]`;
-        } catch {
-        }
-      }
-      if (value instanceof Error) {
-        return { name: value.name, message: value.message, stack: value.stack };
-      }
-      if (value instanceof WeakRef)
-        return "[WeakRef]";
-      if (value instanceof WeakMap)
-        return "[WeakMap]";
-      if (value instanceof WeakSet)
-        return "[WeakSet]";
-      if (value instanceof ArrayBuffer)
-        return "[ArrayBuffer]";
-      if (typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer)
-        return "[SharedArrayBuffer]";
-      try {
-        const seen = /* @__PURE__ */ new WeakSet();
-        const json2 = JSON.stringify(value, (_key, v) => {
-          if (typeof v === "object" && v !== null) {
-            if (seen.has(v))
-              return "[Circular]";
-            seen.add(v);
-          }
-          if (typeof v === "function")
-            return `[Function: ${v.name || "anonymous"}]`;
-          if (typeof v === "bigint")
-            return `[BigInt: ${v.toString()}]`;
-          if (typeof v === "symbol")
-            return `[Symbol: ${v.description ?? ""}]`;
-          if (v instanceof WeakRef)
-            return "[WeakRef]";
-          if (v instanceof WeakMap)
-            return "[WeakMap]";
-          if (v instanceof WeakSet)
-            return "[WeakSet]";
-          if (v instanceof ArrayBuffer)
-            return "[ArrayBuffer]";
-          if (typeof SharedArrayBuffer !== "undefined" && v instanceof SharedArrayBuffer)
-            return "[SharedArrayBuffer]";
-          return v;
-        });
-        if (json2.length > MAX_SERIALIZED_SIZE) {
-          return `[Object truncated: ${json2.length} chars]`;
-        }
-        return JSON.parse(json2);
-      } catch {
-        return `[Unserializable: ${typeof value}]`;
-      }
-    } catch {
-      return `[Unserializable: ${typeof value}]`;
-    }
-  };
-  var safeSerialize = (args) => {
-    const capped = args.length > MAX_DATA_LENGTH ? args.slice(0, MAX_DATA_LENGTH) : args;
-    return capped.map(safeSerializeArg);
-  };
-  var CONSOLE_METHODS = {
-    debug: "debug",
-    info: "info",
-    warning: "warn",
-    error: "error"
-  };
-  var defaultTransport = (entry) => {
-    const method = CONSOLE_METHODS[entry.level];
-    console[method](`[sdk.log] ${entry.message}`, ...entry.data);
-  };
-  var activeTransport = defaultTransport;
-  var _setLogTransport = (transport) => {
-    const previous = activeTransport;
-    activeTransport = transport;
-    return () => {
-      if (activeTransport === transport)
-        activeTransport = previous;
-    };
-  };
-  var makeLogMethod = (level) => (message, ...args) => {
-    const entry = {
-      level,
-      message,
-      data: safeSerialize(args),
-      ts: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    activeTransport(entry);
-  };
-  var log = Object.freeze({
-    debug: makeLogMethod("debug"),
-    info: makeLogMethod("info"),
-    warn: makeLogMethod("warning"),
-    error: makeLogMethod("error")
-  });
-  var ot = globalThis.__openTabs ?? {};
-  globalThis.__openTabs = ot;
-  ot._setLogTransport = _setLogTransport;
-  ot.log = log;
-
-  // node_modules/@opentabs-dev/plugin-sdk/dist/storage.js
-  var withIframeFallback = (fn) => {
-    try {
-      const iframe = document.createElement("iframe");
-      iframe.style.display = "none";
-      document.body.appendChild(iframe);
-      try {
-        const iframeStorage = iframe.contentWindow?.localStorage;
-        return iframeStorage ? fn(iframeStorage) : null;
-      } finally {
-        document.body.removeChild(iframe);
-      }
-    } catch {
-      return null;
-    }
-  };
-  var getWindowLocalStorage = () => window.localStorage;
-  var getLocalStorage = (key) => {
-    let storage;
-    try {
-      storage = getWindowLocalStorage();
-    } catch {
-      return null;
-    }
-    if (storage) {
-      try {
-        return storage.getItem(key);
-      } catch {
-        return null;
-      }
-    }
-    return withIframeFallback((s) => s.getItem(key));
-  };
-  var getAuthCache = (namespace) => {
-    try {
-      const ns = globalThis.__openTabs;
-      const cache = ns?.tokenCache;
-      return cache?.[namespace] ?? null;
-    } catch {
-      return null;
-    }
-  };
-  var setAuthCache = (namespace, value) => {
-    try {
-      const g = globalThis;
-      if (!g.__openTabs)
-        g.__openTabs = {};
-      const ns = g.__openTabs;
-      if (!ns.tokenCache)
-        ns.tokenCache = {};
-      ns.tokenCache[namespace] = value;
-    } catch {
-    }
-  };
-  var clearAuthCache = (namespace) => {
-    try {
-      const ns = globalThis.__openTabs;
-      const cache = ns?.tokenCache;
-      if (cache)
-        cache[namespace] = void 0;
-    } catch {
-    }
-  };
-
-  // node_modules/@opentabs-dev/plugin-sdk/dist/index.js
-  var defineTool = (config2) => config2;
-  var OpenTabsPlugin = class {
-    /**
-     * Chrome match patterns for URLs that should NOT match this plugin.
-     * Tabs matching both urlPatterns and excludePatterns are excluded.
-     * Useful when a broad urlPattern overlaps with another plugin's domain.
-     * @see https://developer.chrome.com/docs/extensions/develop/concepts/match-patterns
-     */
-    excludePatterns;
-    /**
-     * URL to open when no matching tab exists and the user triggers an
-     * 'open tab' action from the side panel. Should be a concrete URL
-     * (e.g., 'https://github.com'), not a match pattern.
-     */
-    homepage;
-    /** Typed configuration schema — declares settings that users provide via config.json or the side panel. */
-    configSchema;
-  };
-
-  // src/hack2hire-api.ts
-  var API_BASE = "https://api.hack2hire.com/algro/v1";
-  var readJsonString = (key) => {
-    const raw = getLocalStorage(key);
-    if (!raw) return null;
-    try {
-      const parsed = JSON.parse(raw);
-      return typeof parsed === "string" && parsed.length > 0 ? parsed : null;
-    } catch {
-      return null;
-    }
-  };
-  var getAuth = () => {
-    const cached2 = getAuthCache("hack2hire");
-    if (cached2?.token && cached2?.userId) return cached2;
-    const token = readJsonString("ALGRO_TOKEN");
-    const userId = readJsonString("USER_ID");
-    if (!token || !userId) return null;
-    const auth = { token, userId };
-    setAuthCache("hack2hire", auth);
-    return auth;
-  };
-  var isAuthenticated = () => getAuth() !== null;
-  var waitForAuth = () => waitUntil(() => isAuthenticated(), { interval: 500, timeout: 5e3 }).then(
-    () => true,
-    () => false
-  );
-  var api = async (endpoint, query) => {
-    const auth = getAuth();
-    if (!auth) throw ToolError.auth("Not authenticated \u2014 please log in to Hack2Hire.");
-    const qs = query ? buildQueryString(query) : "";
-    const url2 = qs ? `${API_BASE}${endpoint}?${qs}` : `${API_BASE}${endpoint}`;
-    let response;
-    try {
-      response = await fetchFromPage(url2, {
-        method: "GET",
-        headers: {
-          Authorization: `Bearer ${auth.token}`,
-          "x-user-id": auth.userId,
-          Accept: "application/json"
-        },
-        credentials: "omit"
-      });
-    } catch (err2) {
-      if (err2 instanceof ToolError) {
-        if (err2.category === "auth") clearAuthCache("hack2hire");
-        throw err2;
-      }
-      throw ToolError.internal(`Network error: ${err2 instanceof Error ? err2.message : String(err2)}`);
-    }
-    const envelope = await response.json();
-    return envelope.data;
-  };
-
   // node_modules/zod/v4/classic/external.js
   var external_exports = {};
   __export(external_exports, {
@@ -13534,1450 +13075,1909 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     $ZodCIDRv4.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
-  function cidrv42(params) {
-    return _cidrv4(ZodCIDRv4, params);
+  function cidrv42(params) {
+    return _cidrv4(ZodCIDRv4, params);
+  }
+  var ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => {
+    $ZodCIDRv6.init(inst, def);
+    ZodStringFormat.init(inst, def);
+  });
+  function cidrv62(params) {
+    return _cidrv6(ZodCIDRv6, params);
+  }
+  var ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => {
+    $ZodBase64.init(inst, def);
+    ZodStringFormat.init(inst, def);
+  });
+  function base642(params) {
+    return _base64(ZodBase64, params);
+  }
+  var ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => {
+    $ZodBase64URL.init(inst, def);
+    ZodStringFormat.init(inst, def);
+  });
+  function base64url2(params) {
+    return _base64url(ZodBase64URL, params);
+  }
+  var ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => {
+    $ZodE164.init(inst, def);
+    ZodStringFormat.init(inst, def);
+  });
+  function e1642(params) {
+    return _e164(ZodE164, params);
+  }
+  var ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
+    $ZodJWT.init(inst, def);
+    ZodStringFormat.init(inst, def);
+  });
+  function jwt(params) {
+    return _jwt(ZodJWT, params);
+  }
+  var ZodCustomStringFormat = /* @__PURE__ */ $constructor("ZodCustomStringFormat", (inst, def) => {
+    $ZodCustomStringFormat.init(inst, def);
+    ZodStringFormat.init(inst, def);
+  });
+  function stringFormat(format, fnOrRegex, _params = {}) {
+    return _stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
+  }
+  function hostname2(_params) {
+    return _stringFormat(ZodCustomStringFormat, "hostname", regexes_exports.hostname, _params);
+  }
+  function hex2(_params) {
+    return _stringFormat(ZodCustomStringFormat, "hex", regexes_exports.hex, _params);
+  }
+  function hash(alg, params) {
+    const enc = params?.enc ?? "hex";
+    const format = `${alg}_${enc}`;
+    const regex = regexes_exports[format];
+    if (!regex)
+      throw new Error(`Unrecognized hash format: ${format}`);
+    return _stringFormat(ZodCustomStringFormat, format, regex, params);
+  }
+  var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
+    $ZodNumber.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2, params);
+    _installLazyMethods(inst, "ZodNumber", {
+      gt(value, params) {
+        return this.check(_gt(value, params));
+      },
+      gte(value, params) {
+        return this.check(_gte(value, params));
+      },
+      min(value, params) {
+        return this.check(_gte(value, params));
+      },
+      lt(value, params) {
+        return this.check(_lt(value, params));
+      },
+      lte(value, params) {
+        return this.check(_lte(value, params));
+      },
+      max(value, params) {
+        return this.check(_lte(value, params));
+      },
+      int(params) {
+        return this.check(int(params));
+      },
+      safe(params) {
+        return this.check(int(params));
+      },
+      positive(params) {
+        return this.check(_gt(0, params));
+      },
+      nonnegative(params) {
+        return this.check(_gte(0, params));
+      },
+      negative(params) {
+        return this.check(_lt(0, params));
+      },
+      nonpositive(params) {
+        return this.check(_lte(0, params));
+      },
+      multipleOf(value, params) {
+        return this.check(_multipleOf(value, params));
+      },
+      step(value, params) {
+        return this.check(_multipleOf(value, params));
+      },
+      finite() {
+        return this;
+      }
+    });
+    const bag = inst._zod.bag;
+    inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
+    inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
+    inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
+    inst.isFinite = true;
+    inst.format = bag.format ?? null;
+  });
+  function number2(params) {
+    return _number(ZodNumber, params);
+  }
+  var ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
+    $ZodNumberFormat.init(inst, def);
+    ZodNumber.init(inst, def);
+  });
+  function int(params) {
+    return _int(ZodNumberFormat, params);
+  }
+  function float32(params) {
+    return _float32(ZodNumberFormat, params);
+  }
+  function float64(params) {
+    return _float64(ZodNumberFormat, params);
+  }
+  function int32(params) {
+    return _int32(ZodNumberFormat, params);
+  }
+  function uint32(params) {
+    return _uint32(ZodNumberFormat, params);
+  }
+  var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
+    $ZodBoolean.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => booleanProcessor(inst, ctx, json2, params);
+  });
+  function boolean2(params) {
+    return _boolean(ZodBoolean, params);
+  }
+  var ZodBigInt = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => {
+    $ZodBigInt.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => bigintProcessor(inst, ctx, json2, params);
+    inst.gte = (value, params) => inst.check(_gte(value, params));
+    inst.min = (value, params) => inst.check(_gte(value, params));
+    inst.gt = (value, params) => inst.check(_gt(value, params));
+    inst.gte = (value, params) => inst.check(_gte(value, params));
+    inst.min = (value, params) => inst.check(_gte(value, params));
+    inst.lt = (value, params) => inst.check(_lt(value, params));
+    inst.lte = (value, params) => inst.check(_lte(value, params));
+    inst.max = (value, params) => inst.check(_lte(value, params));
+    inst.positive = (params) => inst.check(_gt(BigInt(0), params));
+    inst.negative = (params) => inst.check(_lt(BigInt(0), params));
+    inst.nonpositive = (params) => inst.check(_lte(BigInt(0), params));
+    inst.nonnegative = (params) => inst.check(_gte(BigInt(0), params));
+    inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
+    const bag = inst._zod.bag;
+    inst.minValue = bag.minimum ?? null;
+    inst.maxValue = bag.maximum ?? null;
+    inst.format = bag.format ?? null;
+  });
+  function bigint2(params) {
+    return _bigint(ZodBigInt, params);
+  }
+  var ZodBigIntFormat = /* @__PURE__ */ $constructor("ZodBigIntFormat", (inst, def) => {
+    $ZodBigIntFormat.init(inst, def);
+    ZodBigInt.init(inst, def);
+  });
+  function int64(params) {
+    return _int64(ZodBigIntFormat, params);
+  }
+  function uint64(params) {
+    return _uint64(ZodBigIntFormat, params);
+  }
+  var ZodSymbol = /* @__PURE__ */ $constructor("ZodSymbol", (inst, def) => {
+    $ZodSymbol.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => symbolProcessor(inst, ctx, json2, params);
+  });
+  function symbol(params) {
+    return _symbol(ZodSymbol, params);
+  }
+  var ZodUndefined = /* @__PURE__ */ $constructor("ZodUndefined", (inst, def) => {
+    $ZodUndefined.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => undefinedProcessor(inst, ctx, json2, params);
+  });
+  function _undefined3(params) {
+    return _undefined2(ZodUndefined, params);
   }
-  var ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => {
-    $ZodCIDRv6.init(inst, def);
-    ZodStringFormat.init(inst, def);
+  var ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
+    $ZodNull.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => nullProcessor(inst, ctx, json2, params);
   });
-  function cidrv62(params) {
-    return _cidrv6(ZodCIDRv6, params);
+  function _null3(params) {
+    return _null2(ZodNull, params);
   }
-  var ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => {
-    $ZodBase64.init(inst, def);
-    ZodStringFormat.init(inst, def);
+  var ZodAny = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
+    $ZodAny.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => anyProcessor(inst, ctx, json2, params);
   });
-  function base642(params) {
-    return _base64(ZodBase64, params);
+  function any() {
+    return _any(ZodAny);
   }
-  var ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => {
-    $ZodBase64URL.init(inst, def);
-    ZodStringFormat.init(inst, def);
+  var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
+    $ZodUnknown.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => unknownProcessor(inst, ctx, json2, params);
   });
-  function base64url2(params) {
-    return _base64url(ZodBase64URL, params);
+  function unknown() {
+    return _unknown(ZodUnknown);
   }
-  var ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => {
-    $ZodE164.init(inst, def);
-    ZodStringFormat.init(inst, def);
+  var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
+    $ZodNever.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => neverProcessor(inst, ctx, json2, params);
   });
-  function e1642(params) {
-    return _e164(ZodE164, params);
+  function never(params) {
+    return _never(ZodNever, params);
   }
-  var ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
-    $ZodJWT.init(inst, def);
-    ZodStringFormat.init(inst, def);
+  var ZodVoid = /* @__PURE__ */ $constructor("ZodVoid", (inst, def) => {
+    $ZodVoid.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => voidProcessor(inst, ctx, json2, params);
   });
-  function jwt(params) {
-    return _jwt(ZodJWT, params);
+  function _void2(params) {
+    return _void(ZodVoid, params);
   }
-  var ZodCustomStringFormat = /* @__PURE__ */ $constructor("ZodCustomStringFormat", (inst, def) => {
-    $ZodCustomStringFormat.init(inst, def);
-    ZodStringFormat.init(inst, def);
+  var ZodDate = /* @__PURE__ */ $constructor("ZodDate", (inst, def) => {
+    $ZodDate.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => dateProcessor(inst, ctx, json2, params);
+    inst.min = (value, params) => inst.check(_gte(value, params));
+    inst.max = (value, params) => inst.check(_lte(value, params));
+    const c = inst._zod.bag;
+    inst.minDate = c.minimum ? new Date(c.minimum) : null;
+    inst.maxDate = c.maximum ? new Date(c.maximum) : null;
   });
-  function stringFormat(format, fnOrRegex, _params = {}) {
-    return _stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
-  }
-  function hostname2(_params) {
-    return _stringFormat(ZodCustomStringFormat, "hostname", regexes_exports.hostname, _params);
-  }
-  function hex2(_params) {
-    return _stringFormat(ZodCustomStringFormat, "hex", regexes_exports.hex, _params);
-  }
-  function hash(alg, params) {
-    const enc = params?.enc ?? "hex";
-    const format = `${alg}_${enc}`;
-    const regex = regexes_exports[format];
-    if (!regex)
-      throw new Error(`Unrecognized hash format: ${format}`);
-    return _stringFormat(ZodCustomStringFormat, format, regex, params);
+  function date3(params) {
+    return _date(ZodDate, params);
   }
-  var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
-    $ZodNumber.init(inst, def);
+  var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
+    $ZodArray.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2, params);
-    _installLazyMethods(inst, "ZodNumber", {
-      gt(value, params) {
-        return this.check(_gt(value, params));
+    inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params);
+    inst.element = def.element;
+    _installLazyMethods(inst, "ZodArray", {
+      min(n, params) {
+        return this.check(_minLength(n, params));
       },
-      gte(value, params) {
-        return this.check(_gte(value, params));
+      nonempty(params) {
+        return this.check(_minLength(1, params));
       },
-      min(value, params) {
-        return this.check(_gte(value, params));
+      max(n, params) {
+        return this.check(_maxLength(n, params));
       },
-      lt(value, params) {
-        return this.check(_lt(value, params));
+      length(n, params) {
+        return this.check(_length(n, params));
       },
-      lte(value, params) {
-        return this.check(_lte(value, params));
+      unwrap() {
+        return this.element;
+      }
+    });
+  });
+  function array(element, params) {
+    return _array(ZodArray, element, params);
+  }
+  function keyof(schema) {
+    const shape = schema._zod.def.shape;
+    return _enum2(Object.keys(shape));
+  }
+  var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
+    $ZodObjectJIT.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => objectProcessor(inst, ctx, json2, params);
+    util_exports.defineLazy(inst, "shape", () => {
+      return def.shape;
+    });
+    _installLazyMethods(inst, "ZodObject", {
+      keyof() {
+        return _enum2(Object.keys(this._zod.def.shape));
       },
-      max(value, params) {
-        return this.check(_lte(value, params));
+      catchall(catchall) {
+        return this.clone({ ...this._zod.def, catchall });
       },
-      int(params) {
-        return this.check(int(params));
+      passthrough() {
+        return this.clone({ ...this._zod.def, catchall: unknown() });
       },
-      safe(params) {
-        return this.check(int(params));
+      loose() {
+        return this.clone({ ...this._zod.def, catchall: unknown() });
       },
-      positive(params) {
-        return this.check(_gt(0, params));
+      strict() {
+        return this.clone({ ...this._zod.def, catchall: never() });
       },
-      nonnegative(params) {
-        return this.check(_gte(0, params));
+      strip() {
+        return this.clone({ ...this._zod.def, catchall: void 0 });
       },
-      negative(params) {
-        return this.check(_lt(0, params));
+      extend(incoming) {
+        return util_exports.extend(this, incoming);
       },
-      nonpositive(params) {
-        return this.check(_lte(0, params));
+      safeExtend(incoming) {
+        return util_exports.safeExtend(this, incoming);
       },
-      multipleOf(value, params) {
-        return this.check(_multipleOf(value, params));
+      merge(other) {
+        return util_exports.merge(this, other);
       },
-      step(value, params) {
-        return this.check(_multipleOf(value, params));
+      pick(mask) {
+        return util_exports.pick(this, mask);
       },
-      finite() {
-        return this;
+      omit(mask) {
+        return util_exports.omit(this, mask);
+      },
+      partial(...args) {
+        return util_exports.partial(ZodOptional, this, args[0]);
+      },
+      required(...args) {
+        return util_exports.required(ZodNonOptional, this, args[0]);
       }
     });
-    const bag = inst._zod.bag;
-    inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
-    inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
-    inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
-    inst.isFinite = true;
-    inst.format = bag.format ?? null;
   });
-  function number2(params) {
-    return _number(ZodNumber, params);
+  function object(shape, params) {
+    const def = {
+      type: "object",
+      shape: shape ?? {},
+      ...util_exports.normalizeParams(params)
+    };
+    return new ZodObject(def);
+  }
+  function strictObject(shape, params) {
+    return new ZodObject({
+      type: "object",
+      shape,
+      catchall: never(),
+      ...util_exports.normalizeParams(params)
+    });
+  }
+  function looseObject(shape, params) {
+    return new ZodObject({
+      type: "object",
+      shape,
+      catchall: unknown(),
+      ...util_exports.normalizeParams(params)
+    });
+  }
+  var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
+    $ZodUnion.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
+    inst.options = def.options;
+  });
+  function union(options, params) {
+    return new ZodUnion({
+      type: "union",
+      options,
+      ...util_exports.normalizeParams(params)
+    });
+  }
+  var ZodXor = /* @__PURE__ */ $constructor("ZodXor", (inst, def) => {
+    ZodUnion.init(inst, def);
+    $ZodXor.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
+    inst.options = def.options;
+  });
+  function xor(options, params) {
+    return new ZodXor({
+      type: "union",
+      options,
+      inclusive: false,
+      ...util_exports.normalizeParams(params)
+    });
+  }
+  var ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("ZodDiscriminatedUnion", (inst, def) => {
+    ZodUnion.init(inst, def);
+    $ZodDiscriminatedUnion.init(inst, def);
+  });
+  function discriminatedUnion(discriminator, options, params) {
+    return new ZodDiscriminatedUnion({
+      type: "union",
+      options,
+      discriminator,
+      ...util_exports.normalizeParams(params)
+    });
+  }
+  var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
+    $ZodIntersection.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => intersectionProcessor(inst, ctx, json2, params);
+  });
+  function intersection(left, right) {
+    return new ZodIntersection({
+      type: "intersection",
+      left,
+      right
+    });
+  }
+  var ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
+    $ZodTuple.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => tupleProcessor(inst, ctx, json2, params);
+    inst.rest = (rest) => inst.clone({
+      ...inst._zod.def,
+      rest
+    });
+  });
+  function tuple(items, _paramsOrRest, _params) {
+    const hasRest = _paramsOrRest instanceof $ZodType;
+    const params = hasRest ? _params : _paramsOrRest;
+    const rest = hasRest ? _paramsOrRest : null;
+    return new ZodTuple({
+      type: "tuple",
+      items,
+      rest,
+      ...util_exports.normalizeParams(params)
+    });
   }
-  var ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
-    $ZodNumberFormat.init(inst, def);
-    ZodNumber.init(inst, def);
+  var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
+    $ZodRecord.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => recordProcessor(inst, ctx, json2, params);
+    inst.keyType = def.keyType;
+    inst.valueType = def.valueType;
   });
-  function int(params) {
-    return _int(ZodNumberFormat, params);
+  function record(keyType, valueType, params) {
+    if (!valueType || !valueType._zod) {
+      return new ZodRecord({
+        type: "record",
+        keyType: string2(),
+        valueType: keyType,
+        ...util_exports.normalizeParams(valueType)
+      });
+    }
+    return new ZodRecord({
+      type: "record",
+      keyType,
+      valueType,
+      ...util_exports.normalizeParams(params)
+    });
   }
-  function float32(params) {
-    return _float32(ZodNumberFormat, params);
+  function partialRecord(keyType, valueType, params) {
+    const k = clone(keyType);
+    k._zod.values = void 0;
+    return new ZodRecord({
+      type: "record",
+      keyType: k,
+      valueType,
+      ...util_exports.normalizeParams(params)
+    });
   }
-  function float64(params) {
-    return _float64(ZodNumberFormat, params);
+  function looseRecord(keyType, valueType, params) {
+    return new ZodRecord({
+      type: "record",
+      keyType,
+      valueType,
+      mode: "loose",
+      ...util_exports.normalizeParams(params)
+    });
   }
-  function int32(params) {
-    return _int32(ZodNumberFormat, params);
+  var ZodMap = /* @__PURE__ */ $constructor("ZodMap", (inst, def) => {
+    $ZodMap.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => mapProcessor(inst, ctx, json2, params);
+    inst.keyType = def.keyType;
+    inst.valueType = def.valueType;
+    inst.min = (...args) => inst.check(_minSize(...args));
+    inst.nonempty = (params) => inst.check(_minSize(1, params));
+    inst.max = (...args) => inst.check(_maxSize(...args));
+    inst.size = (...args) => inst.check(_size(...args));
+  });
+  function map(keyType, valueType, params) {
+    return new ZodMap({
+      type: "map",
+      keyType,
+      valueType,
+      ...util_exports.normalizeParams(params)
+    });
   }
-  function uint32(params) {
-    return _uint32(ZodNumberFormat, params);
+  var ZodSet = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => {
+    $ZodSet.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => setProcessor(inst, ctx, json2, params);
+    inst.min = (...args) => inst.check(_minSize(...args));
+    inst.nonempty = (params) => inst.check(_minSize(1, params));
+    inst.max = (...args) => inst.check(_maxSize(...args));
+    inst.size = (...args) => inst.check(_size(...args));
+  });
+  function set(valueType, params) {
+    return new ZodSet({
+      type: "set",
+      valueType,
+      ...util_exports.normalizeParams(params)
+    });
   }
-  var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
-    $ZodBoolean.init(inst, def);
+  var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
+    $ZodEnum.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => booleanProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json2, params) => enumProcessor(inst, ctx, json2, params);
+    inst.enum = def.entries;
+    inst.options = Object.values(def.entries);
+    const keys = new Set(Object.keys(def.entries));
+    inst.extract = (values, params) => {
+      const newEntries = {};
+      for (const value of values) {
+        if (keys.has(value)) {
+          newEntries[value] = def.entries[value];
+        } else
+          throw new Error(`Key ${value} not found in enum`);
+      }
+      return new ZodEnum({
+        ...def,
+        checks: [],
+        ...util_exports.normalizeParams(params),
+        entries: newEntries
+      });
+    };
+    inst.exclude = (values, params) => {
+      const newEntries = { ...def.entries };
+      for (const value of values) {
+        if (keys.has(value)) {
+          delete newEntries[value];
+        } else
+          throw new Error(`Key ${value} not found in enum`);
+      }
+      return new ZodEnum({
+        ...def,
+        checks: [],
+        ...util_exports.normalizeParams(params),
+        entries: newEntries
+      });
+    };
   });
-  function boolean2(params) {
-    return _boolean(ZodBoolean, params);
+  function _enum2(values, params) {
+    const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
+    return new ZodEnum({
+      type: "enum",
+      entries,
+      ...util_exports.normalizeParams(params)
+    });
   }
-  var ZodBigInt = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => {
-    $ZodBigInt.init(inst, def);
+  function nativeEnum(entries, params) {
+    return new ZodEnum({
+      type: "enum",
+      entries,
+      ...util_exports.normalizeParams(params)
+    });
+  }
+  var ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
+    $ZodLiteral.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => bigintProcessor(inst, ctx, json2, params);
-    inst.gte = (value, params) => inst.check(_gte(value, params));
-    inst.min = (value, params) => inst.check(_gte(value, params));
-    inst.gt = (value, params) => inst.check(_gt(value, params));
-    inst.gte = (value, params) => inst.check(_gte(value, params));
-    inst.min = (value, params) => inst.check(_gte(value, params));
-    inst.lt = (value, params) => inst.check(_lt(value, params));
-    inst.lte = (value, params) => inst.check(_lte(value, params));
-    inst.max = (value, params) => inst.check(_lte(value, params));
-    inst.positive = (params) => inst.check(_gt(BigInt(0), params));
-    inst.negative = (params) => inst.check(_lt(BigInt(0), params));
-    inst.nonpositive = (params) => inst.check(_lte(BigInt(0), params));
-    inst.nonnegative = (params) => inst.check(_gte(BigInt(0), params));
-    inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
-    const bag = inst._zod.bag;
-    inst.minValue = bag.minimum ?? null;
-    inst.maxValue = bag.maximum ?? null;
-    inst.format = bag.format ?? null;
+    inst._zod.processJSONSchema = (ctx, json2, params) => literalProcessor(inst, ctx, json2, params);
+    inst.values = new Set(def.values);
+    Object.defineProperty(inst, "value", {
+      get() {
+        if (def.values.length > 1) {
+          throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
+        }
+        return def.values[0];
+      }
+    });
   });
-  function bigint2(params) {
-    return _bigint(ZodBigInt, params);
+  function literal(value, params) {
+    return new ZodLiteral({
+      type: "literal",
+      values: Array.isArray(value) ? value : [value],
+      ...util_exports.normalizeParams(params)
+    });
   }
-  var ZodBigIntFormat = /* @__PURE__ */ $constructor("ZodBigIntFormat", (inst, def) => {
-    $ZodBigIntFormat.init(inst, def);
-    ZodBigInt.init(inst, def);
+  var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
+    $ZodFile.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => fileProcessor(inst, ctx, json2, params);
+    inst.min = (size, params) => inst.check(_minSize(size, params));
+    inst.max = (size, params) => inst.check(_maxSize(size, params));
+    inst.mime = (types, params) => inst.check(_mime(Array.isArray(types) ? types : [types], params));
+  });
+  function file(params) {
+    return _file(ZodFile, params);
+  }
+  var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
+    $ZodTransform.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => transformProcessor(inst, ctx, json2, params);
+    inst._zod.parse = (payload, _ctx) => {
+      if (_ctx.direction === "backward") {
+        throw new $ZodEncodeError(inst.constructor.name);
+      }
+      payload.addIssue = (issue2) => {
+        if (typeof issue2 === "string") {
+          payload.issues.push(util_exports.issue(issue2, payload.value, def));
+        } else {
+          const _issue = issue2;
+          if (_issue.fatal)
+            _issue.continue = false;
+          _issue.code ?? (_issue.code = "custom");
+          _issue.input ?? (_issue.input = payload.value);
+          _issue.inst ?? (_issue.inst = inst);
+          payload.issues.push(util_exports.issue(_issue));
+        }
+      };
+      const output = def.transform(payload.value, payload);
+      if (output instanceof Promise) {
+        return output.then((output2) => {
+          payload.value = output2;
+          payload.fallback = true;
+          return payload;
+        });
+      }
+      payload.value = output;
+      payload.fallback = true;
+      return payload;
+    };
   });
-  function int64(params) {
-    return _int64(ZodBigIntFormat, params);
-  }
-  function uint64(params) {
-    return _uint64(ZodBigIntFormat, params);
+  function transform(fn) {
+    return new ZodTransform({
+      type: "transform",
+      transform: fn
+    });
   }
-  var ZodSymbol = /* @__PURE__ */ $constructor("ZodSymbol", (inst, def) => {
-    $ZodSymbol.init(inst, def);
+  var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
+    $ZodOptional.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => symbolProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
+    inst.unwrap = () => inst._zod.def.innerType;
   });
-  function symbol(params) {
-    return _symbol(ZodSymbol, params);
+  function optional(innerType) {
+    return new ZodOptional({
+      type: "optional",
+      innerType
+    });
   }
-  var ZodUndefined = /* @__PURE__ */ $constructor("ZodUndefined", (inst, def) => {
-    $ZodUndefined.init(inst, def);
+  var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
+    $ZodExactOptional.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => undefinedProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
+    inst.unwrap = () => inst._zod.def.innerType;
   });
-  function _undefined3(params) {
-    return _undefined2(ZodUndefined, params);
+  function exactOptional(innerType) {
+    return new ZodExactOptional({
+      type: "optional",
+      innerType
+    });
   }
-  var ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
-    $ZodNull.init(inst, def);
+  var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
+    $ZodNullable.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => nullProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json2, params) => nullableProcessor(inst, ctx, json2, params);
+    inst.unwrap = () => inst._zod.def.innerType;
   });
-  function _null3(params) {
-    return _null2(ZodNull, params);
+  function nullable(innerType) {
+    return new ZodNullable({
+      type: "nullable",
+      innerType
+    });
   }
-  var ZodAny = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
-    $ZodAny.init(inst, def);
+  function nullish2(innerType) {
+    return optional(nullable(innerType));
+  }
+  var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
+    $ZodDefault.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => anyProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json2, params) => defaultProcessor(inst, ctx, json2, params);
+    inst.unwrap = () => inst._zod.def.innerType;
+    inst.removeDefault = inst.unwrap;
   });
-  function any() {
-    return _any(ZodAny);
+  function _default2(innerType, defaultValue) {
+    return new ZodDefault({
+      type: "default",
+      innerType,
+      get defaultValue() {
+        return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue);
+      }
+    });
   }
-  var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
-    $ZodUnknown.init(inst, def);
+  var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
+    $ZodPrefault.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => unknownProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json2, params) => prefaultProcessor(inst, ctx, json2, params);
+    inst.unwrap = () => inst._zod.def.innerType;
   });
-  function unknown() {
-    return _unknown(ZodUnknown);
+  function prefault(innerType, defaultValue) {
+    return new ZodPrefault({
+      type: "prefault",
+      innerType,
+      get defaultValue() {
+        return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue);
+      }
+    });
   }
-  var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
-    $ZodNever.init(inst, def);
+  var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
+    $ZodNonOptional.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => neverProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json2, params) => nonoptionalProcessor(inst, ctx, json2, params);
+    inst.unwrap = () => inst._zod.def.innerType;
   });
-  function never(params) {
-    return _never(ZodNever, params);
+  function nonoptional(innerType, params) {
+    return new ZodNonOptional({
+      type: "nonoptional",
+      innerType,
+      ...util_exports.normalizeParams(params)
+    });
   }
-  var ZodVoid = /* @__PURE__ */ $constructor("ZodVoid", (inst, def) => {
-    $ZodVoid.init(inst, def);
+  var ZodSuccess = /* @__PURE__ */ $constructor("ZodSuccess", (inst, def) => {
+    $ZodSuccess.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => voidProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json2, params) => successProcessor(inst, ctx, json2, params);
+    inst.unwrap = () => inst._zod.def.innerType;
   });
-  function _void2(params) {
-    return _void(ZodVoid, params);
+  function success(innerType) {
+    return new ZodSuccess({
+      type: "success",
+      innerType
+    });
   }
-  var ZodDate = /* @__PURE__ */ $constructor("ZodDate", (inst, def) => {
-    $ZodDate.init(inst, def);
+  var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
+    $ZodCatch.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => dateProcessor(inst, ctx, json2, params);
-    inst.min = (value, params) => inst.check(_gte(value, params));
-    inst.max = (value, params) => inst.check(_lte(value, params));
-    const c = inst._zod.bag;
-    inst.minDate = c.minimum ? new Date(c.minimum) : null;
-    inst.maxDate = c.maximum ? new Date(c.maximum) : null;
+    inst._zod.processJSONSchema = (ctx, json2, params) => catchProcessor(inst, ctx, json2, params);
+    inst.unwrap = () => inst._zod.def.innerType;
+    inst.removeCatch = inst.unwrap;
   });
-  function date3(params) {
-    return _date(ZodDate, params);
+  function _catch2(innerType, catchValue) {
+    return new ZodCatch({
+      type: "catch",
+      innerType,
+      catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
+    });
   }
-  var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
-    $ZodArray.init(inst, def);
+  var ZodNaN = /* @__PURE__ */ $constructor("ZodNaN", (inst, def) => {
+    $ZodNaN.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params);
-    inst.element = def.element;
-    _installLazyMethods(inst, "ZodArray", {
-      min(n, params) {
-        return this.check(_minLength(n, params));
-      },
-      nonempty(params) {
-        return this.check(_minLength(1, params));
-      },
-      max(n, params) {
-        return this.check(_maxLength(n, params));
-      },
-      length(n, params) {
-        return this.check(_length(n, params));
-      },
-      unwrap() {
-        return this.element;
-      }
-    });
+    inst._zod.processJSONSchema = (ctx, json2, params) => nanProcessor(inst, ctx, json2, params);
   });
-  function array(element, params) {
-    return _array(ZodArray, element, params);
-  }
-  function keyof(schema) {
-    const shape = schema._zod.def.shape;
-    return _enum2(Object.keys(shape));
+  function nan(params) {
+    return _nan(ZodNaN, params);
   }
-  var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
-    $ZodObjectJIT.init(inst, def);
+  var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
+    $ZodPipe.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => objectProcessor(inst, ctx, json2, params);
-    util_exports.defineLazy(inst, "shape", () => {
-      return def.shape;
-    });
-    _installLazyMethods(inst, "ZodObject", {
-      keyof() {
-        return _enum2(Object.keys(this._zod.def.shape));
-      },
-      catchall(catchall) {
-        return this.clone({ ...this._zod.def, catchall });
-      },
-      passthrough() {
-        return this.clone({ ...this._zod.def, catchall: unknown() });
-      },
-      loose() {
-        return this.clone({ ...this._zod.def, catchall: unknown() });
-      },
-      strict() {
-        return this.clone({ ...this._zod.def, catchall: never() });
-      },
-      strip() {
-        return this.clone({ ...this._zod.def, catchall: void 0 });
-      },
-      extend(incoming) {
-        return util_exports.extend(this, incoming);
-      },
-      safeExtend(incoming) {
-        return util_exports.safeExtend(this, incoming);
-      },
-      merge(other) {
-        return util_exports.merge(this, other);
-      },
-      pick(mask) {
-        return util_exports.pick(this, mask);
-      },
-      omit(mask) {
-        return util_exports.omit(this, mask);
-      },
-      partial(...args) {
-        return util_exports.partial(ZodOptional, this, args[0]);
-      },
-      required(...args) {
-        return util_exports.required(ZodNonOptional, this, args[0]);
-      }
+    inst._zod.processJSONSchema = (ctx, json2, params) => pipeProcessor(inst, ctx, json2, params);
+    inst.in = def.in;
+    inst.out = def.out;
+  });
+  function pipe(in_, out) {
+    return new ZodPipe({
+      type: "pipe",
+      in: in_,
+      out
+      // ...util.normalizeParams(params),
     });
+  }
+  var ZodCodec = /* @__PURE__ */ $constructor("ZodCodec", (inst, def) => {
+    ZodPipe.init(inst, def);
+    $ZodCodec.init(inst, def);
   });
-  function object(shape, params) {
-    const def = {
-      type: "object",
-      shape: shape ?? {},
-      ...util_exports.normalizeParams(params)
-    };
-    return new ZodObject(def);
+  function codec(in_, out, params) {
+    return new ZodCodec({
+      type: "pipe",
+      in: in_,
+      out,
+      transform: params.decode,
+      reverseTransform: params.encode
+    });
   }
-  function strictObject(shape, params) {
-    return new ZodObject({
-      type: "object",
-      shape,
-      catchall: never(),
-      ...util_exports.normalizeParams(params)
+  function invertCodec(codec2) {
+    const def = codec2._zod.def;
+    return new ZodCodec({
+      type: "pipe",
+      in: def.out,
+      out: def.in,
+      transform: def.reverseTransform,
+      reverseTransform: def.transform
     });
   }
-  function looseObject(shape, params) {
-    return new ZodObject({
-      type: "object",
-      shape,
-      catchall: unknown(),
-      ...util_exports.normalizeParams(params)
+  var ZodPreprocess = /* @__PURE__ */ $constructor("ZodPreprocess", (inst, def) => {
+    ZodPipe.init(inst, def);
+    $ZodPreprocess.init(inst, def);
+  });
+  var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
+    $ZodReadonly.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => readonlyProcessor(inst, ctx, json2, params);
+    inst.unwrap = () => inst._zod.def.innerType;
+  });
+  function readonly(innerType) {
+    return new ZodReadonly({
+      type: "readonly",
+      innerType
     });
   }
-  var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
-    $ZodUnion.init(inst, def);
+  var ZodTemplateLiteral = /* @__PURE__ */ $constructor("ZodTemplateLiteral", (inst, def) => {
+    $ZodTemplateLiteral.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
-    inst.options = def.options;
+    inst._zod.processJSONSchema = (ctx, json2, params) => templateLiteralProcessor(inst, ctx, json2, params);
   });
-  function union(options, params) {
-    return new ZodUnion({
-      type: "union",
-      options,
+  function templateLiteral(parts, params) {
+    return new ZodTemplateLiteral({
+      type: "template_literal",
+      parts,
       ...util_exports.normalizeParams(params)
     });
   }
-  var ZodXor = /* @__PURE__ */ $constructor("ZodXor", (inst, def) => {
-    ZodUnion.init(inst, def);
-    $ZodXor.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
-    inst.options = def.options;
+  var ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
+    $ZodLazy.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => lazyProcessor(inst, ctx, json2, params);
+    inst.unwrap = () => inst._zod.def.getter();
   });
-  function xor(options, params) {
-    return new ZodXor({
-      type: "union",
-      options,
-      inclusive: false,
-      ...util_exports.normalizeParams(params)
+  function lazy(getter) {
+    return new ZodLazy({
+      type: "lazy",
+      getter
     });
   }
-  var ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("ZodDiscriminatedUnion", (inst, def) => {
-    ZodUnion.init(inst, def);
-    $ZodDiscriminatedUnion.init(inst, def);
+  var ZodPromise = /* @__PURE__ */ $constructor("ZodPromise", (inst, def) => {
+    $ZodPromise.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json2, params) => promiseProcessor(inst, ctx, json2, params);
+    inst.unwrap = () => inst._zod.def.innerType;
   });
-  function discriminatedUnion(discriminator, options, params) {
-    return new ZodDiscriminatedUnion({
-      type: "union",
-      options,
-      discriminator,
-      ...util_exports.normalizeParams(params)
+  function promise(innerType) {
+    return new ZodPromise({
+      type: "promise",
+      innerType
     });
   }
-  var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
-    $ZodIntersection.init(inst, def);
+  var ZodFunction = /* @__PURE__ */ $constructor("ZodFunction", (inst, def) => {
+    $ZodFunction.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => intersectionProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json2, params) => functionProcessor(inst, ctx, json2, params);
   });
-  function intersection(left, right) {
-    return new ZodIntersection({
-      type: "intersection",
-      left,
-      right
+  function _function(params) {
+    return new ZodFunction({
+      type: "function",
+      input: Array.isArray(params?.input) ? tuple(params?.input) : params?.input ?? array(unknown()),
+      output: params?.output ?? unknown()
     });
   }
-  var ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
-    $ZodTuple.init(inst, def);
+  var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
+    $ZodCustom.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => tupleProcessor(inst, ctx, json2, params);
-    inst.rest = (rest) => inst.clone({
-      ...inst._zod.def,
-      rest
-    });
+    inst._zod.processJSONSchema = (ctx, json2, params) => customProcessor(inst, ctx, json2, params);
   });
-  function tuple(items, _paramsOrRest, _params) {
-    const hasRest = _paramsOrRest instanceof $ZodType;
-    const params = hasRest ? _params : _paramsOrRest;
-    const rest = hasRest ? _paramsOrRest : null;
-    return new ZodTuple({
-      type: "tuple",
-      items,
-      rest,
+  function check(fn) {
+    const ch = new $ZodCheck({
+      check: "custom"
+      // ...util.normalizeParams(params),
+    });
+    ch._zod.check = fn;
+    return ch;
+  }
+  function custom(fn, _params) {
+    return _custom(ZodCustom, fn ?? (() => true), _params);
+  }
+  function refine(fn, _params = {}) {
+    return _refine(ZodCustom, fn, _params);
+  }
+  function superRefine(fn, params) {
+    return _superRefine(fn, params);
+  }
+  var describe2 = describe;
+  var meta2 = meta;
+  function _instanceof(cls, params = {}) {
+    const inst = new ZodCustom({
+      type: "custom",
+      check: "custom",
+      fn: (data) => data instanceof cls,
+      abort: true,
       ...util_exports.normalizeParams(params)
     });
+    inst._zod.bag.Class = cls;
+    inst._zod.check = (payload) => {
+      if (!(payload.value instanceof cls)) {
+        payload.issues.push({
+          code: "invalid_type",
+          expected: cls.name,
+          input: payload.value,
+          inst,
+          path: [...inst._zod.def.path ?? []]
+        });
+      }
+    };
+    return inst;
   }
-  var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
-    $ZodRecord.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => recordProcessor(inst, ctx, json2, params);
-    inst.keyType = def.keyType;
-    inst.valueType = def.valueType;
-  });
-  function record(keyType, valueType, params) {
-    if (!valueType || !valueType._zod) {
-      return new ZodRecord({
-        type: "record",
-        keyType: string2(),
-        valueType: keyType,
-        ...util_exports.normalizeParams(valueType)
-      });
+  var stringbool = (...args) => _stringbool({
+    Codec: ZodCodec,
+    Boolean: ZodBoolean,
+    String: ZodString
+  }, ...args);
+  function json(params) {
+    const jsonSchema = lazy(() => {
+      return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record(string2(), jsonSchema)]);
+    });
+    return jsonSchema;
+  }
+  function preprocess(fn, schema) {
+    return new ZodPreprocess({
+      type: "pipe",
+      in: transform(fn),
+      out: schema
+    });
+  }
+
+  // node_modules/zod/v4/classic/compat.js
+  var ZodIssueCode = {
+    invalid_type: "invalid_type",
+    too_big: "too_big",
+    too_small: "too_small",
+    invalid_format: "invalid_format",
+    not_multiple_of: "not_multiple_of",
+    unrecognized_keys: "unrecognized_keys",
+    invalid_union: "invalid_union",
+    invalid_key: "invalid_key",
+    invalid_element: "invalid_element",
+    invalid_value: "invalid_value",
+    custom: "custom"
+  };
+  function setErrorMap(map2) {
+    config({
+      customError: map2
+    });
+  }
+  function getErrorMap() {
+    return config().customError;
+  }
+  var ZodFirstPartyTypeKind;
+  /* @__PURE__ */ (function(ZodFirstPartyTypeKind2) {
+  })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+
+  // node_modules/zod/v4/classic/from-json-schema.js
+  var z = {
+    ...schemas_exports2,
+    ...checks_exports2,
+    iso: iso_exports
+  };
+  var RECOGNIZED_KEYS = /* @__PURE__ */ new Set([
+    // Schema identification
+    "$schema",
+    "$ref",
+    "$defs",
+    "definitions",
+    // Core schema keywords
+    "$id",
+    "id",
+    "$comment",
+    "$anchor",
+    "$vocabulary",
+    "$dynamicRef",
+    "$dynamicAnchor",
+    // Type
+    "type",
+    "enum",
+    "const",
+    // Composition
+    "anyOf",
+    "oneOf",
+    "allOf",
+    "not",
+    // Object
+    "properties",
+    "required",
+    "additionalProperties",
+    "patternProperties",
+    "propertyNames",
+    "minProperties",
+    "maxProperties",
+    // Array
+    "items",
+    "prefixItems",
+    "additionalItems",
+    "minItems",
+    "maxItems",
+    "uniqueItems",
+    "contains",
+    "minContains",
+    "maxContains",
+    // String
+    "minLength",
+    "maxLength",
+    "pattern",
+    "format",
+    // Number
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+    // Already handled metadata
+    "description",
+    "default",
+    // Content
+    "contentEncoding",
+    "contentMediaType",
+    "contentSchema",
+    // Unsupported (error-throwing)
+    "unevaluatedItems",
+    "unevaluatedProperties",
+    "if",
+    "then",
+    "else",
+    "dependentSchemas",
+    "dependentRequired",
+    // OpenAPI
+    "nullable",
+    "readOnly"
+  ]);
+  function detectVersion(schema, defaultTarget) {
+    const $schema = schema.$schema;
+    if ($schema === "https://json-schema.org/draft/2020-12/schema") {
+      return "draft-2020-12";
     }
-    return new ZodRecord({
-      type: "record",
-      keyType,
-      valueType,
-      ...util_exports.normalizeParams(params)
-    });
-  }
-  function partialRecord(keyType, valueType, params) {
-    const k = clone(keyType);
-    k._zod.values = void 0;
-    return new ZodRecord({
-      type: "record",
-      keyType: k,
-      valueType,
-      ...util_exports.normalizeParams(params)
-    });
-  }
-  function looseRecord(keyType, valueType, params) {
-    return new ZodRecord({
-      type: "record",
-      keyType,
-      valueType,
-      mode: "loose",
-      ...util_exports.normalizeParams(params)
-    });
-  }
-  var ZodMap = /* @__PURE__ */ $constructor("ZodMap", (inst, def) => {
-    $ZodMap.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => mapProcessor(inst, ctx, json2, params);
-    inst.keyType = def.keyType;
-    inst.valueType = def.valueType;
-    inst.min = (...args) => inst.check(_minSize(...args));
-    inst.nonempty = (params) => inst.check(_minSize(1, params));
-    inst.max = (...args) => inst.check(_maxSize(...args));
-    inst.size = (...args) => inst.check(_size(...args));
-  });
-  function map(keyType, valueType, params) {
-    return new ZodMap({
-      type: "map",
-      keyType,
-      valueType,
-      ...util_exports.normalizeParams(params)
-    });
+    if ($schema === "http://json-schema.org/draft-07/schema#") {
+      return "draft-7";
+    }
+    if ($schema === "http://json-schema.org/draft-04/schema#") {
+      return "draft-4";
+    }
+    return defaultTarget ?? "draft-2020-12";
   }
-  var ZodSet = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => {
-    $ZodSet.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => setProcessor(inst, ctx, json2, params);
-    inst.min = (...args) => inst.check(_minSize(...args));
-    inst.nonempty = (params) => inst.check(_minSize(1, params));
-    inst.max = (...args) => inst.check(_maxSize(...args));
-    inst.size = (...args) => inst.check(_size(...args));
-  });
-  function set(valueType, params) {
-    return new ZodSet({
-      type: "set",
-      valueType,
-      ...util_exports.normalizeParams(params)
-    });
+  function resolveRef(ref, ctx) {
+    if (!ref.startsWith("#")) {
+      throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
+    }
+    const path = ref.slice(1).split("/").filter(Boolean);
+    if (path.length === 0) {
+      return ctx.rootSchema;
+    }
+    const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
+    if (path[0] === defsKey) {
+      const key = path[1];
+      if (!key || !ctx.defs[key]) {
+        throw new Error(`Reference not found: ${ref}`);
+      }
+      return ctx.defs[key];
+    }
+    throw new Error(`Reference not found: ${ref}`);
   }
-  var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
-    $ZodEnum.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => enumProcessor(inst, ctx, json2, params);
-    inst.enum = def.entries;
-    inst.options = Object.values(def.entries);
-    const keys = new Set(Object.keys(def.entries));
-    inst.extract = (values, params) => {
-      const newEntries = {};
-      for (const value of values) {
-        if (keys.has(value)) {
-          newEntries[value] = def.entries[value];
-        } else
-          throw new Error(`Key ${value} not found in enum`);
+  function convertBaseSchema(schema, ctx) {
+    if (schema.not !== void 0) {
+      if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
+        return z.never();
       }
-      return new ZodEnum({
-        ...def,
-        checks: [],
-        ...util_exports.normalizeParams(params),
-        entries: newEntries
+      throw new Error("not is not supported in Zod (except { not: {} } for never)");
+    }
+    if (schema.unevaluatedItems !== void 0) {
+      throw new Error("unevaluatedItems is not supported");
+    }
+    if (schema.unevaluatedProperties !== void 0) {
+      throw new Error("unevaluatedProperties is not supported");
+    }
+    if (schema.if !== void 0 || schema.then !== void 0 || schema.else !== void 0) {
+      throw new Error("Conditional schemas (if/then/else) are not supported");
+    }
+    if (schema.dependentSchemas !== void 0 || schema.dependentRequired !== void 0) {
+      throw new Error("dependentSchemas and dependentRequired are not supported");
+    }
+    if (schema.$ref) {
+      const refPath = schema.$ref;
+      if (ctx.refs.has(refPath)) {
+        return ctx.refs.get(refPath);
+      }
+      if (ctx.processing.has(refPath)) {
+        return z.lazy(() => {
+          if (!ctx.refs.has(refPath)) {
+            throw new Error(`Circular reference not resolved: ${refPath}`);
+          }
+          return ctx.refs.get(refPath);
+        });
+      }
+      ctx.processing.add(refPath);
+      const resolved = resolveRef(refPath, ctx);
+      const zodSchema2 = convertSchema(resolved, ctx);
+      ctx.refs.set(refPath, zodSchema2);
+      ctx.processing.delete(refPath);
+      return zodSchema2;
+    }
+    if (schema.enum !== void 0) {
+      const enumValues = schema.enum;
+      if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
+        return z.null();
+      }
+      if (enumValues.length === 0) {
+        return z.never();
+      }
+      if (enumValues.length === 1) {
+        return z.literal(enumValues[0]);
+      }
+      if (enumValues.every((v) => typeof v === "string")) {
+        return z.enum(enumValues);
+      }
+      const literalSchemas = enumValues.map((v) => z.literal(v));
+      if (literalSchemas.length < 2) {
+        return literalSchemas[0];
+      }
+      return z.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
+    }
+    if (schema.const !== void 0) {
+      return z.literal(schema.const);
+    }
+    const type = schema.type;
+    if (Array.isArray(type)) {
+      const typeSchemas = type.map((t) => {
+        const typeSchema = { ...schema, type: t };
+        return convertBaseSchema(typeSchema, ctx);
       });
-    };
-    inst.exclude = (values, params) => {
-      const newEntries = { ...def.entries };
-      for (const value of values) {
-        if (keys.has(value)) {
-          delete newEntries[value];
-        } else
-          throw new Error(`Key ${value} not found in enum`);
+      if (typeSchemas.length === 0) {
+        return z.never();
+      }
+      if (typeSchemas.length === 1) {
+        return typeSchemas[0];
+      }
+      return z.union(typeSchemas);
+    }
+    if (!type) {
+      return z.any();
+    }
+    let zodSchema;
+    switch (type) {
+      case "string": {
+        let stringSchema = z.string();
+        if (schema.format) {
+          const format = schema.format;
+          if (format === "email") {
+            stringSchema = stringSchema.check(z.email());
+          } else if (format === "uri" || format === "uri-reference") {
+            stringSchema = stringSchema.check(z.url());
+          } else if (format === "uuid" || format === "guid") {
+            stringSchema = stringSchema.check(z.uuid());
+          } else if (format === "date-time") {
+            stringSchema = stringSchema.check(z.iso.datetime());
+          } else if (format === "date") {
+            stringSchema = stringSchema.check(z.iso.date());
+          } else if (format === "time") {
+            stringSchema = stringSchema.check(z.iso.time());
+          } else if (format === "duration") {
+            stringSchema = stringSchema.check(z.iso.duration());
+          } else if (format === "ipv4") {
+            stringSchema = stringSchema.check(z.ipv4());
+          } else if (format === "ipv6") {
+            stringSchema = stringSchema.check(z.ipv6());
+          } else if (format === "mac") {
+            stringSchema = stringSchema.check(z.mac());
+          } else if (format === "cidr") {
+            stringSchema = stringSchema.check(z.cidrv4());
+          } else if (format === "cidr-v6") {
+            stringSchema = stringSchema.check(z.cidrv6());
+          } else if (format === "base64") {
+            stringSchema = stringSchema.check(z.base64());
+          } else if (format === "base64url") {
+            stringSchema = stringSchema.check(z.base64url());
+          } else if (format === "e164") {
+            stringSchema = stringSchema.check(z.e164());
+          } else if (format === "jwt") {
+            stringSchema = stringSchema.check(z.jwt());
+          } else if (format === "emoji") {
+            stringSchema = stringSchema.check(z.emoji());
+          } else if (format === "nanoid") {
+            stringSchema = stringSchema.check(z.nanoid());
+          } else if (format === "cuid") {
+            stringSchema = stringSchema.check(z.cuid());
+          } else if (format === "cuid2") {
+            stringSchema = stringSchema.check(z.cuid2());
+          } else if (format === "ulid") {
+            stringSchema = stringSchema.check(z.ulid());
+          } else if (format === "xid") {
+            stringSchema = stringSchema.check(z.xid());
+          } else if (format === "ksuid") {
+            stringSchema = stringSchema.check(z.ksuid());
+          }
+        }
+        if (typeof schema.minLength === "number") {
+          stringSchema = stringSchema.min(schema.minLength);
+        }
+        if (typeof schema.maxLength === "number") {
+          stringSchema = stringSchema.max(schema.maxLength);
+        }
+        if (schema.pattern) {
+          stringSchema = stringSchema.regex(new RegExp(schema.pattern));
+        }
+        zodSchema = stringSchema;
+        break;
       }
-      return new ZodEnum({
-        ...def,
-        checks: [],
-        ...util_exports.normalizeParams(params),
-        entries: newEntries
-      });
-    };
-  });
-  function _enum2(values, params) {
-    const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
-    return new ZodEnum({
-      type: "enum",
-      entries,
-      ...util_exports.normalizeParams(params)
-    });
-  }
-  function nativeEnum(entries, params) {
-    return new ZodEnum({
-      type: "enum",
-      entries,
-      ...util_exports.normalizeParams(params)
-    });
-  }
-  var ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
-    $ZodLiteral.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => literalProcessor(inst, ctx, json2, params);
-    inst.values = new Set(def.values);
-    Object.defineProperty(inst, "value", {
-      get() {
-        if (def.values.length > 1) {
-          throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
+      case "number":
+      case "integer": {
+        let numberSchema = type === "integer" ? z.number().int() : z.number();
+        if (typeof schema.minimum === "number") {
+          numberSchema = numberSchema.min(schema.minimum);
         }
-        return def.values[0];
+        if (typeof schema.maximum === "number") {
+          numberSchema = numberSchema.max(schema.maximum);
+        }
+        if (typeof schema.exclusiveMinimum === "number") {
+          numberSchema = numberSchema.gt(schema.exclusiveMinimum);
+        } else if (schema.exclusiveMinimum === true && typeof schema.minimum === "number") {
+          numberSchema = numberSchema.gt(schema.minimum);
+        }
+        if (typeof schema.exclusiveMaximum === "number") {
+          numberSchema = numberSchema.lt(schema.exclusiveMaximum);
+        } else if (schema.exclusiveMaximum === true && typeof schema.maximum === "number") {
+          numberSchema = numberSchema.lt(schema.maximum);
+        }
+        if (typeof schema.multipleOf === "number") {
+          numberSchema = numberSchema.multipleOf(schema.multipleOf);
+        }
+        zodSchema = numberSchema;
+        break;
       }
-    });
-  });
-  function literal(value, params) {
-    return new ZodLiteral({
-      type: "literal",
-      values: Array.isArray(value) ? value : [value],
-      ...util_exports.normalizeParams(params)
-    });
-  }
-  var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
-    $ZodFile.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => fileProcessor(inst, ctx, json2, params);
-    inst.min = (size, params) => inst.check(_minSize(size, params));
-    inst.max = (size, params) => inst.check(_maxSize(size, params));
-    inst.mime = (types, params) => inst.check(_mime(Array.isArray(types) ? types : [types], params));
-  });
-  function file(params) {
-    return _file(ZodFile, params);
-  }
-  var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
-    $ZodTransform.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => transformProcessor(inst, ctx, json2, params);
-    inst._zod.parse = (payload, _ctx) => {
-      if (_ctx.direction === "backward") {
-        throw new $ZodEncodeError(inst.constructor.name);
+      case "boolean": {
+        zodSchema = z.boolean();
+        break;
       }
-      payload.addIssue = (issue2) => {
-        if (typeof issue2 === "string") {
-          payload.issues.push(util_exports.issue(issue2, payload.value, def));
+      case "null": {
+        zodSchema = z.null();
+        break;
+      }
+      case "object": {
+        const shape = {};
+        const properties = schema.properties || {};
+        const requiredSet = new Set(schema.required || []);
+        for (const [key, propSchema] of Object.entries(properties)) {
+          const propZodSchema = convertSchema(propSchema, ctx);
+          shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
+        }
+        if (schema.propertyNames) {
+          const keySchema = convertSchema(schema.propertyNames, ctx);
+          const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z.any();
+          if (Object.keys(shape).length === 0) {
+            zodSchema = z.record(keySchema, valueSchema);
+            break;
+          }
+          const objectSchema2 = z.object(shape).passthrough();
+          const recordSchema = z.looseRecord(keySchema, valueSchema);
+          zodSchema = z.intersection(objectSchema2, recordSchema);
+          break;
+        }
+        if (schema.patternProperties) {
+          const patternProps = schema.patternProperties;
+          const patternKeys = Object.keys(patternProps);
+          const looseRecords = [];
+          for (const pattern of patternKeys) {
+            const patternValue = convertSchema(patternProps[pattern], ctx);
+            const keySchema = z.string().regex(new RegExp(pattern));
+            looseRecords.push(z.looseRecord(keySchema, patternValue));
+          }
+          const schemasToIntersect = [];
+          if (Object.keys(shape).length > 0) {
+            schemasToIntersect.push(z.object(shape).passthrough());
+          }
+          schemasToIntersect.push(...looseRecords);
+          if (schemasToIntersect.length === 0) {
+            zodSchema = z.object({}).passthrough();
+          } else if (schemasToIntersect.length === 1) {
+            zodSchema = schemasToIntersect[0];
+          } else {
+            let result = z.intersection(schemasToIntersect[0], schemasToIntersect[1]);
+            for (let i = 2; i < schemasToIntersect.length; i++) {
+              result = z.intersection(result, schemasToIntersect[i]);
+            }
+            zodSchema = result;
+          }
+          break;
+        }
+        const objectSchema = z.object(shape);
+        if (schema.additionalProperties === false) {
+          zodSchema = objectSchema.strict();
+        } else if (typeof schema.additionalProperties === "object") {
+          zodSchema = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
         } else {
-          const _issue = issue2;
-          if (_issue.fatal)
-            _issue.continue = false;
-          _issue.code ?? (_issue.code = "custom");
-          _issue.input ?? (_issue.input = payload.value);
-          _issue.inst ?? (_issue.inst = inst);
-          payload.issues.push(util_exports.issue(_issue));
+          zodSchema = objectSchema.passthrough();
+        }
+        break;
+      }
+      case "array": {
+        const prefixItems = schema.prefixItems;
+        const items = schema.items;
+        if (prefixItems && Array.isArray(prefixItems)) {
+          const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
+          const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
+          if (rest) {
+            zodSchema = z.tuple(tupleItems).rest(rest);
+          } else {
+            zodSchema = z.tuple(tupleItems);
+          }
+          if (typeof schema.minItems === "number") {
+            zodSchema = zodSchema.check(z.minLength(schema.minItems));
+          }
+          if (typeof schema.maxItems === "number") {
+            zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
+          }
+        } else if (Array.isArray(items)) {
+          const tupleItems = items.map((item) => convertSchema(item, ctx));
+          const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
+          if (rest) {
+            zodSchema = z.tuple(tupleItems).rest(rest);
+          } else {
+            zodSchema = z.tuple(tupleItems);
+          }
+          if (typeof schema.minItems === "number") {
+            zodSchema = zodSchema.check(z.minLength(schema.minItems));
+          }
+          if (typeof schema.maxItems === "number") {
+            zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
+          }
+        } else if (items !== void 0) {
+          const element = convertSchema(items, ctx);
+          let arraySchema = z.array(element);
+          if (typeof schema.minItems === "number") {
+            arraySchema = arraySchema.min(schema.minItems);
+          }
+          if (typeof schema.maxItems === "number") {
+            arraySchema = arraySchema.max(schema.maxItems);
+          }
+          zodSchema = arraySchema;
+        } else {
+          zodSchema = z.array(z.any());
+        }
+        break;
+      }
+      default:
+        throw new Error(`Unsupported type: ${type}`);
+    }
+    return zodSchema;
+  }
+  function convertSchema(schema, ctx) {
+    if (typeof schema === "boolean") {
+      return schema ? z.any() : z.never();
+    }
+    let baseSchema = convertBaseSchema(schema, ctx);
+    const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
+    if (schema.anyOf && Array.isArray(schema.anyOf)) {
+      const options = schema.anyOf.map((s) => convertSchema(s, ctx));
+      const anyOfUnion = z.union(options);
+      baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
+    }
+    if (schema.oneOf && Array.isArray(schema.oneOf)) {
+      const options = schema.oneOf.map((s) => convertSchema(s, ctx));
+      const oneOfUnion = z.xor(options);
+      baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
+    }
+    if (schema.allOf && Array.isArray(schema.allOf)) {
+      if (schema.allOf.length === 0) {
+        baseSchema = hasExplicitType ? baseSchema : z.any();
+      } else {
+        let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
+        const startIdx = hasExplicitType ? 0 : 1;
+        for (let i = startIdx; i < schema.allOf.length; i++) {
+          result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
         }
-      };
-      const output = def.transform(payload.value, payload);
-      if (output instanceof Promise) {
-        return output.then((output2) => {
-          payload.value = output2;
-          payload.fallback = true;
-          return payload;
-        });
+        baseSchema = result;
       }
-      payload.value = output;
-      payload.fallback = true;
-      return payload;
-    };
-  });
-  function transform(fn) {
-    return new ZodTransform({
-      type: "transform",
-      transform: fn
-    });
-  }
-  var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
-    $ZodOptional.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
-    inst.unwrap = () => inst._zod.def.innerType;
-  });
-  function optional(innerType) {
-    return new ZodOptional({
-      type: "optional",
-      innerType
-    });
-  }
-  var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
-    $ZodExactOptional.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
-    inst.unwrap = () => inst._zod.def.innerType;
-  });
-  function exactOptional(innerType) {
-    return new ZodExactOptional({
-      type: "optional",
-      innerType
-    });
-  }
-  var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
-    $ZodNullable.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => nullableProcessor(inst, ctx, json2, params);
-    inst.unwrap = () => inst._zod.def.innerType;
-  });
-  function nullable(innerType) {
-    return new ZodNullable({
-      type: "nullable",
-      innerType
-    });
-  }
-  function nullish2(innerType) {
-    return optional(nullable(innerType));
-  }
-  var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
-    $ZodDefault.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => defaultProcessor(inst, ctx, json2, params);
-    inst.unwrap = () => inst._zod.def.innerType;
-    inst.removeDefault = inst.unwrap;
-  });
-  function _default2(innerType, defaultValue) {
-    return new ZodDefault({
-      type: "default",
-      innerType,
-      get defaultValue() {
-        return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue);
+    }
+    if (schema.nullable === true && ctx.version === "openapi-3.0") {
+      baseSchema = z.nullable(baseSchema);
+    }
+    if (schema.readOnly === true) {
+      baseSchema = z.readonly(baseSchema);
+    }
+    if (schema.default !== void 0) {
+      baseSchema = baseSchema.default(schema.default);
+    }
+    const extraMeta = {};
+    const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
+    for (const key of coreMetadataKeys) {
+      if (key in schema) {
+        extraMeta[key] = schema[key];
       }
-    });
-  }
-  var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
-    $ZodPrefault.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => prefaultProcessor(inst, ctx, json2, params);
-    inst.unwrap = () => inst._zod.def.innerType;
-  });
-  function prefault(innerType, defaultValue) {
-    return new ZodPrefault({
-      type: "prefault",
-      innerType,
-      get defaultValue() {
-        return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue);
+    }
+    const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
+    for (const key of contentMetadataKeys) {
+      if (key in schema) {
+        extraMeta[key] = schema[key];
       }
-    });
-  }
-  var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
-    $ZodNonOptional.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => nonoptionalProcessor(inst, ctx, json2, params);
-    inst.unwrap = () => inst._zod.def.innerType;
-  });
-  function nonoptional(innerType, params) {
-    return new ZodNonOptional({
-      type: "nonoptional",
-      innerType,
-      ...util_exports.normalizeParams(params)
-    });
-  }
-  var ZodSuccess = /* @__PURE__ */ $constructor("ZodSuccess", (inst, def) => {
-    $ZodSuccess.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => successProcessor(inst, ctx, json2, params);
-    inst.unwrap = () => inst._zod.def.innerType;
-  });
-  function success(innerType) {
-    return new ZodSuccess({
-      type: "success",
-      innerType
-    });
-  }
-  var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
-    $ZodCatch.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => catchProcessor(inst, ctx, json2, params);
-    inst.unwrap = () => inst._zod.def.innerType;
-    inst.removeCatch = inst.unwrap;
-  });
-  function _catch2(innerType, catchValue) {
-    return new ZodCatch({
-      type: "catch",
-      innerType,
-      catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
-    });
-  }
-  var ZodNaN = /* @__PURE__ */ $constructor("ZodNaN", (inst, def) => {
-    $ZodNaN.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => nanProcessor(inst, ctx, json2, params);
-  });
-  function nan(params) {
-    return _nan(ZodNaN, params);
-  }
-  var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
-    $ZodPipe.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => pipeProcessor(inst, ctx, json2, params);
-    inst.in = def.in;
-    inst.out = def.out;
-  });
-  function pipe(in_, out) {
-    return new ZodPipe({
-      type: "pipe",
-      in: in_,
-      out
-      // ...util.normalizeParams(params),
-    });
-  }
-  var ZodCodec = /* @__PURE__ */ $constructor("ZodCodec", (inst, def) => {
-    ZodPipe.init(inst, def);
-    $ZodCodec.init(inst, def);
-  });
-  function codec(in_, out, params) {
-    return new ZodCodec({
-      type: "pipe",
-      in: in_,
-      out,
-      transform: params.decode,
-      reverseTransform: params.encode
-    });
-  }
-  function invertCodec(codec2) {
-    const def = codec2._zod.def;
-    return new ZodCodec({
-      type: "pipe",
-      in: def.out,
-      out: def.in,
-      transform: def.reverseTransform,
-      reverseTransform: def.transform
-    });
-  }
-  var ZodPreprocess = /* @__PURE__ */ $constructor("ZodPreprocess", (inst, def) => {
-    ZodPipe.init(inst, def);
-    $ZodPreprocess.init(inst, def);
-  });
-  var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
-    $ZodReadonly.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => readonlyProcessor(inst, ctx, json2, params);
-    inst.unwrap = () => inst._zod.def.innerType;
-  });
-  function readonly(innerType) {
-    return new ZodReadonly({
-      type: "readonly",
-      innerType
-    });
-  }
-  var ZodTemplateLiteral = /* @__PURE__ */ $constructor("ZodTemplateLiteral", (inst, def) => {
-    $ZodTemplateLiteral.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => templateLiteralProcessor(inst, ctx, json2, params);
-  });
-  function templateLiteral(parts, params) {
-    return new ZodTemplateLiteral({
-      type: "template_literal",
-      parts,
-      ...util_exports.normalizeParams(params)
-    });
-  }
-  var ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
-    $ZodLazy.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => lazyProcessor(inst, ctx, json2, params);
-    inst.unwrap = () => inst._zod.def.getter();
-  });
-  function lazy(getter) {
-    return new ZodLazy({
-      type: "lazy",
-      getter
-    });
-  }
-  var ZodPromise = /* @__PURE__ */ $constructor("ZodPromise", (inst, def) => {
-    $ZodPromise.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => promiseProcessor(inst, ctx, json2, params);
-    inst.unwrap = () => inst._zod.def.innerType;
-  });
-  function promise(innerType) {
-    return new ZodPromise({
-      type: "promise",
-      innerType
-    });
+    }
+    for (const key of Object.keys(schema)) {
+      if (!RECOGNIZED_KEYS.has(key)) {
+        extraMeta[key] = schema[key];
+      }
+    }
+    if (Object.keys(extraMeta).length > 0) {
+      ctx.registry.add(baseSchema, extraMeta);
+    }
+    if (schema.description) {
+      baseSchema = baseSchema.describe(schema.description);
+    }
+    return baseSchema;
   }
-  var ZodFunction = /* @__PURE__ */ $constructor("ZodFunction", (inst, def) => {
-    $ZodFunction.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => functionProcessor(inst, ctx, json2, params);
-  });
-  function _function(params) {
-    return new ZodFunction({
-      type: "function",
-      input: Array.isArray(params?.input) ? tuple(params?.input) : params?.input ?? array(unknown()),
-      output: params?.output ?? unknown()
-    });
+  function fromJSONSchema(schema, params) {
+    if (typeof schema === "boolean") {
+      return schema ? z.any() : z.never();
+    }
+    let normalized;
+    try {
+      normalized = JSON.parse(JSON.stringify(schema));
+    } catch {
+      throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
+    }
+    const version2 = detectVersion(normalized, params?.defaultTarget);
+    const defs = normalized.$defs || normalized.definitions || {};
+    const ctx = {
+      version: version2,
+      defs,
+      refs: /* @__PURE__ */ new Map(),
+      processing: /* @__PURE__ */ new Set(),
+      rootSchema: normalized,
+      registry: params?.registry ?? globalRegistry
+    };
+    return convertSchema(normalized, ctx);
   }
-  var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
-    $ZodCustom.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => customProcessor(inst, ctx, json2, params);
+
+  // node_modules/zod/v4/classic/coerce.js
+  var coerce_exports = {};
+  __export(coerce_exports, {
+    bigint: () => bigint3,
+    boolean: () => boolean3,
+    date: () => date4,
+    number: () => number3,
+    string: () => string3
   });
-  function check(fn) {
-    const ch = new $ZodCheck({
-      check: "custom"
-      // ...util.normalizeParams(params),
-    });
-    ch._zod.check = fn;
-    return ch;
-  }
-  function custom(fn, _params) {
-    return _custom(ZodCustom, fn ?? (() => true), _params);
-  }
-  function refine(fn, _params = {}) {
-    return _refine(ZodCustom, fn, _params);
+  function string3(params) {
+    return _coercedString(ZodString, params);
   }
-  function superRefine(fn, params) {
-    return _superRefine(fn, params);
+  function number3(params) {
+    return _coercedNumber(ZodNumber, params);
   }
-  var describe2 = describe;
-  var meta2 = meta;
-  function _instanceof(cls, params = {}) {
-    const inst = new ZodCustom({
-      type: "custom",
-      check: "custom",
-      fn: (data) => data instanceof cls,
-      abort: true,
-      ...util_exports.normalizeParams(params)
-    });
-    inst._zod.bag.Class = cls;
-    inst._zod.check = (payload) => {
-      if (!(payload.value instanceof cls)) {
-        payload.issues.push({
-          code: "invalid_type",
-          expected: cls.name,
-          input: payload.value,
-          inst,
-          path: [...inst._zod.def.path ?? []]
-        });
-      }
-    };
-    return inst;
+  function boolean3(params) {
+    return _coercedBoolean(ZodBoolean, params);
   }
-  var stringbool = (...args) => _stringbool({
-    Codec: ZodCodec,
-    Boolean: ZodBoolean,
-    String: ZodString
-  }, ...args);
-  function json(params) {
-    const jsonSchema = lazy(() => {
-      return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record(string2(), jsonSchema)]);
-    });
-    return jsonSchema;
+  function bigint3(params) {
+    return _coercedBigint(ZodBigInt, params);
   }
-  function preprocess(fn, schema) {
-    return new ZodPreprocess({
-      type: "pipe",
-      in: transform(fn),
-      out: schema
-    });
+  function date4(params) {
+    return _coercedDate(ZodDate, params);
   }
 
-  // node_modules/zod/v4/classic/compat.js
-  var ZodIssueCode = {
-    invalid_type: "invalid_type",
-    too_big: "too_big",
-    too_small: "too_small",
-    invalid_format: "invalid_format",
-    not_multiple_of: "not_multiple_of",
-    unrecognized_keys: "unrecognized_keys",
-    invalid_union: "invalid_union",
-    invalid_key: "invalid_key",
-    invalid_element: "invalid_element",
-    invalid_value: "invalid_value",
-    custom: "custom"
-  };
-  function setErrorMap(map2) {
-    config({
-      customError: map2
-    });
-  }
-  function getErrorMap() {
-    return config().customError;
-  }
-  var ZodFirstPartyTypeKind;
-  /* @__PURE__ */ (function(ZodFirstPartyTypeKind2) {
-  })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+  // node_modules/zod/v4/classic/external.js
+  config(en_default());
 
-  // node_modules/zod/v4/classic/from-json-schema.js
-  var z = {
-    ...schemas_exports2,
-    ...checks_exports2,
-    iso: iso_exports
-  };
-  var RECOGNIZED_KEYS = /* @__PURE__ */ new Set([
-    // Schema identification
-    "$schema",
-    "$ref",
-    "$defs",
-    "definitions",
-    // Core schema keywords
-    "$id",
-    "id",
-    "$comment",
-    "$anchor",
-    "$vocabulary",
-    "$dynamicRef",
-    "$dynamicAnchor",
-    // Type
-    "type",
-    "enum",
-    "const",
-    // Composition
-    "anyOf",
-    "oneOf",
-    "allOf",
-    "not",
-    // Object
-    "properties",
-    "required",
-    "additionalProperties",
-    "patternProperties",
-    "propertyNames",
-    "minProperties",
-    "maxProperties",
-    // Array
-    "items",
-    "prefixItems",
-    "additionalItems",
-    "minItems",
-    "maxItems",
-    "uniqueItems",
-    "contains",
-    "minContains",
-    "maxContains",
-    // String
-    "minLength",
-    "maxLength",
-    "pattern",
-    "format",
-    // Number
-    "minimum",
-    "maximum",
-    "exclusiveMinimum",
-    "exclusiveMaximum",
-    "multipleOf",
-    // Already handled metadata
-    "description",
-    "default",
-    // Content
-    "contentEncoding",
-    "contentMediaType",
-    "contentSchema",
-    // Unsupported (error-throwing)
-    "unevaluatedItems",
-    "unevaluatedProperties",
-    "if",
-    "then",
-    "else",
-    "dependentSchemas",
-    "dependentRequired",
-    // OpenAPI
-    "nullable",
-    "readOnly"
-  ]);
-  function detectVersion(schema, defaultTarget) {
-    const $schema = schema.$schema;
-    if ($schema === "https://json-schema.org/draft/2020-12/schema") {
-      return "draft-2020-12";
+  // node_modules/@opentabs-dev/shared/dist/error.js
+  var toErrorMessage = (err2) => err2 instanceof Error ? err2.message : String(err2);
+
+  // node_modules/@opentabs-dev/plugin-sdk/dist/errors.js
+  var ToolError = class _ToolError extends Error {
+    code;
+    /** Whether this error is retryable (defaults to false). */
+    retryable;
+    /** Suggested delay before retrying, in milliseconds. */
+    retryAfterMs;
+    /** Error category for structured error classification. */
+    category;
+    constructor(message, code, opts) {
+      super(message);
+      this.code = code;
+      this.name = "ToolError";
+      this.retryable = opts?.retryable ?? false;
+      this.retryAfterMs = opts?.retryAfterMs;
+      this.category = opts?.category;
+    }
+    /** Authentication or authorization error (not retryable). Accepts an optional domain-specific code. */
+    static auth(message, code) {
+      return new _ToolError(message, code ?? "AUTH_ERROR", { category: "auth", retryable: false });
+    }
+    /** Resource not found (not retryable). Accepts an optional domain-specific code. */
+    static notFound(message, code) {
+      return new _ToolError(message, code ?? "NOT_FOUND", { category: "not_found", retryable: false });
+    }
+    /** Rate limited (retryable). Accepts an optional retry delay in milliseconds and an optional domain-specific code. */
+    static rateLimited(message, retryAfterMs, code) {
+      return new _ToolError(message, code ?? "RATE_LIMITED", { category: "rate_limit", retryable: true, retryAfterMs });
     }
-    if ($schema === "http://json-schema.org/draft-07/schema#") {
-      return "draft-7";
+    /** Input validation error (not retryable). Accepts an optional domain-specific code. */
+    static validation(message, code) {
+      return new _ToolError(message, code ?? "VALIDATION_ERROR", { category: "validation", retryable: false });
     }
-    if ($schema === "http://json-schema.org/draft-04/schema#") {
-      return "draft-4";
+    /** Operation timed out (retryable). Accepts an optional domain-specific code. */
+    static timeout(message, code) {
+      return new _ToolError(message, code ?? "TIMEOUT", { category: "timeout", retryable: true });
     }
-    return defaultTarget ?? "draft-2020-12";
-  }
-  function resolveRef(ref, ctx) {
-    if (!ref.startsWith("#")) {
-      throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
+    /** Internal/unexpected error (not retryable). Accepts an optional domain-specific code. */
+    static internal(message, code) {
+      return new _ToolError(message, code ?? "INTERNAL_ERROR", { category: "internal", retryable: false });
     }
-    const path = ref.slice(1).split("/").filter(Boolean);
-    if (path.length === 0) {
-      return ctx.rootSchema;
+  };
+
+  // node_modules/@opentabs-dev/plugin-sdk/dist/fetch.js
+  var MAX_ERROR_BODY_LENGTH = 512;
+  var httpStatusToToolError = (response, message) => {
+    const status = response.status;
+    if (status === 401 || status === 403) {
+      return ToolError.auth(message);
     }
-    const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-    if (path[0] === defsKey) {
-      const key = path[1];
-      if (!key || !ctx.defs[key]) {
-        throw new Error(`Reference not found: ${ref}`);
-      }
-      return ctx.defs[key];
+    if (status === 404) {
+      return ToolError.notFound(message);
     }
-    throw new Error(`Reference not found: ${ref}`);
-  }
-  function convertBaseSchema(schema, ctx) {
-    if (schema.not !== void 0) {
-      if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
-        return z.never();
-      }
-      throw new Error("not is not supported in Zod (except { not: {} } for never)");
+    if (status === 429) {
+      const retryAfter = response.headers.get("Retry-After");
+      const retryAfterMs = retryAfter !== null ? parseRetryAfterMs(retryAfter) : void 0;
+      return ToolError.rateLimited(message, retryAfterMs);
     }
-    if (schema.unevaluatedItems !== void 0) {
-      throw new Error("unevaluatedItems is not supported");
+    if (status === 400 || status === 422) {
+      return ToolError.validation(message);
     }
-    if (schema.unevaluatedProperties !== void 0) {
-      throw new Error("unevaluatedProperties is not supported");
+    if (status === 408) {
+      return ToolError.timeout(message);
     }
-    if (schema.if !== void 0 || schema.then !== void 0 || schema.else !== void 0) {
-      throw new Error("Conditional schemas (if/then/else) are not supported");
+    if (status >= 500) {
+      const TRANSIENT_5XX = /* @__PURE__ */ new Set([500, 502, 503, 504]);
+      const retryable = TRANSIENT_5XX.has(status);
+      const retryAfter = status === 503 ? response.headers.get("Retry-After") : null;
+      const retryAfterMs = retryAfter !== null ? parseRetryAfterMs(retryAfter) : void 0;
+      return new ToolError(message, "http_error", { category: "internal", retryable, retryAfterMs });
     }
-    if (schema.dependentSchemas !== void 0 || schema.dependentRequired !== void 0) {
-      throw new Error("dependentSchemas and dependentRequired are not supported");
+    if (status >= 400 && status < 500) {
+      return new ToolError(message, "http_error", { retryable: false });
     }
-    if (schema.$ref) {
-      const refPath = schema.$ref;
-      if (ctx.refs.has(refPath)) {
-        return ctx.refs.get(refPath);
-      }
-      if (ctx.processing.has(refPath)) {
-        return z.lazy(() => {
-          if (!ctx.refs.has(refPath)) {
-            throw new Error(`Circular reference not resolved: ${refPath}`);
-          }
-          return ctx.refs.get(refPath);
-        });
-      }
-      ctx.processing.add(refPath);
-      const resolved = resolveRef(refPath, ctx);
-      const zodSchema2 = convertSchema(resolved, ctx);
-      ctx.refs.set(refPath, zodSchema2);
-      ctx.processing.delete(refPath);
-      return zodSchema2;
+    return new ToolError(message, "http_error", { category: "internal" });
+  };
+  var parseRetryAfterMs = (value) => {
+    const seconds = Number(value);
+    if (!Number.isNaN(seconds) && seconds >= 0) {
+      return seconds * 1e3;
     }
-    if (schema.enum !== void 0) {
-      const enumValues = schema.enum;
-      if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
-        return z.null();
-      }
-      if (enumValues.length === 0) {
-        return z.never();
-      }
-      if (enumValues.length === 1) {
-        return z.literal(enumValues[0]);
-      }
-      if (enumValues.every((v) => typeof v === "string")) {
-        return z.enum(enumValues);
-      }
-      const literalSchemas = enumValues.map((v) => z.literal(v));
-      if (literalSchemas.length < 2) {
-        return literalSchemas[0];
-      }
-      return z.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
+    const date5 = Date.parse(value);
+    if (!Number.isNaN(date5)) {
+      const ms = date5 - Date.now();
+      return ms > 0 ? ms : void 0;
     }
-    if (schema.const !== void 0) {
-      return z.literal(schema.const);
+    return void 0;
+  };
+  var buildQueryString = (params) => {
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0)
+        continue;
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          searchParams.append(key, String(item));
+        }
+      } else {
+        searchParams.append(key, String(value));
+      }
     }
-    const type = schema.type;
-    if (Array.isArray(type)) {
-      const typeSchemas = type.map((t) => {
-        const typeSchema = { ...schema, type: t };
-        return convertBaseSchema(typeSchema, ctx);
+    return searchParams.toString();
+  };
+  var fetchFromPage = async (url2, init) => {
+    const { timeout = 3e4, signal, ...rest } = init ?? {};
+    const timeoutSignal = AbortSignal.timeout(timeout);
+    const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+    let response;
+    try {
+      response = await fetch(url2, {
+        credentials: "include",
+        ...rest,
+        signal: combinedSignal
       });
-      if (typeSchemas.length === 0) {
-        return z.never();
+    } catch (error51) {
+      if (error51 instanceof DOMException && error51.name === "TimeoutError") {
+        throw ToolError.timeout(`fetchFromPage: request timed out after ${timeout}ms for ${url2}`);
       }
-      if (typeSchemas.length === 1) {
-        return typeSchemas[0];
+      if (combinedSignal.aborted) {
+        throw new ToolError(`fetchFromPage: request aborted for ${url2}`, "aborted");
       }
-      return z.union(typeSchemas);
+      throw new ToolError(`fetchFromPage: network error for ${url2}: ${toErrorMessage(error51)}`, "network_error", {
+        category: "internal",
+        retryable: true
+      });
     }
-    if (!type) {
-      return z.any();
+    if (!response.ok) {
+      const rawText = await response.text().catch(() => response.statusText);
+      const errorText = rawText.length > MAX_ERROR_BODY_LENGTH ? `${rawText.slice(0, MAX_ERROR_BODY_LENGTH)}\u2026` : rawText;
+      const msg = `fetchFromPage: HTTP ${response.status} for ${url2}: ${errorText}`;
+      throw httpStatusToToolError(response, msg);
     }
-    let zodSchema;
-    switch (type) {
-      case "string": {
-        let stringSchema = z.string();
-        if (schema.format) {
-          const format = schema.format;
-          if (format === "email") {
-            stringSchema = stringSchema.check(z.email());
-          } else if (format === "uri" || format === "uri-reference") {
-            stringSchema = stringSchema.check(z.url());
-          } else if (format === "uuid" || format === "guid") {
-            stringSchema = stringSchema.check(z.uuid());
-          } else if (format === "date-time") {
-            stringSchema = stringSchema.check(z.iso.datetime());
-          } else if (format === "date") {
-            stringSchema = stringSchema.check(z.iso.date());
-          } else if (format === "time") {
-            stringSchema = stringSchema.check(z.iso.time());
-          } else if (format === "duration") {
-            stringSchema = stringSchema.check(z.iso.duration());
-          } else if (format === "ipv4") {
-            stringSchema = stringSchema.check(z.ipv4());
-          } else if (format === "ipv6") {
-            stringSchema = stringSchema.check(z.ipv6());
-          } else if (format === "mac") {
-            stringSchema = stringSchema.check(z.mac());
-          } else if (format === "cidr") {
-            stringSchema = stringSchema.check(z.cidrv4());
-          } else if (format === "cidr-v6") {
-            stringSchema = stringSchema.check(z.cidrv6());
-          } else if (format === "base64") {
-            stringSchema = stringSchema.check(z.base64());
-          } else if (format === "base64url") {
-            stringSchema = stringSchema.check(z.base64url());
-          } else if (format === "e164") {
-            stringSchema = stringSchema.check(z.e164());
-          } else if (format === "jwt") {
-            stringSchema = stringSchema.check(z.jwt());
-          } else if (format === "emoji") {
-            stringSchema = stringSchema.check(z.emoji());
-          } else if (format === "nanoid") {
-            stringSchema = stringSchema.check(z.nanoid());
-          } else if (format === "cuid") {
-            stringSchema = stringSchema.check(z.cuid());
-          } else if (format === "cuid2") {
-            stringSchema = stringSchema.check(z.cuid2());
-          } else if (format === "ulid") {
-            stringSchema = stringSchema.check(z.ulid());
-          } else if (format === "xid") {
-            stringSchema = stringSchema.check(z.xid());
-          } else if (format === "ksuid") {
-            stringSchema = stringSchema.check(z.ksuid());
+    return response;
+  };
+
+  // node_modules/@opentabs-dev/plugin-sdk/dist/timing.js
+  var waitUntil = (predicate, opts) => {
+    const interval = opts?.interval ?? 200;
+    const timeout = opts?.timeout ?? 1e4;
+    const signal = opts?.signal;
+    const abortReason = () => signal?.reason instanceof Error ? signal.reason : new Error("waitUntil: aborted");
+    if (signal?.aborted)
+      return Promise.reject(abortReason());
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let poller;
+      let lastPredicateError;
+      const isSettled = () => settled;
+      const cleanup = () => {
+        settled = true;
+        clearTimeout(timer);
+        clearTimeout(poller);
+        signal?.removeEventListener("abort", onAbort);
+      };
+      const onAbort = () => {
+        if (isSettled())
+          return;
+        cleanup();
+        reject(abortReason());
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      const timer = setTimeout(() => {
+        if (isSettled())
+          return;
+        cleanup();
+        const errorContext = lastPredicateError instanceof Error ? `: predicate last threw \u2014 ${lastPredicateError.message}` : "";
+        reject(new Error(`waitUntil: timed out after ${timeout}ms waiting for predicate to return true${errorContext}`));
+      }, timeout);
+      const check2 = async () => {
+        if (isSettled())
+          return;
+        try {
+          const result = await predicate();
+          if (result) {
+            cleanup();
+            resolve();
+            return;
           }
+        } catch (err2) {
+          lastPredicateError = err2;
         }
-        if (typeof schema.minLength === "number") {
-          stringSchema = stringSchema.min(schema.minLength);
-        }
-        if (typeof schema.maxLength === "number") {
-          stringSchema = stringSchema.max(schema.maxLength);
-        }
-        if (schema.pattern) {
-          stringSchema = stringSchema.regex(new RegExp(schema.pattern));
-        }
-        zodSchema = stringSchema;
-        break;
-      }
-      case "number":
-      case "integer": {
-        let numberSchema = type === "integer" ? z.number().int() : z.number();
-        if (typeof schema.minimum === "number") {
-          numberSchema = numberSchema.min(schema.minimum);
-        }
-        if (typeof schema.maximum === "number") {
-          numberSchema = numberSchema.max(schema.maximum);
-        }
-        if (typeof schema.exclusiveMinimum === "number") {
-          numberSchema = numberSchema.gt(schema.exclusiveMinimum);
-        } else if (schema.exclusiveMinimum === true && typeof schema.minimum === "number") {
-          numberSchema = numberSchema.gt(schema.minimum);
-        }
-        if (typeof schema.exclusiveMaximum === "number") {
-          numberSchema = numberSchema.lt(schema.exclusiveMaximum);
-        } else if (schema.exclusiveMaximum === true && typeof schema.maximum === "number") {
-          numberSchema = numberSchema.lt(schema.maximum);
-        }
-        if (typeof schema.multipleOf === "number") {
-          numberSchema = numberSchema.multipleOf(schema.multipleOf);
+        if (!isSettled()) {
+          poller = setTimeout(() => void check2(), interval);
         }
-        zodSchema = numberSchema;
-        break;
-      }
-      case "boolean": {
-        zodSchema = z.boolean();
-        break;
-      }
-      case "null": {
-        zodSchema = z.null();
-        break;
+      };
+      void check2();
+    });
+  };
+
+  // node_modules/@opentabs-dev/plugin-sdk/dist/log.js
+  var MAX_DATA_LENGTH = 10;
+  var MAX_STRING_LENGTH = 4096;
+  var MAX_SERIALIZED_SIZE = 64 * 1024;
+  var safeSerializeArg = (value) => {
+    try {
+      if (value === null || value === void 0)
+        return value;
+      const type = typeof value;
+      if (type === "boolean" || type === "number")
+        return value;
+      if (type === "string") {
+        return value.length > MAX_STRING_LENGTH ? `${value.slice(0, MAX_STRING_LENGTH)}\u2026` : value;
       }
-      case "object": {
-        const shape = {};
-        const properties = schema.properties || {};
-        const requiredSet = new Set(schema.required || []);
-        for (const [key, propSchema] of Object.entries(properties)) {
-          const propZodSchema = convertSchema(propSchema, ctx);
-          shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
-        }
-        if (schema.propertyNames) {
-          const keySchema = convertSchema(schema.propertyNames, ctx);
-          const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z.any();
-          if (Object.keys(shape).length === 0) {
-            zodSchema = z.record(keySchema, valueSchema);
-            break;
-          }
-          const objectSchema2 = z.object(shape).passthrough();
-          const recordSchema = z.looseRecord(keySchema, valueSchema);
-          zodSchema = z.intersection(objectSchema2, recordSchema);
-          break;
-        }
-        if (schema.patternProperties) {
-          const patternProps = schema.patternProperties;
-          const patternKeys = Object.keys(patternProps);
-          const looseRecords = [];
-          for (const pattern of patternKeys) {
-            const patternValue = convertSchema(patternProps[pattern], ctx);
-            const keySchema = z.string().regex(new RegExp(pattern));
-            looseRecords.push(z.looseRecord(keySchema, patternValue));
-          }
-          const schemasToIntersect = [];
-          if (Object.keys(shape).length > 0) {
-            schemasToIntersect.push(z.object(shape).passthrough());
-          }
-          schemasToIntersect.push(...looseRecords);
-          if (schemasToIntersect.length === 0) {
-            zodSchema = z.object({}).passthrough();
-          } else if (schemasToIntersect.length === 1) {
-            zodSchema = schemasToIntersect[0];
-          } else {
-            let result = z.intersection(schemasToIntersect[0], schemasToIntersect[1]);
-            for (let i = 2; i < schemasToIntersect.length; i++) {
-              result = z.intersection(result, schemasToIntersect[i]);
+      if (type === "function")
+        return `[Function: ${value.name || "anonymous"}]`;
+      if (type === "symbol")
+        return `[Symbol: ${value.description ?? ""}]`;
+      if (type === "bigint")
+        return `[BigInt: ${value.toString()}]`;
+      if (typeof value.nodeType === "number" && typeof value.nodeName === "string") {
+        try {
+          const node = value;
+          let classStr = "";
+          if (typeof node.className === "string") {
+            classStr = node.className ? `.${node.className.split(" ")[0] ?? ""}` : "";
+          } else if (node.className !== null && typeof node.className === "object") {
+            const baseVal = node.className.baseVal;
+            if (typeof baseVal === "string") {
+              classStr = baseVal ? `.${baseVal.split(" ")[0] ?? ""}` : "";
             }
-            zodSchema = result;
           }
-          break;
-        }
-        const objectSchema = z.object(shape);
-        if (schema.additionalProperties === false) {
-          zodSchema = objectSchema.strict();
-        } else if (typeof schema.additionalProperties === "object") {
-          zodSchema = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
-        } else {
-          zodSchema = objectSchema.passthrough();
+          return `[${node.nodeName}${node.id ? `#${node.id}` : ""}${classStr}]`;
+        } catch {
         }
-        break;
       }
-      case "array": {
-        const prefixItems = schema.prefixItems;
-        const items = schema.items;
-        if (prefixItems && Array.isArray(prefixItems)) {
-          const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
-          const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
-          if (rest) {
-            zodSchema = z.tuple(tupleItems).rest(rest);
-          } else {
-            zodSchema = z.tuple(tupleItems);
-          }
-          if (typeof schema.minItems === "number") {
-            zodSchema = zodSchema.check(z.minLength(schema.minItems));
-          }
-          if (typeof schema.maxItems === "number") {
-            zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
-          }
-        } else if (Array.isArray(items)) {
-          const tupleItems = items.map((item) => convertSchema(item, ctx));
-          const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
-          if (rest) {
-            zodSchema = z.tuple(tupleItems).rest(rest);
-          } else {
-            zodSchema = z.tuple(tupleItems);
-          }
-          if (typeof schema.minItems === "number") {
-            zodSchema = zodSchema.check(z.minLength(schema.minItems));
-          }
-          if (typeof schema.maxItems === "number") {
-            zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
-          }
-        } else if (items !== void 0) {
-          const element = convertSchema(items, ctx);
-          let arraySchema = z.array(element);
-          if (typeof schema.minItems === "number") {
-            arraySchema = arraySchema.min(schema.minItems);
-          }
-          if (typeof schema.maxItems === "number") {
-            arraySchema = arraySchema.max(schema.maxItems);
-          }
-          zodSchema = arraySchema;
-        } else {
-          zodSchema = z.array(z.any());
-        }
-        break;
+      if (value instanceof Error) {
+        return { name: value.name, message: value.message, stack: value.stack };
       }
-      default:
-        throw new Error(`Unsupported type: ${type}`);
-    }
-    return zodSchema;
-  }
-  function convertSchema(schema, ctx) {
-    if (typeof schema === "boolean") {
-      return schema ? z.any() : z.never();
-    }
-    let baseSchema = convertBaseSchema(schema, ctx);
-    const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
-    if (schema.anyOf && Array.isArray(schema.anyOf)) {
-      const options = schema.anyOf.map((s) => convertSchema(s, ctx));
-      const anyOfUnion = z.union(options);
-      baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
-    }
-    if (schema.oneOf && Array.isArray(schema.oneOf)) {
-      const options = schema.oneOf.map((s) => convertSchema(s, ctx));
-      const oneOfUnion = z.xor(options);
-      baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
-    }
-    if (schema.allOf && Array.isArray(schema.allOf)) {
-      if (schema.allOf.length === 0) {
-        baseSchema = hasExplicitType ? baseSchema : z.any();
-      } else {
-        let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
-        const startIdx = hasExplicitType ? 0 : 1;
-        for (let i = startIdx; i < schema.allOf.length; i++) {
-          result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
+      if (value instanceof WeakRef)
+        return "[WeakRef]";
+      if (value instanceof WeakMap)
+        return "[WeakMap]";
+      if (value instanceof WeakSet)
+        return "[WeakSet]";
+      if (value instanceof ArrayBuffer)
+        return "[ArrayBuffer]";
+      if (typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer)
+        return "[SharedArrayBuffer]";
+      try {
+        const seen = /* @__PURE__ */ new WeakSet();
+        const json2 = JSON.stringify(value, (_key, v) => {
+          if (typeof v === "object" && v !== null) {
+            if (seen.has(v))
+              return "[Circular]";
+            seen.add(v);
+          }
+          if (typeof v === "function")
+            return `[Function: ${v.name || "anonymous"}]`;
+          if (typeof v === "bigint")
+            return `[BigInt: ${v.toString()}]`;
+          if (typeof v === "symbol")
+            return `[Symbol: ${v.description ?? ""}]`;
+          if (v instanceof WeakRef)
+            return "[WeakRef]";
+          if (v instanceof WeakMap)
+            return "[WeakMap]";
+          if (v instanceof WeakSet)
+            return "[WeakSet]";
+          if (v instanceof ArrayBuffer)
+            return "[ArrayBuffer]";
+          if (typeof SharedArrayBuffer !== "undefined" && v instanceof SharedArrayBuffer)
+            return "[SharedArrayBuffer]";
+          return v;
+        });
+        if (json2.length > MAX_SERIALIZED_SIZE) {
+          return `[Object truncated: ${json2.length} chars]`;
         }
-        baseSchema = result;
+        return JSON.parse(json2);
+      } catch {
+        return `[Unserializable: ${typeof value}]`;
       }
+    } catch {
+      return `[Unserializable: ${typeof value}]`;
     }
-    if (schema.nullable === true && ctx.version === "openapi-3.0") {
-      baseSchema = z.nullable(baseSchema);
-    }
-    if (schema.readOnly === true) {
-      baseSchema = z.readonly(baseSchema);
-    }
-    if (schema.default !== void 0) {
-      baseSchema = baseSchema.default(schema.default);
-    }
-    const extraMeta = {};
-    const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
-    for (const key of coreMetadataKeys) {
-      if (key in schema) {
-        extraMeta[key] = schema[key];
+  };
+  var safeSerialize = (args) => {
+    const capped = args.length > MAX_DATA_LENGTH ? args.slice(0, MAX_DATA_LENGTH) : args;
+    return capped.map(safeSerializeArg);
+  };
+  var CONSOLE_METHODS = {
+    debug: "debug",
+    info: "info",
+    warning: "warn",
+    error: "error"
+  };
+  var defaultTransport = (entry) => {
+    const method = CONSOLE_METHODS[entry.level];
+    console[method](`[sdk.log] ${entry.message}`, ...entry.data);
+  };
+  var activeTransport = defaultTransport;
+  var _setLogTransport = (transport) => {
+    const previous = activeTransport;
+    activeTransport = transport;
+    return () => {
+      if (activeTransport === transport)
+        activeTransport = previous;
+    };
+  };
+  var makeLogMethod = (level) => (message, ...args) => {
+    const entry = {
+      level,
+      message,
+      data: safeSerialize(args),
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    activeTransport(entry);
+  };
+  var log = Object.freeze({
+    debug: makeLogMethod("debug"),
+    info: makeLogMethod("info"),
+    warn: makeLogMethod("warning"),
+    error: makeLogMethod("error")
+  });
+  var ot = globalThis.__openTabs ?? {};
+  globalThis.__openTabs = ot;
+  ot._setLogTransport = _setLogTransport;
+  ot.log = log;
+
+  // node_modules/@opentabs-dev/plugin-sdk/dist/storage.js
+  var withIframeFallback = (fn) => {
+    try {
+      const iframe = document.createElement("iframe");
+      iframe.style.display = "none";
+      document.body.appendChild(iframe);
+      try {
+        const iframeStorage = iframe.contentWindow?.localStorage;
+        return iframeStorage ? fn(iframeStorage) : null;
+      } finally {
+        document.body.removeChild(iframe);
       }
+    } catch {
+      return null;
     }
-    const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
-    for (const key of contentMetadataKeys) {
-      if (key in schema) {
-        extraMeta[key] = schema[key];
-      }
+  };
+  var getWindowLocalStorage = () => window.localStorage;
+  var getLocalStorage = (key) => {
+    let storage;
+    try {
+      storage = getWindowLocalStorage();
+    } catch {
+      return null;
     }
-    for (const key of Object.keys(schema)) {
-      if (!RECOGNIZED_KEYS.has(key)) {
-        extraMeta[key] = schema[key];
+    if (storage) {
+      try {
+        return storage.getItem(key);
+      } catch {
+        return null;
       }
     }
-    if (Object.keys(extraMeta).length > 0) {
-      ctx.registry.add(baseSchema, extraMeta);
-    }
-    if (schema.description) {
-      baseSchema = baseSchema.describe(schema.description);
+    return withIframeFallback((s) => s.getItem(key));
+  };
+  var getAuthCache = (namespace) => {
+    try {
+      const ns = globalThis.__openTabs;
+      const cache = ns?.tokenCache;
+      return cache?.[namespace] ?? null;
+    } catch {
+      return null;
     }
-    return baseSchema;
-  }
-  function fromJSONSchema(schema, params) {
-    if (typeof schema === "boolean") {
-      return schema ? z.any() : z.never();
+  };
+  var setAuthCache = (namespace, value) => {
+    try {
+      const g = globalThis;
+      if (!g.__openTabs)
+        g.__openTabs = {};
+      const ns = g.__openTabs;
+      if (!ns.tokenCache)
+        ns.tokenCache = {};
+      ns.tokenCache[namespace] = value;
+    } catch {
     }
-    let normalized;
+  };
+  var clearAuthCache = (namespace) => {
     try {
-      normalized = JSON.parse(JSON.stringify(schema));
+      const ns = globalThis.__openTabs;
+      const cache = ns?.tokenCache;
+      if (cache)
+        cache[namespace] = void 0;
     } catch {
-      throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
     }
-    const version2 = detectVersion(normalized, params?.defaultTarget);
-    const defs = normalized.$defs || normalized.definitions || {};
-    const ctx = {
-      version: version2,
-      defs,
-      refs: /* @__PURE__ */ new Map(),
-      processing: /* @__PURE__ */ new Set(),
-      rootSchema: normalized,
-      registry: params?.registry ?? globalRegistry
-    };
-    return convertSchema(normalized, ctx);
-  }
+  };
 
-  // node_modules/zod/v4/classic/coerce.js
-  var coerce_exports = {};
-  __export(coerce_exports, {
-    bigint: () => bigint3,
-    boolean: () => boolean3,
-    date: () => date4,
-    number: () => number3,
-    string: () => string3
-  });
-  function string3(params) {
-    return _coercedString(ZodString, params);
-  }
-  function number3(params) {
-    return _coercedNumber(ZodNumber, params);
-  }
-  function boolean3(params) {
-    return _coercedBoolean(ZodBoolean, params);
-  }
-  function bigint3(params) {
-    return _coercedBigint(ZodBigInt, params);
-  }
-  function date4(params) {
-    return _coercedDate(ZodDate, params);
-  }
+  // node_modules/@opentabs-dev/plugin-sdk/dist/index.js
+  var defineTool = (config2) => config2;
+  var OpenTabsPlugin = class {
+    /**
+     * Chrome match patterns for URLs that should NOT match this plugin.
+     * Tabs matching both urlPatterns and excludePatterns are excluded.
+     * Useful when a broad urlPattern overlaps with another plugin's domain.
+     * @see https://developer.chrome.com/docs/extensions/develop/concepts/match-patterns
+     */
+    excludePatterns;
+    /**
+     * URL to open when no matching tab exists and the user triggers an
+     * 'open tab' action from the side panel. Should be a concrete URL
+     * (e.g., 'https://github.com'), not a match pattern.
+     */
+    homepage;
+    /** Typed configuration schema — declares settings that users provide via config.json or the side panel. */
+    configSchema;
+  };
 
-  // node_modules/zod/v4/classic/external.js
-  config(en_default());
+  // src/hack2hire-api.ts
+  var API_BASE = "https://api.hack2hire.com/algro/v1";
+  var readJsonString = (key) => {
+    const raw = getLocalStorage(key);
+    if (!raw) return null;
+    try {
+      const parsed = JSON.parse(raw);
+      return typeof parsed === "string" && parsed.length > 0 ? parsed : null;
+    } catch {
+      return null;
+    }
+  };
+  var getAuth = () => {
+    const cached2 = getAuthCache("hack2hire");
+    if (cached2?.token && cached2?.userId) return cached2;
+    const token = readJsonString("ALGRO_TOKEN");
+    const userId = readJsonString("USER_ID");
+    if (!token || !userId) return null;
+    const auth = { token, userId };
+    setAuthCache("hack2hire", auth);
+    return auth;
+  };
+  var isAuthenticated = () => getAuth() !== null;
+  var waitForAuth = () => waitUntil(() => isAuthenticated(), { interval: 500, timeout: 5e3 }).then(
+    () => true,
+    () => false
+  );
+  var api = async (endpoint, query) => {
+    const auth = getAuth();
+    if (!auth) throw ToolError.auth("Not authenticated \u2014 please log in to Hack2Hire.");
+    const qs = query ? buildQueryString(query) : "";
+    const url2 = qs ? `${API_BASE}${endpoint}?${qs}` : `${API_BASE}${endpoint}`;
+    let response;
+    try {
+      response = await fetchFromPage(url2, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${auth.token}`,
+          "x-user-id": auth.userId,
+          Accept: "application/json"
+        },
+        credentials: "omit"
+      });
+    } catch (err2) {
+      if (err2 instanceof ToolError) {
+        if (err2.category === "auth") clearAuthCache("hack2hire");
+        throw err2;
+      }
+      throw ToolError.internal(`Network error: ${err2 instanceof Error ? err2.message : String(err2)}`);
+    }
+    const envelope = await response.json();
+    return envelope.data;
+  };
 
   // src/tools/get-completed-question-count.ts
   var getCompletedQuestionCount = defineTool({
@@ -15642,7 +15642,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   };
   var src_default = new Hack2HirePlugin();
 
-  // dist/_adapter_entry_18289137-327a-4604-bd70-733b1f86a202.ts
+  // dist/_adapter_entry_e151ae7e-aae4-433e-848f-0c258f7a3ea7.ts
+  external_exports.config({ jitless: true });
   if (!globalThis.__openTabs) {
     globalThis.__openTabs = {};
   } else {
@@ -15860,5 +15861,5 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     };
     delete src_default.onDeactivate;
   }
-})();(function(){var o=(globalThis).__openTabs;if(o&&o.adapters&&o.adapters["hack2hire"]){var a=o.adapters["hack2hire"];a.__adapterHash="2840aa78cf5fae8f2d475b0ed8d9d6a03e0fee6b59e9726d75b9f28623222eb3";if(a.tools&&Array.isArray(a.tools)){for(var i=0;i<a.tools.length;i++){Object.freeze(a.tools[i]);}Object.freeze(a.tools);}Object.freeze(a);Object.defineProperty(o.adapters,"hack2hire",{value:a,writable:false,configurable:false,enumerable:true});Object.defineProperty(o,"adapters",{value:o.adapters,writable:false,configurable:false});}})();
+})();(function(){var o=(globalThis).__openTabs;if(o&&o.adapters&&o.adapters["hack2hire"]){var a=o.adapters["hack2hire"];a.__adapterHash="8bbf9de6b715710a4dcc9208636595e4ed34f390f61f05e1966e46eec37f9fae";if(a.tools&&Array.isArray(a.tools)){for(var i=0;i<a.tools.length;i++){Object.freeze(a.tools[i]);}Object.freeze(a.tools);}Object.freeze(a);Object.defineProperty(o.adapters,"hack2hire",{value:a,writable:false,configurable:false,enumerable:true});Object.defineProperty(o,"adapters",{value:o.adapters,writable:false,configurable:false});}})();
 //# sourceMappingURL=adapter.iife.js.map