@opentabs-dev/opentabs-plugin-priceline 0.0.83 → 0.0.85

package/dist/adapter.iife.js

@@ -74,9 +74,11 @@
       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: true, retryAfterMs });
+      return new ToolError(message, "http_error", { category: "internal", retryable, retryAfterMs });
     }
     if (status >= 400 && status < 500) {
       return new ToolError(message, "http_error", { retryable: false });
@@ -121,14 +123,14 @@
         ...rest2,
         signal: combinedSignal
       });
-    } catch (error48) {
-      if (error48 instanceof DOMException && error48.name === "TimeoutError") {
+    } 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(error48)}`, "network_error", {
+      throw new ToolError(`fetchFromPage: network error for ${url2}: ${toErrorMessage(error51)}`, "network_error", {
         category: "internal",
         retryable: true
       });
@@ -178,6 +180,7 @@
     return new Promise((resolve, reject) => {
       let settled = false;
       let poller;
+      let lastPredicateError;
       const isSettled = () => settled;
       const cleanup = () => {
         settled = true;
@@ -196,7 +199,8 @@
         if (isSettled())
           return;
         cleanup();
-        reject(new Error(`waitUntil: timed out after ${timeout}ms waiting for predicate to return true`));
+        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())
@@ -208,7 +212,8 @@
             resolve();
             return;
           }
-        } catch {
+        } catch (err2) {
+          lastPredicateError = err2;
         }
         if (!isSettled()) {
           poller = setTimeout(() => void check2(), interval);
@@ -451,7 +456,9 @@
 
   // src/priceline-api.ts
   var GRAPH_BASE = "https://www.priceline.com/pws/v0/pcln-graph/?gqlOp=";
+  var FLY_GRAPH_URL = "https://www.priceline.com/pws/v0/fly/graph/query";
   var REST_BASE = "https://www.priceline.com/pws/v0";
+  var AC_BASE = "https://www.priceline.com/svcs/ac/index";
   var decodeJwtPayload = (jwt2) => {
     try {
       const parts = jwt2.split(".");
@@ -507,17 +514,20 @@
   var getEmail = () => requireAuth().email;
   var getCguid = () => requireAuth().cguid;
   var getAuthToken = () => requireAuth().authToken;
-  var graphql = async (operationName, variables, persistedHash) => {
+  var graphql = async (operationName, variables, queryOrPersistedHash) => {
     const auth = requireAuth();
     const url2 = `${GRAPH_BASE}${operationName}`;
     const reqBody = {
       operationName,
       variables
     };
-    if (persistedHash) {
+    const isPersistedHash = typeof queryOrPersistedHash === "string" && /^[a-f0-9]{64}$/.test(queryOrPersistedHash);
+    if (queryOrPersistedHash && isPersistedHash) {
       reqBody.extensions = {
-        persistedQuery: { version: 1, sha256Hash: persistedHash }
+        persistedQuery: { version: 1, sha256Hash: queryOrPersistedHash }
       };
+    } else if (queryOrPersistedHash) {
+      reqBody.query = queryOrPersistedHash;
     }
     const headers = {
       "Content-Type": "application/json",
@@ -558,6 +568,33 @@
     if (data === void 0) throw ToolError.internal(`Empty response from ${endpoint}`);
     return data;
   };
+  var autocomplete = async (product, query) => {
+    const encoded = encodeURIComponent(query);
+    const url2 = `${AC_BASE}/${product}/${encoded}/0/9/0/0`;
+    const data = await fetchJSON(url2);
+    return data?.searchItems ?? [];
+  };
+  var flyGraphql = async (operationName, variables, query) => {
+    const headers = {
+      "Content-Type": "application/json",
+      "apollographql-client-name": "m-fly-search",
+      "apollographql-client-version": "main-0.0.19"
+    };
+    const resp = await fetchJSON(FLY_GRAPH_URL, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ operationName, variables, query })
+    }) ?? {};
+    const errors = resp.errors ?? [];
+    if (errors.length > 0 && !resp.data) {
+      const first = errors[0] ?? {};
+      const code = first.extensions?.code ?? "";
+      const message = first.message ?? "Unknown GraphQL error";
+      if (code === "UNAUTHENTICATED") throw ToolError.auth(`Auth error: ${message}`);
+      throw ToolError.internal(`GraphQL error (${operationName}): ${message}`);
+    }
+    return resp.data ?? {};
+  };
 
   // node_modules/zod/v4/classic/external.js
   var external_exports = {};
@@ -699,6 +736,7 @@
     int32: () => int32,
     int64: () => int64,
     intersection: () => intersection,
+    invertCodec: () => invertCodec,
     ipv4: () => ipv42,
     ipv6: () => ipv62,
     iso: () => iso_exports,
@@ -1079,7 +1117,8 @@
   });
 
   // node_modules/zod/v4/core/core.js
-  var NEVER = Object.freeze({
+  var _a;
+  var NEVER = /* @__PURE__ */ Object.freeze({
     status: "aborted"
   });
   // @__NO_SIDE_EFFECTS__
@@ -1114,10 +1153,10 @@
     }
     Object.defineProperty(Definition, "name", { value: name });
     function _(def) {
-      var _a2;
+      var _a3;
       const inst = params?.Parent ? new Definition() : this;
       init(inst, def);
-      (_a2 = inst._zod).deferred ?? (_a2.deferred = []);
+      (_a3 = inst._zod).deferred ?? (_a3.deferred = []);
       for (const fn of inst._zod.deferred) {
         fn();
       }
@@ -1146,7 +1185,8 @@
       this.name = "ZodEncodeError";
     }
   };
-  var globalConfig = {};
+  (_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});
+  var globalConfig = globalThis.__zod_globalConfig;
   function config(newConfig) {
     if (newConfig)
       Object.assign(globalConfig, newConfig);
@@ -1179,6 +1219,7 @@
     defineLazy: () => defineLazy,
     esc: () => esc,
     escapeRegex: () => escapeRegex,
+    explicitlyAborted: () => explicitlyAborted,
     extend: () => extend,
     finalizeIssue: () => finalizeIssue,
     floatSafeRemainder: () => floatSafeRemainder,
@@ -1267,19 +1308,12 @@
     return source.slice(start, end);
   }
   function floatSafeRemainder(val, step) {
-    const valDecCount = (val.toString().split(".")[1] || "").length;
-    const stepString = step.toString();
-    let stepDecCount = (stepString.split(".")[1] || "").length;
-    if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
-      const match = stepString.match(/\d?e-(\d?)/);
-      if (match?.[1]) {
-        stepDecCount = Number.parseInt(match[1]);
-      }
-    }
-    const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
-    const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
-    const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
-    return valInt % stepInt / 10 ** decCount;
+    const ratio = val / step;
+    const roundedRatio = Math.round(ratio);
+    const tolerance = Number.EPSILON * Math.max(Math.abs(ratio), 1);
+    if (Math.abs(ratio - roundedRatio) < tolerance)
+      return 0;
+    return ratio - roundedRatio;
   }
   var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
   function defineLazy(object2, key, getter) {
@@ -1361,7 +1395,10 @@
   function isObject(data) {
     return typeof data === "object" && data !== null && !Array.isArray(data);
   }
-  var allowsEval = cached(() => {
+  var allowsEval = /* @__PURE__ */ cached(() => {
+    if (globalConfig.jitless) {
+      return false;
+    }
     if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
       return false;
     }
@@ -1394,6 +1431,10 @@
       return { ...o };
     if (Array.isArray(o))
       return [...o];
+    if (o instanceof Map)
+      return new Map(o);
+    if (o instanceof Set)
+      return new Set(o);
     return o;
   }
   function numKeys(data) {
@@ -1450,7 +1491,14 @@
     }
   };
   var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
-  var primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
+  var primitiveTypes = /* @__PURE__ */ new Set([
+    "string",
+    "number",
+    "bigint",
+    "boolean",
+    "symbol",
+    "undefined"
+  ]);
   function escapeRegex(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   }
@@ -1619,6 +1667,9 @@
     return clone(schema, def);
   }
   function merge(a, b) {
+    if (a._zod.def.checks?.length) {
+      throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
+    }
     const def = mergeDefs(a._zod.def, {
       get shape() {
         const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
@@ -1628,8 +1679,7 @@
       get catchall() {
         return b._zod.def.catchall;
       },
-      checks: []
-      // delete existing checks
+      checks: b._zod.def.checks ?? []
     });
     return clone(a, def);
   }
@@ -1712,10 +1762,20 @@
     }
     return false;
   }
+  function explicitlyAborted(x, startIndex = 0) {
+    if (x.aborted === true)
+      return true;
+    for (let i = startIndex; i < x.issues.length; i++) {
+      if (x.issues[i]?.continue === false) {
+        return true;
+      }
+    }
+    return false;
+  }
   function prefixIssues(path, issues) {
     return issues.map((iss) => {
-      var _a2;
-      (_a2 = iss).path ?? (_a2.path = []);
+      var _a3;
+      (_a3 = iss).path ?? (_a3.path = []);
       iss.path.unshift(path);
       return iss;
     });
@@ -1724,17 +1784,14 @@
     return typeof message === "string" ? message : message?.message;
   }
   function finalizeIssue(iss, ctx, config2) {
-    const full = { ...iss, path: iss.path ?? [] };
-    if (!iss.message) {
-      const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
-      full.message = message;
+    const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
+    const { inst: _inst, continue: _continue, input: _input, ...rest2 } = iss;
+    rest2.path ?? (rest2.path = []);
+    rest2.message = message;
+    if (ctx?.reportInput) {
+      rest2.input = _input;
     }
-    delete full.inst;
-    delete full.continue;
-    if (!ctx?.reportInput) {
-      delete full.input;
-    }
-    return full;
+    return rest2;
   }
   function getSizableOrigin(input) {
     if (input instanceof Set)
@@ -1851,10 +1908,10 @@
   };
   var $ZodError = $constructor("$ZodError", initializer);
   var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
-  function flattenError(error48, mapper = (issue2) => issue2.message) {
+  function flattenError(error51, mapper = (issue2) => issue2.message) {
     const fieldErrors = {};
     const formErrors = [];
-    for (const sub of error48.issues) {
+    for (const sub of error51.issues) {
       if (sub.path.length > 0) {
         fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
         fieldErrors[sub.path[0]].push(mapper(sub));
@@ -1864,50 +1921,53 @@
     }
     return { formErrors, fieldErrors };
   }
-  function formatError(error48, mapper = (issue2) => issue2.message) {
+  function formatError(error51, mapper = (issue2) => issue2.message) {
     const fieldErrors = { _errors: [] };
-    const processError = (error49) => {
-      for (const issue2 of error49.issues) {
+    const processError = (error52, path = []) => {
+      for (const issue2 of error52.issues) {
         if (issue2.code === "invalid_union" && issue2.errors.length) {
-          issue2.errors.map((issues) => processError({ issues }));
+          issue2.errors.map((issues) => processError({ issues }, [...path, ...issue2.path]));
         } else if (issue2.code === "invalid_key") {
-          processError({ issues: issue2.issues });
+          processError({ issues: issue2.issues }, [...path, ...issue2.path]);
         } else if (issue2.code === "invalid_element") {
-          processError({ issues: issue2.issues });
-        } else if (issue2.path.length === 0) {
-          fieldErrors._errors.push(mapper(issue2));
+          processError({ issues: issue2.issues }, [...path, ...issue2.path]);
         } else {
-          let curr = fieldErrors;
-          let i = 0;
-          while (i < issue2.path.length) {
-            const el = issue2.path[i];
-            const terminal = i === issue2.path.length - 1;
-            if (!terminal) {
-              curr[el] = curr[el] || { _errors: [] };
-            } else {
-              curr[el] = curr[el] || { _errors: [] };
-              curr[el]._errors.push(mapper(issue2));
+          const fullpath = [...path, ...issue2.path];
+          if (fullpath.length === 0) {
+            fieldErrors._errors.push(mapper(issue2));
+          } else {
+            let curr = fieldErrors;
+            let i = 0;
+            while (i < fullpath.length) {
+              const el = fullpath[i];
+              const terminal = i === fullpath.length - 1;
+              if (!terminal) {
+                curr[el] = curr[el] || { _errors: [] };
+              } else {
+                curr[el] = curr[el] || { _errors: [] };
+                curr[el]._errors.push(mapper(issue2));
+              }
+              curr = curr[el];
+              i++;
             }
-            curr = curr[el];
-            i++;
           }
         }
       }
     };
-    processError(error48);
+    processError(error51);
     return fieldErrors;
   }
-  function treeifyError(error48, mapper = (issue2) => issue2.message) {
+  function treeifyError(error51, mapper = (issue2) => issue2.message) {
     const result = { errors: [] };
-    const processError = (error49, path = []) => {
-      var _a2, _b;
-      for (const issue2 of error49.issues) {
+    const processError = (error52, path = []) => {
+      var _a3, _b;
+      for (const issue2 of error52.issues) {
         if (issue2.code === "invalid_union" && issue2.errors.length) {
-          issue2.errors.map((issues) => processError({ issues }, issue2.path));
+          issue2.errors.map((issues) => processError({ issues }, [...path, ...issue2.path]));
         } else if (issue2.code === "invalid_key") {
-          processError({ issues: issue2.issues }, issue2.path);
+          processError({ issues: issue2.issues }, [...path, ...issue2.path]);
         } else if (issue2.code === "invalid_element") {
-          processError({ issues: issue2.issues }, issue2.path);
+          processError({ issues: issue2.issues }, [...path, ...issue2.path]);
         } else {
           const fullpath = [...path, ...issue2.path];
           if (fullpath.length === 0) {
@@ -1921,7 +1981,7 @@
             const terminal = i === fullpath.length - 1;
             if (typeof el === "string") {
               curr.properties ?? (curr.properties = {});
-              (_a2 = curr.properties)[el] ?? (_a2[el] = { errors: [] });
+              (_a3 = curr.properties)[el] ?? (_a3[el] = { errors: [] });
               curr = curr.properties[el];
             } else {
               curr.items ?? (curr.items = []);
@@ -1936,7 +1996,7 @@
         }
       }
     };
-    processError(error48);
+    processError(error51);
     return result;
   }
   function toDotPath(_path) {
@@ -1957,9 +2017,9 @@
     }
     return segs.join("");
   }
-  function prettifyError(error48) {
+  function prettifyError(error51) {
     const lines = [];
-    const issues = [...error48.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
+    const issues = [...error51.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
     for (const issue2 of issues) {
       lines.push(`\u2716 ${issue2.message}`);
       if (issue2.path?.length)
@@ -1970,7 +2030,7 @@
 
   // node_modules/zod/v4/core/parse.js
   var _parse = (_Err) => (schema, value, _ctx, _params) => {
-    const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
+    const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
     const result = schema._zod.run({ value, issues: [] }, ctx);
     if (result instanceof Promise) {
       throw new $ZodAsyncError();
@@ -1984,7 +2044,7 @@
   };
   var parse = /* @__PURE__ */ _parse($ZodRealError);
   var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
-    const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+    const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
     let result = schema._zod.run({ value, issues: [] }, ctx);
     if (result instanceof Promise)
       result = await result;
@@ -2009,7 +2069,7 @@
   };
   var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
   var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
-    const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+    const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
     let result = schema._zod.run({ value, issues: [] }, ctx);
     if (result instanceof Promise)
       result = await result;
@@ -2020,7 +2080,7 @@
   };
   var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
   var _encode = (_Err) => (schema, value, _ctx) => {
-    const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
     return _parse(_Err)(schema, value, ctx);
   };
   var encode = /* @__PURE__ */ _encode($ZodRealError);
@@ -2029,7 +2089,7 @@
   };
   var decode = /* @__PURE__ */ _decode($ZodRealError);
   var _encodeAsync = (_Err) => async (schema, value, _ctx) => {
-    const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
     return _parseAsync(_Err)(schema, value, ctx);
   };
   var encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
@@ -2038,7 +2098,7 @@
   };
   var decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
   var _safeEncode = (_Err) => (schema, value, _ctx) => {
-    const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
     return _safeParse(_Err)(schema, value, ctx);
   };
   var safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError);
@@ -2047,7 +2107,7 @@
   };
   var safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError);
   var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
-    const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
     return _safeParseAsync(_Err)(schema, value, ctx);
   };
   var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);
@@ -2080,6 +2140,7 @@
     hex: () => hex,
     hostname: () => hostname,
     html5Email: () => html5Email,
+    httpProtocol: () => httpProtocol,
     idnEmail: () => idnEmail,
     integer: () => integer,
     ipv4: () => ipv4,
@@ -2118,7 +2179,7 @@
     uuid7: () => uuid7,
     xid: () => xid
   });
-  var cuid = /^[cC][^\s-]{8,}$/;
+  var cuid = /^[cC][0-9a-z]{6,}$/;
   var cuid2 = /^[0-9a-z]+$/;
   var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
   var xid = /^[0-9a-vA-V]{20}$/;
@@ -2157,6 +2218,7 @@
   var base64url = /^[A-Za-z0-9_-]*$/;
   var hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
   var domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
+  var httpProtocol = /^https?$/;
   var e164 = /^\+[1-9]\d{6,14}$/;
   var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
   var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
@@ -2215,10 +2277,10 @@
 
   // node_modules/zod/v4/core/checks.js
   var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
-    var _a2;
+    var _a3;
     inst._zod ?? (inst._zod = {});
     inst._zod.def = def;
-    (_a2 = inst._zod).onattach ?? (_a2.onattach = []);
+    (_a3 = inst._zod).onattach ?? (_a3.onattach = []);
   });
   var numericOriginMap = {
     number: "number",
@@ -2284,8 +2346,8 @@
   var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
     $ZodCheck.init(inst, def);
     inst._zod.onattach.push((inst2) => {
-      var _a2;
-      (_a2 = inst2._zod.bag).multipleOf ?? (_a2.multipleOf = def.value);
+      var _a3;
+      (_a3 = inst2._zod.bag).multipleOf ?? (_a3.multipleOf = def.value);
     });
     inst._zod.check = (payload) => {
       if (typeof payload.value !== typeof def.value)
@@ -2418,9 +2480,9 @@
     };
   });
   var $ZodCheckMaxSize = /* @__PURE__ */ $constructor("$ZodCheckMaxSize", (inst, def) => {
-    var _a2;
+    var _a3;
     $ZodCheck.init(inst, def);
-    (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
+    (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
       const val = payload.value;
       return !nullish(val) && val.size !== void 0;
     });
@@ -2446,9 +2508,9 @@
     };
   });
   var $ZodCheckMinSize = /* @__PURE__ */ $constructor("$ZodCheckMinSize", (inst, def) => {
-    var _a2;
+    var _a3;
     $ZodCheck.init(inst, def);
-    (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
+    (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
       const val = payload.value;
       return !nullish(val) && val.size !== void 0;
     });
@@ -2474,9 +2536,9 @@
     };
   });
   var $ZodCheckSizeEquals = /* @__PURE__ */ $constructor("$ZodCheckSizeEquals", (inst, def) => {
-    var _a2;
+    var _a3;
     $ZodCheck.init(inst, def);
-    (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
+    (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
       const val = payload.value;
       return !nullish(val) && val.size !== void 0;
     });
@@ -2504,9 +2566,9 @@
     };
   });
   var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
-    var _a2;
+    var _a3;
     $ZodCheck.init(inst, def);
-    (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
+    (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
       const val = payload.value;
       return !nullish(val) && val.length !== void 0;
     });
@@ -2533,9 +2595,9 @@
     };
   });
   var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
-    var _a2;
+    var _a3;
     $ZodCheck.init(inst, def);
-    (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
+    (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
       const val = payload.value;
       return !nullish(val) && val.length !== void 0;
     });
@@ -2562,9 +2624,9 @@
     };
   });
   var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
-    var _a2;
+    var _a3;
     $ZodCheck.init(inst, def);
-    (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
+    (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
       const val = payload.value;
       return !nullish(val) && val.length !== void 0;
     });
@@ -2593,7 +2655,7 @@
     };
   });
   var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
-    var _a2, _b;
+    var _a3, _b;
     $ZodCheck.init(inst, def);
     inst._zod.onattach.push((inst2) => {
       const bag = inst2._zod.bag;
@@ -2604,7 +2666,7 @@
       }
     });
     if (def.pattern)
-      (_a2 = inst._zod).check ?? (_a2.check = (payload) => {
+      (_a3 = inst._zod).check ?? (_a3.check = (payload) => {
         def.pattern.lastIndex = 0;
         if (def.pattern.test(payload.value))
           return;
@@ -2800,13 +2862,13 @@
   // node_modules/zod/v4/core/versions.js
   var version = {
     major: 4,
-    minor: 3,
-    patch: 6
+    minor: 4,
+    patch: 1
   };
 
   // node_modules/zod/v4/core/schemas.js
   var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
-    var _a2;
+    var _a3;
     inst ?? (inst = {});
     inst._zod.def = def;
     inst._zod.bag = inst._zod.bag || {};
@@ -2821,7 +2883,7 @@
       }
     }
     if (checks.length === 0) {
-      (_a2 = inst._zod).deferred ?? (_a2.deferred = []);
+      (_a3 = inst._zod).deferred ?? (_a3.deferred = []);
       inst._zod.deferred?.push(() => {
         inst._zod.run = inst._zod.parse;
       });
@@ -2831,6 +2893,8 @@
         let asyncResult;
         for (const ch of checks2) {
           if (ch._zod.def.when) {
+            if (explicitlyAborted(payload))
+              continue;
             const shouldRun = ch._zod.def.when(payload);
             if (!shouldRun)
               continue;
@@ -2971,6 +3035,19 @@
     inst._zod.check = (payload) => {
       try {
         const trimmed = payload.value.trim();
+        if (!def.normalize && def.protocol?.source === httpProtocol.source) {
+          if (!/^https?:\/\//i.test(trimmed)) {
+            payload.issues.push({
+              code: "invalid_format",
+              format: "url",
+              note: "Invalid URL format",
+              input: payload.value,
+              inst,
+              continue: !def.abort
+            });
+            return;
+          }
+        }
         const url2 = new URL(trimmed);
         if (def.hostname) {
           def.hostname.lastIndex = 0;
@@ -3124,6 +3201,8 @@
   function isValidBase64(data) {
     if (data === "")
       return true;
+    if (/\s/.test(data))
+      return false;
     if (data.length % 4 !== 0)
       return false;
     try {
@@ -3316,8 +3395,6 @@
     $ZodType.init(inst, def);
     inst._zod.pattern = _undefined;
     inst._zod.values = /* @__PURE__ */ new Set([void 0]);
-    inst._zod.optin = "optional";
-    inst._zod.optout = "optional";
     inst._zod.parse = (payload, _ctx) => {
       const input = payload.value;
       if (typeof input === "undefined")
@@ -3446,15 +3523,27 @@
       return payload;
     };
   });
-  function handlePropertyResult(result, final, key, input, isOptionalOut) {
+  function handlePropertyResult(result, final, key, input, isOptionalIn, isOptionalOut) {
+    const isPresent = key in input;
     if (result.issues.length) {
-      if (isOptionalOut && !(key in input)) {
+      if (isOptionalIn && isOptionalOut && !isPresent) {
         return;
       }
       final.issues.push(...prefixIssues(key, result.issues));
     }
+    if (!isPresent && !isOptionalIn) {
+      if (!result.issues.length) {
+        final.issues.push({
+          code: "invalid_type",
+          expected: "nonoptional",
+          input: void 0,
+          path: [key]
+        });
+      }
+      return;
+    }
     if (result.value === void 0) {
-      if (key in input) {
+      if (isPresent) {
         final.value[key] = void 0;
       }
     } else {
@@ -3482,8 +3571,11 @@
     const keySet = def.keySet;
     const _catchall = def.catchall._zod;
     const t = _catchall.def.type;
+    const isOptionalIn = _catchall.optin === "optional";
     const isOptionalOut = _catchall.optout === "optional";
     for (const key in input) {
+      if (key === "__proto__")
+        continue;
       if (keySet.has(key))
         continue;
       if (t === "never") {
@@ -3492,9 +3584,9 @@
       }
       const r = _catchall.run({ value: input[key], issues: [] }, ctx);
       if (r instanceof Promise) {
-        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
+        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut)));
       } else {
-        handlePropertyResult(r, payload, key, input, isOptionalOut);
+        handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
       }
     }
     if (unrecognized.length) {
@@ -3560,12 +3652,13 @@
       const shape = value.shape;
       for (const key of value.keys) {
         const el = shape[key];
+        const isOptionalIn = el._zod.optin === "optional";
         const isOptionalOut = el._zod.optout === "optional";
         const r = el._zod.run({ value: input[key], issues: [] }, ctx);
         if (r instanceof Promise) {
-          proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
+          proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut)));
         } else {
-          handlePropertyResult(r, payload, key, input, isOptionalOut);
+          handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
         }
       }
       if (!catchall) {
@@ -3596,9 +3689,10 @@
         const id = ids[key];
         const k = esc(key);
         const schema = shape[key];
+        const isOptionalIn = schema?._zod?.optin === "optional";
         const isOptionalOut = schema?._zod?.optout === "optional";
         doc.write(`const ${id} = ${parseStr(key)};`);
-        if (isOptionalOut) {
+        if (isOptionalIn && isOptionalOut) {
           doc.write(`
         if (${id}.issues.length) {
           if (${k} in input) {
@@ -3617,6 +3711,33 @@
           newResult[${k}] = ${id}.value;
         }
         
+      `);
+        } else if (!isOptionalIn) {
+          doc.write(`
+        const ${id}_present = ${k} in input;
+        if (${id}.issues.length) {
+          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${k}, ...iss.path] : [${k}]
+          })));
+        }
+        if (!${id}_present && !${id}.issues.length) {
+          payload.issues.push({
+            code: "invalid_type",
+            expected: "nonoptional",
+            input: undefined,
+            path: [${k}]
+          });
+        }
+
+        if (${id}_present) {
+          if (${id}.value === undefined) {
+            newResult[${k}] = undefined;
+          } else {
+            newResult[${k}] = ${id}.value;
+          }
+        }
+
       `);
         } else {
           doc.write(`
@@ -3710,10 +3831,9 @@
       }
       return void 0;
     });
-    const single = def.options.length === 1;
-    const first = def.options[0]._zod.run;
+    const first = def.options.length === 1 ? def.options[0]._zod.run : null;
     inst._zod.parse = (payload, ctx) => {
-      if (single) {
+      if (first) {
         return first(payload, ctx);
       }
       let async = false;
@@ -3766,10 +3886,9 @@
   var $ZodXor = /* @__PURE__ */ $constructor("$ZodXor", (inst, def) => {
     $ZodUnion.init(inst, def);
     def.inclusive = false;
-    const single = def.options.length === 1;
-    const first = def.options[0]._zod.run;
+    const first = def.options.length === 1 ? def.options[0]._zod.run : null;
     inst._zod.parse = (payload, ctx) => {
-      if (single) {
+      if (first) {
         return first(payload, ctx);
       }
       let async = false;
@@ -3844,7 +3963,7 @@
       if (opt) {
         return opt._zod.run(payload, ctx);
       }
-      if (def.unionFallback) {
+      if (def.unionFallback || ctx.direction === "backward") {
         return _super(payload, ctx);
       }
       payload.issues.push({
@@ -3852,6 +3971,7 @@
         errors: [],
         note: "No matching discriminator",
         discriminator: def.discriminator,
+        options: Array.from(disc.value.keys()),
         input,
         path: [def.discriminator],
         inst
@@ -3973,64 +4093,96 @@
       }
       payload.value = [];
       const proms = [];
-      const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
-      const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex;
+      const optinStart = getTupleOptStart(items, "optin");
+      const optoutStart = getTupleOptStart(items, "optout");
       if (!def.rest) {
-        const tooBig = input.length > items.length;
-        const tooSmall = input.length < optStart - 1;
-        if (tooBig || tooSmall) {
+        if (input.length < optinStart) {
           payload.issues.push({
-            ...tooBig ? { code: "too_big", maximum: items.length, inclusive: true } : { code: "too_small", minimum: items.length },
+            code: "too_small",
+            minimum: optinStart,
+            inclusive: true,
             input,
             inst,
             origin: "array"
           });
           return payload;
         }
-      }
-      let i = -1;
-      for (const item of items) {
-        i++;
-        if (i >= input.length) {
-          if (i >= optStart)
-            continue;
+        if (input.length > items.length) {
+          payload.issues.push({
+            code: "too_big",
+            maximum: items.length,
+            inclusive: true,
+            input,
+            inst,
+            origin: "array"
+          });
         }
-        const result = item._zod.run({
-          value: input[i],
-          issues: []
-        }, ctx);
-        if (result instanceof Promise) {
-          proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
+      }
+      const itemResults = new Array(items.length);
+      for (let i = 0; i < items.length; i++) {
+        const r = items[i]._zod.run({ value: input[i], issues: [] }, ctx);
+        if (r instanceof Promise) {
+          proms.push(r.then((rr) => {
+            itemResults[i] = rr;
+          }));
         } else {
-          handleTupleResult(result, payload, i);
+          itemResults[i] = r;
         }
       }
       if (def.rest) {
+        let i = items.length - 1;
         const rest2 = input.slice(items.length);
         for (const el of rest2) {
           i++;
-          const result = def.rest._zod.run({
-            value: el,
-            issues: []
-          }, ctx);
+          const result = def.rest._zod.run({ value: el, issues: [] }, ctx);
           if (result instanceof Promise) {
-            proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
+            proms.push(result.then((r) => handleTupleResult(r, payload, i)));
           } else {
             handleTupleResult(result, payload, i);
           }
         }
       }
-      if (proms.length)
-        return Promise.all(proms).then(() => payload);
-      return payload;
+      if (proms.length) {
+        return Promise.all(proms).then(() => handleTupleResults(itemResults, payload, items, input, optoutStart));
+      }
+      return handleTupleResults(itemResults, payload, items, input, optoutStart);
     };
   });
+  function getTupleOptStart(items, key) {
+    for (let i = items.length - 1; i >= 0; i--) {
+      if (items[i]._zod[key] !== "optional")
+        return i + 1;
+    }
+    return 0;
+  }
   function handleTupleResult(result, final, index) {
     if (result.issues.length) {
       final.issues.push(...prefixIssues(index, result.issues));
     }
     final.value[index] = result.value;
   }
+  function handleTupleResults(itemResults, final, items, input, optoutStart) {
+    for (let i = 0; i < items.length; i++) {
+      const r = itemResults[i];
+      const isPresent = i < input.length;
+      if (r.issues.length) {
+        if (!isPresent && i >= optoutStart) {
+          final.value.length = i;
+          break;
+        }
+        final.issues.push(...prefixIssues(i, r.issues));
+      }
+      final.value[i] = r.value;
+    }
+    for (let i = final.value.length - 1; i >= input.length; i--) {
+      if (items[i]._zod.optout === "optional" && final.value[i] === void 0) {
+        final.value.length = i;
+      } else {
+        break;
+      }
+    }
+    return final;
+  }
   var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.parse = (payload, ctx) => {
@@ -4052,19 +4204,35 @@
         for (const key of values) {
           if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
             recordKeys.add(typeof key === "number" ? key.toString() : key);
+            const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+            if (keyResult instanceof Promise) {
+              throw new Error("Async schemas not supported in object keys currently");
+            }
+            if (keyResult.issues.length) {
+              payload.issues.push({
+                code: "invalid_key",
+                origin: "record",
+                issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+                input: key,
+                path: [key],
+                inst
+              });
+              continue;
+            }
+            const outKey = keyResult.value;
             const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
             if (result instanceof Promise) {
               proms.push(result.then((result2) => {
                 if (result2.issues.length) {
                   payload.issues.push(...prefixIssues(key, result2.issues));
                 }
-                payload.value[key] = result2.value;
+                payload.value[outKey] = result2.value;
               }));
             } else {
               if (result.issues.length) {
                 payload.issues.push(...prefixIssues(key, result.issues));
               }
-              payload.value[key] = result.value;
+              payload.value[outKey] = result.value;
             }
           }
         }
@@ -4088,6 +4256,8 @@
         for (const key of Reflect.ownKeys(input)) {
           if (key === "__proto__")
             continue;
+          if (!Object.prototype.propertyIsEnumerable.call(input, key))
+            continue;
           let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
           if (keyResult instanceof Promise) {
             throw new Error("Async schemas not supported in object keys currently");
@@ -4731,7 +4901,12 @@
   });
   var $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => {
     $ZodType.init(inst, def);
-    defineLazy(inst._zod, "innerType", () => def.getter());
+    defineLazy(inst._zod, "innerType", () => {
+      const d = def;
+      if (!d._cachedInner)
+        d._cachedInner = def.getter();
+      return d._cachedInner;
+    });
     defineLazy(inst._zod, "pattern", () => inst._zod.innerType?._zod?.pattern);
     defineLazy(inst._zod, "propValues", () => inst._zod.innerType?._zod?.propValues);
     defineLazy(inst._zod, "optin", () => inst._zod.innerType?._zod?.optin ?? void 0);
@@ -4786,6 +4961,7 @@
     cs: () => cs_default,
     da: () => da_default,
     de: () => de_default,
+    el: () => el_default,
     en: () => en_default,
     eo: () => eo_default,
     es: () => es_default,
@@ -4794,6 +4970,7 @@
     fr: () => fr_default,
     frCA: () => fr_CA_default,
     he: () => he_default,
+    hr: () => hr_default,
     hu: () => hu_default,
     hy: () => hy_default,
     id: () => id_default,
@@ -4813,6 +4990,7 @@
     pl: () => pl_default,
     ps: () => ps_default,
     pt: () => pt_default,
+    ro: () => ro_default,
     ru: () => ru_default,
     sl: () => sl_default,
     sv: () => sv_default,
@@ -5766,8 +5944,118 @@
     };
   }
 
-  // node_modules/zod/v4/locales/en.js
+  // node_modules/zod/v4/locales/el.js
   var error9 = () => {
+    const Sizable = {
+      string: { unit: "\u03C7\u03B1\u03C1\u03B1\u03BA\u03C4\u03AE\u03C1\u03B5\u03C2", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
+      file: { unit: "bytes", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
+      array: { unit: "\u03C3\u03C4\u03BF\u03B9\u03C7\u03B5\u03AF\u03B1", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
+      set: { unit: "\u03C3\u03C4\u03BF\u03B9\u03C7\u03B5\u03AF\u03B1", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
+      map: { unit: "\u03BA\u03B1\u03C4\u03B1\u03C7\u03C9\u03C1\u03AE\u03C3\u03B5\u03B9\u03C2", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" }
+    };
+    function getSizing(origin) {
+      return Sizable[origin] ?? null;
+    }
+    const FormatDictionary = {
+      regex: "\u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2",
+      email: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 email",
+      url: "URL",
+      emoji: "emoji",
+      uuid: "UUID",
+      uuidv4: "UUIDv4",
+      uuidv6: "UUIDv6",
+      nanoid: "nanoid",
+      guid: "GUID",
+      cuid: "cuid",
+      cuid2: "cuid2",
+      ulid: "ULID",
+      xid: "XID",
+      ksuid: "KSUID",
+      datetime: "ISO \u03B7\u03BC\u03B5\u03C1\u03BF\u03BC\u03B7\u03BD\u03AF\u03B1 \u03BA\u03B1\u03B9 \u03CE\u03C1\u03B1",
+      date: "ISO \u03B7\u03BC\u03B5\u03C1\u03BF\u03BC\u03B7\u03BD\u03AF\u03B1",
+      time: "ISO \u03CE\u03C1\u03B1",
+      duration: "ISO \u03B4\u03B9\u03AC\u03C1\u03BA\u03B5\u03B9\u03B1",
+      ipv4: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 IPv4",
+      ipv6: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 IPv6",
+      mac: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 MAC",
+      cidrv4: "\u03B5\u03CD\u03C1\u03BF\u03C2 IPv4",
+      cidrv6: "\u03B5\u03CD\u03C1\u03BF\u03C2 IPv6",
+      base64: "\u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC \u03BA\u03C9\u03B4\u03B9\u03BA\u03BF\u03C0\u03BF\u03B9\u03B7\u03BC\u03AD\u03BD\u03B7 \u03C3\u03B5 base64",
+      base64url: "\u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC \u03BA\u03C9\u03B4\u03B9\u03BA\u03BF\u03C0\u03BF\u03B9\u03B7\u03BC\u03AD\u03BD\u03B7 \u03C3\u03B5 base64url",
+      json_string: "\u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC JSON",
+      e164: "\u03B1\u03C1\u03B9\u03B8\u03BC\u03CC\u03C2 E.164",
+      jwt: "JWT",
+      template_literal: "\u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2"
+    };
+    const TypeDictionary = {
+      nan: "NaN"
+    };
+    return (issue2) => {
+      switch (issue2.code) {
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (typeof issue2.expected === "string" && /^[A-Z]/.test(issue2.expected)) {
+            return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD instanceof ${issue2.expected}, \u03BB\u03AE\u03C6\u03B8\u03B7\u03BA\u03B5 ${received}`;
+          }
+          return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${expected}, \u03BB\u03AE\u03C6\u03B8\u03B7\u03BA\u03B5 ${received}`;
+        }
+        case "invalid_value":
+          if (issue2.values.length === 1)
+            return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${stringifyPrimitive(issue2.values[0])}`;
+          return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03C0\u03B9\u03BB\u03BF\u03B3\u03AE: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD \u03AD\u03BD\u03B1 \u03B1\u03C0\u03CC ${joinValues(issue2.values, "|")}`;
+        case "too_big": {
+          const adj = issue2.inclusive ? "<=" : "<";
+          const sizing = getSizing(issue2.origin);
+          if (sizing)
+            return `\u03A0\u03BF\u03BB\u03CD \u03BC\u03B5\u03B3\u03AC\u03BB\u03BF: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${issue2.origin ?? "\u03C4\u03B9\u03BC\u03AE"} \u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9 ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u03C3\u03C4\u03BF\u03B9\u03C7\u03B5\u03AF\u03B1"}`;
+          return `\u03A0\u03BF\u03BB\u03CD \u03BC\u03B5\u03B3\u03AC\u03BB\u03BF: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${issue2.origin ?? "\u03C4\u03B9\u03BC\u03AE"} \u03BD\u03B1 \u03B5\u03AF\u03BD\u03B1\u03B9 ${adj}${issue2.maximum.toString()}`;
+        }
+        case "too_small": {
+          const adj = issue2.inclusive ? ">=" : ">";
+          const sizing = getSizing(issue2.origin);
+          if (sizing) {
+            return `\u03A0\u03BF\u03BB\u03CD \u03BC\u03B9\u03BA\u03C1\u03CC: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${issue2.origin} \u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9 ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
+          }
+          return `\u03A0\u03BF\u03BB\u03CD \u03BC\u03B9\u03BA\u03C1\u03CC: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${issue2.origin} \u03BD\u03B1 \u03B5\u03AF\u03BD\u03B1\u03B9 ${adj}${issue2.minimum.toString()}`;
+        }
+        case "invalid_format": {
+          const _issue = issue2;
+          if (_issue.format === "starts_with") {
+            return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03BE\u03B5\u03BA\u03B9\u03BD\u03AC \u03BC\u03B5 "${_issue.prefix}"`;
+          }
+          if (_issue.format === "ends_with")
+            return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03C4\u03B5\u03BB\u03B5\u03B9\u03CE\u03BD\u03B5\u03B9 \u03BC\u03B5 "${_issue.suffix}"`;
+          if (_issue.format === "includes")
+            return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03C0\u03B5\u03C1\u03B9\u03AD\u03C7\u03B5\u03B9 "${_issue.includes}"`;
+          if (_issue.format === "regex")
+            return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03C4\u03B1\u03B9\u03C1\u03B9\u03AC\u03B6\u03B5\u03B9 \u03BC\u03B5 \u03C4\u03BF \u03BC\u03BF\u03C4\u03AF\u03B2\u03BF ${_issue.pattern}`;
+          return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03BF: ${FormatDictionary[_issue.format] ?? issue2.format}`;
+        }
+        case "not_multiple_of":
+          return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03BF\u03C2 \u03B1\u03C1\u03B9\u03B8\u03BC\u03CC\u03C2: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03B5\u03AF\u03BD\u03B1\u03B9 \u03C0\u03BF\u03BB\u03BB\u03B1\u03C0\u03BB\u03AC\u03C3\u03B9\u03BF \u03C4\u03BF\u03C5 ${issue2.divisor}`;
+        case "unrecognized_keys":
+          return `\u0386\u03B3\u03BD\u03C9\u03C3\u03C4${issue2.keys.length > 1 ? "\u03B1" : "\u03BF"} \u03BA\u03BB\u03B5\u03B9\u03B4${issue2.keys.length > 1 ? "\u03B9\u03AC" : "\u03AF"}: ${joinValues(issue2.keys, ", ")}`;
+        case "invalid_key":
+          return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03BF \u03BA\u03BB\u03B5\u03B9\u03B4\u03AF \u03C3\u03C4\u03BF ${issue2.origin}`;
+        case "invalid_union":
+          return "\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2";
+        case "invalid_element":
+          return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C4\u03B9\u03BC\u03AE \u03C3\u03C4\u03BF ${issue2.origin}`;
+        default:
+          return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2`;
+      }
+    };
+  };
+  function el_default() {
+    return {
+      localeError: error9()
+    };
+  }
+
+  // node_modules/zod/v4/locales/en.js
+  var error10 = () => {
     const Sizable = {
       string: { unit: "characters", verb: "to have" },
       file: { unit: "bytes", verb: "to have" },
@@ -5861,6 +6149,10 @@
         case "invalid_key":
           return `Invalid key in ${issue2.origin}`;
         case "invalid_union":
+          if (issue2.options && Array.isArray(issue2.options) && issue2.options.length > 0) {
+            const opts = issue2.options.map((o) => `'${o}'`).join(" | ");
+            return `Invalid discriminator value. Expected ${opts}`;
+          }
           return "Invalid input";
         case "invalid_element":
           return `Invalid value in ${issue2.origin}`;
@@ -5871,12 +6163,12 @@
   };
   function en_default() {
     return {
-      localeError: error9()
+      localeError: error10()
     };
   }
 
   // node_modules/zod/v4/locales/eo.js
-  var error10 = () => {
+  var error11 = () => {
     const Sizable = {
       string: { unit: "karaktrojn", verb: "havi" },
       file: { unit: "bajtojn", verb: "havi" },
@@ -5981,12 +6273,12 @@
   };
   function eo_default() {
     return {
-      localeError: error10()
+      localeError: error11()
     };
   }
 
   // node_modules/zod/v4/locales/es.js
-  var error11 = () => {
+  var error12 = () => {
     const Sizable = {
       string: { unit: "caracteres", verb: "tener" },
       file: { unit: "bytes", verb: "tener" },
@@ -6114,12 +6406,12 @@
   };
   function es_default() {
     return {
-      localeError: error11()
+      localeError: error12()
     };
   }
 
   // node_modules/zod/v4/locales/fa.js
-  var error12 = () => {
+  var error13 = () => {
     const Sizable = {
       string: { unit: "\u06A9\u0627\u0631\u0627\u06A9\u062A\u0631", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
       file: { unit: "\u0628\u0627\u06CC\u062A", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
@@ -6229,12 +6521,12 @@
   };
   function fa_default() {
     return {
-      localeError: error12()
+      localeError: error13()
     };
   }
 
   // node_modules/zod/v4/locales/fi.js
-  var error13 = () => {
+  var error14 = () => {
     const Sizable = {
       string: { unit: "merkki\xE4", subject: "merkkijonon" },
       file: { unit: "tavua", subject: "tiedoston" },
@@ -6342,12 +6634,12 @@
   };
   function fi_default() {
     return {
-      localeError: error13()
+      localeError: error14()
     };
   }
 
   // node_modules/zod/v4/locales/fr.js
-  var error14 = () => {
+  var error15 = () => {
     const Sizable = {
       string: { unit: "caract\xE8res", verb: "avoir" },
       file: { unit: "octets", verb: "avoir" },
@@ -6388,9 +6680,27 @@
       template_literal: "entr\xE9e"
     };
     const TypeDictionary = {
-      nan: "NaN",
+      string: "cha\xEEne",
       number: "nombre",
-      array: "tableau"
+      int: "entier",
+      boolean: "bool\xE9en",
+      bigint: "grand entier",
+      symbol: "symbole",
+      undefined: "ind\xE9fini",
+      null: "null",
+      never: "jamais",
+      void: "vide",
+      date: "date",
+      array: "tableau",
+      object: "objet",
+      tuple: "tuple",
+      record: "enregistrement",
+      map: "carte",
+      set: "ensemble",
+      file: "fichier",
+      nonoptional: "non-optionnel",
+      nan: "NaN",
+      function: "fonction"
     };
     return (issue2) => {
       switch (issue2.code) {
@@ -6411,16 +6721,15 @@
           const adj = issue2.inclusive ? "<=" : "<";
           const sizing = getSizing(issue2.origin);
           if (sizing)
-            return `Trop grand : ${issue2.origin ?? "valeur"} doit ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\xE9l\xE9ment(s)"}`;
-          return `Trop grand : ${issue2.origin ?? "valeur"} doit \xEAtre ${adj}${issue2.maximum.toString()}`;
+            return `Trop grand : ${TypeDictionary[issue2.origin] ?? "valeur"} doit ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\xE9l\xE9ment(s)"}`;
+          return `Trop grand : ${TypeDictionary[issue2.origin] ?? "valeur"} doit \xEAtre ${adj}${issue2.maximum.toString()}`;
         }
         case "too_small": {
           const adj = issue2.inclusive ? ">=" : ">";
           const sizing = getSizing(issue2.origin);
-          if (sizing) {
-            return `Trop petit : ${issue2.origin} doit ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
-          }
-          return `Trop petit : ${issue2.origin} doit \xEAtre ${adj}${issue2.minimum.toString()}`;
+          if (sizing)
+            return `Trop petit : ${TypeDictionary[issue2.origin] ?? "valeur"} doit ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
+          return `Trop petit : ${TypeDictionary[issue2.origin] ?? "valeur"} doit \xEAtre ${adj}${issue2.minimum.toString()}`;
         }
         case "invalid_format": {
           const _issue = issue2;
@@ -6451,12 +6760,12 @@
   };
   function fr_default() {
     return {
-      localeError: error14()
+      localeError: error15()
     };
   }
 
   // node_modules/zod/v4/locales/fr-CA.js
-  var error15 = () => {
+  var error16 = () => {
     const Sizable = {
       string: { unit: "caract\xE8res", verb: "avoir" },
       file: { unit: "octets", verb: "avoir" },
@@ -6559,12 +6868,12 @@
   };
   function fr_CA_default() {
     return {
-      localeError: error15()
+      localeError: error16()
     };
   }
 
   // node_modules/zod/v4/locales/he.js
-  var error16 = () => {
+  var error17 = () => {
     const TypeNames = {
       string: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA", gender: "f" },
       number: { label: "\u05DE\u05E1\u05E4\u05E8", gender: "m" },
@@ -6754,24 +7063,24 @@
   };
   function he_default() {
     return {
-      localeError: error16()
+      localeError: error17()
     };
   }
 
-  // node_modules/zod/v4/locales/hu.js
-  var error17 = () => {
+  // node_modules/zod/v4/locales/hr.js
+  var error18 = () => {
     const Sizable = {
-      string: { unit: "karakter", verb: "legyen" },
-      file: { unit: "byte", verb: "legyen" },
-      array: { unit: "elem", verb: "legyen" },
-      set: { unit: "elem", verb: "legyen" }
+      string: { unit: "znakova", verb: "imati" },
+      file: { unit: "bajtova", verb: "imati" },
+      array: { unit: "stavki", verb: "imati" },
+      set: { unit: "stavki", verb: "imati" }
     };
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
     const FormatDictionary = {
-      regex: "bemenet",
-      email: "email c\xEDm",
+      regex: "unos",
+      email: "email adresa",
       url: "URL",
       emoji: "emoji",
       uuid: "UUID",
@@ -6784,25 +7093,148 @@
       ulid: "ULID",
       xid: "XID",
       ksuid: "KSUID",
-      datetime: "ISO id\u0151b\xE9lyeg",
-      date: "ISO d\xE1tum",
-      time: "ISO id\u0151",
-      duration: "ISO id\u0151intervallum",
-      ipv4: "IPv4 c\xEDm",
-      ipv6: "IPv6 c\xEDm",
-      cidrv4: "IPv4 tartom\xE1ny",
-      cidrv6: "IPv6 tartom\xE1ny",
-      base64: "base64-k\xF3dolt string",
-      base64url: "base64url-k\xF3dolt string",
-      json_string: "JSON string",
-      e164: "E.164 sz\xE1m",
+      datetime: "ISO datum i vrijeme",
+      date: "ISO datum",
+      time: "ISO vrijeme",
+      duration: "ISO trajanje",
+      ipv4: "IPv4 adresa",
+      ipv6: "IPv6 adresa",
+      cidrv4: "IPv4 raspon",
+      cidrv6: "IPv6 raspon",
+      base64: "base64 kodirani tekst",
+      base64url: "base64url kodirani tekst",
+      json_string: "JSON tekst",
+      e164: "E.164 broj",
       jwt: "JWT",
-      template_literal: "bemenet"
+      template_literal: "unos"
     };
     const TypeDictionary = {
       nan: "NaN",
-      number: "sz\xE1m",
-      array: "t\xF6mb"
+      string: "tekst",
+      number: "broj",
+      boolean: "boolean",
+      array: "niz",
+      object: "objekt",
+      set: "skup",
+      file: "datoteka",
+      date: "datum",
+      bigint: "bigint",
+      symbol: "simbol",
+      undefined: "undefined",
+      null: "null",
+      function: "funkcija",
+      map: "mapa"
+    };
+    return (issue2) => {
+      switch (issue2.code) {
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Neispravan unos: o\u010Dekuje se instanceof ${issue2.expected}, a primljeno je ${received}`;
+          }
+          return `Neispravan unos: o\u010Dekuje se ${expected}, a primljeno je ${received}`;
+        }
+        case "invalid_value":
+          if (issue2.values.length === 1)
+            return `Neispravna vrijednost: o\u010Dekivano ${stringifyPrimitive(issue2.values[0])}`;
+          return `Neispravna opcija: o\u010Dekivano jedno od ${joinValues(issue2.values, "|")}`;
+        case "too_big": {
+          const adj = issue2.inclusive ? "<=" : "<";
+          const sizing = getSizing(issue2.origin);
+          const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
+          if (sizing)
+            return `Preveliko: o\u010Dekivano da ${origin ?? "vrijednost"} ima ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elemenata"}`;
+          return `Preveliko: o\u010Dekivano da ${origin ?? "vrijednost"} bude ${adj}${issue2.maximum.toString()}`;
+        }
+        case "too_small": {
+          const adj = issue2.inclusive ? ">=" : ">";
+          const sizing = getSizing(issue2.origin);
+          const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
+          if (sizing) {
+            return `Premalo: o\u010Dekivano da ${origin} ima ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
+          }
+          return `Premalo: o\u010Dekivano da ${origin} bude ${adj}${issue2.minimum.toString()}`;
+        }
+        case "invalid_format": {
+          const _issue = issue2;
+          if (_issue.format === "starts_with")
+            return `Neispravan tekst: mora zapo\u010Dinjati s "${_issue.prefix}"`;
+          if (_issue.format === "ends_with")
+            return `Neispravan tekst: mora zavr\u0161avati s "${_issue.suffix}"`;
+          if (_issue.format === "includes")
+            return `Neispravan tekst: mora sadr\u017Eavati "${_issue.includes}"`;
+          if (_issue.format === "regex")
+            return `Neispravan tekst: mora odgovarati uzorku ${_issue.pattern}`;
+          return `Neispravna ${FormatDictionary[_issue.format] ?? issue2.format}`;
+        }
+        case "not_multiple_of":
+          return `Neispravan broj: mora biti vi\u0161ekratnik od ${issue2.divisor}`;
+        case "unrecognized_keys":
+          return `Neprepoznat${issue2.keys.length > 1 ? "i klju\u010Devi" : " klju\u010D"}: ${joinValues(issue2.keys, ", ")}`;
+        case "invalid_key":
+          return `Neispravan klju\u010D u ${TypeDictionary[issue2.origin] ?? issue2.origin}`;
+        case "invalid_union":
+          return "Neispravan unos";
+        case "invalid_element":
+          return `Neispravna vrijednost u ${TypeDictionary[issue2.origin] ?? issue2.origin}`;
+        default:
+          return `Neispravan unos`;
+      }
+    };
+  };
+  function hr_default() {
+    return {
+      localeError: error18()
+    };
+  }
+
+  // node_modules/zod/v4/locales/hu.js
+  var error19 = () => {
+    const Sizable = {
+      string: { unit: "karakter", verb: "legyen" },
+      file: { unit: "byte", verb: "legyen" },
+      array: { unit: "elem", verb: "legyen" },
+      set: { unit: "elem", verb: "legyen" }
+    };
+    function getSizing(origin) {
+      return Sizable[origin] ?? null;
+    }
+    const FormatDictionary = {
+      regex: "bemenet",
+      email: "email c\xEDm",
+      url: "URL",
+      emoji: "emoji",
+      uuid: "UUID",
+      uuidv4: "UUIDv4",
+      uuidv6: "UUIDv6",
+      nanoid: "nanoid",
+      guid: "GUID",
+      cuid: "cuid",
+      cuid2: "cuid2",
+      ulid: "ULID",
+      xid: "XID",
+      ksuid: "KSUID",
+      datetime: "ISO id\u0151b\xE9lyeg",
+      date: "ISO d\xE1tum",
+      time: "ISO id\u0151",
+      duration: "ISO id\u0151intervallum",
+      ipv4: "IPv4 c\xEDm",
+      ipv6: "IPv6 c\xEDm",
+      cidrv4: "IPv4 tartom\xE1ny",
+      cidrv6: "IPv6 tartom\xE1ny",
+      base64: "base64-k\xF3dolt string",
+      base64url: "base64url-k\xF3dolt string",
+      json_string: "JSON string",
+      e164: "E.164 sz\xE1m",
+      jwt: "JWT",
+      template_literal: "bemenet"
+    };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "sz\xE1m",
+      array: "t\xF6mb"
     };
     return (issue2) => {
       switch (issue2.code) {
@@ -6863,7 +7295,7 @@
   };
   function hu_default() {
     return {
-      localeError: error17()
+      localeError: error19()
     };
   }
 
@@ -6878,7 +7310,7 @@
     const lastChar = word[word.length - 1];
     return word + (vowels.includes(lastChar) ? "\u0576" : "\u0568");
   }
-  var error18 = () => {
+  var error20 = () => {
     const Sizable = {
       string: {
         unit: {
@@ -7011,12 +7443,12 @@
   };
   function hy_default() {
     return {
-      localeError: error18()
+      localeError: error20()
     };
   }
 
   // node_modules/zod/v4/locales/id.js
-  var error19 = () => {
+  var error21 = () => {
     const Sizable = {
       string: { unit: "karakter", verb: "memiliki" },
       file: { unit: "byte", verb: "memiliki" },
@@ -7118,12 +7550,12 @@
   };
   function id_default() {
     return {
-      localeError: error19()
+      localeError: error21()
     };
   }
 
   // node_modules/zod/v4/locales/is.js
-  var error20 = () => {
+  var error22 = () => {
     const Sizable = {
       string: { unit: "stafi", verb: "a\xF0 hafa" },
       file: { unit: "b\xE6ti", verb: "a\xF0 hafa" },
@@ -7228,12 +7660,12 @@
   };
   function is_default() {
     return {
-      localeError: error20()
+      localeError: error22()
     };
   }
 
   // node_modules/zod/v4/locales/it.js
-  var error21 = () => {
+  var error23 = () => {
     const Sizable = {
       string: { unit: "caratteri", verb: "avere" },
       file: { unit: "byte", verb: "avere" },
@@ -7318,7 +7750,7 @@
             return `Stringa non valida: deve includere "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `Stringa non valida: deve corrispondere al pattern ${_issue.pattern}`;
-          return `Invalid ${FormatDictionary[_issue.format] ?? issue2.format}`;
+          return `Input non valido: ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `Numero non valido: deve essere un multiplo di ${issue2.divisor}`;
@@ -7337,12 +7769,12 @@
   };
   function it_default() {
     return {
-      localeError: error21()
+      localeError: error23()
     };
   }
 
   // node_modules/zod/v4/locales/ja.js
-  var error22 = () => {
+  var error24 = () => {
     const Sizable = {
       string: { unit: "\u6587\u5B57", verb: "\u3067\u3042\u308B" },
       file: { unit: "\u30D0\u30A4\u30C8", verb: "\u3067\u3042\u308B" },
@@ -7445,12 +7877,12 @@
   };
   function ja_default() {
     return {
-      localeError: error22()
+      localeError: error24()
     };
   }
 
   // node_modules/zod/v4/locales/ka.js
-  var error23 = () => {
+  var error25 = () => {
     const Sizable = {
       string: { unit: "\u10E1\u10D8\u10DB\u10D1\u10DD\u10DA\u10DD", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
       file: { unit: "\u10D1\u10D0\u10D8\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
@@ -7483,9 +7915,9 @@
       ipv6: "IPv6 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
       cidrv4: "IPv4 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
       cidrv6: "IPv6 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
-      base64: "base64-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
-      base64url: "base64url-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
-      json_string: "JSON \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
+      base64: "base64-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10D5\u10D4\u10DA\u10D8",
+      base64url: "base64url-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10D5\u10D4\u10DA\u10D8",
+      json_string: "JSON \u10D5\u10D4\u10DA\u10D8",
       e164: "E.164 \u10DC\u10DD\u10DB\u10D4\u10E0\u10D8",
       jwt: "JWT",
       template_literal: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0"
@@ -7493,7 +7925,7 @@
     const TypeDictionary = {
       nan: "NaN",
       number: "\u10E0\u10D8\u10EA\u10EE\u10D5\u10D8",
-      string: "\u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
+      string: "\u10D5\u10D4\u10DA\u10D8",
       boolean: "\u10D1\u10E3\u10DA\u10D4\u10D0\u10DC\u10D8",
       function: "\u10E4\u10E3\u10DC\u10E5\u10EA\u10D8\u10D0",
       array: "\u10DB\u10D0\u10E1\u10D8\u10D5\u10D8"
@@ -7531,14 +7963,14 @@
         case "invalid_format": {
           const _issue = issue2;
           if (_issue.format === "starts_with") {
-            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10EC\u10E7\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.prefix}"-\u10D8\u10D7`;
+            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D4\u10DA\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10EC\u10E7\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.prefix}"-\u10D8\u10D7`;
           }
           if (_issue.format === "ends_with")
-            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10DB\u10D7\u10D0\u10D5\u10E0\u10D3\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.suffix}"-\u10D8\u10D7`;
+            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D4\u10DA\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10DB\u10D7\u10D0\u10D5\u10E0\u10D3\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.suffix}"-\u10D8\u10D7`;
           if (_issue.format === "includes")
-            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1 "${_issue.includes}"-\u10E1`;
+            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D4\u10DA\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1 "${_issue.includes}"-\u10E1`;
           if (_issue.format === "regex")
-            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D4\u10E1\u10D0\u10D1\u10D0\u10DB\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 \u10E8\u10D0\u10D1\u10DA\u10DD\u10DC\u10E1 ${_issue.pattern}`;
+            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D4\u10DA\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D4\u10E1\u10D0\u10D1\u10D0\u10DB\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 \u10E8\u10D0\u10D1\u10DA\u10DD\u10DC\u10E1 ${_issue.pattern}`;
           return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
@@ -7558,12 +7990,12 @@
   };
   function ka_default() {
     return {
-      localeError: error23()
+      localeError: error25()
     };
   }
 
   // node_modules/zod/v4/locales/km.js
-  var error24 = () => {
+  var error26 = () => {
     const Sizable = {
       string: { unit: "\u178F\u17BD\u17A2\u1780\u17D2\u179F\u179A", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
       file: { unit: "\u1794\u17C3", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
@@ -7669,7 +8101,7 @@
   };
   function km_default() {
     return {
-      localeError: error24()
+      localeError: error26()
     };
   }
 
@@ -7679,7 +8111,7 @@
   }
 
   // node_modules/zod/v4/locales/ko.js
-  var error25 = () => {
+  var error27 = () => {
     const Sizable = {
       string: { unit: "\uBB38\uC790", verb: "to have" },
       file: { unit: "\uBC14\uC774\uD2B8", verb: "to have" },
@@ -7786,7 +8218,7 @@
   };
   function ko_default() {
     return {
-      localeError: error25()
+      localeError: error27()
     };
   }
 
@@ -7804,7 +8236,7 @@
       return "one";
     return "few";
   }
-  var error26 = () => {
+  var error28 = () => {
     const Sizable = {
       string: {
         unit: {
@@ -7990,12 +8422,12 @@
   };
   function lt_default() {
     return {
-      localeError: error26()
+      localeError: error28()
     };
   }
 
   // node_modules/zod/v4/locales/mk.js
-  var error27 = () => {
+  var error29 = () => {
     const Sizable = {
       string: { unit: "\u0437\u043D\u0430\u0446\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
       file: { unit: "\u0431\u0430\u0458\u0442\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
@@ -8100,12 +8532,12 @@
   };
   function mk_default() {
     return {
-      localeError: error27()
+      localeError: error29()
     };
   }
 
   // node_modules/zod/v4/locales/ms.js
-  var error28 = () => {
+  var error30 = () => {
     const Sizable = {
       string: { unit: "aksara", verb: "mempunyai" },
       file: { unit: "bait", verb: "mempunyai" },
@@ -8208,12 +8640,12 @@
   };
   function ms_default() {
     return {
-      localeError: error28()
+      localeError: error30()
     };
   }
 
   // node_modules/zod/v4/locales/nl.js
-  var error29 = () => {
+  var error31 = () => {
     const Sizable = {
       string: { unit: "tekens", verb: "heeft" },
       file: { unit: "bytes", verb: "heeft" },
@@ -8319,12 +8751,12 @@
   };
   function nl_default() {
     return {
-      localeError: error29()
+      localeError: error31()
     };
   }
 
   // node_modules/zod/v4/locales/no.js
-  var error30 = () => {
+  var error32 = () => {
     const Sizable = {
       string: { unit: "tegn", verb: "\xE5 ha" },
       file: { unit: "bytes", verb: "\xE5 ha" },
@@ -8428,12 +8860,12 @@
   };
   function no_default() {
     return {
-      localeError: error30()
+      localeError: error32()
     };
   }
 
   // node_modules/zod/v4/locales/ota.js
-  var error31 = () => {
+  var error33 = () => {
     const Sizable = {
       string: { unit: "harf", verb: "olmal\u0131d\u0131r" },
       file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
@@ -8538,12 +8970,12 @@
   };
   function ota_default() {
     return {
-      localeError: error31()
+      localeError: error33()
     };
   }
 
   // node_modules/zod/v4/locales/ps.js
-  var error32 = () => {
+  var error34 = () => {
     const Sizable = {
       string: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
       file: { unit: "\u0628\u0627\u06CC\u067C\u0633", verb: "\u0648\u0644\u0631\u064A" },
@@ -8653,12 +9085,12 @@
   };
   function ps_default() {
     return {
-      localeError: error32()
+      localeError: error34()
     };
   }
 
   // node_modules/zod/v4/locales/pl.js
-  var error33 = () => {
+  var error35 = () => {
     const Sizable = {
       string: { unit: "znak\xF3w", verb: "mie\u0107" },
       file: { unit: "bajt\xF3w", verb: "mie\u0107" },
@@ -8763,12 +9195,12 @@
   };
   function pl_default() {
     return {
-      localeError: error33()
+      localeError: error35()
     };
   }
 
   // node_modules/zod/v4/locales/pt.js
-  var error34 = () => {
+  var error36 = () => {
     const Sizable = {
       string: { unit: "caracteres", verb: "ter" },
       file: { unit: "bytes", verb: "ter" },
@@ -8872,7 +9304,127 @@
   };
   function pt_default() {
     return {
-      localeError: error34()
+      localeError: error36()
+    };
+  }
+
+  // node_modules/zod/v4/locales/ro.js
+  var error37 = () => {
+    const Sizable = {
+      string: { unit: "caractere", verb: "s\u0103 aib\u0103" },
+      file: { unit: "octe\u021Bi", verb: "s\u0103 aib\u0103" },
+      array: { unit: "elemente", verb: "s\u0103 aib\u0103" },
+      set: { unit: "elemente", verb: "s\u0103 aib\u0103" },
+      map: { unit: "intr\u0103ri", verb: "s\u0103 aib\u0103" }
+    };
+    function getSizing(origin) {
+      return Sizable[origin] ?? null;
+    }
+    const FormatDictionary = {
+      regex: "intrare",
+      email: "adres\u0103 de email",
+      url: "URL",
+      emoji: "emoji",
+      uuid: "UUID",
+      uuidv4: "UUIDv4",
+      uuidv6: "UUIDv6",
+      nanoid: "nanoid",
+      guid: "GUID",
+      cuid: "cuid",
+      cuid2: "cuid2",
+      ulid: "ULID",
+      xid: "XID",
+      ksuid: "KSUID",
+      datetime: "dat\u0103 \u0219i or\u0103 ISO",
+      date: "dat\u0103 ISO",
+      time: "or\u0103 ISO",
+      duration: "durat\u0103 ISO",
+      ipv4: "adres\u0103 IPv4",
+      ipv6: "adres\u0103 IPv6",
+      mac: "adres\u0103 MAC",
+      cidrv4: "interval IPv4",
+      cidrv6: "interval IPv6",
+      base64: "\u0219ir codat base64",
+      base64url: "\u0219ir codat base64url",
+      json_string: "\u0219ir JSON",
+      e164: "num\u0103r E.164",
+      jwt: "JWT",
+      template_literal: "intrare"
+    };
+    const TypeDictionary = {
+      nan: "NaN",
+      string: "\u0219ir",
+      number: "num\u0103r",
+      boolean: "boolean",
+      function: "func\u021Bie",
+      array: "matrice",
+      object: "obiect",
+      undefined: "nedefinit",
+      symbol: "simbol",
+      bigint: "num\u0103r mare",
+      void: "void",
+      never: "never",
+      map: "hart\u0103",
+      set: "set"
+    };
+    return (issue2) => {
+      switch (issue2.code) {
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          return `Intrare invalid\u0103: a\u0219teptat ${expected}, primit ${received}`;
+        }
+        case "invalid_value":
+          if (issue2.values.length === 1)
+            return `Intrare invalid\u0103: a\u0219teptat ${stringifyPrimitive(issue2.values[0])}`;
+          return `Op\u021Biune invalid\u0103: a\u0219teptat una dintre ${joinValues(issue2.values, "|")}`;
+        case "too_big": {
+          const adj = issue2.inclusive ? "<=" : "<";
+          const sizing = getSizing(issue2.origin);
+          if (sizing)
+            return `Prea mare: a\u0219teptat ca ${issue2.origin ?? "valoarea"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elemente"}`;
+          return `Prea mare: a\u0219teptat ca ${issue2.origin ?? "valoarea"} s\u0103 fie ${adj}${issue2.maximum.toString()}`;
+        }
+        case "too_small": {
+          const adj = issue2.inclusive ? ">=" : ">";
+          const sizing = getSizing(issue2.origin);
+          if (sizing) {
+            return `Prea mic: a\u0219teptat ca ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
+          }
+          return `Prea mic: a\u0219teptat ca ${issue2.origin} s\u0103 fie ${adj}${issue2.minimum.toString()}`;
+        }
+        case "invalid_format": {
+          const _issue = issue2;
+          if (_issue.format === "starts_with") {
+            return `\u0218ir invalid: trebuie s\u0103 \xEEnceap\u0103 cu "${_issue.prefix}"`;
+          }
+          if (_issue.format === "ends_with")
+            return `\u0218ir invalid: trebuie s\u0103 se termine cu "${_issue.suffix}"`;
+          if (_issue.format === "includes")
+            return `\u0218ir invalid: trebuie s\u0103 includ\u0103 "${_issue.includes}"`;
+          if (_issue.format === "regex")
+            return `\u0218ir invalid: trebuie s\u0103 se potriveasc\u0103 cu modelul ${_issue.pattern}`;
+          return `Format invalid: ${FormatDictionary[_issue.format] ?? issue2.format}`;
+        }
+        case "not_multiple_of":
+          return `Num\u0103r invalid: trebuie s\u0103 fie multiplu de ${issue2.divisor}`;
+        case "unrecognized_keys":
+          return `Chei nerecunoscute: ${joinValues(issue2.keys, ", ")}`;
+        case "invalid_key":
+          return `Cheie invalid\u0103 \xEEn ${issue2.origin}`;
+        case "invalid_union":
+          return "Intrare invalid\u0103";
+        case "invalid_element":
+          return `Valoare invalid\u0103 \xEEn ${issue2.origin}`;
+        default:
+          return `Intrare invalid\u0103`;
+      }
+    };
+  };
+  function ro_default() {
+    return {
+      localeError: error37()
     };
   }
 
@@ -8892,7 +9444,7 @@
     }
     return many;
   }
-  var error35 = () => {
+  var error38 = () => {
     const Sizable = {
       string: {
         unit: {
@@ -9029,12 +9581,12 @@
   };
   function ru_default() {
     return {
-      localeError: error35()
+      localeError: error38()
     };
   }
 
   // node_modules/zod/v4/locales/sl.js
-  var error36 = () => {
+  var error39 = () => {
     const Sizable = {
       string: { unit: "znakov", verb: "imeti" },
       file: { unit: "bajtov", verb: "imeti" },
@@ -9139,12 +9691,12 @@
   };
   function sl_default() {
     return {
-      localeError: error36()
+      localeError: error39()
     };
   }
 
   // node_modules/zod/v4/locales/sv.js
-  var error37 = () => {
+  var error40 = () => {
     const Sizable = {
       string: { unit: "tecken", verb: "att ha" },
       file: { unit: "bytes", verb: "att ha" },
@@ -9250,12 +9802,12 @@
   };
   function sv_default() {
     return {
-      localeError: error37()
+      localeError: error40()
     };
   }
 
   // node_modules/zod/v4/locales/ta.js
-  var error38 = () => {
+  var error41 = () => {
     const Sizable = {
       string: { unit: "\u0B8E\u0BB4\u0BC1\u0BA4\u0BCD\u0BA4\u0BC1\u0B95\u0BCD\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
       file: { unit: "\u0BAA\u0BC8\u0B9F\u0BCD\u0B9F\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
@@ -9361,12 +9913,12 @@
   };
   function ta_default() {
     return {
-      localeError: error38()
+      localeError: error41()
     };
   }
 
   // node_modules/zod/v4/locales/th.js
-  var error39 = () => {
+  var error42 = () => {
     const Sizable = {
       string: { unit: "\u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
       file: { unit: "\u0E44\u0E1A\u0E15\u0E4C", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
@@ -9472,12 +10024,12 @@
   };
   function th_default() {
     return {
-      localeError: error39()
+      localeError: error42()
     };
   }
 
   // node_modules/zod/v4/locales/tr.js
-  var error40 = () => {
+  var error43 = () => {
     const Sizable = {
       string: { unit: "karakter", verb: "olmal\u0131" },
       file: { unit: "bayt", verb: "olmal\u0131" },
@@ -9578,12 +10130,12 @@
   };
   function tr_default() {
     return {
-      localeError: error40()
+      localeError: error43()
     };
   }
 
   // node_modules/zod/v4/locales/uk.js
-  var error41 = () => {
+  var error44 = () => {
     const Sizable = {
       string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
       file: { unit: "\u0431\u0430\u0439\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
@@ -9687,7 +10239,7 @@
   };
   function uk_default() {
     return {
-      localeError: error41()
+      localeError: error44()
     };
   }
 
@@ -9697,7 +10249,7 @@
   }
 
   // node_modules/zod/v4/locales/ur.js
-  var error42 = () => {
+  var error45 = () => {
     const Sizable = {
       string: { unit: "\u062D\u0631\u0648\u0641", verb: "\u06C1\u0648\u0646\u0627" },
       file: { unit: "\u0628\u0627\u0626\u0679\u0633", verb: "\u06C1\u0648\u0646\u0627" },
@@ -9803,17 +10355,18 @@
   };
   function ur_default() {
     return {
-      localeError: error42()
+      localeError: error45()
     };
   }
 
   // node_modules/zod/v4/locales/uz.js
-  var error43 = () => {
+  var error46 = () => {
     const Sizable = {
       string: { unit: "belgi", verb: "bo\u2018lishi kerak" },
       file: { unit: "bayt", verb: "bo\u2018lishi kerak" },
       array: { unit: "element", verb: "bo\u2018lishi kerak" },
-      set: { unit: "element", verb: "bo\u2018lishi kerak" }
+      set: { unit: "element", verb: "bo\u2018lishi kerak" },
+      map: { unit: "yozuv", verb: "bo\u2018lishi kerak" }
     };
     function getSizing(origin) {
       return Sizable[origin] ?? null;
@@ -9913,12 +10466,12 @@
   };
   function uz_default() {
     return {
-      localeError: error43()
+      localeError: error46()
     };
   }
 
   // node_modules/zod/v4/locales/vi.js
-  var error44 = () => {
+  var error47 = () => {
     const Sizable = {
       string: { unit: "k\xFD t\u1EF1", verb: "c\xF3" },
       file: { unit: "byte", verb: "c\xF3" },
@@ -10022,12 +10575,12 @@
   };
   function vi_default() {
     return {
-      localeError: error44()
+      localeError: error47()
     };
   }
 
   // node_modules/zod/v4/locales/zh-CN.js
-  var error45 = () => {
+  var error48 = () => {
     const Sizable = {
       string: { unit: "\u5B57\u7B26", verb: "\u5305\u542B" },
       file: { unit: "\u5B57\u8282", verb: "\u5305\u542B" },
@@ -10132,12 +10685,12 @@
   };
   function zh_CN_default() {
     return {
-      localeError: error45()
+      localeError: error48()
     };
   }
 
   // node_modules/zod/v4/locales/zh-TW.js
-  var error46 = () => {
+  var error49 = () => {
     const Sizable = {
       string: { unit: "\u5B57\u5143", verb: "\u64C1\u6709" },
       file: { unit: "\u4F4D\u5143\u7D44", verb: "\u64C1\u6709" },
@@ -10240,12 +10793,12 @@
   };
   function zh_TW_default() {
     return {
-      localeError: error46()
+      localeError: error49()
     };
   }
 
   // node_modules/zod/v4/locales/yo.js
-  var error47 = () => {
+  var error50 = () => {
     const Sizable = {
       string: { unit: "\xE0mi", verb: "n\xED" },
       file: { unit: "bytes", verb: "n\xED" },
@@ -10348,12 +10901,12 @@
   };
   function yo_default() {
     return {
-      localeError: error47()
+      localeError: error50()
     };
   }
 
   // node_modules/zod/v4/core/registries.js
-  var _a;
+  var _a2;
   var $output = /* @__PURE__ */ Symbol("ZodOutput");
   var $input = /* @__PURE__ */ Symbol("ZodInput");
   var $ZodRegistry = class {
@@ -10399,7 +10952,7 @@
   function registry() {
     return new $ZodRegistry();
   }
-  (_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
+  (_a2 = globalThis).__zod_globalRegistry ?? (_a2.__zod_globalRegistry = registry());
   var globalRegistry = globalThis.__zod_globalRegistry;
 
   // node_modules/zod/v4/core/api.js
@@ -11317,7 +11870,7 @@
     return schema;
   }
   // @__NO_SIDE_EFFECTS__
-  function _superRefine(fn) {
+  function _superRefine(fn, params) {
     const ch = /* @__PURE__ */ _check((payload) => {
       payload.addIssue = (issue2) => {
         if (typeof issue2 === "string") {
@@ -11334,7 +11887,7 @@
         }
       };
       return fn(payload.value, payload);
-    });
+    }, params);
     return ch;
   }
   // @__NO_SIDE_EFFECTS__
@@ -11464,7 +12017,7 @@
     };
   }
   function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
-    var _a2;
+    var _a3;
     const def = schema._zod.def;
     const seen = ctx.seen.get(schema);
     if (seen) {
@@ -11511,8 +12064,8 @@
       delete result.schema.examples;
       delete result.schema.default;
     }
-    if (ctx.io === "input" && result.schema._prefault)
-      (_a2 = result.schema).default ?? (_a2.default = result.schema._prefault);
+    if (ctx.io === "input" && "_prefault" in result.schema)
+      (_a3 = result.schema).default ?? (_a3.default = result.schema._prefault);
     delete result.schema._prefault;
     const _result = ctx.seen.get(schema);
     return _result.schema;
@@ -11693,10 +12246,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       result.$id = ctx.external.uri(id);
     }
     Object.assign(result, root.def ?? root.schema);
+    const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
+    if (rootMetaId !== void 0 && result.id === rootMetaId)
+      delete result.id;
     const defs = ctx.external?.defs ?? {};
     for (const entry of ctx.seen.entries()) {
       const seen = entry[1];
       if (seen.def && seen.defId) {
+        if (seen.def.id === seen.defId)
+          delete seen.def.id;
         defs[seen.defId] = seen.def;
       }
     }
@@ -11841,39 +12399,28 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       json2.type = "integer";
     else
       json2.type = "number";
-    if (typeof exclusiveMinimum === "number") {
-      if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+    const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
+    const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
+    const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
+    if (exMin) {
+      if (legacy) {
         json2.minimum = exclusiveMinimum;
         json2.exclusiveMinimum = true;
       } else {
         json2.exclusiveMinimum = exclusiveMinimum;
       }
-    }
-    if (typeof minimum === "number") {
+    } else if (typeof minimum === "number") {
       json2.minimum = minimum;
-      if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
-        if (exclusiveMinimum >= minimum)
-          delete json2.minimum;
-        else
-          delete json2.exclusiveMinimum;
-      }
     }
-    if (typeof exclusiveMaximum === "number") {
-      if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+    if (exMax) {
+      if (legacy) {
         json2.maximum = exclusiveMaximum;
         json2.exclusiveMaximum = true;
       } else {
         json2.exclusiveMaximum = exclusiveMaximum;
       }
-    }
-    if (typeof maximum === "number") {
+    } else if (typeof maximum === "number") {
       json2.maximum = maximum;
-      if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
-        if (exclusiveMaximum <= maximum)
-          delete json2.maximum;
-        else
-          delete json2.exclusiveMaximum;
-      }
     }
     if (typeof multipleOf === "number")
       json2.multipleOf = multipleOf;
@@ -12045,7 +12592,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     if (typeof maximum === "number")
       json2.maxItems = maximum;
     json2.type = "array";
-    json2.items = process2(def.element, ctx, { ...params, path: [...params.path, "items"] });
+    json2.items = process2(def.element, ctx, {
+      ...params,
+      path: [...params.path, "items"]
+    });
   };
   var objectProcessor = (schema, ctx, _json, params) => {
     const json2 = _json;
@@ -12532,6 +13082,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     int32: () => int32,
     int64: () => int64,
     intersection: () => intersection,
+    invertCodec: () => invertCodec,
     ipv4: () => ipv42,
     ipv6: () => ipv62,
     json: () => json,
@@ -12701,8 +13252,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
     });
   };
-  var ZodError = $constructor("ZodError", initializer2);
-  var ZodRealError = $constructor("ZodError", initializer2, {
+  var ZodError = /* @__PURE__ */ $constructor("ZodError", initializer2);
+  var ZodRealError = /* @__PURE__ */ $constructor("ZodError", initializer2, {
     Parent: Error
   });
 
@@ -12721,6 +13272,43 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   var safeDecodeAsync2 = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
 
   // node_modules/zod/v4/classic/schemas.js
+  var _installedGroups = /* @__PURE__ */ new WeakMap();
+  function _installLazyMethods(inst, group, methods) {
+    const proto = Object.getPrototypeOf(inst);
+    let installed = _installedGroups.get(proto);
+    if (!installed) {
+      installed = /* @__PURE__ */ new Set();
+      _installedGroups.set(proto, installed);
+    }
+    if (installed.has(group))
+      return;
+    installed.add(group);
+    for (const key in methods) {
+      const fn = methods[key];
+      Object.defineProperty(proto, key, {
+        configurable: true,
+        enumerable: false,
+        get() {
+          const bound = fn.bind(this);
+          Object.defineProperty(this, key, {
+            configurable: true,
+            writable: true,
+            enumerable: true,
+            value: bound
+          });
+          return bound;
+        },
+        set(v) {
+          Object.defineProperty(this, key, {
+            configurable: true,
+            writable: true,
+            enumerable: true,
+            value: v
+          });
+        }
+      });
+    }
+  }
   var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
     $ZodType.init(inst, def);
     Object.assign(inst["~standard"], {
@@ -12733,23 +13321,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     inst.def = def;
     inst.type = def.type;
     Object.defineProperty(inst, "_def", { value: def });
-    inst.check = (...checks) => {
-      return inst.clone(util_exports.mergeDefs(def, {
-        checks: [
-          ...def.checks ?? [],
-          ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
-        ]
-      }), {
-        parent: true
-      });
-    };
-    inst.with = inst.check;
-    inst.clone = (def2, params) => clone(inst, def2, params);
-    inst.brand = () => inst;
-    inst.register = ((reg, meta3) => {
-      reg.add(inst, meta3);
-      return inst;
-    });
     inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse });
     inst.safeParse = (data, params) => safeParse2(inst, data, params);
     inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
@@ -12763,45 +13334,108 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     inst.safeDecode = (data, params) => safeDecode2(inst, data, params);
     inst.safeEncodeAsync = async (data, params) => safeEncodeAsync2(inst, data, params);
     inst.safeDecodeAsync = async (data, params) => safeDecodeAsync2(inst, data, params);
-    inst.refine = (check2, params) => inst.check(refine(check2, params));
-    inst.superRefine = (refinement) => inst.check(superRefine(refinement));
-    inst.overwrite = (fn) => inst.check(_overwrite(fn));
-    inst.optional = () => optional(inst);
-    inst.exactOptional = () => exactOptional(inst);
-    inst.nullable = () => nullable(inst);
-    inst.nullish = () => optional(nullable(inst));
-    inst.nonoptional = (params) => nonoptional(inst, params);
-    inst.array = () => array(inst);
-    inst.or = (arg) => union([inst, arg]);
-    inst.and = (arg) => intersection(inst, arg);
-    inst.transform = (tx) => pipe(inst, transform(tx));
-    inst.default = (def2) => _default2(inst, def2);
-    inst.prefault = (def2) => prefault(inst, def2);
-    inst.catch = (params) => _catch2(inst, params);
-    inst.pipe = (target) => pipe(inst, target);
-    inst.readonly = () => readonly(inst);
-    inst.describe = (description) => {
-      const cl = inst.clone();
-      globalRegistry.add(cl, { description });
-      return cl;
-    };
+    _installLazyMethods(inst, "ZodType", {
+      check(...chks) {
+        const def2 = this.def;
+        return this.clone(util_exports.mergeDefs(def2, {
+          checks: [
+            ...def2.checks ?? [],
+            ...chks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
+          ]
+        }), { parent: true });
+      },
+      with(...chks) {
+        return this.check(...chks);
+      },
+      clone(def2, params) {
+        return clone(this, def2, params);
+      },
+      brand() {
+        return this;
+      },
+      register(reg, meta3) {
+        reg.add(this, meta3);
+        return this;
+      },
+      refine(check2, params) {
+        return this.check(refine(check2, params));
+      },
+      superRefine(refinement, params) {
+        return this.check(superRefine(refinement, params));
+      },
+      overwrite(fn) {
+        return this.check(_overwrite(fn));
+      },
+      optional() {
+        return optional(this);
+      },
+      exactOptional() {
+        return exactOptional(this);
+      },
+      nullable() {
+        return nullable(this);
+      },
+      nullish() {
+        return optional(nullable(this));
+      },
+      nonoptional(params) {
+        return nonoptional(this, params);
+      },
+      array() {
+        return array(this);
+      },
+      or(arg) {
+        return union([this, arg]);
+      },
+      and(arg) {
+        return intersection(this, arg);
+      },
+      transform(tx) {
+        return pipe(this, transform(tx));
+      },
+      default(d) {
+        return _default2(this, d);
+      },
+      prefault(d) {
+        return prefault(this, d);
+      },
+      catch(params) {
+        return _catch2(this, params);
+      },
+      pipe(target) {
+        return pipe(this, target);
+      },
+      readonly() {
+        return readonly(this);
+      },
+      describe(description) {
+        const cl = this.clone();
+        globalRegistry.add(cl, { description });
+        return cl;
+      },
+      meta(...args) {
+        if (args.length === 0)
+          return globalRegistry.get(this);
+        const cl = this.clone();
+        globalRegistry.add(cl, args[0]);
+        return cl;
+      },
+      isOptional() {
+        return this.safeParse(void 0).success;
+      },
+      isNullable() {
+        return this.safeParse(null).success;
+      },
+      apply(fn) {
+        return fn(this);
+      }
+    });
     Object.defineProperty(inst, "description", {
       get() {
         return globalRegistry.get(inst)?.description;
       },
       configurable: true
     });
-    inst.meta = (...args) => {
-      if (args.length === 0) {
-        return globalRegistry.get(inst);
-      }
-      const cl = inst.clone();
-      globalRegistry.add(cl, args[0]);
-      return cl;
-    };
-    inst.isOptional = () => inst.safeParse(void 0).success;
-    inst.isNullable = () => inst.safeParse(null).success;
-    inst.apply = (fn) => fn(inst);
     return inst;
   });
   var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
@@ -12812,21 +13446,53 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     inst.format = bag.format ?? null;
     inst.minLength = bag.minimum ?? null;
     inst.maxLength = bag.maximum ?? null;
-    inst.regex = (...args) => inst.check(_regex(...args));
-    inst.includes = (...args) => inst.check(_includes(...args));
-    inst.startsWith = (...args) => inst.check(_startsWith(...args));
-    inst.endsWith = (...args) => inst.check(_endsWith(...args));
-    inst.min = (...args) => inst.check(_minLength(...args));
-    inst.max = (...args) => inst.check(_maxLength(...args));
-    inst.length = (...args) => inst.check(_length(...args));
-    inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
-    inst.lowercase = (params) => inst.check(_lowercase(params));
-    inst.uppercase = (params) => inst.check(_uppercase(params));
-    inst.trim = () => inst.check(_trim());
-    inst.normalize = (...args) => inst.check(_normalize(...args));
-    inst.toLowerCase = () => inst.check(_toLowerCase());
-    inst.toUpperCase = () => inst.check(_toUpperCase());
-    inst.slugify = () => inst.check(_slugify());
+    _installLazyMethods(inst, "_ZodString", {
+      regex(...args) {
+        return this.check(_regex(...args));
+      },
+      includes(...args) {
+        return this.check(_includes(...args));
+      },
+      startsWith(...args) {
+        return this.check(_startsWith(...args));
+      },
+      endsWith(...args) {
+        return this.check(_endsWith(...args));
+      },
+      min(...args) {
+        return this.check(_minLength(...args));
+      },
+      max(...args) {
+        return this.check(_maxLength(...args));
+      },
+      length(...args) {
+        return this.check(_length(...args));
+      },
+      nonempty(...args) {
+        return this.check(_minLength(1, ...args));
+      },
+      lowercase(params) {
+        return this.check(_lowercase(params));
+      },
+      uppercase(params) {
+        return this.check(_uppercase(params));
+      },
+      trim() {
+        return this.check(_trim());
+      },
+      normalize(...args) {
+        return this.check(_normalize(...args));
+      },
+      toLowerCase() {
+        return this.check(_toLowerCase());
+      },
+      toUpperCase() {
+        return this.check(_toUpperCase());
+      },
+      slugify() {
+        return this.check(_slugify());
+      }
+    });
   });
   var ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
     $ZodString.init(inst, def);
@@ -12905,7 +13571,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }
   function httpUrl(params) {
     return _url(ZodURL, {
-      protocol: /^https?$/,
+      protocol: regexes_exports.httpProtocol,
       hostname: regexes_exports.domain,
       ...util_exports.normalizeParams(params)
     });
@@ -13047,21 +13713,53 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     $ZodNumber.init(inst, def);
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2, 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.int = (params) => inst.check(int(params));
-    inst.safe = (params) => inst.check(int(params));
-    inst.positive = (params) => inst.check(_gt(0, params));
-    inst.nonnegative = (params) => inst.check(_gte(0, params));
-    inst.negative = (params) => inst.check(_lt(0, params));
-    inst.nonpositive = (params) => inst.check(_lte(0, params));
-    inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
-    inst.step = (value, params) => inst.check(_multipleOf(value, params));
-    inst.finite = () => inst;
+    _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;
@@ -13208,11 +13906,23 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params);
     inst.element = def.element;
-    inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
-    inst.nonempty = (params) => inst.check(_minLength(1, params));
-    inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));
-    inst.length = (len, params) => inst.check(_length(len, params));
-    inst.unwrap = () => inst.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;
+      }
+    });
   });
   function array(element, params) {
     return _array(ZodArray, element, params);
@@ -13228,23 +13938,47 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     util_exports.defineLazy(inst, "shape", () => {
       return def.shape;
     });
-    inst.keyof = () => _enum2(Object.keys(inst._zod.def.shape));
-    inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
-    inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
-    inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
-    inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
-    inst.strip = () => inst.clone({ ...inst._zod.def, catchall: void 0 });
-    inst.extend = (incoming) => {
-      return util_exports.extend(inst, incoming);
-    };
-    inst.safeExtend = (incoming) => {
-      return util_exports.safeExtend(inst, incoming);
-    };
-    inst.merge = (other) => util_exports.merge(inst, other);
-    inst.pick = (mask) => util_exports.pick(inst, mask);
-    inst.omit = (mask) => util_exports.omit(inst, mask);
-    inst.partial = (...args) => util_exports.partial(ZodOptional, inst, args[0]);
-    inst.required = (...args) => util_exports.required(ZodNonOptional, inst, args[0]);
+    _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]);
+      }
+    });
   });
   function object(shape, params) {
     const def = {
@@ -13349,6 +14083,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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)
+      });
+    }
     return new ZodRecord({
       type: "record",
       keyType,
@@ -13678,6 +14420,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       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 ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
     $ZodReadonly.init(inst, def);
     ZodType.init(inst, def);
@@ -13757,8 +14509,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   function refine(fn, _params = {}) {
     return _refine(ZodCustom, fn, _params);
   }
-  function superRefine(fn) {
-    return _superRefine(fn);
+  function superRefine(fn, params) {
+    return _superRefine(fn, params);
   }
   var describe2 = describe;
   var meta2 = meta;
@@ -14217,12 +14969,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       default:
         throw new Error(`Unsupported type: ${type}`);
     }
-    if (schema.description) {
-      zodSchema = zodSchema.describe(schema.description);
-    }
-    if (schema.default !== void 0) {
-      zodSchema = zodSchema.default(schema.default);
-    }
     return zodSchema;
   }
   function convertSchema(schema, ctx) {
@@ -14259,6 +15005,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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) {
@@ -14280,23 +15029,32 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     if (Object.keys(extraMeta).length > 0) {
       ctx.registry.add(baseSchema, extraMeta);
     }
+    if (schema.description) {
+      baseSchema = baseSchema.describe(schema.description);
+    }
     return baseSchema;
   }
   function fromJSONSchema(schema, params) {
     if (typeof schema === "boolean") {
       return schema ? z.any() : z.never();
     }
-    const version2 = detectVersion(schema, params?.defaultTarget);
-    const defs = schema.$defs || schema.definitions || {};
+    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: schema,
+      rootSchema: normalized,
       registry: params?.registry ?? globalRegistry
     };
-    return convertSchema(schema, ctx);
+    return convertSchema(normalized, ctx);
   }
 
   // node_modules/zod/v4/classic/coerce.js
@@ -14327,104 +15085,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   // node_modules/zod/v4/classic/external.js
   config(en_default());
 
-  // src/tools/get-abandoned-items.ts
-  var PERSISTED_HASH = "bd547859ce08366e86541b80eb6951d93aa36e1e4608842366309826793c223f";
-  var getAbandonedItems = defineTool({
-    name: "get_abandoned_items",
-    displayName: "Get Abandoned Items",
-    description: "Get items the user previously viewed or added to cart but did not complete booking. Useful for resuming interrupted booking flows.",
-    summary: "Get your abandoned cart items",
-    icon: "shopping-cart",
-    group: "Account",
-    input: external_exports.object({}),
-    output: external_exports.object({
-      items: external_exports.array(
-        external_exports.object({
-          type: external_exports.string().describe("Item type (HOTEL, FLIGHT, CAR)"),
-          hotel_name: external_exports.string().describe("Hotel name (if hotel)"),
-          hotel_id: external_exports.string().describe("Hotel ID (if hotel)"),
-          city_name: external_exports.string().describe("City name"),
-          check_in: external_exports.string().describe("Check-in date"),
-          check_out: external_exports.string().describe("Check-out date"),
-          price: external_exports.number().describe("Price at time of abandonment")
-        })
-      ).describe("Abandoned booking items")
-    }),
-    handle: async () => {
-      const data = await graphql("getAbandonedItemsByCguid", { cguid: getCguid() }, PERSISTED_HASH);
-      const items = data.getAbandonedItemsByCguid ?? [];
-      return {
-        items: items.map((item) => ({
-          type: item.type ?? "",
-          hotel_name: item.hotelName ?? "",
-          hotel_id: item.hotelId ?? "",
-          city_name: item.cityName ?? "",
-          check_in: item.checkIn ?? "",
-          check_out: item.checkOut ?? "",
-          price: item.price ?? 0
-        }))
-      };
-    }
-  });
-
-  // src/tools/get-customer-coupons.ts
-  var PERSISTED_HASH2 = "a1131592ee367b7b6dbe778e942d09d7d0219d5eacf47810a1894116d7454b6d";
-  var isCouponError = (v) => {
-    return "customerCouponError" in v;
-  };
-  var getCustomerCoupons = defineTool({
-    name: "get_customer_coupons",
-    displayName: "Get Customer Coupons",
-    description: "Get available coupons for the authenticated user. Coupons can be filtered by product type (STAY, FLY, DRIVE). Returns coupon codes, descriptions, expiration dates, and discount amounts.",
-    summary: "Get your available coupons",
-    icon: "ticket",
-    group: "Account",
-    input: external_exports.object({
-      product: external_exports.enum(["STAY", "FLY", "DRIVE"]).optional().describe("Product type to filter coupons (default STAY)")
-    }),
-    output: external_exports.object({
-      coupons: external_exports.array(
-        external_exports.object({
-          coupon_code: external_exports.string().describe("Coupon code"),
-          description: external_exports.string().describe("Coupon description"),
-          expiration_date: external_exports.string().describe("Expiration date"),
-          min_spend: external_exports.number().describe("Minimum spend amount"),
-          discount: external_exports.number().describe("Discount amount"),
-          discount_type: external_exports.string().describe("Discount type (PERCENT, FIXED)")
-        })
-      ).describe("Available coupons"),
-      message: external_exports.string().describe("Status message (e.g., no coupons found)")
-    }),
-    handle: async (params) => {
-      const data = await graphql(
-        "CustomerCoupons",
-        {
-          customerRequestOptions: {
-            products: [params.product ?? "STAY"]
-          }
-        },
-        PERSISTED_HASH2
-      );
-      const result = data.customerCoupons;
-      if (!result || isCouponError(result)) {
-        return {
-          coupons: [],
-          message: result?.customerCouponError ?? "No coupons available"
-        };
-      }
-      const couponData = result;
-      const coupons = (couponData.customerCoupons ?? []).map((c) => ({
-        coupon_code: c.couponCode ?? "",
-        description: c.description ?? "",
-        expiration_date: c.expirationDate ?? "",
-        min_spend: c.minSpend ?? 0,
-        discount: c.discount ?? 0,
-        discount_type: c.discountType ?? ""
-      }));
-      return { coupons, message: coupons.length > 0 ? "OK" : "No coupons available" };
-    }
-  });
-
   // src/tools/schemas.ts
   var searchItemSchema = external_exports.object({
     id: external_exports.string().describe("Location ID (city ID, POI ID, etc.)"),
@@ -14576,6 +15236,239 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     is_top_rated: e.topBadges?.isTopRated ?? false,
     is_top_booked: e.topBadges?.isTopBooked ?? false
   });
+  var airportSchema = external_exports.object({
+    id: external_exports.string().describe("IATA code for an airport (e.g., JFK, LAX) or city code for a metro area (e.g., NYC)"),
+    type: external_exports.string().describe("Entry type \u2014 AIRPORT for a specific airport, GDS_CITY for a multi-airport metropolitan area"),
+    display_name: external_exports.string().describe('Full display name (e.g., "New York City, NY - John F Kennedy Intl Airport (JFK)")'),
+    city_name: external_exports.string().describe("City name"),
+    state_code: external_exports.string().describe("State or province code (US only)"),
+    country_code: external_exports.string().describe("ISO country code (e.g., US, GB)"),
+    latitude: external_exports.number().describe("Airport latitude in decimal degrees; 0 for multi-airport metro entries"),
+    longitude: external_exports.number().describe("Airport longitude in decimal degrees; 0 for multi-airport metro entries"),
+    timezone: external_exports.string().describe("IANA timezone name (e.g., America/New_York)")
+  });
+  var mapAirport = (a) => ({
+    id: a.id ?? "",
+    type: a.subType ?? "",
+    display_name: a.displayName ?? "",
+    city_name: a.cityName ?? "",
+    state_code: a.stateCode ?? "",
+    country_code: a.countryCode ?? "",
+    latitude: a.lat ?? 0,
+    longitude: a.lon ?? 0,
+    timezone: a.timeZoneName ?? ""
+  });
+  var flightFareRecordSchema = external_exports.object({
+    dates: external_exports.array(external_exports.string()).describe(
+      "Travel date(s) in YYYY-MM-DD format. One entry for one-way searches; two entries (depart, return) for round-trip."
+    ),
+    min_price: external_exports.number().describe("Minimum fare per passenger in the response currency"),
+    currency: external_exports.string().describe("Currency code (e.g., USD)"),
+    is_private_fare: external_exports.boolean().describe("Whether the fare is a members-only private rate"),
+    stops_by_slice: external_exports.array(
+      external_exports.object({
+        slice_id: external_exports.number().int().describe("Slice number (1 for outbound, 2 for return)"),
+        stops: external_exports.number().int().describe("Number of stops for this slice (0 = non-stop)")
+      })
+    ).describe("Stop counts for each flight slice"),
+    takeoff_times: external_exports.array(external_exports.string()).describe("Departure times per slice in HH:MM (24h)"),
+    landing_times: external_exports.array(external_exports.string()).describe("Arrival times per slice in HH:MM (24h)")
+  });
+  var mapFlightFareRecord = (r) => ({
+    dates: r.dates ?? [],
+    min_price: r.minimumFare?.amtPerPax ?? 0,
+    currency: r.minimumFare?.currency ?? "",
+    is_private_fare: r.minimumFare?.isPrivateFare ?? false,
+    stops_by_slice: (r.minimumFare?.listOfStops ?? []).map((s) => ({
+      slice_id: s.sliceId ?? 0,
+      stops: s.stops ?? 0
+    })),
+    takeoff_times: r.minimumFare?.commonAttributes?.takeOffTimes ?? [],
+    landing_times: r.minimumFare?.commonAttributes?.landingTimes ?? []
+  });
+  var flightPriceWatchSchema = external_exports.object({
+    origin_code: external_exports.string().describe("Origin airport or city code"),
+    destination_code: external_exports.string().describe("Destination airport or city code"),
+    depart_date: external_exports.string().describe("Outbound date in YYYY-MM-DD format"),
+    return_date: external_exports.string().describe("Return date in YYYY-MM-DD format, empty for one-way watches"),
+    cabin_class: external_exports.string().describe("Cabin class (ECO, BUS, FIRST)"),
+    current_price: external_exports.number().describe("Most recently observed minimum fare"),
+    target_price: external_exports.number().describe("User-set target fare for alerts"),
+    is_active: external_exports.boolean().describe("Whether the watch is currently active"),
+    created_at: external_exports.string().describe("When the watch was created (ISO 8601)")
+  });
+  var mapFlightPriceWatch = (w) => ({
+    origin_code: w.originCityCode ?? "",
+    destination_code: w.destCityCode ?? "",
+    depart_date: w.departDate ?? "",
+    return_date: w.returnDate ?? "",
+    cabin_class: w.cabinClass ?? "",
+    current_price: w.currentPrice ?? 0,
+    target_price: w.targetPrice ?? 0,
+    is_active: w.active ?? false,
+    created_at: w.createdDate ?? ""
+  });
+
+  // src/tools/find-cheapest-flight-date.ts
+  var PRICE_CALENDAR_QUERY = `
+  query airPriceGuideCalendar($input: AirPriceGuideRequest) {
+    airPriceGuide(input: $input) {
+      error { type code message }
+      records {
+        dates
+        minimumFare {
+          isPrivateFare
+          currency
+          amtPerPax
+          commonAttributes { takeOffTimes landingTimes }
+          listOfStops { sliceId stops }
+        }
+      }
+    }
+  }`;
+  var findCheapestFlightDate = defineTool({
+    name: "find_cheapest_flight_date",
+    displayName: "Find Cheapest Flight Date",
+    description: "Find the single cheapest date to fly a route within a given date window. Returns the bottom N fares ordered from lowest to highest price, so the caller can pick the best date that fits their schedule. Works for one-way routes; for round-trip price optimization use get_flight_price_calendar with two trips.",
+    summary: "Find the cheapest flight date in a window",
+    icon: "piggy-bank",
+    group: "Flights",
+    input: external_exports.object({
+      origin: external_exports.string().describe("Origin airport or city code (e.g., JFK, NYC)"),
+      destination: external_exports.string().describe("Destination airport or city code (e.g., LAX, LON)"),
+      depart_date_from: external_exports.string().describe("Start of departure window in YYYY-MM-DD format"),
+      depart_date_to: external_exports.string().describe("End of departure window in YYYY-MM-DD format"),
+      top_n: external_exports.number().int().min(1).max(30).optional().describe("Number of cheapest dates to return (default 5, max 30)"),
+      cabin_class: external_exports.enum(["ECO", "PREMIUM", "BUS", "FIRST"]).optional().describe("Cabin class filter (default ECO)")
+    }),
+    output: external_exports.object({
+      records: external_exports.array(flightFareRecordSchema).describe("Cheapest flight dates in the window, sorted ascending by price")
+    }),
+    handle: async (params) => {
+      const variables = {
+        input: {
+          trips: [
+            {
+              originCity: [params.origin],
+              destinationCity: [params.destination],
+              departDateRange: { fromDate: params.depart_date_from, toDate: params.depart_date_to }
+            }
+          ],
+          size: 720,
+          consumer: "PCLN-HOME",
+          cabinClass: params.cabin_class ?? "ECO"
+        }
+      };
+      const data = await graphql("airPriceGuideCalendar", variables, PRICE_CALENDAR_QUERY);
+      const guide = data.airPriceGuide;
+      if (guide?.error) {
+        const msg = guide.error.message ?? "";
+        if (msg === "Zero results") return { records: [] };
+        throw ToolError.internal(`Flight price calendar error: ${msg}`);
+      }
+      const raw = guide?.records ?? [];
+      const mapped = raw.map(mapFlightFareRecord).filter((r) => r.min_price > 0).sort((a, b) => a.min_price - b.min_price).slice(0, params.top_n ?? 5);
+      return { records: mapped };
+    }
+  });
+
+  // src/tools/get-abandoned-items.ts
+  var PERSISTED_HASH = "bd547859ce08366e86541b80eb6951d93aa36e1e4608842366309826793c223f";
+  var getAbandonedItems = defineTool({
+    name: "get_abandoned_items",
+    displayName: "Get Abandoned Items",
+    description: "Get items the user previously viewed or added to cart but did not complete booking. Useful for resuming interrupted booking flows.",
+    summary: "Get your abandoned cart items",
+    icon: "shopping-cart",
+    group: "Account",
+    input: external_exports.object({}),
+    output: external_exports.object({
+      items: external_exports.array(
+        external_exports.object({
+          type: external_exports.string().describe("Item type (HOTEL, FLIGHT, CAR)"),
+          hotel_name: external_exports.string().describe("Hotel name (if hotel)"),
+          hotel_id: external_exports.string().describe("Hotel ID (if hotel)"),
+          city_name: external_exports.string().describe("City name"),
+          check_in: external_exports.string().describe("Check-in date"),
+          check_out: external_exports.string().describe("Check-out date"),
+          price: external_exports.number().describe("Price at time of abandonment")
+        })
+      ).describe("Abandoned booking items")
+    }),
+    handle: async () => {
+      const data = await graphql("getAbandonedItemsByCguid", { cguid: getCguid() }, PERSISTED_HASH);
+      const items = data.getAbandonedItemsByCguid ?? [];
+      return {
+        items: items.map((item) => ({
+          type: item.type ?? "",
+          hotel_name: item.hotelName ?? "",
+          hotel_id: item.hotelId ?? "",
+          city_name: item.cityName ?? "",
+          check_in: item.checkIn ?? "",
+          check_out: item.checkOut ?? "",
+          price: item.price ?? 0
+        }))
+      };
+    }
+  });
+
+  // src/tools/get-customer-coupons.ts
+  var PERSISTED_HASH2 = "a1131592ee367b7b6dbe778e942d09d7d0219d5eacf47810a1894116d7454b6d";
+  var isCouponError = (v) => {
+    return "customerCouponError" in v;
+  };
+  var getCustomerCoupons = defineTool({
+    name: "get_customer_coupons",
+    displayName: "Get Customer Coupons",
+    description: "Get available coupons for the authenticated user. Coupons can be filtered by product type (STAY, FLY, DRIVE). Returns coupon codes, descriptions, expiration dates, and discount amounts.",
+    summary: "Get your available coupons",
+    icon: "ticket",
+    group: "Account",
+    input: external_exports.object({
+      product: external_exports.enum(["STAY", "FLY", "DRIVE"]).optional().describe("Product type to filter coupons (default STAY)")
+    }),
+    output: external_exports.object({
+      coupons: external_exports.array(
+        external_exports.object({
+          coupon_code: external_exports.string().describe("Coupon code"),
+          description: external_exports.string().describe("Coupon description"),
+          expiration_date: external_exports.string().describe("Expiration date"),
+          min_spend: external_exports.number().describe("Minimum spend amount"),
+          discount: external_exports.number().describe("Discount amount"),
+          discount_type: external_exports.string().describe("Discount type (PERCENT, FIXED)")
+        })
+      ).describe("Available coupons"),
+      message: external_exports.string().describe("Status message (e.g., no coupons found)")
+    }),
+    handle: async (params) => {
+      const data = await graphql(
+        "CustomerCoupons",
+        {
+          customerRequestOptions: {
+            products: [params.product ?? "STAY"]
+          }
+        },
+        PERSISTED_HASH2
+      );
+      const result = data.customerCoupons;
+      if (!result || isCouponError(result)) {
+        return {
+          coupons: [],
+          message: result?.customerCouponError ?? "No coupons available"
+        };
+      }
+      const couponData = result;
+      const coupons = (couponData.customerCoupons ?? []).map((c) => ({
+        coupon_code: c.couponCode ?? "",
+        description: c.description ?? "",
+        expiration_date: c.expirationDate ?? "",
+        min_spend: c.minSpend ?? 0,
+        discount: c.discount ?? 0,
+        discount_type: c.discountType ?? ""
+      }));
+      return { coupons, message: coupons.length > 0 ? "OK" : "No coupons available" };
+    }
+  });
 
   // src/tools/get-customer-profile.ts
   var PERSISTED_HASH3 = "48d8218318dd4384631ab71f001f4475b9e47312a6bcfea98af8beb90526d7ff";
@@ -14644,6 +15537,80 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   });
 
+  // src/tools/get-flight-price-calendar.ts
+  var PRICE_CALENDAR_QUERY2 = `
+  query airPriceGuideCalendar($input: AirPriceGuideRequest) {
+    airPriceGuide(input: $input) {
+      error { type code message }
+      records {
+        dates
+        minimumFare {
+          isPrivateFare
+          currency
+          amtPerPax
+          commonAttributes { takeOffTimes landingTimes }
+          listOfStops { sliceId stops }
+        }
+      }
+    }
+  }`;
+  var cabinClassSchema = external_exports.enum(["ECO", "PREMIUM", "BUS", "FIRST"]).describe("Cabin class \u2014 ECO (economy), PREMIUM (premium economy), BUS (business), FIRST (first)");
+  var tripSchema = external_exports.object({
+    origin: external_exports.string().describe("Origin airport/city code (e.g., JFK, NYC)"),
+    destination: external_exports.string().describe("Destination airport/city code (e.g., LAX, LON)"),
+    depart_date: external_exports.string().optional().describe("Single departure date in YYYY-MM-DD format. Provide either this or depart_date_range, not both."),
+    depart_date_from: external_exports.string().optional().describe("Start of departure date window in YYYY-MM-DD format. Pair with depart_date_to for range searches."),
+    depart_date_to: external_exports.string().optional().describe("End of departure date window in YYYY-MM-DD format. Pair with depart_date_from for range searches.")
+  }).describe("A single flight slice (leg). For one-way pass one slice; for round-trip pass two (outbound + return).");
+  var buildTrip = (t) => {
+    const trip = {
+      originCity: [t.origin],
+      destinationCity: [t.destination]
+    };
+    if (t.depart_date_from && t.depart_date_to) {
+      trip.departDateRange = { fromDate: t.depart_date_from, toDate: t.depart_date_to };
+    } else if (t.depart_date) {
+      trip.departDate = t.depart_date;
+    } else {
+      throw ToolError.validation("Each trip must have either depart_date or both depart_date_from and depart_date_to.");
+    }
+    return trip;
+  };
+  var getFlightPriceCalendar = defineTool({
+    name: "get_flight_price_calendar",
+    displayName: "Get Flight Price Calendar",
+    description: "Get Priceline's fare forecast for a route over a date range. Returns the cheapest available fare for each date (or date combination for round-trips), along with departure/arrival times and stop counts. Pass a single `trips` entry for one-way, or two entries (outbound + return) for round-trip. Each trip can be a single date (`depart_date`) or a date window (`depart_date_from`/`depart_date_to`). Useful for finding the cheapest date to fly before booking.",
+    summary: "Flight fare forecast for a date range",
+    icon: "calendar-range",
+    group: "Flights",
+    input: external_exports.object({
+      trips: external_exports.array(tripSchema).min(1).max(6).describe("Flight slices \u2014 1 for one-way, 2 for round-trip, up to 6 for multi-city"),
+      cabin_class: cabinClassSchema.optional().describe("Cabin class filter (default ECO)")
+    }),
+    output: external_exports.object({
+      records: external_exports.array(flightFareRecordSchema).describe("Cheapest fares by date combination, sorted by trip dates")
+    }),
+    handle: async (params) => {
+      const variables = {
+        input: {
+          trips: params.trips.map(buildTrip),
+          size: 720,
+          consumer: "PCLN-HOME",
+          cabinClass: params.cabin_class ?? "ECO"
+        }
+      };
+      const data = await graphql("airPriceGuideCalendar", variables, PRICE_CALENDAR_QUERY2);
+      const guide = data.airPriceGuide;
+      if (guide?.error) {
+        const msg = guide.error.message ?? "";
+        if (msg === "Zero results") return { records: [] };
+        throw ToolError.internal(`Flight price calendar error: ${msg}`);
+      }
+      const records = guide?.records ?? [];
+      return { records: records.map(mapFlightFareRecord) };
+    }
+  });
+
   // src/tools/get-hotel-descriptions.ts
   var PERSISTED_HASH5 = "991edc70fc5972ea86c4db02e07cc45ba1b75fffa12f4b5e2bd3998faaaf70c7";
   var getHotelDescriptions = defineTool({
@@ -14794,6 +15761,93 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   });
 
+  // src/tools/list-flight-price-watches.ts
+  var PRICE_WATCH_LIST_QUERY = `
+  query PriceWatches($input: AirPriceWatchGetListRequest!) {
+    airPriceWatchGetListResponse(input: $input) {
+      status statusCode statusMessage email
+      error { code message }
+      priceWatchGetListResp
+    }
+  }`;
+  var generateRequestId = () => {
+    return `opentabs-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+  };
+  var listFlightPriceWatches = defineTool({
+    name: "list_flight_price_watches",
+    displayName: "List Flight Price Watches",
+    description: "List the authenticated user's active Priceline flight price watches. Returns watches the user has set up to track fare changes on specific routes. Each entry includes origin, destination, travel dates, cabin class, current price, and target price.",
+    summary: "List user's flight price alerts",
+    icon: "bell",
+    group: "Flights",
+    input: external_exports.object({
+      include_inactive: external_exports.boolean().optional().describe("Include inactive (paused or expired) watches in addition to active ones (default false)")
+    }),
+    output: external_exports.object({
+      price_watches: external_exports.array(flightPriceWatchSchema).describe("Active flight price watches for the signed-in user")
+    }),
+    handle: async (params) => {
+      const email3 = getEmail();
+      const variables = {
+        input: {
+          email: email3,
+          requestId: generateRequestId(),
+          includeInactive: params.include_inactive ?? false,
+          includeOptedOut: false
+        }
+      };
+      const data = await flyGraphql("PriceWatches", variables, PRICE_WATCH_LIST_QUERY);
+      const resp = data.airPriceWatchGetListResponse;
+      if (resp?.status === "ERROR") {
+        throw ToolError.internal(`Price watch list error: ${resp.statusMessage ?? "unknown error"}`);
+      }
+      if (resp?.error) {
+        throw ToolError.internal(`Price watch list error: ${resp.error.message ?? "unknown error"}`);
+      }
+      const list = resp?.priceWatchGetListResp?.priceWatches ?? resp?.priceWatchGetListResp?.optedInData ?? [];
+      return { price_watches: list.map(mapFlightPriceWatch) };
+    }
+  });
+
+  // src/tools/navigate-to-flight-search.ts
+  var tripTypeSchema = external_exports.enum(["OW", "RT"]).describe("Trip type \u2014 OW (one-way) or RT (round-trip)");
+  var cabinClassSchema2 = external_exports.enum(["ECONOMY", "PREMIUM", "BUSINESS", "FIRST"]).describe("Cabin class for the search URL");
+  var toYmd = (date5) => {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(date5);
+    if (!match) throw new Error(`Invalid date ${date5} \u2014 expected YYYY-MM-DD`);
+    return date5;
+  };
+  var navigateToFlightSearch = defineTool({
+    name: "navigate_to_flight_search",
+    displayName: "Navigate to Flight Search",
+    description: "Open Priceline's flight search results page for a given route and dates in the user's browser. This navigates the current tab so the user can review flights, apply filters, and book in their authenticated session. Use this after get_flight_price_calendar or find_cheapest_flight_date has identified a good route/date \u2014 it hands control back to the user for the full search and booking flow. Requires airport/city codes (use search_airports to find them).",
+    summary: "Open Priceline flight search for a route",
+    icon: "plane",
+    group: "Flights",
+    input: external_exports.object({
+      origin: external_exports.string().describe("Origin airport or city code (e.g., JFK, NYC)"),
+      destination: external_exports.string().describe("Destination airport or city code (e.g., LAX, LON)"),
+      depart_date: external_exports.string().describe("Departure date in YYYY-MM-DD format"),
+      return_date: external_exports.string().optional().describe("Return date in YYYY-MM-DD format (round-trip only; omit for one-way)"),
+      trip_type: tripTypeSchema.optional().describe("Trip type (default OW for one-way, RT when return_date is set)"),
+      cabin_class: cabinClassSchema2.optional().describe("Cabin class (default ECONOMY)"),
+      passengers: external_exports.number().int().min(1).max(8).optional().describe("Number of passengers (default 1)")
+    }),
+    output: external_exports.object({
+      url: external_exports.string().describe("The Priceline flight search URL that was opened")
+    }),
+    handle: async (params) => {
+      const depart = toYmd(params.depart_date);
+      const tripType = params.trip_type ?? (params.return_date ? "RT" : "OW");
+      const cabin = params.cabin_class ?? "ECONOMY";
+      const pax = params.passengers ?? 1;
+      const returnSegment = tripType === "RT" && params.return_date ? `/${toYmd(params.return_date)}` : "";
+      const url2 = `https://www.priceline.com/m/fly/search/${params.origin}-${params.destination}/${depart}${returnSegment}/?tripType=${tripType}&cabinClass=${cabin}&numOfPassengers=${pax}`;
+      window.location.href = url2;
+      return { url: url2 };
+    }
+  });
+
   // src/tools/navigate-to-hotel.ts
   var navigateToHotel = defineTool({
     name: "navigate_to_hotel",
@@ -14850,6 +15904,26 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   });
 
+  // src/tools/search-airports.ts
+  var searchAirports = defineTool({
+    name: "search_airports",
+    displayName: "Search Airports",
+    description: "Find airports and multi-airport metro areas matching a keyword. Returns IATA codes (e.g., JFK, LAX) for specific airports and three-letter city codes (e.g., NYC, LON) for metros that combine all nearby airports. Use the returned `id` value as the origin or destination code in other flight tools. Results are ranked by relevance.",
+    summary: "Find airport and city codes by keyword",
+    icon: "plane-takeoff",
+    group: "Flights",
+    input: external_exports.object({
+      keyword: external_exports.string().describe('Search keyword \u2014 a city name, airport name, or IATA code (e.g., "new york", "heathrow", "JFK")')
+    }),
+    output: external_exports.object({
+      airports: external_exports.array(airportSchema).describe("Matching airports and metro areas ranked by relevance")
+    }),
+    handle: async (params) => {
+      const items = await autocomplete("flights", params.keyword);
+      return { airports: items.map(mapAirport) };
+    }
+  });
+
   // src/tools/search-hotels.ts
   var PERSISTED_HASH9 = "ffaeed6473a0adf0074403134bb897df6c6f402f9a0322017b0ec4d268d943c3";
   var searchHotels = defineTool({
@@ -14993,6 +16067,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       getMerchandisingBadges,
       getPriceGuidance,
       navigateToHotel,
+      // Flights
+      searchAirports,
+      getFlightPriceCalendar,
+      findCheapestFlightDate,
+      listFlightPriceWatches,
+      navigateToFlightSearch,
       // Account
       getCustomerProfile,
       getCustomerCoupons,
@@ -15006,7 +16086,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   };
   var src_default = new PricelinePlugin();
 
-  // dist/_adapter_entry_03f3ef40-74be-43b4-b215-1aacc602d473.ts
+  // dist/_adapter_entry_42ad1878-e5c5-4b74-9b7c-c78c0e998891.ts
   if (!globalThis.__openTabs) {
     globalThis.__openTabs = {};
   } else {
@@ -15094,6 +16174,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     const origHandle = tool.handle;
     tool.handle = async function(...handleArgs) {
       const startTime = performance.now();
+      const runtime = globalThis.__openTabs;
+      runtime._pluginName = "priceline";
       if (hasLifecycleHooks && typeof src_default.onToolInvocationStart === "function") {
         try {
           src_default.onToolInvocationStart(tool.name);
@@ -15222,5 +16304,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["priceline"]){var a=o.adapters["priceline"];a.__adapterHash="abb117c5974a46ba0c1bff5eb05937bf9eb486e043e1d7d88a0d8cdce998ac3a";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,"priceline",{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["priceline"]){var a=o.adapters["priceline"];a.__adapterHash="9fc3443ca87448f19750143d81ee45e4ea133cfdb224402a7ea25247692a5bd5";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,"priceline",{value:a,writable:false,configurable:false,enumerable:true});Object.defineProperty(o,"adapters",{value:o.adapters,writable:false,configurable:false});}})();
 //# sourceMappingURL=adapter.iife.js.map