@wavelengthusaf/components 3.3.11 → 3.4.0

package/dist/cjs/index.cjs

@@ -7,6 +7,10 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -989,7 +993,7 @@ var require_react_is_production = __commonJS({
     var REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list");
     var REACT_MEMO_TYPE = Symbol.for("react.memo");
     var REACT_LAZY_TYPE = Symbol.for("react.lazy");
-    var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen");
+    var REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition");
     var REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
     function typeOf(object) {
       if ("object" === typeof object && null !== object) {
@@ -1002,6 +1006,7 @@ var require_react_is_production = __commonJS({
               case REACT_STRICT_MODE_TYPE:
               case REACT_SUSPENSE_TYPE:
               case REACT_SUSPENSE_LIST_TYPE:
+              case REACT_VIEW_TRANSITION_TYPE:
                 return object;
               default:
                 switch (object = object && object.$$typeof, object) {
@@ -1070,7 +1075,7 @@ var require_react_is_production = __commonJS({
       return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
     };
     exports.isValidElementType = function(type) {
-      return "string" === typeof type || "function" === typeof type || type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_OFFSCREEN_TYPE || "object" === typeof type && null !== type && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_CONSUMER_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_CLIENT_REFERENCE || void 0 !== type.getModuleId) ? true : false;
+      return "string" === typeof type || "function" === typeof type || type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || "object" === typeof type && null !== type && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_CONSUMER_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_CLIENT_REFERENCE || void 0 !== type.getModuleId) ? true : false;
     };
     exports.typeOf = typeOf;
   }
@@ -1080,7 +1085,7 @@ var require_react_is_production = __commonJS({
 var require_react_is_development2 = __commonJS({
   "../../node_modules/react-is/cjs/react-is.development.js"(exports) {
     "use strict";
-    "production" !== process.env.NODE_ENV && function() {
+    "production" !== process.env.NODE_ENV && (function() {
       function typeOf(object) {
         if ("object" === typeof object && null !== object) {
           var $$typeof = object.$$typeof;
@@ -1092,6 +1097,7 @@ var require_react_is_development2 = __commonJS({
                 case REACT_STRICT_MODE_TYPE:
                 case REACT_SUSPENSE_TYPE:
                 case REACT_SUSPENSE_LIST_TYPE:
+                case REACT_VIEW_TRANSITION_TYPE:
                   return object;
                 default:
                   switch (object = object && object.$$typeof, object) {
@@ -1113,7 +1119,7 @@ var require_react_is_development2 = __commonJS({
       }
       var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler");
       Symbol.for("react.provider");
-      var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
+      var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
       exports.ContextConsumer = REACT_CONSUMER_TYPE;
       exports.ContextProvider = REACT_CONTEXT_TYPE;
       exports.Element = REACT_ELEMENT_TYPE;
@@ -1163,10 +1169,10 @@ var require_react_is_development2 = __commonJS({
         return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
       };
       exports.isValidElementType = function(type) {
-        return "string" === typeof type || "function" === typeof type || type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_OFFSCREEN_TYPE || "object" === typeof type && null !== type && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_CONSUMER_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_CLIENT_REFERENCE || void 0 !== type.getModuleId) ? true : false;
+        return "string" === typeof type || "function" === typeof type || type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || "object" === typeof type && null !== type && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_CONSUMER_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_CLIENT_REFERENCE || void 0 !== type.getModuleId) ? true : false;
       };
       exports.typeOf = typeOf;
-    }();
+    })();
   }
 });
 
@@ -1466,105 +1472,2945 @@ var WavelengthButton = class extends HTMLElement {
     if (this.hasAttribute("padding") && padding2 && padding2.trim() !== "") {
       this.button.style.padding = padding2;
     } else {
-      this.applyPresetSize(size);
+      this.applyPresetSize(size);
+    }
+    if (width2) this.button.style.width = width2;
+    this.button.style.height = height2;
+    if (variant === "contained") {
+      this.button.style.backgroundColor = colorOne;
+      this.button.style.color = colorTwo;
+      this.button.style.border = `0.063rem solid ${colorOne}`;
+      this.button.style.boxShadow = boxShadow || "0rem 0.125rem 0.25rem -0.063rem #000000";
+    } else if (variant === "outlined") {
+      this.button.style.backgroundColor = "transparent";
+      this.button.style.color = colorOne;
+      this.button.style.border = `0.063rem solid ${colorOne}`;
+      this.button.style.boxShadow = boxShadow || "none";
+    } else {
+      this.button.style.backgroundColor = "transparent";
+      this.button.style.color = colorOne;
+      this.button.style.border = "none";
+      this.button.style.boxShadow = boxShadow || "none";
+    }
+    if (href && !disabled) {
+      this.button.onclick = () => window.open(href, target);
+      this.button.style.cursor = "pointer";
+    } else {
+      this.button.onclick = null;
+    }
+    this.button.removeEventListener("mouseenter", this.handleHoverIn);
+    this.button.removeEventListener("mouseleave", this.handleHoverOut);
+    this.handleHoverIn = () => {
+      if (variant === "contained") {
+        this.button.style.backgroundColor = this.shadeColor(colorOne, -15);
+      } else {
+        this.button.style.backgroundColor = this.hexToRgba(colorOne, 0.05);
+      }
+    };
+    this.handleHoverOut = () => {
+      if (variant === "contained") {
+        this.button.style.backgroundColor = colorOne;
+      } else {
+        this.button.style.backgroundColor = "transparent";
+      }
+    };
+    this.button.addEventListener("mouseenter", this.handleHoverIn);
+    this.button.addEventListener("mouseleave", this.handleHoverOut);
+  }
+  applyPresetSize(size) {
+    if (size === "small") {
+      this.button.style.padding = "0.5rem";
+    } else if (size === "medium") {
+      this.button.style.padding = "0.6875rem 0.75rem";
+    } else if (size === "large") {
+      this.button.style.padding = "0.875rem 1rem";
+    }
+  }
+  hexToRgba(hex, alpha) {
+    let r = 0, g = 0, b = 0;
+    if (hex.length === 4) {
+      r = parseInt(hex[1] + hex[1], 16);
+      g = parseInt(hex[2] + hex[2], 16);
+      b = parseInt(hex[3] + hex[3], 16);
+    } else if (hex.length === 7) {
+      r = parseInt(hex[1] + hex[2], 16);
+      g = parseInt(hex[3] + hex[4], 16);
+      b = parseInt(hex[5] + hex[6], 16);
+    }
+    return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+  }
+  shadeColor(hex, percent) {
+    let R = parseInt(hex.substring(1, 3), 16);
+    let G = parseInt(hex.substring(3, 5), 16);
+    let B = parseInt(hex.substring(5, 7), 16);
+    R = Math.min(255, Math.max(0, R + R * percent / 100));
+    G = Math.min(255, Math.max(0, G + G * percent / 100));
+    B = Math.min(255, Math.max(0, B + B * percent / 100));
+    const toHex = (c) => {
+      const hex2 = Math.round(c).toString(16);
+      return hex2.length === 1 ? "0" + hex2 : hex2;
+    };
+    return `#${toHex(R)}${toHex(G)}${toHex(B)}`;
+  }
+  handleRipple(event) {
+    if (this.button.disabled) return;
+    const variant = this.getAttribute("variant") || "outlined";
+    const colorOne = this.getAttribute("color-one") || "#1976D2";
+    const ripple = document.createElement("span");
+    ripple.className = "ripple";
+    const color2 = variant === "contained" ? this.hexToRgba(this.shadeColor(colorOne, 40), 0.6) : this.hexToRgba(this.shadeColor(colorOne, -40), 0.3);
+    ripple.style.backgroundColor = color2;
+    const rect = this.button.getBoundingClientRect();
+    const size = Math.max(rect.width, rect.height);
+    ripple.style.width = ripple.style.height = `${size}px`;
+    ripple.style.left = `${event.clientX - rect.left - size / 2}px`;
+    ripple.style.top = `${event.clientY - rect.top - size / 2}px`;
+    this.button.appendChild(ripple);
+    setTimeout(() => ripple.remove(), 600);
+  }
+};
+if (!customElements.get("wavelength-button")) {
+  customElements.define("wavelength-button", WavelengthButton);
+}
+
+// src/form/zodToFields.ts
+function camelToPascalLabel(name) {
+  return name.replace(/([A-Z])/g, " $1").replace(/\b\w/g, (c) => c.toUpperCase()).trim();
+}
+function unwrap(t) {
+  let cur = t;
+  while (cur && cur._def) {
+    const next = cur._def.innerType || cur._def.schema || cur._def.type;
+    if (next && typeof next === "object") {
+      cur = next;
+    } else {
+      break;
+    }
+  }
+  return cur;
+}
+function isZodType(core, type) {
+  const anyCore = core;
+  const typeName = _optionalChain([anyCore, 'optionalAccess', _6 => _6._def, 'optionalAccess', _7 => _7.typeName]);
+  if (typeof typeName === "string" && typeName === type) return true;
+  const ctorName = _optionalChain([anyCore, 'optionalAccess', _8 => _8.constructor, 'optionalAccess', _9 => _9.name]);
+  return ctorName === type;
+}
+function zodToFields(schema) {
+  const fields = [];
+  const shape2 = schema.shape;
+  for (const [name, zt] of Object.entries(shape2)) {
+    const core = unwrap(zt);
+    let type;
+    if (isZodType(core, "ZodString")) type = "text";
+    else if (isZodType(core, "ZodNumber")) type = "number";
+    else if (isZodType(core, "ZodBoolean")) type = "checkbox";
+    if (type) {
+      const anyZt = zt;
+      const field = {
+        name,
+        label: camelToPascalLabel(name),
+        type,
+        required: typeof anyZt.isOptional === "function" ? !anyZt.isOptional() : true
+      };
+      const placeholder = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce((typeof anyZt.meta === "function" ? _optionalChain([anyZt, 'access', _10 => _10.meta, 'call', _11 => _11(), 'optionalAccess', _12 => _12.placeholder]) : void 0), () => ( _optionalChain([anyZt, 'optionalAccess', _13 => _13.description]))), () => ( _optionalChain([anyZt, 'optionalAccess', _14 => _14._def, 'optionalAccess', _15 => _15.description]))), () => ( (typeof core.meta === "function" ? _optionalChain([core, 'access', _16 => _16.meta, 'call', _17 => _17(), 'optionalAccess', _18 => _18.placeholder]) : void 0))), () => ( _optionalChain([core, 'optionalAccess', _19 => _19.description]))), () => ( _optionalChain([core, 'optionalAccess', _20 => _20._def, 'optionalAccess', _21 => _21.description]))), () => ( field.label));
+      field.placeholder = placeholder;
+      if (type === "text") {
+        const checks = _nullishCoalesce(_optionalChain([core, 'optionalAccess', _22 => _22._def, 'optionalAccess', _23 => _23.checks]), () => ( []));
+        for (const chk of checks) {
+          const kind = chk.kind || _optionalChain([chk, 'access', _24 => _24._zod, 'optionalAccess', _25 => _25.def, 'optionalAccess', _26 => _26.check]);
+          const min = _nullishCoalesce(chk.value, () => ( _optionalChain([chk, 'access', _27 => _27._zod, 'optionalAccess', _28 => _28.def, 'optionalAccess', _29 => _29.minimum])));
+          const max = _nullishCoalesce(chk.value, () => ( _optionalChain([chk, 'access', _30 => _30._zod, 'optionalAccess', _31 => _31.def, 'optionalAccess', _32 => _32.maximum])));
+          if ((kind === "min" || kind === "min_length") && typeof min === "number") {
+            field.minLength = min;
+          }
+          if ((kind === "max" || kind === "max_length") && typeof max === "number") {
+            field.maxLength = max;
+          }
+        }
+      }
+      fields.push(field);
+    }
+  }
+  return fields;
+}
+
+// ../../node_modules/zod/v4/core/core.js
+var NEVER = Object.freeze({
+  status: "aborted"
+});
+// @__NO_SIDE_EFFECTS__
+function $constructor(name, initializer3, params) {
+  function init(inst, def) {
+    var _a;
+    Object.defineProperty(inst, "_zod", {
+      value: _nullishCoalesce(inst._zod, () => ( {})),
+      enumerable: false
+    });
+    _nullishCoalesce((_a = inst._zod).traits, () => ( (_a.traits = /* @__PURE__ */ new Set())));
+    inst._zod.traits.add(name);
+    initializer3(inst, def);
+    for (const k in _.prototype) {
+      if (!(k in inst))
+        Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
+    }
+    inst._zod.constr = _;
+    inst._zod.def = def;
+  }
+  const Parent = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _33 => _33.Parent]), () => ( Object));
+  class Definition extends Parent {
+  }
+  Object.defineProperty(Definition, "name", { value: name });
+  function _(def) {
+    var _a;
+    const inst = _optionalChain([params, 'optionalAccess', _34 => _34.Parent]) ? new Definition() : this;
+    init(inst, def);
+    _nullishCoalesce((_a = inst._zod).deferred, () => ( (_a.deferred = [])));
+    for (const fn of inst._zod.deferred) {
+      fn();
+    }
+    return inst;
+  }
+  Object.defineProperty(_, "init", { value: init });
+  Object.defineProperty(_, Symbol.hasInstance, {
+    value: (inst) => {
+      if (_optionalChain([params, 'optionalAccess', _35 => _35.Parent]) && inst instanceof params.Parent)
+        return true;
+      return _optionalChain([inst, 'optionalAccess', _36 => _36._zod, 'optionalAccess', _37 => _37.traits, 'optionalAccess', _38 => _38.has, 'call', _39 => _39(name)]);
+    }
+  });
+  Object.defineProperty(_, "name", { value: name });
+  return _;
+}
+var $brand = Symbol("zod_brand");
+var $ZodAsyncError = class extends Error {
+  constructor() {
+    super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
+  }
+};
+var $ZodEncodeError = class extends Error {
+  constructor(name) {
+    super(`Encountered unidirectional transform during encode: ${name}`);
+    this.name = "ZodEncodeError";
+  }
+};
+var globalConfig = {};
+function config(newConfig) {
+  if (newConfig)
+    Object.assign(globalConfig, newConfig);
+  return globalConfig;
+}
+
+// ../../node_modules/zod/v4/core/util.js
+var util_exports = {};
+__export(util_exports, {
+  BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES,
+  Class: () => Class,
+  NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
+  aborted: () => aborted,
+  allowsEval: () => allowsEval,
+  assert: () => assert,
+  assertEqual: () => assertEqual,
+  assertIs: () => assertIs,
+  assertNever: () => assertNever,
+  assertNotEqual: () => assertNotEqual,
+  assignProp: () => assignProp,
+  base64ToUint8Array: () => base64ToUint8Array,
+  base64urlToUint8Array: () => base64urlToUint8Array,
+  cached: () => cached,
+  captureStackTrace: () => captureStackTrace,
+  cleanEnum: () => cleanEnum,
+  cleanRegex: () => cleanRegex,
+  clone: () => clone,
+  cloneDef: () => cloneDef,
+  createTransparentProxy: () => createTransparentProxy,
+  defineLazy: () => defineLazy,
+  esc: () => esc,
+  escapeRegex: () => escapeRegex,
+  extend: () => extend,
+  finalizeIssue: () => finalizeIssue,
+  floatSafeRemainder: () => floatSafeRemainder,
+  getElementAtPath: () => getElementAtPath,
+  getEnumValues: () => getEnumValues,
+  getLengthableOrigin: () => getLengthableOrigin,
+  getParsedType: () => getParsedType,
+  getSizableOrigin: () => getSizableOrigin,
+  hexToUint8Array: () => hexToUint8Array,
+  isObject: () => isObject,
+  isPlainObject: () => isPlainObject,
+  issue: () => issue,
+  joinValues: () => joinValues,
+  jsonStringifyReplacer: () => jsonStringifyReplacer,
+  merge: () => merge,
+  mergeDefs: () => mergeDefs,
+  normalizeParams: () => normalizeParams,
+  nullish: () => nullish,
+  numKeys: () => numKeys,
+  objectClone: () => objectClone,
+  omit: () => omit,
+  optionalKeys: () => optionalKeys,
+  partial: () => partial,
+  pick: () => pick,
+  prefixIssues: () => prefixIssues,
+  primitiveTypes: () => primitiveTypes,
+  promiseAllObject: () => promiseAllObject,
+  propertyKeyTypes: () => propertyKeyTypes,
+  randomString: () => randomString,
+  required: () => required,
+  safeExtend: () => safeExtend,
+  shallowClone: () => shallowClone,
+  stringifyPrimitive: () => stringifyPrimitive,
+  uint8ArrayToBase64: () => uint8ArrayToBase64,
+  uint8ArrayToBase64url: () => uint8ArrayToBase64url,
+  uint8ArrayToHex: () => uint8ArrayToHex,
+  unwrapMessage: () => unwrapMessage
+});
+function assertEqual(val) {
+  return val;
+}
+function assertNotEqual(val) {
+  return val;
+}
+function assertIs(_arg) {
+}
+function assertNever(_x) {
+  throw new Error();
+}
+function assert(_) {
+}
+function getEnumValues(entries) {
+  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
+  const values2 = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
+  return values2;
+}
+function joinValues(array2, separator = "|") {
+  return array2.map((val) => stringifyPrimitive(val)).join(separator);
+}
+function jsonStringifyReplacer(_, value) {
+  if (typeof value === "bigint")
+    return value.toString();
+  return value;
+}
+function cached(getter) {
+  const set = false;
+  return {
+    get value() {
+      if (!set) {
+        const value = getter();
+        Object.defineProperty(this, "value", { value });
+        return value;
+      }
+      throw new Error("cached value already set");
+    }
+  };
+}
+function nullish(input) {
+  return input === null || input === void 0;
+}
+function cleanRegex(source) {
+  const start = source.startsWith("^") ? 1 : 0;
+  const end = source.endsWith("$") ? source.length - 1 : source.length;
+  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 (_optionalChain([match, 'optionalAccess', _40 => _40[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;
+}
+var EVALUATING = Symbol("evaluating");
+function defineLazy(object, key, getter) {
+  let value = void 0;
+  Object.defineProperty(object, key, {
+    get() {
+      if (value === EVALUATING) {
+        return void 0;
+      }
+      if (value === void 0) {
+        value = EVALUATING;
+        value = getter();
+      }
+      return value;
+    },
+    set(v) {
+      Object.defineProperty(object, key, {
+        value: v
+        // configurable: true,
+      });
+    },
+    configurable: true
+  });
+}
+function objectClone(obj) {
+  return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
+}
+function assignProp(target, prop, value) {
+  Object.defineProperty(target, prop, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+}
+function mergeDefs(...defs) {
+  const mergedDescriptors = {};
+  for (const def of defs) {
+    const descriptors = Object.getOwnPropertyDescriptors(def);
+    Object.assign(mergedDescriptors, descriptors);
+  }
+  return Object.defineProperties({}, mergedDescriptors);
+}
+function cloneDef(schema) {
+  return mergeDefs(schema._zod.def);
+}
+function getElementAtPath(obj, path) {
+  if (!path)
+    return obj;
+  return path.reduce((acc, key) => _optionalChain([acc, 'optionalAccess', _41 => _41[key]]), obj);
+}
+function promiseAllObject(promisesObj) {
+  const keys = Object.keys(promisesObj);
+  const promises = keys.map((key) => promisesObj[key]);
+  return Promise.all(promises).then((results) => {
+    const resolvedObj = {};
+    for (let i = 0; i < keys.length; i++) {
+      resolvedObj[keys[i]] = results[i];
+    }
+    return resolvedObj;
+  });
+}
+function randomString(length = 10) {
+  const chars = "abcdefghijklmnopqrstuvwxyz";
+  let str = "";
+  for (let i = 0; i < length; i++) {
+    str += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return str;
+}
+function esc(str) {
+  return JSON.stringify(str);
+}
+var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {
+};
+function isObject(data) {
+  return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+var allowsEval = cached(() => {
+  if (typeof navigator !== "undefined" && _optionalChain([navigator, 'optionalAccess', _42 => _42.userAgent, 'optionalAccess', _43 => _43.includes, 'call', _44 => _44("Cloudflare")])) {
+    return false;
+  }
+  try {
+    const F = Function;
+    new F("");
+    return true;
+  } catch (_) {
+    return false;
+  }
+});
+function isPlainObject(o) {
+  if (isObject(o) === false)
+    return false;
+  const ctor = o.constructor;
+  if (ctor === void 0)
+    return true;
+  const prot = ctor.prototype;
+  if (isObject(prot) === false)
+    return false;
+  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
+    return false;
+  }
+  return true;
+}
+function shallowClone(o) {
+  if (isPlainObject(o))
+    return { ...o };
+  return o;
+}
+function numKeys(data) {
+  let keyCount = 0;
+  for (const key in data) {
+    if (Object.prototype.hasOwnProperty.call(data, key)) {
+      keyCount++;
+    }
+  }
+  return keyCount;
+}
+var getParsedType = (data) => {
+  const t = typeof data;
+  switch (t) {
+    case "undefined":
+      return "undefined";
+    case "string":
+      return "string";
+    case "number":
+      return Number.isNaN(data) ? "nan" : "number";
+    case "boolean":
+      return "boolean";
+    case "function":
+      return "function";
+    case "bigint":
+      return "bigint";
+    case "symbol":
+      return "symbol";
+    case "object":
+      if (Array.isArray(data)) {
+        return "array";
+      }
+      if (data === null) {
+        return "null";
+      }
+      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
+        return "promise";
+      }
+      if (typeof Map !== "undefined" && data instanceof Map) {
+        return "map";
+      }
+      if (typeof Set !== "undefined" && data instanceof Set) {
+        return "set";
+      }
+      if (typeof Date !== "undefined" && data instanceof Date) {
+        return "date";
+      }
+      if (typeof File !== "undefined" && data instanceof File) {
+        return "file";
+      }
+      return "object";
+    default:
+      throw new Error(`Unknown data type: ${t}`);
+  }
+};
+var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
+var primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function clone(inst, def, params) {
+  const cl = new inst._zod.constr(_nullishCoalesce(def, () => ( inst._zod.def)));
+  if (!def || _optionalChain([params, 'optionalAccess', _45 => _45.parent]))
+    cl._zod.parent = inst;
+  return cl;
+}
+function normalizeParams(_params) {
+  const params = _params;
+  if (!params)
+    return {};
+  if (typeof params === "string")
+    return { error: () => params };
+  if (_optionalChain([params, 'optionalAccess', _46 => _46.message]) !== void 0) {
+    if (_optionalChain([params, 'optionalAccess', _47 => _47.error]) !== void 0)
+      throw new Error("Cannot specify both `message` and `error` params");
+    params.error = params.message;
+  }
+  delete params.message;
+  if (typeof params.error === "string")
+    return { ...params, error: () => params.error };
+  return params;
+}
+function createTransparentProxy(getter) {
+  let target;
+  return new Proxy({}, {
+    get(_, prop, receiver) {
+      _nullishCoalesce(target, () => ( (target = getter())));
+      return Reflect.get(target, prop, receiver);
+    },
+    set(_, prop, value, receiver) {
+      _nullishCoalesce(target, () => ( (target = getter())));
+      return Reflect.set(target, prop, value, receiver);
+    },
+    has(_, prop) {
+      _nullishCoalesce(target, () => ( (target = getter())));
+      return Reflect.has(target, prop);
+    },
+    deleteProperty(_, prop) {
+      _nullishCoalesce(target, () => ( (target = getter())));
+      return Reflect.deleteProperty(target, prop);
+    },
+    ownKeys(_) {
+      _nullishCoalesce(target, () => ( (target = getter())));
+      return Reflect.ownKeys(target);
+    },
+    getOwnPropertyDescriptor(_, prop) {
+      _nullishCoalesce(target, () => ( (target = getter())));
+      return Reflect.getOwnPropertyDescriptor(target, prop);
+    },
+    defineProperty(_, prop, descriptor) {
+      _nullishCoalesce(target, () => ( (target = getter())));
+      return Reflect.defineProperty(target, prop, descriptor);
+    }
+  });
+}
+function stringifyPrimitive(value) {
+  if (typeof value === "bigint")
+    return value.toString() + "n";
+  if (typeof value === "string")
+    return `"${value}"`;
+  return `${value}`;
+}
+function optionalKeys(shape2) {
+  return Object.keys(shape2).filter((k) => {
+    return shape2[k]._zod.optin === "optional" && shape2[k]._zod.optout === "optional";
+  });
+}
+var NUMBER_FORMAT_RANGES = {
+  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+  int32: [-2147483648, 2147483647],
+  uint32: [0, 4294967295],
+  float32: [-34028234663852886e22, 34028234663852886e22],
+  float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
+};
+var BIGINT_FORMAT_RANGES = {
+  int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
+  uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
+};
+function pick(schema, mask) {
+  const currDef = schema._zod.def;
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const newShape = {};
+      for (const key in mask) {
+        if (!(key in currDef.shape)) {
+          throw new Error(`Unrecognized key: "${key}"`);
+        }
+        if (!mask[key])
+          continue;
+        newShape[key] = currDef.shape[key];
+      }
+      assignProp(this, "shape", newShape);
+      return newShape;
+    },
+    checks: []
+  });
+  return clone(schema, def);
+}
+function omit(schema, mask) {
+  const currDef = schema._zod.def;
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const newShape = { ...schema._zod.def.shape };
+      for (const key in mask) {
+        if (!(key in currDef.shape)) {
+          throw new Error(`Unrecognized key: "${key}"`);
+        }
+        if (!mask[key])
+          continue;
+        delete newShape[key];
+      }
+      assignProp(this, "shape", newShape);
+      return newShape;
+    },
+    checks: []
+  });
+  return clone(schema, def);
+}
+function extend(schema, shape2) {
+  if (!isPlainObject(shape2)) {
+    throw new Error("Invalid input to extend: expected a plain object");
+  }
+  const checks = schema._zod.def.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    throw new Error("Object schemas containing refinements cannot be extended. Use `.safeExtend()` instead.");
+  }
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const _shape = { ...schema._zod.def.shape, ...shape2 };
+      assignProp(this, "shape", _shape);
+      return _shape;
+    },
+    checks: []
+  });
+  return clone(schema, def);
+}
+function safeExtend(schema, shape2) {
+  if (!isPlainObject(shape2)) {
+    throw new Error("Invalid input to safeExtend: expected a plain object");
+  }
+  const def = {
+    ...schema._zod.def,
+    get shape() {
+      const _shape = { ...schema._zod.def.shape, ...shape2 };
+      assignProp(this, "shape", _shape);
+      return _shape;
+    },
+    checks: schema._zod.def.checks
+  };
+  return clone(schema, def);
+}
+function merge(a, b) {
+  const def = mergeDefs(a._zod.def, {
+    get shape() {
+      const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
+      assignProp(this, "shape", _shape);
+      return _shape;
+    },
+    get catchall() {
+      return b._zod.def.catchall;
+    },
+    checks: []
+    // delete existing checks
+  });
+  return clone(a, def);
+}
+function partial(Class2, schema, mask) {
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const oldShape = schema._zod.def.shape;
+      const shape2 = { ...oldShape };
+      if (mask) {
+        for (const key in mask) {
+          if (!(key in oldShape)) {
+            throw new Error(`Unrecognized key: "${key}"`);
+          }
+          if (!mask[key])
+            continue;
+          shape2[key] = Class2 ? new Class2({
+            type: "optional",
+            innerType: oldShape[key]
+          }) : oldShape[key];
+        }
+      } else {
+        for (const key in oldShape) {
+          shape2[key] = Class2 ? new Class2({
+            type: "optional",
+            innerType: oldShape[key]
+          }) : oldShape[key];
+        }
+      }
+      assignProp(this, "shape", shape2);
+      return shape2;
+    },
+    checks: []
+  });
+  return clone(schema, def);
+}
+function required(Class2, schema, mask) {
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const oldShape = schema._zod.def.shape;
+      const shape2 = { ...oldShape };
+      if (mask) {
+        for (const key in mask) {
+          if (!(key in shape2)) {
+            throw new Error(`Unrecognized key: "${key}"`);
+          }
+          if (!mask[key])
+            continue;
+          shape2[key] = new Class2({
+            type: "nonoptional",
+            innerType: oldShape[key]
+          });
+        }
+      } else {
+        for (const key in oldShape) {
+          shape2[key] = new Class2({
+            type: "nonoptional",
+            innerType: oldShape[key]
+          });
+        }
+      }
+      assignProp(this, "shape", shape2);
+      return shape2;
+    },
+    checks: []
+  });
+  return clone(schema, def);
+}
+function aborted(x, startIndex = 0) {
+  if (x.aborted === true)
+    return true;
+  for (let i = startIndex; i < x.issues.length; i++) {
+    if (_optionalChain([x, 'access', _48 => _48.issues, 'access', _49 => _49[i], 'optionalAccess', _50 => _50.continue]) !== true) {
+      return true;
+    }
+  }
+  return false;
+}
+function prefixIssues(path, issues) {
+  return issues.map((iss) => {
+    var _a;
+    _nullishCoalesce((_a = iss).path, () => ( (_a.path = [])));
+    iss.path.unshift(path);
+    return iss;
+  });
+}
+function unwrapMessage(message) {
+  return typeof message === "string" ? message : _optionalChain([message, 'optionalAccess', _51 => _51.message]);
+}
+function finalizeIssue(iss, ctx, config2) {
+  const full = { ...iss, path: _nullishCoalesce(iss.path, () => ( [])) };
+  if (!iss.message) {
+    const message = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(unwrapMessage(_optionalChain([iss, 'access', _52 => _52.inst, 'optionalAccess', _53 => _53._zod, 'access', _54 => _54.def, 'optionalAccess', _55 => _55.error, 'optionalCall', _56 => _56(iss)])), () => ( unwrapMessage(_optionalChain([ctx, 'optionalAccess', _57 => _57.error, 'optionalCall', _58 => _58(iss)])))), () => ( unwrapMessage(_optionalChain([config2, 'access', _59 => _59.customError, 'optionalCall', _60 => _60(iss)])))), () => ( unwrapMessage(_optionalChain([config2, 'access', _61 => _61.localeError, 'optionalCall', _62 => _62(iss)])))), () => ( "Invalid input"));
+    full.message = message;
+  }
+  delete full.inst;
+  delete full.continue;
+  if (!_optionalChain([ctx, 'optionalAccess', _63 => _63.reportInput])) {
+    delete full.input;
+  }
+  return full;
+}
+function getSizableOrigin(input) {
+  if (input instanceof Set)
+    return "set";
+  if (input instanceof Map)
+    return "map";
+  if (input instanceof File)
+    return "file";
+  return "unknown";
+}
+function getLengthableOrigin(input) {
+  if (Array.isArray(input))
+    return "array";
+  if (typeof input === "string")
+    return "string";
+  return "unknown";
+}
+function issue(...args) {
+  const [iss, input, inst] = args;
+  if (typeof iss === "string") {
+    return {
+      message: iss,
+      code: "custom",
+      input,
+      inst
+    };
+  }
+  return { ...iss };
+}
+function cleanEnum(obj) {
+  return Object.entries(obj).filter(([k, _]) => {
+    return Number.isNaN(Number.parseInt(k, 10));
+  }).map((el) => el[1]);
+}
+function base64ToUint8Array(base64) {
+  const binaryString = atob(base64);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes;
+}
+function uint8ArrayToBase64(bytes) {
+  let binaryString = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binaryString += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binaryString);
+}
+function base64urlToUint8Array(base64url) {
+  const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
+  const padding2 = "=".repeat((4 - base64.length % 4) % 4);
+  return base64ToUint8Array(base64 + padding2);
+}
+function uint8ArrayToBase64url(bytes) {
+  return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function hexToUint8Array(hex) {
+  const cleanHex = hex.replace(/^0x/, "");
+  if (cleanHex.length % 2 !== 0) {
+    throw new Error("Invalid hex string length");
+  }
+  const bytes = new Uint8Array(cleanHex.length / 2);
+  for (let i = 0; i < cleanHex.length; i += 2) {
+    bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
+  }
+  return bytes;
+}
+function uint8ArrayToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var Class = class {
+  constructor(..._args) {
+  }
+};
+
+// ../../node_modules/zod/v4/core/errors.js
+var initializer = (inst, def) => {
+  inst.name = "$ZodError";
+  Object.defineProperty(inst, "_zod", {
+    value: inst._zod,
+    enumerable: false
+  });
+  Object.defineProperty(inst, "issues", {
+    value: def,
+    enumerable: false
+  });
+  inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
+  Object.defineProperty(inst, "toString", {
+    value: () => inst.message,
+    enumerable: false
+  });
+};
+var $ZodError = $constructor("$ZodError", initializer);
+var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
+function flattenError(error, mapper = (issue2) => issue2.message) {
+  const fieldErrors = {};
+  const formErrors = [];
+  for (const sub of error.issues) {
+    if (sub.path.length > 0) {
+      fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+      fieldErrors[sub.path[0]].push(mapper(sub));
+    } else {
+      formErrors.push(mapper(sub));
+    }
+  }
+  return { formErrors, fieldErrors };
+}
+function formatError(error, _mapper) {
+  const mapper = _mapper || function(issue2) {
+    return issue2.message;
+  };
+  const fieldErrors = { _errors: [] };
+  const processError = (error2) => {
+    for (const issue2 of error2.issues) {
+      if (issue2.code === "invalid_union" && issue2.errors.length) {
+        issue2.errors.map((issues) => processError({ issues }));
+      } else if (issue2.code === "invalid_key") {
+        processError({ issues: issue2.issues });
+      } else if (issue2.code === "invalid_element") {
+        processError({ issues: issue2.issues });
+      } else if (issue2.path.length === 0) {
+        fieldErrors._errors.push(mapper(issue2));
+      } 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));
+          }
+          curr = curr[el];
+          i++;
+        }
+      }
+    }
+  };
+  processError(error);
+  return fieldErrors;
+}
+
+// ../../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 result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) {
+    throw new $ZodAsyncError();
+  }
+  if (result.issues.length) {
+    const e = new (_nullishCoalesce(_optionalChain([_params, 'optionalAccess', _64 => _64.Err]), () => ( _Err)))(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+    captureStackTrace(e, _optionalChain([_params, 'optionalAccess', _65 => _65.callee]));
+    throw e;
+  }
+  return result.value;
+};
+var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
+  const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+  let result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise)
+    result = await result;
+  if (result.issues.length) {
+    const e = new (_nullishCoalesce(_optionalChain([params, 'optionalAccess', _66 => _66.Err]), () => ( _Err)))(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+    captureStackTrace(e, _optionalChain([params, 'optionalAccess', _67 => _67.callee]));
+    throw e;
+  }
+  return result.value;
+};
+var _safeParse = (_Err) => (schema, value, _ctx) => {
+  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
+  const result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) {
+    throw new $ZodAsyncError();
+  }
+  return result.issues.length ? {
+    success: false,
+    error: new (_nullishCoalesce(_Err, () => ( $ZodError)))(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  } : { success: true, data: result.value };
+};
+var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
+var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
+  const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+  let result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise)
+    result = await result;
+  return result.issues.length ? {
+    success: false,
+    error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  } : { success: true, data: result.value };
+};
+var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
+var _encode = (_Err) => (schema, value, _ctx) => {
+  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+  return _parse(_Err)(schema, value, ctx);
+};
+var _decode = (_Err) => (schema, value, _ctx) => {
+  return _parse(_Err)(schema, value, _ctx);
+};
+var _encodeAsync = (_Err) => async (schema, value, _ctx) => {
+  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+  return _parseAsync(_Err)(schema, value, ctx);
+};
+var _decodeAsync = (_Err) => async (schema, value, _ctx) => {
+  return _parseAsync(_Err)(schema, value, _ctx);
+};
+var _safeEncode = (_Err) => (schema, value, _ctx) => {
+  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+  return _safeParse(_Err)(schema, value, ctx);
+};
+var _safeDecode = (_Err) => (schema, value, _ctx) => {
+  return _safeParse(_Err)(schema, value, _ctx);
+};
+var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
+  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+  return _safeParseAsync(_Err)(schema, value, ctx);
+};
+var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
+  return _safeParseAsync(_Err)(schema, value, _ctx);
+};
+
+// ../../node_modules/zod/v4/core/checks.js
+var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
+  var _a;
+  _nullishCoalesce(inst._zod, () => ( (inst._zod = {})));
+  inst._zod.def = def;
+  _nullishCoalesce((_a = inst._zod).onattach, () => ( (_a.onattach = [])));
+});
+var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
+  var _a;
+  $ZodCheck.init(inst, def);
+  _nullishCoalesce((_a = inst._zod.def).when, () => ( (_a.when = (payload) => {
+    const val = payload.value;
+    return !nullish(val) && val.length !== void 0;
+  })));
+  inst._zod.onattach.push((inst2) => {
+    const curr = _nullishCoalesce(inst2._zod.bag.maximum, () => ( Number.POSITIVE_INFINITY));
+    if (def.maximum < curr)
+      inst2._zod.bag.maximum = def.maximum;
+  });
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    const length = input.length;
+    if (length <= def.maximum)
+      return;
+    const origin = getLengthableOrigin(input);
+    payload.issues.push({
+      origin,
+      code: "too_big",
+      maximum: def.maximum,
+      inclusive: true,
+      input,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
+  var _a;
+  $ZodCheck.init(inst, def);
+  _nullishCoalesce((_a = inst._zod.def).when, () => ( (_a.when = (payload) => {
+    const val = payload.value;
+    return !nullish(val) && val.length !== void 0;
+  })));
+  inst._zod.onattach.push((inst2) => {
+    const curr = _nullishCoalesce(inst2._zod.bag.minimum, () => ( Number.NEGATIVE_INFINITY));
+    if (def.minimum > curr)
+      inst2._zod.bag.minimum = def.minimum;
+  });
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    const length = input.length;
+    if (length >= def.minimum)
+      return;
+    const origin = getLengthableOrigin(input);
+    payload.issues.push({
+      origin,
+      code: "too_small",
+      minimum: def.minimum,
+      inclusive: true,
+      input,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
+  var _a;
+  $ZodCheck.init(inst, def);
+  _nullishCoalesce((_a = inst._zod.def).when, () => ( (_a.when = (payload) => {
+    const val = payload.value;
+    return !nullish(val) && val.length !== void 0;
+  })));
+  inst._zod.onattach.push((inst2) => {
+    const bag = inst2._zod.bag;
+    bag.minimum = def.length;
+    bag.maximum = def.length;
+    bag.length = def.length;
+  });
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    const length = input.length;
+    if (length === def.length)
+      return;
+    const origin = getLengthableOrigin(input);
+    const tooBig = length > def.length;
+    payload.issues.push({
+      origin,
+      ...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length },
+      inclusive: true,
+      exact: true,
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  inst._zod.check = (payload) => {
+    payload.value = def.tx(payload.value);
+  };
+});
+
+// ../../node_modules/zod/v4/core/doc.js
+var Doc = class {
+  constructor(args = []) {
+    this.content = [];
+    this.indent = 0;
+    if (this)
+      this.args = args;
+  }
+  indented(fn) {
+    this.indent += 1;
+    fn(this);
+    this.indent -= 1;
+  }
+  write(arg) {
+    if (typeof arg === "function") {
+      arg(this, { execution: "sync" });
+      arg(this, { execution: "async" });
+      return;
+    }
+    const content = arg;
+    const lines = content.split("\n").filter((x) => x);
+    const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
+    const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
+    for (const line of dedented) {
+      this.content.push(line);
+    }
+  }
+  compile() {
+    const F = Function;
+    const args = _optionalChain([this, 'optionalAccess', _68 => _68.args]);
+    const content = _nullishCoalesce(_optionalChain([this, 'optionalAccess', _69 => _69.content]), () => ( [``]));
+    const lines = [...content.map((x) => `  ${x}`)];
+    return new F(...args, lines.join("\n"));
+  }
+};
+
+// ../../node_modules/zod/v4/core/versions.js
+var version = {
+  major: 4,
+  minor: 1,
+  patch: 5
+};
+
+// ../../node_modules/zod/v4/core/schemas.js
+var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
+  var _a;
+  _nullishCoalesce(inst, () => ( (inst = {})));
+  inst._zod.def = def;
+  inst._zod.bag = inst._zod.bag || {};
+  inst._zod.version = version;
+  const checks = [..._nullishCoalesce(inst._zod.def.checks, () => ( []))];
+  if (inst._zod.traits.has("$ZodCheck")) {
+    checks.unshift(inst);
+  }
+  for (const ch of checks) {
+    for (const fn of ch._zod.onattach) {
+      fn(inst);
+    }
+  }
+  if (checks.length === 0) {
+    _nullishCoalesce((_a = inst._zod).deferred, () => ( (_a.deferred = [])));
+    _optionalChain([inst, 'access', _70 => _70._zod, 'access', _71 => _71.deferred, 'optionalAccess', _72 => _72.push, 'call', _73 => _73(() => {
+      inst._zod.run = inst._zod.parse;
+    })]);
+  } else {
+    const runChecks = (payload, checks2, ctx) => {
+      let isAborted = aborted(payload);
+      let asyncResult;
+      for (const ch of checks2) {
+        if (ch._zod.def.when) {
+          const shouldRun = ch._zod.def.when(payload);
+          if (!shouldRun)
+            continue;
+        } else if (isAborted) {
+          continue;
+        }
+        const currLen = payload.issues.length;
+        const _ = ch._zod.check(payload);
+        if (_ instanceof Promise && _optionalChain([ctx, 'optionalAccess', _74 => _74.async]) === false) {
+          throw new $ZodAsyncError();
+        }
+        if (asyncResult || _ instanceof Promise) {
+          asyncResult = (_nullishCoalesce(asyncResult, () => ( Promise.resolve()))).then(async () => {
+            await _;
+            const nextLen = payload.issues.length;
+            if (nextLen === currLen)
+              return;
+            if (!isAborted)
+              isAborted = aborted(payload, currLen);
+          });
+        } else {
+          const nextLen = payload.issues.length;
+          if (nextLen === currLen)
+            continue;
+          if (!isAborted)
+            isAborted = aborted(payload, currLen);
+        }
+      }
+      if (asyncResult) {
+        return asyncResult.then(() => {
+          return payload;
+        });
+      }
+      return payload;
+    };
+    const handleCanaryResult = (canary, payload, ctx) => {
+      if (aborted(canary)) {
+        canary.aborted = true;
+        return canary;
+      }
+      const checkResult = runChecks(payload, checks, ctx);
+      if (checkResult instanceof Promise) {
+        if (ctx.async === false)
+          throw new $ZodAsyncError();
+        return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx));
+      }
+      return inst._zod.parse(checkResult, ctx);
+    };
+    inst._zod.run = (payload, ctx) => {
+      if (ctx.skipChecks) {
+        return inst._zod.parse(payload, ctx);
+      }
+      if (ctx.direction === "backward") {
+        const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });
+        if (canary instanceof Promise) {
+          return canary.then((canary2) => {
+            return handleCanaryResult(canary2, payload, ctx);
+          });
+        }
+        return handleCanaryResult(canary, payload, ctx);
+      }
+      const result = inst._zod.parse(payload, ctx);
+      if (result instanceof Promise) {
+        if (ctx.async === false)
+          throw new $ZodAsyncError();
+        return result.then((result2) => runChecks(result2, checks, ctx));
+      }
+      return runChecks(result, checks, ctx);
+    };
+  }
+  inst["~standard"] = {
+    validate: (value) => {
+      try {
+        const r = safeParse(inst, value);
+        return r.success ? { value: r.data } : { issues: _optionalChain([r, 'access', _75 => _75.error, 'optionalAccess', _76 => _76.issues]) };
+      } catch (_) {
+        return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: _optionalChain([r, 'access', _77 => _77.error, 'optionalAccess', _78 => _78.issues]) });
+      }
+    },
+    vendor: "zod",
+    version: 1
+  };
+});
+var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload) => payload;
+});
+var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, _ctx) => {
+    payload.issues.push({
+      expected: "never",
+      code: "invalid_type",
+      input: payload.value,
+      inst
+    });
+    return payload;
+  };
+});
+function handleArrayResult(result, final, index) {
+  if (result.issues.length) {
+    final.issues.push(...prefixIssues(index, result.issues));
+  }
+  final.value[index] = result.value;
+}
+var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, ctx) => {
+    const input = payload.value;
+    if (!Array.isArray(input)) {
+      payload.issues.push({
+        expected: "array",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    }
+    payload.value = Array(input.length);
+    const proms = [];
+    for (let i = 0; i < input.length; i++) {
+      const item = input[i];
+      const result = def.element._zod.run({
+        value: item,
+        issues: []
+      }, ctx);
+      if (result instanceof Promise) {
+        proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
+      } else {
+        handleArrayResult(result, payload, i);
+      }
+    }
+    if (proms.length) {
+      return Promise.all(proms).then(() => payload);
+    }
+    return payload;
+  };
+});
+function handlePropertyResult(result, final, key, input) {
+  if (result.issues.length) {
+    final.issues.push(...prefixIssues(key, result.issues));
+  }
+  if (result.value === void 0) {
+    if (key in input) {
+      final.value[key] = void 0;
+    }
+  } else {
+    final.value[key] = result.value;
+  }
+}
+function normalizeDef(def) {
+  const keys = Object.keys(def.shape);
+  for (const k of keys) {
+    if (!def.shape[k]._zod.traits.has("$ZodType")) {
+      throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
+    }
+  }
+  const okeys = optionalKeys(def.shape);
+  return {
+    ...def,
+    keys,
+    keySet: new Set(keys),
+    numKeys: keys.length,
+    optionalKeys: new Set(okeys)
+  };
+}
+function handleCatchall(proms, input, payload, ctx, def, inst) {
+  const unrecognized = [];
+  const keySet = def.keySet;
+  const _catchall = def.catchall._zod;
+  const t = _catchall.def.type;
+  for (const key of Object.keys(input)) {
+    if (keySet.has(key))
+      continue;
+    if (t === "never") {
+      unrecognized.push(key);
+      continue;
+    }
+    const r = _catchall.run({ value: input[key], issues: [] }, ctx);
+    if (r instanceof Promise) {
+      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input)));
+    } else {
+      handlePropertyResult(r, payload, key, input);
+    }
+  }
+  if (unrecognized.length) {
+    payload.issues.push({
+      code: "unrecognized_keys",
+      keys: unrecognized,
+      input,
+      inst
+    });
+  }
+  if (!proms.length)
+    return payload;
+  return Promise.all(proms).then(() => {
+    return payload;
+  });
+}
+var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
+  $ZodType.init(inst, def);
+  const _normalized = cached(() => normalizeDef(def));
+  defineLazy(inst._zod, "propValues", () => {
+    const shape2 = def.shape;
+    const propValues = {};
+    for (const key in shape2) {
+      const field = shape2[key]._zod;
+      if (field.values) {
+        _nullishCoalesce(propValues[key], () => ( (propValues[key] = /* @__PURE__ */ new Set())));
+        for (const v of field.values)
+          propValues[key].add(v);
+      }
+    }
+    return propValues;
+  });
+  const isObject2 = isObject;
+  const catchall = def.catchall;
+  let value;
+  inst._zod.parse = (payload, ctx) => {
+    _nullishCoalesce(value, () => ( (value = _normalized.value)));
+    const input = payload.value;
+    if (!isObject2(input)) {
+      payload.issues.push({
+        expected: "object",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    }
+    payload.value = {};
+    const proms = [];
+    const shape2 = value.shape;
+    for (const key of value.keys) {
+      const el = shape2[key];
+      const r = el._zod.run({ value: input[key], issues: [] }, ctx);
+      if (r instanceof Promise) {
+        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input)));
+      } else {
+        handlePropertyResult(r, payload, key, input);
+      }
+    }
+    if (!catchall) {
+      return proms.length ? Promise.all(proms).then(() => payload) : payload;
+    }
+    return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
+  };
+});
+var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => {
+  $ZodObject.init(inst, def);
+  const superParse = inst._zod.parse;
+  const _normalized = cached(() => normalizeDef(def));
+  const generateFastpass = (shape2) => {
+    const doc = new Doc(["shape", "payload", "ctx"]);
+    const normalized = _normalized.value;
+    const parseStr = (key) => {
+      const k = esc(key);
+      return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
+    };
+    doc.write(`const input = payload.value;`);
+    const ids = /* @__PURE__ */ Object.create(null);
+    let counter = 0;
+    for (const key of normalized.keys) {
+      ids[key] = `key_${counter++}`;
+    }
+    doc.write(`const newResult = {}`);
+    for (const key of normalized.keys) {
+      const id = ids[key];
+      const k = esc(key);
+      doc.write(`const ${id} = ${parseStr(key)};`);
+      doc.write(`
+        if (${id}.issues.length) {
+          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${k}, ...iss.path] : [${k}]
+          })));
+        }
+        
+        if (${id}.value === undefined) {
+          if (${k} in input) {
+            newResult[${k}] = undefined;
+          }
+        } else {
+          newResult[${k}] = ${id}.value;
+        }
+      `);
+    }
+    doc.write(`payload.value = newResult;`);
+    doc.write(`return payload;`);
+    const fn = doc.compile();
+    return (payload, ctx) => fn(shape2, payload, ctx);
+  };
+  let fastpass;
+  const isObject2 = isObject;
+  const jit = !globalConfig.jitless;
+  const allowsEval2 = allowsEval;
+  const fastEnabled = jit && allowsEval2.value;
+  const catchall = def.catchall;
+  let value;
+  inst._zod.parse = (payload, ctx) => {
+    _nullishCoalesce(value, () => ( (value = _normalized.value)));
+    const input = payload.value;
+    if (!isObject2(input)) {
+      payload.issues.push({
+        expected: "object",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    }
+    if (jit && fastEnabled && _optionalChain([ctx, 'optionalAccess', _79 => _79.async]) === false && ctx.jitless !== true) {
+      if (!fastpass)
+        fastpass = generateFastpass(def.shape);
+      payload = fastpass(payload, ctx);
+      if (!catchall)
+        return payload;
+      return handleCatchall([], input, payload, ctx, value, inst);
+    }
+    return superParse(payload, ctx);
+  };
+});
+function handleUnionResults(results, final, inst, ctx) {
+  for (const result of results) {
+    if (result.issues.length === 0) {
+      final.value = result.value;
+      return final;
+    }
+  }
+  const nonaborted = results.filter((r) => !aborted(r));
+  if (nonaborted.length === 1) {
+    final.value = nonaborted[0].value;
+    return nonaborted[0];
+  }
+  final.issues.push({
+    code: "invalid_union",
+    input: final.value,
+    inst,
+    errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  });
+  return final;
+}
+var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
+  $ZodType.init(inst, def);
+  defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0);
+  defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
+  defineLazy(inst._zod, "values", () => {
+    if (def.options.every((o) => o._zod.values)) {
+      return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
+    }
+    return void 0;
+  });
+  defineLazy(inst._zod, "pattern", () => {
+    if (def.options.every((o) => o._zod.pattern)) {
+      const patterns = def.options.map((o) => o._zod.pattern);
+      return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
+    }
+    return void 0;
+  });
+  const single = def.options.length === 1;
+  const first = def.options[0]._zod.run;
+  inst._zod.parse = (payload, ctx) => {
+    if (single) {
+      return first(payload, ctx);
+    }
+    let async = false;
+    const results = [];
+    for (const option of def.options) {
+      const result = option._zod.run({
+        value: payload.value,
+        issues: []
+      }, ctx);
+      if (result instanceof Promise) {
+        results.push(result);
+        async = true;
+      } else {
+        if (result.issues.length === 0)
+          return result;
+        results.push(result);
+      }
+    }
+    if (!async)
+      return handleUnionResults(results, payload, inst, ctx);
+    return Promise.all(results).then((results2) => {
+      return handleUnionResults(results2, payload, inst, ctx);
+    });
+  };
+});
+var $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, ctx) => {
+    const input = payload.value;
+    const left = def.left._zod.run({ value: input, issues: [] }, ctx);
+    const right = def.right._zod.run({ value: input, issues: [] }, ctx);
+    const async = left instanceof Promise || right instanceof Promise;
+    if (async) {
+      return Promise.all([left, right]).then(([left2, right2]) => {
+        return handleIntersectionResults(payload, left2, right2);
+      });
+    }
+    return handleIntersectionResults(payload, left, right);
+  };
+});
+function mergeValues(a, b) {
+  if (a === b) {
+    return { valid: true, data: a };
+  }
+  if (a instanceof Date && b instanceof Date && +a === +b) {
+    return { valid: true, data: a };
+  }
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const bKeys = Object.keys(b);
+    const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
+    const newObj = { ...a, ...b };
+    for (const key of sharedKeys) {
+      const sharedValue = mergeValues(a[key], b[key]);
+      if (!sharedValue.valid) {
+        return {
+          valid: false,
+          mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
+        };
+      }
+      newObj[key] = sharedValue.data;
+    }
+    return { valid: true, data: newObj };
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) {
+      return { valid: false, mergeErrorPath: [] };
+    }
+    const newArray = [];
+    for (let index = 0; index < a.length; index++) {
+      const itemA = a[index];
+      const itemB = b[index];
+      const sharedValue = mergeValues(itemA, itemB);
+      if (!sharedValue.valid) {
+        return {
+          valid: false,
+          mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
+        };
+      }
+      newArray.push(sharedValue.data);
+    }
+    return { valid: true, data: newArray };
+  }
+  return { valid: false, mergeErrorPath: [] };
+}
+function handleIntersectionResults(result, left, right) {
+  if (left.issues.length) {
+    result.issues.push(...left.issues);
+  }
+  if (right.issues.length) {
+    result.issues.push(...right.issues);
+  }
+  if (aborted(result))
+    return result;
+  const merged = mergeValues(left.value, right.value);
+  if (!merged.valid) {
+    throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
+  }
+  result.value = merged.data;
+  return result;
+}
+var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
+  $ZodType.init(inst, def);
+  const values2 = getEnumValues(def.entries);
+  const valuesSet = new Set(values2);
+  inst._zod.values = valuesSet;
+  inst._zod.pattern = new RegExp(`^(${values2.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
+  inst._zod.parse = (payload, _ctx) => {
+    const input = payload.value;
+    if (valuesSet.has(input)) {
+      return payload;
+    }
+    payload.issues.push({
+      code: "invalid_value",
+      values: values2,
+      input,
+      inst
+    });
+    return payload;
+  };
+});
+var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, ctx) => {
+    if (ctx.direction === "backward") {
+      throw new $ZodEncodeError(inst.constructor.name);
+    }
+    const _out = def.transform(payload.value, payload);
+    if (ctx.async) {
+      const output = _out instanceof Promise ? _out : Promise.resolve(_out);
+      return output.then((output2) => {
+        payload.value = output2;
+        return payload;
+      });
+    }
+    if (_out instanceof Promise) {
+      throw new $ZodAsyncError();
+    }
+    payload.value = _out;
+    return payload;
+  };
+});
+function handleOptionalResult(result, input) {
+  if (result.issues.length && input === void 0) {
+    return { issues: [], value: void 0 };
+  }
+  return result;
+}
+var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.optin = "optional";
+  inst._zod.optout = "optional";
+  defineLazy(inst._zod, "values", () => {
+    return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0;
+  });
+  defineLazy(inst._zod, "pattern", () => {
+    const pattern = def.innerType._zod.pattern;
+    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
+  });
+  inst._zod.parse = (payload, ctx) => {
+    if (def.innerType._zod.optin === "optional") {
+      const result = def.innerType._zod.run(payload, ctx);
+      if (result instanceof Promise)
+        return result.then((r) => handleOptionalResult(r, payload.value));
+      return handleOptionalResult(result, payload.value);
+    }
+    if (payload.value === void 0) {
+      return payload;
+    }
+    return def.innerType._zod.run(payload, ctx);
+  };
+});
+var $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
+  $ZodType.init(inst, def);
+  defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
+  defineLazy(inst._zod, "pattern", () => {
+    const pattern = def.innerType._zod.pattern;
+    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
+  });
+  defineLazy(inst._zod, "values", () => {
+    return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0;
+  });
+  inst._zod.parse = (payload, ctx) => {
+    if (payload.value === null)
+      return payload;
+    return def.innerType._zod.run(payload, ctx);
+  };
+});
+var $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.optin = "optional";
+  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+  inst._zod.parse = (payload, ctx) => {
+    if (ctx.direction === "backward") {
+      return def.innerType._zod.run(payload, ctx);
+    }
+    if (payload.value === void 0) {
+      payload.value = def.defaultValue;
+      return payload;
+    }
+    const result = def.innerType._zod.run(payload, ctx);
+    if (result instanceof Promise) {
+      return result.then((result2) => handleDefaultResult(result2, def));
+    }
+    return handleDefaultResult(result, def);
+  };
+});
+function handleDefaultResult(payload, def) {
+  if (payload.value === void 0) {
+    payload.value = def.defaultValue;
+  }
+  return payload;
+}
+var $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.optin = "optional";
+  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+  inst._zod.parse = (payload, ctx) => {
+    if (ctx.direction === "backward") {
+      return def.innerType._zod.run(payload, ctx);
+    }
+    if (payload.value === void 0) {
+      payload.value = def.defaultValue;
+    }
+    return def.innerType._zod.run(payload, ctx);
+  };
+});
+var $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
+  $ZodType.init(inst, def);
+  defineLazy(inst._zod, "values", () => {
+    const v = def.innerType._zod.values;
+    return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;
+  });
+  inst._zod.parse = (payload, ctx) => {
+    const result = def.innerType._zod.run(payload, ctx);
+    if (result instanceof Promise) {
+      return result.then((result2) => handleNonOptionalResult(result2, inst));
+    }
+    return handleNonOptionalResult(result, inst);
+  };
+});
+function handleNonOptionalResult(payload, inst) {
+  if (!payload.issues.length && payload.value === void 0) {
+    payload.issues.push({
+      code: "invalid_type",
+      expected: "nonoptional",
+      input: payload.value,
+      inst
+    });
+  }
+  return payload;
+}
+var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
+  $ZodType.init(inst, def);
+  defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
+  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+  inst._zod.parse = (payload, ctx) => {
+    if (ctx.direction === "backward") {
+      return def.innerType._zod.run(payload, ctx);
+    }
+    const result = def.innerType._zod.run(payload, ctx);
+    if (result instanceof Promise) {
+      return result.then((result2) => {
+        payload.value = result2.value;
+        if (result2.issues.length) {
+          payload.value = def.catchValue({
+            ...payload,
+            error: {
+              issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config()))
+            },
+            input: payload.value
+          });
+          payload.issues = [];
+        }
+        return payload;
+      });
+    }
+    payload.value = result.value;
+    if (result.issues.length) {
+      payload.value = def.catchValue({
+        ...payload,
+        error: {
+          issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config()))
+        },
+        input: payload.value
+      });
+      payload.issues = [];
+    }
+    return payload;
+  };
+});
+var $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => {
+  $ZodType.init(inst, def);
+  defineLazy(inst._zod, "values", () => def.in._zod.values);
+  defineLazy(inst._zod, "optin", () => def.in._zod.optin);
+  defineLazy(inst._zod, "optout", () => def.out._zod.optout);
+  defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
+  inst._zod.parse = (payload, ctx) => {
+    if (ctx.direction === "backward") {
+      const right = def.out._zod.run(payload, ctx);
+      if (right instanceof Promise) {
+        return right.then((right2) => handlePipeResult(right2, def.in, ctx));
+      }
+      return handlePipeResult(right, def.in, ctx);
+    }
+    const left = def.in._zod.run(payload, ctx);
+    if (left instanceof Promise) {
+      return left.then((left2) => handlePipeResult(left2, def.out, ctx));
+    }
+    return handlePipeResult(left, def.out, ctx);
+  };
+});
+function handlePipeResult(left, next, ctx) {
+  if (left.issues.length) {
+    left.aborted = true;
+    return left;
+  }
+  return next._zod.run({ value: left.value, issues: left.issues }, ctx);
+}
+var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
+  $ZodType.init(inst, def);
+  defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
+  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+  defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
+  inst._zod.parse = (payload, ctx) => {
+    if (ctx.direction === "backward") {
+      return def.innerType._zod.run(payload, ctx);
+    }
+    const result = def.innerType._zod.run(payload, ctx);
+    if (result instanceof Promise) {
+      return result.then(handleReadonlyResult);
+    }
+    return handleReadonlyResult(result);
+  };
+});
+function handleReadonlyResult(payload) {
+  payload.value = Object.freeze(payload.value);
+  return payload;
+}
+var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, _) => {
+    return payload;
+  };
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    const r = def.fn(input);
+    if (r instanceof Promise) {
+      return r.then((r2) => handleRefineResult(r2, payload, input, inst));
+    }
+    handleRefineResult(r, payload, input, inst);
+    return;
+  };
+});
+function handleRefineResult(result, payload, input, inst) {
+  if (!result) {
+    const _iss = {
+      code: "custom",
+      input,
+      inst,
+      // incorporates params.error into issue reporting
+      path: [..._nullishCoalesce(inst._zod.def.path, () => ( []))],
+      // incorporates params.error into issue reporting
+      continue: !inst._zod.def.abort
+      // params: inst._zod.def.params,
+    };
+    if (inst._zod.def.params)
+      _iss.params = inst._zod.def.params;
+    payload.issues.push(issue(_iss));
+  }
+}
+
+// ../../node_modules/zod/v4/core/registries.js
+var $output = Symbol("ZodOutput");
+var $input = Symbol("ZodInput");
+var $ZodRegistry = class {
+  constructor() {
+    this._map = /* @__PURE__ */ new Map();
+    this._idmap = /* @__PURE__ */ new Map();
+  }
+  add(schema, ..._meta) {
+    const meta = _meta[0];
+    this._map.set(schema, meta);
+    if (meta && typeof meta === "object" && "id" in meta) {
+      if (this._idmap.has(meta.id)) {
+        throw new Error(`ID ${meta.id} already exists in the registry`);
+      }
+      this._idmap.set(meta.id, schema);
+    }
+    return this;
+  }
+  clear() {
+    this._map = /* @__PURE__ */ new Map();
+    this._idmap = /* @__PURE__ */ new Map();
+    return this;
+  }
+  remove(schema) {
+    const meta = this._map.get(schema);
+    if (meta && typeof meta === "object" && "id" in meta) {
+      this._idmap.delete(meta.id);
+    }
+    this._map.delete(schema);
+    return this;
+  }
+  get(schema) {
+    const p = schema._zod.parent;
+    if (p) {
+      const pm = { ..._nullishCoalesce(this.get(p), () => ( {})) };
+      delete pm.id;
+      const f = { ...pm, ...this._map.get(schema) };
+      return Object.keys(f).length ? f : void 0;
+    }
+    return this._map.get(schema);
+  }
+  has(schema) {
+    return this._map.has(schema);
+  }
+};
+function registry() {
+  return new $ZodRegistry();
+}
+var globalRegistry = /* @__PURE__ */ registry();
+
+// ../../node_modules/zod/v4/core/api.js
+function _unknown(Class2) {
+  return new Class2({
+    type: "unknown"
+  });
+}
+function _never(Class2, params) {
+  return new Class2({
+    type: "never",
+    ...normalizeParams(params)
+  });
+}
+function _maxLength(maximum, params) {
+  const ch = new $ZodCheckMaxLength({
+    check: "max_length",
+    ...normalizeParams(params),
+    maximum
+  });
+  return ch;
+}
+function _minLength(minimum, params) {
+  return new $ZodCheckMinLength({
+    check: "min_length",
+    ...normalizeParams(params),
+    minimum
+  });
+}
+function _length(length, params) {
+  return new $ZodCheckLengthEquals({
+    check: "length_equals",
+    ...normalizeParams(params),
+    length
+  });
+}
+function _overwrite(tx) {
+  return new $ZodCheckOverwrite({
+    check: "overwrite",
+    tx
+  });
+}
+function _array(Class2, element, params) {
+  return new Class2({
+    type: "array",
+    element,
+    // get element() {
+    //   return element;
+    // },
+    ...normalizeParams(params)
+  });
+}
+function _refine(Class2, fn, _params) {
+  const schema = new Class2({
+    type: "custom",
+    check: "custom",
+    fn,
+    ...normalizeParams(_params)
+  });
+  return schema;
+}
+function _superRefine(fn) {
+  const ch = _check((payload) => {
+    payload.addIssue = (issue2) => {
+      if (typeof issue2 === "string") {
+        payload.issues.push(issue(issue2, payload.value, ch._zod.def));
+      } else {
+        const _issue = issue2;
+        if (_issue.fatal)
+          _issue.continue = false;
+        _nullishCoalesce(_issue.code, () => ( (_issue.code = "custom")));
+        _nullishCoalesce(_issue.input, () => ( (_issue.input = payload.value)));
+        _nullishCoalesce(_issue.inst, () => ( (_issue.inst = ch)));
+        _nullishCoalesce(_issue.continue, () => ( (_issue.continue = !ch._zod.def.abort)));
+        payload.issues.push(issue(_issue));
+      }
+    };
+    return fn(payload.value, payload);
+  });
+  return ch;
+}
+function _check(fn, params) {
+  const ch = new $ZodCheck({
+    check: "custom",
+    ...normalizeParams(params)
+  });
+  ch._zod.check = fn;
+  return ch;
+}
+
+// ../../node_modules/zod/v4/classic/errors.js
+var initializer2 = (inst, issues) => {
+  $ZodError.init(inst, issues);
+  inst.name = "ZodError";
+  Object.defineProperties(inst, {
+    format: {
+      value: (mapper) => formatError(inst, mapper)
+      // enumerable: false,
+    },
+    flatten: {
+      value: (mapper) => flattenError(inst, mapper)
+      // enumerable: false,
+    },
+    addIssue: {
+      value: (issue2) => {
+        inst.issues.push(issue2);
+        inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
+      }
+      // enumerable: false,
+    },
+    addIssues: {
+      value: (issues2) => {
+        inst.issues.push(...issues2);
+        inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
+      }
+      // enumerable: false,
+    },
+    isEmpty: {
+      get() {
+        return inst.issues.length === 0;
+      }
+      // enumerable: false,
+    }
+  });
+};
+var ZodError = $constructor("ZodError", initializer2);
+var ZodRealError = $constructor("ZodError", initializer2, {
+  Parent: Error
+});
+
+// ../../node_modules/zod/v4/classic/parse.js
+var parse2 = /* @__PURE__ */ _parse(ZodRealError);
+var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
+var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
+var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
+var encode = /* @__PURE__ */ _encode(ZodRealError);
+var decode = /* @__PURE__ */ _decode(ZodRealError);
+var encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError);
+var decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError);
+var safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError);
+var safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
+var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
+var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
+
+// ../../node_modules/zod/v4/classic/schemas.js
+var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst.def = def;
+  inst.type = def.type;
+  Object.defineProperty(inst, "_def", { value: def });
+  inst.check = (...checks) => {
+    return inst.clone(
+      {
+        ...def,
+        checks: [
+          ..._nullishCoalesce(def.checks, () => ( [])),
+          ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
+        ]
+      }
+      // { parent: true }
+    );
+  };
+  inst.clone = (def2, params) => clone(inst, def2, params);
+  inst.brand = () => inst;
+  inst.register = ((reg, meta) => {
+    reg.add(inst, meta);
+    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 });
+  inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
+  inst.spa = inst.safeParseAsync;
+  inst.encode = (data, params) => encode(inst, data, params);
+  inst.decode = (data, params) => decode(inst, data, params);
+  inst.encodeAsync = async (data, params) => encodeAsync(inst, data, params);
+  inst.decodeAsync = async (data, params) => decodeAsync(inst, data, params);
+  inst.safeEncode = (data, params) => safeEncode(inst, data, params);
+  inst.safeDecode = (data, params) => safeDecode(inst, data, params);
+  inst.safeEncodeAsync = async (data, params) => safeEncodeAsync(inst, data, params);
+  inst.safeDecodeAsync = async (data, params) => safeDecodeAsync(inst, data, params);
+  inst.refine = (check, params) => inst.check(refine(check, params));
+  inst.superRefine = (refinement) => inst.check(superRefine(refinement));
+  inst.overwrite = (fn) => inst.check(_overwrite(fn));
+  inst.optional = () => optional(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) => _default(inst, def2);
+  inst.prefault = (def2) => prefault(inst, def2);
+  inst.catch = (params) => _catch(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;
+  };
+  Object.defineProperty(inst, "description", {
+    get() {
+      return _optionalChain([globalRegistry, 'access', _80 => _80.get, 'call', _81 => _81(inst), 'optionalAccess', _82 => _82.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;
+  return inst;
+});
+var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
+  $ZodUnknown.init(inst, def);
+  ZodType.init(inst, def);
+});
+function unknown() {
+  return _unknown(ZodUnknown);
+}
+var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
+  $ZodNever.init(inst, def);
+  ZodType.init(inst, def);
+});
+function never(params) {
+  return _never(ZodNever, params);
+}
+var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
+  $ZodArray.init(inst, def);
+  ZodType.init(inst, def);
+  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;
+});
+function array(element, params) {
+  return _array(ZodArray, element, params);
+}
+var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
+  $ZodObjectJIT.init(inst, def);
+  ZodType.init(inst, def);
+  util_exports.defineLazy(inst, "shape", () => def.shape);
+  inst.keyof = () => _enum(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]);
+});
+var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
+  $ZodUnion.init(inst, def);
+  ZodType.init(inst, def);
+  inst.options = def.options;
+});
+function union(options, params) {
+  return new ZodUnion({
+    type: "union",
+    options,
+    ...util_exports.normalizeParams(params)
+  });
+}
+var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
+  $ZodIntersection.init(inst, def);
+  ZodType.init(inst, def);
+});
+function intersection(left, right) {
+  return new ZodIntersection({
+    type: "intersection",
+    left,
+    right
+  });
+}
+var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
+  $ZodEnum.init(inst, def);
+  ZodType.init(inst, def);
+  inst.enum = def.entries;
+  inst.options = Object.values(def.entries);
+  const keys = new Set(Object.keys(def.entries));
+  inst.extract = (values2, params) => {
+    const newEntries = {};
+    for (const value of values2) {
+      if (keys.has(value)) {
+        newEntries[value] = def.entries[value];
+      } else
+        throw new Error(`Key ${value} not found in enum`);
+    }
+    return new ZodEnum({
+      ...def,
+      checks: [],
+      ...util_exports.normalizeParams(params),
+      entries: newEntries
+    });
+  };
+  inst.exclude = (values2, params) => {
+    const newEntries = { ...def.entries };
+    for (const value of values2) {
+      if (keys.has(value)) {
+        delete newEntries[value];
+      } else
+        throw new Error(`Key ${value} not found in enum`);
+    }
+    return new ZodEnum({
+      ...def,
+      checks: [],
+      ...util_exports.normalizeParams(params),
+      entries: newEntries
+    });
+  };
+});
+function _enum(values2, params) {
+  const entries = Array.isArray(values2) ? Object.fromEntries(values2.map((v) => [v, v])) : values2;
+  return new ZodEnum({
+    type: "enum",
+    entries,
+    ...util_exports.normalizeParams(params)
+  });
+}
+var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
+  $ZodTransform.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.parse = (payload, _ctx) => {
+    if (_ctx.direction === "backward") {
+      throw new $ZodEncodeError(inst.constructor.name);
+    }
+    payload.addIssue = (issue2) => {
+      if (typeof issue2 === "string") {
+        payload.issues.push(util_exports.issue(issue2, payload.value, def));
+      } else {
+        const _issue = issue2;
+        if (_issue.fatal)
+          _issue.continue = false;
+        _nullishCoalesce(_issue.code, () => ( (_issue.code = "custom")));
+        _nullishCoalesce(_issue.input, () => ( (_issue.input = payload.value)));
+        _nullishCoalesce(_issue.inst, () => ( (_issue.inst = inst)));
+        payload.issues.push(util_exports.issue(_issue));
+      }
+    };
+    const output = def.transform(payload.value, payload);
+    if (output instanceof Promise) {
+      return output.then((output2) => {
+        payload.value = output2;
+        return payload;
+      });
+    }
+    payload.value = output;
+    return payload;
+  };
+});
+function transform(fn) {
+  return new ZodTransform({
+    type: "transform",
+    transform: fn
+  });
+}
+var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
+  $ZodOptional.init(inst, def);
+  ZodType.init(inst, def);
+  inst.unwrap = () => inst._zod.def.innerType;
+});
+function optional(innerType) {
+  return new ZodOptional({
+    type: "optional",
+    innerType
+  });
+}
+var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
+  $ZodNullable.init(inst, def);
+  ZodType.init(inst, def);
+  inst.unwrap = () => inst._zod.def.innerType;
+});
+function nullable(innerType) {
+  return new ZodNullable({
+    type: "nullable",
+    innerType
+  });
+}
+var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
+  $ZodDefault.init(inst, def);
+  ZodType.init(inst, def);
+  inst.unwrap = () => inst._zod.def.innerType;
+  inst.removeDefault = inst.unwrap;
+});
+function _default(innerType, defaultValue) {
+  return new ZodDefault({
+    type: "default",
+    innerType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue);
+    }
+  });
+}
+var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
+  $ZodPrefault.init(inst, def);
+  ZodType.init(inst, def);
+  inst.unwrap = () => inst._zod.def.innerType;
+});
+function prefault(innerType, defaultValue) {
+  return new ZodPrefault({
+    type: "prefault",
+    innerType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue);
+    }
+  });
+}
+var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
+  $ZodNonOptional.init(inst, def);
+  ZodType.init(inst, def);
+  inst.unwrap = () => inst._zod.def.innerType;
+});
+function nonoptional(innerType, params) {
+  return new ZodNonOptional({
+    type: "nonoptional",
+    innerType,
+    ...util_exports.normalizeParams(params)
+  });
+}
+var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
+  $ZodCatch.init(inst, def);
+  ZodType.init(inst, def);
+  inst.unwrap = () => inst._zod.def.innerType;
+  inst.removeCatch = inst.unwrap;
+});
+function _catch(innerType, catchValue) {
+  return new ZodCatch({
+    type: "catch",
+    innerType,
+    catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
+  });
+}
+var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
+  $ZodPipe.init(inst, def);
+  ZodType.init(inst, def);
+  inst.in = def.in;
+  inst.out = def.out;
+});
+function pipe(in_, out) {
+  return new ZodPipe({
+    type: "pipe",
+    in: in_,
+    out
+    // ...util.normalizeParams(params),
+  });
+}
+var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
+  $ZodReadonly.init(inst, def);
+  ZodType.init(inst, def);
+  inst.unwrap = () => inst._zod.def.innerType;
+});
+function readonly(innerType) {
+  return new ZodReadonly({
+    type: "readonly",
+    innerType
+  });
+}
+var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
+  $ZodCustom.init(inst, def);
+  ZodType.init(inst, def);
+});
+function refine(fn, _params = {}) {
+  return _refine(ZodCustom, fn, _params);
+}
+function superRefine(fn) {
+  return _superRefine(fn);
+}
+
+// src/form/validator.ts
+var Validator = class {
+  constructor(schema) {
+    this.schema = schema;
+  }
+  /**
+   * Validate the entire object payload.
+   */
+  validate(payload) {
+    const parsed = this.schema.safeParse(payload);
+    if (parsed.success) {
+      return { isValid: true, value: parsed.data };
+    }
+    return { isValid: false, issues: parsed.error.issues };
+  }
+  /**
+   * Validate only the fields present in `payload`.
+   * Returns success if all provided keys pass their individual checks.
+   */
+  validatePartial(payload) {
+    if (!(this.schema instanceof ZodObject)) {
+      throw new Error("Partial validation requires a ZodObject schema");
+    }
+    const partialSchema = this.schema.strict().partial();
+    const parsed = partialSchema.safeParse(payload);
+    if (parsed.success) {
+      return { isValid: true, value: parsed.data };
+    } else {
+      return { isValid: false, issues: parsed.error.issues };
+    }
+  }
+  /**
+   * Validate a single property by key and value.
+   * Requires the schema to be a ZodObject.
+   */
+  validateProperty(key, value) {
+    return this.validatePartial({ [key]: value });
+  }
+};
+
+// src/web-components/wavelength-form.ts
+var WavelengthForm = class extends HTMLElement {
+  constructor() {
+    super();
+    this._fields = [];
+    this._value = {};
+    this._errors = {};
+    this._inputProps = {};
+    this._idPrefix = "";
+    this._title = "";
+    this._titleAlign = "left";
+    this._titleColor = "";
+    this._formWidth = "300px";
+    // --- Event handlers ---
+    this.onInputChange = (name, rawValue) => {
+      this._value = { ...this._value, [name]: rawValue };
+      const res = _optionalChain([this, 'access', _83 => _83._validator, 'optionalAccess', _84 => _84.validate, 'call', _85 => _85(this._value)]);
+      const issues = res && !res.isValid ? _nullishCoalesce(res.issues, () => ( [])) : [];
+      this.dispatchEvent(
+        new CustomEvent("form-change", {
+          detail: { value: { ...this._value }, issues }
+        })
+      );
+    };
+    this.onBlur = (name) => {
+      const field = this._fields.find((f) => f.name === name);
+      const el = this.queryFieldEl(name);
+      if (!field || !el) return;
+      let value;
+      if (field.type === "checkbox") {
+        value = el.checked;
+      } else if (field.type === "number") {
+        const raw = _nullishCoalesce(el.value, () => ( ""));
+        value = raw === "" ? void 0 : Number(raw);
+      } else {
+        value = _nullishCoalesce(el.value, () => ( ""));
+      }
+      this.validateField(name, value);
+    };
+    this.onSubmit = (e) => {
+      e.preventDefault();
+      const res = this.validateAll();
+      const submitEvent = typeof SubmitEvent === "function" ? new SubmitEvent("submit", { bubbles: true, cancelable: true, composed: true }) : new Event("submit", { bubbles: true, cancelable: true, composed: true });
+      this.dispatchEvent(submitEvent);
+      if (res.isValid) {
+        this.dispatchEvent(new CustomEvent("form-valid", { detail: { value: res.value, issues: [] } }));
+      } else {
+        this.dispatchEvent(new CustomEvent("form-invalid", { detail: { value: res.value, issues: res.issues } }));
+      }
+    };
+    this._shadow = this.attachShadow({ mode: "open" });
+  }
+  static get observedAttributes() {
+    return ["id-prefix", "title", "title-align", "title-color", "form-width"];
+  }
+  // --- Public API ---
+  /**
+   * Assign a Zod object schema to render. (required)
+   */
+  set schema(s) {
+    this._schema = s;
+    this._validator = s ? new Validator(s) : void 0;
+    this._fields = s ? zodToFields(s) : [];
+    this._errors = {};
+    this.render();
+  }
+  get schema() {
+    return this._schema;
+  }
+  /**
+   * Optional initial values. You can also set individual values
+   * by dispatching inputChange from your inputs after mount.
+   */
+  set value(v) {
+    this._value = _nullishCoalesce(v, () => ( {}));
+    this.render();
+  }
+  get value() {
+    return this.collectValues();
+  }
+  set leftButton(v) {
+    this._leftButton = v;
+    this.render();
+  }
+  get leftButton() {
+    return this._leftButton;
+  }
+  set centerButton(v) {
+    this._centerButton = v;
+    this.render();
+  }
+  get centerButton() {
+    return this._centerButton;
+  }
+  set rightButton(v) {
+    this._rightButton = v;
+    this.render();
+  }
+  get rightButton() {
+    return this._rightButton;
+  }
+  set inputProps(v) {
+    this._inputProps = _nullishCoalesce(v, () => ( {}));
+    this.render();
+  }
+  get inputProps() {
+    return this._inputProps;
+  }
+  set idPrefix(v) {
+    this._idPrefix = _nullishCoalesce(v, () => ( ""));
+    this.render();
+  }
+  get idPrefix() {
+    return this._idPrefix || void 0;
+  }
+  /** Heading text displayed above the form */
+  set title(v) {
+    this._title = _nullishCoalesce(v, () => ( ""));
+    if (v === "") {
+      this.removeAttribute("title");
+    } else {
+      this.setAttribute("title", v);
     }
-    if (width2) this.button.style.width = width2;
-    this.button.style.height = height2;
-    if (variant === "contained") {
-      this.button.style.backgroundColor = colorOne;
-      this.button.style.color = colorTwo;
-      this.button.style.border = `0.063rem solid ${colorOne}`;
-      this.button.style.boxShadow = boxShadow || "0rem 0.125rem 0.25rem -0.063rem #000000";
-    } else if (variant === "outlined") {
-      this.button.style.backgroundColor = "transparent";
-      this.button.style.color = colorOne;
-      this.button.style.border = `0.063rem solid ${colorOne}`;
-      this.button.style.boxShadow = boxShadow || "none";
+    this.render();
+  }
+  get title() {
+    return this._title;
+  }
+  /** CSS text-align value applied to the heading */
+  set titleAlign(v) {
+    this._titleAlign = _nullishCoalesce(v, () => ( "left"));
+    this.setAttribute("title-align", this._titleAlign);
+    this.render();
+  }
+  get titleAlign() {
+    return this._titleAlign;
+  }
+  /** Color applied to the heading text */
+  set titleColor(v) {
+    this._titleColor = _nullishCoalesce(v, () => ( ""));
+    if (v === void 0) {
+      this.removeAttribute("title-color");
     } else {
-      this.button.style.backgroundColor = "transparent";
-      this.button.style.color = colorOne;
-      this.button.style.border = "none";
-      this.button.style.boxShadow = boxShadow || "none";
+      this.setAttribute("title-color", this._titleColor);
     }
-    if (href && !disabled) {
-      this.button.onclick = () => window.open(href, target);
-      this.button.style.cursor = "pointer";
+    this.render();
+  }
+  get titleColor() {
+    return this._titleColor || void 0;
+  }
+  /** Width applied to the form element */
+  set formWidth(v) {
+    this._formWidth = _nullishCoalesce(v, () => ( "300px"));
+    if (v === void 0) {
+      this.removeAttribute("form-width");
     } else {
-      this.button.onclick = null;
+      this.setAttribute("form-width", this._formWidth);
     }
-    this.button.removeEventListener("mouseenter", this.handleHoverIn);
-    this.button.removeEventListener("mouseleave", this.handleHoverOut);
-    this.handleHoverIn = () => {
-      if (variant === "contained") {
-        this.button.style.backgroundColor = this.shadeColor(colorOne, -15);
-      } else {
-        this.button.style.backgroundColor = this.hexToRgba(colorOne, 0.05);
+    this.render();
+  }
+  get formWidth() {
+    return this._formWidth;
+  }
+  /** Array describing how many fields appear in each row */
+  set layout(v) {
+    this._layout = v;
+    this.render();
+  }
+  get layout() {
+    return this._layout;
+  }
+  /**
+   * Imperative validation without submitting.
+   * Returns true if the current form values are valid.
+   */
+  validate() {
+    return this.validateAll().isValid;
+  }
+  connectedCallback() {
+    this.render();
+  }
+  attributeChangedCallback(name, _old, value) {
+    if (name === "id-prefix") {
+      this._idPrefix = _nullishCoalesce(value, () => ( ""));
+      this.render();
+    } else if (name === "title") {
+      this._title = _nullishCoalesce(value, () => ( ""));
+      this.render();
+    } else if (name === "title-align") {
+      this._titleAlign = _nullishCoalesce(value, () => ( "left"));
+      this.render();
+    } else if (name === "title-color") {
+      this._titleColor = _nullishCoalesce(value, () => ( ""));
+      this.render();
+    } else if (name === "form-width") {
+      this._formWidth = _nullishCoalesce(value, () => ( "300px"));
+      if (value === null) {
+        this.removeAttribute("form-width");
       }
-    };
-    this.handleHoverOut = () => {
-      if (variant === "contained") {
-        this.button.style.backgroundColor = colorOne;
+      this.render();
+    }
+  }
+  // --- Internal helpers ---
+  collectValues() {
+    const next = {};
+    for (const f of this._fields) {
+      const el = this.queryFieldEl(f.name);
+      if (!el) continue;
+      if (f.type === "checkbox") {
+        next[f.name] = el.checked;
+      } else if (f.type === "number") {
+        const val = _nullishCoalesce(el.value, () => ( ""));
+        next[f.name] = val === "" ? void 0 : Number(val);
       } else {
-        this.button.style.backgroundColor = "transparent";
+        const val = _nullishCoalesce(el.value, () => ( ""));
+        next[f.name] = val;
       }
-    };
-    this.button.addEventListener("mouseenter", this.handleHoverIn);
-    this.button.addEventListener("mouseleave", this.handleHoverOut);
-  }
-  applyPresetSize(size) {
-    if (size === "small") {
-      this.button.style.padding = "0.5rem";
-    } else if (size === "medium") {
-      this.button.style.padding = "0.6875rem 0.75rem";
-    } else if (size === "large") {
-      this.button.style.padding = "0.875rem 1rem";
     }
+    return next;
   }
-  hexToRgba(hex, alpha) {
-    let r = 0, g = 0, b = 0;
-    if (hex.length === 4) {
-      r = parseInt(hex[1] + hex[1], 16);
-      g = parseInt(hex[2] + hex[2], 16);
-      b = parseInt(hex[3] + hex[3], 16);
-    } else if (hex.length === 7) {
-      r = parseInt(hex[1] + hex[2], 16);
-      g = parseInt(hex[3] + hex[4], 16);
-      b = parseInt(hex[5] + hex[6], 16);
+  queryFieldEl(name) {
+    return this._shadow.querySelector(`[data-name="${name}"]`);
+  }
+  setFieldError(name, message) {
+    const el = this.queryFieldEl(name);
+    if (!el) return;
+    if (message) {
+      const existing = this._errors[name];
+      const pieces = [...existing ? existing.split("\n") : [], ...message.split("\n")].filter((m) => m !== "");
+      const combined = Array.from(new Set(pieces)).join("\n");
+      el.setAttribute("error-message", combined);
+      el.setAttribute("force-error", "");
+      this._errors[name] = combined;
+    } else {
+      el.removeAttribute("force-error");
+      el.removeAttribute("error-message");
+      delete this._errors[name];
     }
-    return `rgba(${r}, ${g}, ${b}, ${alpha})`;
   }
-  shadeColor(hex, percent) {
-    let R = parseInt(hex.substring(1, 3), 16);
-    let G = parseInt(hex.substring(3, 5), 16);
-    let B = parseInt(hex.substring(5, 7), 16);
-    R = Math.min(255, Math.max(0, R + R * percent / 100));
-    G = Math.min(255, Math.max(0, G + G * percent / 100));
-    B = Math.min(255, Math.max(0, B + B * percent / 100));
-    const toHex = (c) => {
-      const hex2 = Math.round(c).toString(16);
-      return hex2.length === 1 ? "0" + hex2 : hex2;
+  validateField(name, value) {
+    if (!this._validator) return;
+    const res = this._validator.validateProperty(name, value);
+    if (res.isValid) {
+      this.setFieldError(name, void 0);
+    } else {
+      const issues = _nullishCoalesce(_optionalChain([res, 'access', _86 => _86.issues, 'optionalAccess', _87 => _87.filter, 'call', _88 => _88((i) => _optionalChain([i, 'access', _89 => _89.path, 'optionalAccess', _90 => _90[0]]) === name)]), () => ( []));
+      const messages = issues.map((i) => i.message).join("\n");
+      this.setFieldError(name, issues.length > 0 ? messages : "Invalid value");
+    }
+  }
+  validateAll() {
+    if (!this._validator) {
+      return { isValid: true, value: this.collectValues(), issues: [] };
+    }
+    const values2 = this.collectValues();
+    for (const f of this._fields) this.setFieldError(f.name, void 0);
+    const res = this._validator.validate(values2);
+    if (res.isValid) {
+      return { isValid: true, value: res.value, issues: [] };
+    }
+    for (const f of this._fields) {
+      const issues = _nullishCoalesce(_optionalChain([res, 'access', _91 => _91.issues, 'optionalAccess', _92 => _92.filter, 'call', _93 => _93((i) => _optionalChain([i, 'access', _94 => _94.path, 'optionalAccess', _95 => _95[0]]) === f.name)]), () => ( []));
+      if (issues.length > 0) {
+        const messages = issues.map((i) => i.message).join("\n");
+        this.setFieldError(f.name, messages);
+      }
+    }
+    return { isValid: false, value: values2, issues: _nullishCoalesce(res.issues, () => ( [])) };
+  }
+  // --- Rendering ---
+  render() {
+    const css2 = (
+      /*css*/
+      `
+      :host { display: block; font: 14px/1.4 system-ui, sans-serif; }
+      form { display: grid; gap: 12px; }
+      .field-row { display: grid; gap: 12px; }
+      .row { display: grid; gap: 6px; }
+      .checkbox-row { display: flex; align-items: center; gap: 6px; }
+      .actions {
+        margin-top: 8px;
+        display: flex;
+        gap: 8px;
+      }
+      .actions > .left,
+      .actions > .center,
+      .actions > .right {
+        flex: 1;
+        display: flex;
+      }
+      .actions > .left { justify-content: flex-start; }
+      .actions > .center { justify-content: center; }
+      .actions > .right { justify-content: flex-end; }
+    `
+    );
+    const form = document.createElement("form");
+    form.noValidate = true;
+    form.addEventListener("submit", this.onSubmit);
+    form.style.width = this._formWidth;
+    const layout = this._layout && this._layout.length > 0 ? [...this._layout] : [];
+    let total = layout.reduce((a, b) => a + b, 0);
+    while (total < this._fields.length) {
+      layout.push(1);
+      total += 1;
+    }
+    let fieldIndex = 0;
+    for (const cols of layout) {
+      if (fieldIndex >= this._fields.length) break;
+      const rowWrap = document.createElement("div");
+      rowWrap.className = "field-row";
+      rowWrap.style.gridTemplateColumns = `repeat(${cols}, 1fr)`;
+      for (let i = 0; i < cols && fieldIndex < this._fields.length; i++) {
+        const f = this._fields[fieldIndex++];
+        const cell = document.createElement("div");
+        cell.className = f.type === "checkbox" ? "row checkbox-row" : "row";
+        const fieldId = this._idPrefix ? `${this._idPrefix}-${f.name}` : f.name;
+        if (f.type === "checkbox") {
+          const input = document.createElement("input");
+          input.type = "checkbox";
+          input.id = fieldId;
+          input.setAttribute("data-name", f.name);
+          input.name = fieldId;
+          if (this._value[f.name] !== void 0) {
+            input.checked = Boolean(this._value[f.name]);
+          }
+          input.addEventListener("change", () => {
+            this.onInputChange(f.name, input.checked);
+          });
+          input.addEventListener("blur", () => this.onBlur(f.name));
+          const label = document.createElement("label");
+          label.htmlFor = fieldId;
+          label.textContent = f.label;
+          cell.appendChild(input);
+          cell.appendChild(label);
+        } else {
+          const input = document.createElement("wavelength-input");
+          if (this._inputProps) {
+            for (const [key, value] of Object.entries(this._inputProps)) {
+              if (value !== void 0) input.setAttribute(key, String(value));
+            }
+          }
+          input.setAttribute("data-name", f.name);
+          input.setAttribute("name", fieldId);
+          if (f.placeholder !== void 0) {
+            input.setAttribute("placeholder", f.placeholder);
+            input.setAttribute("label", f.placeholder);
+          } else {
+            input.setAttribute("label", f.label);
+          }
+          input.setAttribute("validation-type", "manual");
+          input.setAttribute("id", fieldId);
+          if (f.type === "number") {
+            input.setAttribute("input-type", "number");
+          }
+          if (f.required) {
+            input.setAttribute("required", "");
+          }
+          if (f.minLength !== void 0) {
+            input.setAttribute("min-length", String(f.minLength));
+          }
+          if (f.maxLength !== void 0) {
+            input.setAttribute("max-length", String(f.maxLength));
+          }
+          if (this._value[f.name] !== null && this._value[f.name] !== void 0) {
+            input.value = String(this._value[f.name]);
+          }
+          input.addEventListener("inputChange", ((e) => {
+            const detail = _nullishCoalesce(e.detail, () => ( {}));
+            let val = _nullishCoalesce(detail.value, () => ( ""));
+            if (f.type === "number") {
+              val = val === "" ? "" : Number(val);
+            }
+            this.onInputChange(f.name, val);
+          }));
+          input.addEventListener("blur", (() => this.onBlur(f.name)));
+          cell.appendChild(input);
+        }
+        rowWrap.appendChild(cell);
+      }
+      form.appendChild(rowWrap);
+    }
+    const actions = document.createElement("div");
+    actions.className = "actions";
+    const leftSlot = document.createElement("div");
+    leftSlot.className = "left";
+    const centerSlot = document.createElement("div");
+    centerSlot.className = "center";
+    const rightSlot = document.createElement("div");
+    rightSlot.className = "right";
+    const buildButton = (cfg, defaultEvent) => {
+      const btn = document.createElement("wavelength-button");
+      const requestedType = _nullishCoalesce(_optionalChain([cfg, 'access', _96 => _96.buttonProps, 'optionalAccess', _97 => _97.type]), () => ( ""));
+      const type = requestedType === "submit" ? "submit" : "button";
+      if (cfg.buttonProps) {
+        for (const [key, value] of Object.entries(cfg.buttonProps)) {
+          if (key === "type") continue;
+          if (value !== void 0) btn.setAttribute(key, String(value));
+        }
+      }
+      btn.setAttribute("type", type);
+      if (cfg.label) btn.textContent = cfg.label;
+      btn.addEventListener("click", (e) => {
+        const ev = _nullishCoalesce(cfg.eventName, () => ( defaultEvent));
+        if (requestedType === "submit") {
+          form.requestSubmit();
+        } else {
+          e.preventDefault();
+        }
+        this.dispatchEvent(new CustomEvent(ev));
+      });
+      return btn;
     };
-    return `#${toHex(R)}${toHex(G)}${toHex(B)}`;
-  }
-  handleRipple(event) {
-    if (this.button.disabled) return;
-    const variant = this.getAttribute("variant") || "outlined";
-    const colorOne = this.getAttribute("color-one") || "#1976D2";
-    const ripple = document.createElement("span");
-    ripple.className = "ripple";
-    const color2 = variant === "contained" ? this.hexToRgba(this.shadeColor(colorOne, 40), 0.6) : this.hexToRgba(this.shadeColor(colorOne, -40), 0.3);
-    ripple.style.backgroundColor = color2;
-    const rect = this.button.getBoundingClientRect();
-    const size = Math.max(rect.width, rect.height);
-    ripple.style.width = ripple.style.height = `${size}px`;
-    ripple.style.left = `${event.clientX - rect.left - size / 2}px`;
-    ripple.style.top = `${event.clientY - rect.top - size / 2}px`;
-    this.button.appendChild(ripple);
-    setTimeout(() => ripple.remove(), 600);
+    if (this._leftButton) {
+      leftSlot.appendChild(buildButton(this._leftButton, "form-left"));
+    }
+    if (this._centerButton) {
+      centerSlot.appendChild(buildButton(this._centerButton, "form-center"));
+    }
+    if (this._rightButton) {
+      rightSlot.appendChild(buildButton(this._rightButton, "form-right"));
+    }
+    if (leftSlot.children.length + centerSlot.children.length + rightSlot.children.length > 0) {
+      actions.append(leftSlot, centerSlot, rightSlot);
+      form.appendChild(actions);
+    }
+    this._shadow.innerHTML = `<style>${css2}</style>`;
+    if (this._title) {
+      const heading = document.createElement("h2");
+      heading.textContent = this._title;
+      heading.style.textAlign = this._titleAlign;
+      if (this._titleColor) {
+        heading.style.color = this._titleColor;
+      }
+      heading.style.userSelect = "none";
+      heading.style.setProperty("-webkit-user-select", "none");
+      this._shadow.appendChild(heading);
+    }
+    this._shadow.appendChild(form);
+    for (const [name, msg] of Object.entries(this._errors)) {
+      this.setFieldError(name, msg);
+    }
   }
 };
-if (!customElements.get("wavelength-button")) {
-  customElements.define("wavelength-button", WavelengthButton);
+if (!customElements.get("wavelength-form")) {
+  customElements.define("wavelength-form", WavelengthForm);
 }
 
 // src/web-components/wavelength-progress-bar.ts
@@ -1649,13 +4495,14 @@ customElements.define("wavelength-progress-bar", WavelengthProgressBar);
 // src/web-components/wavelength-input.ts
 var template3 = document.createElement("template");
 template3.innerHTML = `
-<style>  
-  :host {  
-    display: inline-block;  
-    font-family: sans-serif;  
-    --wavelength-container-background: #f8f8f8;  
-    --wavelength-label-background: #ffffff;  
-  }  
+<style>
+  :host {
+    display: block;
+    width: 100%;
+    font-family: sans-serif;
+    --wavelength-container-background: #f8f8f8;
+    --wavelength-label-background: #ffffff;
+  }
 
   .field-wrapper {  
     position: relative;  
@@ -1782,6 +4629,14 @@ template3.innerHTML = `
 </div>
 <div class="helper-message" id="helper"></div>
 `;
+function getAncestor(el) {
+  if (!el) return null;
+  if (el.parentElement) {
+    return el.parentElement;
+  }
+  const root = el.getRootNode();
+  return root instanceof ShadowRoot ? root.host : null;
+}
 var WavelengthInput = class extends HTMLElement {
   constructor() {
     super();
@@ -1794,6 +4649,7 @@ var WavelengthInput = class extends HTMLElement {
     this._debounceValidate = () => {
     };
     this._debounceTimeout = null;
+    this._lastErrorMessage = "";
     this._onInput = () => {
       this.setAttribute("value", this.inputEl.value);
       this.internals.setFormValue(this.inputEl.value);
@@ -1819,8 +4675,15 @@ var WavelengthInput = class extends HTMLElement {
         this.hasBlurred = true;
       }
       const shouldValidate = this.validationType === "onBlur" || this.validationType === "always";
+      let isValid = true;
+      if (shouldValidate) {
+        isValid = this._validate();
+      }
+      const hasError = this.hasAttribute("data-error") || this.hasAttribute("force-error");
+      if (hasError) {
+        return;
+      }
       if (shouldValidate) {
-        const isValid = this._validate();
         if (isValid) {
           this.inputEl.style.borderColor = this.getAttribute("border-color") || "#cccccc";
         }
@@ -1893,7 +4756,7 @@ var WavelengthInput = class extends HTMLElement {
     this._applyAttributes();
     this._setupDebouncedValidation();
     const maxLengthAttr = this.getAttribute("max-length");
-    const value = _optionalChain([this, 'access', _6 => _6.inputEl, 'optionalAccess', _7 => _7.value, 'optionalAccess', _8 => _8.trim, 'optionalCall', _9 => _9()]) || "";
+    const value = _optionalChain([this, 'access', _98 => _98.inputEl, 'optionalAccess', _99 => _99.value, 'optionalAccess', _100 => _100.trim, 'optionalCall', _101 => _101()]) || "";
     this.inputEl.addEventListener("input", this._onInput);
     this.inputEl.addEventListener("blur", this._onBlur);
     this.inputEl.addEventListener("focus", this._onFocus);
@@ -1918,13 +4781,13 @@ var WavelengthInput = class extends HTMLElement {
     this._bgObserver = new MutationObserver(() => {
       requestAnimationFrame(() => this._applyColors());
     });
-    let ancestor = this.parentElement;
+    let ancestor = getAncestor(this);
     while (ancestor && ancestor !== document.body) {
       this._bgObserver.observe(ancestor, {
         attributes: true,
         attributeFilter: ["class", "style"]
       });
-      ancestor = ancestor.parentElement;
+      ancestor = getAncestor(ancestor);
     }
     this._bgObserver.observe(document.body, {
       attributes: true,
@@ -1961,35 +4824,42 @@ var WavelengthInput = class extends HTMLElement {
     if (!bypassTypeCheck && (validationType === "manual" || validationType === "none") && !force) {
       return true;
     }
-    const shouldValidate = bypassTypeCheck || force || validationType === "always" || validationType === "onBlur" && this.hasBlurred;
-    const errors = [];
+    const shouldValidate = bypassTypeCheck || validationType === "always" || validationType === "onBlur" && this.hasBlurred;
+    const errors = /* @__PURE__ */ new Set();
     if (force) {
-      errors.push(errorMessage || "Invalid input.");
-    }
-    if (isRequired && isEmpty2 && shouldValidate) {
-      errors.push("This field is required.");
+      if (errorMessage) {
+        errors.add(errorMessage);
+      }
     }
-    if (regexAttr && !isEmpty2 && shouldValidate) {
-      try {
-        const regex = new RegExp(regexAttr);
-        if (!regex.test(value)) {
-          errors.push(errorMessage || "Input does not match the required pattern.");
+    if (!force) {
+      if (isRequired && isEmpty2 && shouldValidate) {
+        errors.add(_nullishCoalesce(errorMessage, () => ( "This field is required.")));
+      }
+      if (regexAttr && !isEmpty2 && shouldValidate) {
+        try {
+          const regex = new RegExp(regexAttr);
+          if (!regex.test(value)) {
+            errors.add(_nullishCoalesce(errorMessage, () => ( "Input does not match the required pattern.")));
+          }
+        } catch (e) {
+          console.warn(`[WavelengthInput] Invalid regex pattern: "${regexAttr}"`, e);
+          errors.add("Invalid regex pattern.");
         }
-      } catch (e) {
-        console.warn(`[WavelengthInput] Invalid regex pattern: "${regexAttr}"`, e);
-        errors.push("Invalid regex pattern.");
+      }
+      const min = parseInt(_nullishCoalesce(minLengthAttr, () => ( "")), 10);
+      if (!isNaN(min) && value.length < min && shouldValidate) {
+        errors.add(_nullishCoalesce(minLengthMessage, () => ( `MINIMUM length is ${min} characters.`)));
+      }
+      const max = parseInt(_nullishCoalesce(maxLengthAttr, () => ( "")), 10);
+      if (!isNaN(max) && value.length > max && shouldValidate) {
+        errors.add(_nullishCoalesce(maxLengthMessage, () => ( `MAXIMUM length is ${max} characters.`)));
       }
     }
-    const min = parseInt(_nullishCoalesce(minLengthAttr, () => ( "")), 10);
-    if (!isNaN(min) && value.length < min && shouldValidate) {
-      errors.push(minLengthMessage || `MINIMUM length is ${min} characters.`);
-    }
-    const max = parseInt(_nullishCoalesce(maxLengthAttr, () => ( "")), 10);
-    if (!isNaN(max) && value.length > max && shouldValidate) {
-      errors.push(maxLengthMessage || `MAXIMUM length is ${max} characters.`);
-    }
-    if (errors.length > 0) {
-      this._showError(errors.join("\n"));
+    if (errors.size > 0) {
+      const message = Array.from(errors).join("\n");
+      if (message !== this._lastErrorMessage) {
+        this._showError(message);
+      }
       return false;
     }
     this._clearError(helperMessage || "");
@@ -1997,12 +4867,17 @@ var WavelengthInput = class extends HTMLElement {
   }
   _showError(message) {
     const htmlMessage = message.replace(/\n/g, "<br>");
+    if (this.helperEl.innerHTML === htmlMessage) {
+      this._lastErrorMessage = message;
+      return;
+    }
     this.helperEl.innerHTML = htmlMessage;
     this.helperEl.classList.add("error");
     this.inputEl.style.borderColor = "red";
     this.helperEl.style.color = "red";
     this.inputEl.setAttribute("aria-invalid", "true");
     this.setAttribute("data-error", "true");
+    this._lastErrorMessage = message;
   }
   _clearError(helperText) {
     const borderColor2 = this.isFocused ? this.getAttribute("focus-color") || "#5e9ed6" : this.getAttribute("border-color") || "#cccccc";
@@ -2014,6 +4889,7 @@ var WavelengthInput = class extends HTMLElement {
     this.inputEl.setAttribute("aria-invalid", "false");
     this.removeAttribute("data-error");
     this._applyValidationHint();
+    this._lastErrorMessage = "";
   }
   _applyAttributes() {
     this._applyContent();
@@ -2059,7 +4935,8 @@ var WavelengthInput = class extends HTMLElement {
     this._updateRequiredMarker();
   }
   _applyLayout() {
-    const width2 = this.getAttribute("width") || "320px";
+    const widthAttr = this.getAttribute("width");
+    const width2 = widthAttr || "100%";
     const rawPadding = this.getAttribute("padding") || "16.5px 14px";
     const paddingParts = rawPadding.trim().split(/\s+/);
     let leftPaddingPx;
@@ -2079,8 +4956,8 @@ var WavelengthInput = class extends HTMLElement {
       default:
         leftPaddingPx = 14;
     }
-    const parsedWidth = parseInt(width2, 10);
-    const helperWidth = `${parsedWidth - leftPaddingPx}px`;
+    const isNumericWidth = widthAttr ? /^\d+(px)?$/.test(widthAttr.trim()) : false;
+    const helperWidth = isNumericWidth ? `${parseInt(widthAttr, 10) - leftPaddingPx}px` : `calc(${width2} - ${leftPaddingPx}px)`;
     this.inputEl.style.width = width2;
     this.inputEl.style.padding = rawPadding;
     this.inputEl.style.height = this.getAttribute("height") || "";
@@ -2106,7 +4983,7 @@ var WavelengthInput = class extends HTMLElement {
         containerBg = bg;
         break;
       }
-      el = el.parentElement;
+      el = getAncestor(el);
     }
     this.inputEl.style.backgroundColor = InputBg;
     this.labelEl.style.setProperty("--wavelength-label-background", InputBg);
@@ -2159,6 +5036,13 @@ var WavelengthInput = class extends HTMLElement {
       case "helper-message":
         this._applyValidationHint();
         break;
+      case "error-message":
+      case "force-error":
+        this._applyAttributes();
+        if (!this.hasAttribute("error-message") && !this.hasAttribute("force-error")) {
+          this._clearError(this.getAttribute("helper-message") || "");
+        }
+        break;
       case "validation-type":
         this.validationType = validTypes.includes(newValue) ? newValue : "none";
         break;
@@ -2295,8 +5179,8 @@ var WavelengthTitleBar = class extends HTMLElement {
         }`;
       shadow.appendChild(fallbackStyle);
     }
-    const wrapper = document.createElement("div");
-    wrapper.classList.add("title-bar");
+    const wrapper2 = document.createElement("div");
+    wrapper2.classList.add("title-bar");
     const title = document.createElement("div");
     title.classList.add("title");
     title.textContent = this.getAttribute("title-text") || "Default Title";
@@ -2331,9 +5215,9 @@ var WavelengthTitleBar = class extends HTMLElement {
   }
 `;
     shadow.appendChild(style3);
-    wrapper.appendChild(title);
-    wrapper.appendChild(subtitle);
-    shadow.appendChild(wrapper);
+    wrapper2.appendChild(title);
+    wrapper2.appendChild(subtitle);
+    shadow.appendChild(wrapper2);
   }
   connectedCallback() {
     if (!fontsInjected) {
@@ -2351,8 +5235,8 @@ var WavelengthTitleBar = class extends HTMLElement {
   }
   attributeChangedCallback(name, oldValue, newValue) {
     if (oldValue === newValue) return;
-    const titleElement = _optionalChain([this, 'access', _10 => _10.shadowRoot, 'optionalAccess', _11 => _11.querySelector, 'call', _12 => _12(".title")]);
-    const subtitleElement = _optionalChain([this, 'access', _13 => _13.shadowRoot, 'optionalAccess', _14 => _14.querySelector, 'call', _15 => _15(".subtitle")]);
+    const titleElement = _optionalChain([this, 'access', _102 => _102.shadowRoot, 'optionalAccess', _103 => _103.querySelector, 'call', _104 => _104(".title")]);
+    const subtitleElement = _optionalChain([this, 'access', _105 => _105.shadowRoot, 'optionalAccess', _106 => _106.querySelector, 'call', _107 => _107(".subtitle")]);
     switch (name) {
       case "title-text":
         if (titleElement) titleElement.textContent = newValue;
@@ -2466,6 +5350,7 @@ var WavelengthButton2 = ({
   }, []);
   return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "wavelength-button", { ref, className, style: style3, ...rest, children });
 };
+WavelengthButton2.displayName = "WavelengthButton";
 
 // src/components/buttons/WavelengthDropdownButton/WavelengthDropdownButton.tsx
 var _Button = require('@mui/material/Button'); var _Button2 = _interopRequireDefault(_Button);
@@ -2481,6 +5366,273 @@ function formatMuiErrorMessage(code) {
 
 // ../../node_modules/@mui/styled-engine/index.js
 var _styled = require('@emotion/styled'); var _styled2 = _interopRequireDefault(_styled);
+
+// ../../node_modules/@emotion/hash/dist/emotion-hash.esm.js
+function murmur2(str) {
+  var h = 0;
+  var k, i = 0, len = str.length;
+  for (; len >= 4; ++i, len -= 4) {
+    k = str.charCodeAt(i) & 255 | (str.charCodeAt(++i) & 255) << 8 | (str.charCodeAt(++i) & 255) << 16 | (str.charCodeAt(++i) & 255) << 24;
+    k = /* Math.imul(k, m): */
+    (k & 65535) * 1540483477 + ((k >>> 16) * 59797 << 16);
+    k ^= /* k >>> r: */
+    k >>> 24;
+    h = /* Math.imul(k, m): */
+    (k & 65535) * 1540483477 + ((k >>> 16) * 59797 << 16) ^ /* Math.imul(h, m): */
+    (h & 65535) * 1540483477 + ((h >>> 16) * 59797 << 16);
+  }
+  switch (len) {
+    case 3:
+      h ^= (str.charCodeAt(i + 2) & 255) << 16;
+    case 2:
+      h ^= (str.charCodeAt(i + 1) & 255) << 8;
+    case 1:
+      h ^= str.charCodeAt(i) & 255;
+      h = /* Math.imul(h, m): */
+      (h & 65535) * 1540483477 + ((h >>> 16) * 59797 << 16);
+  }
+  h ^= h >>> 13;
+  h = /* Math.imul(h, m): */
+  (h & 65535) * 1540483477 + ((h >>> 16) * 59797 << 16);
+  return ((h ^ h >>> 15) >>> 0).toString(36);
+}
+
+// ../../node_modules/@emotion/unitless/dist/emotion-unitless.esm.js
+var unitlessKeys = {
+  animationIterationCount: 1,
+  aspectRatio: 1,
+  borderImageOutset: 1,
+  borderImageSlice: 1,
+  borderImageWidth: 1,
+  boxFlex: 1,
+  boxFlexGroup: 1,
+  boxOrdinalGroup: 1,
+  columnCount: 1,
+  columns: 1,
+  flex: 1,
+  flexGrow: 1,
+  flexPositive: 1,
+  flexShrink: 1,
+  flexNegative: 1,
+  flexOrder: 1,
+  gridRow: 1,
+  gridRowEnd: 1,
+  gridRowSpan: 1,
+  gridRowStart: 1,
+  gridColumn: 1,
+  gridColumnEnd: 1,
+  gridColumnSpan: 1,
+  gridColumnStart: 1,
+  msGridRow: 1,
+  msGridRowSpan: 1,
+  msGridColumn: 1,
+  msGridColumnSpan: 1,
+  fontWeight: 1,
+  lineHeight: 1,
+  opacity: 1,
+  order: 1,
+  orphans: 1,
+  scale: 1,
+  tabSize: 1,
+  widows: 1,
+  zIndex: 1,
+  zoom: 1,
+  WebkitLineClamp: 1,
+  // SVG-related properties
+  fillOpacity: 1,
+  floodOpacity: 1,
+  stopOpacity: 1,
+  strokeDasharray: 1,
+  strokeDashoffset: 1,
+  strokeMiterlimit: 1,
+  strokeOpacity: 1,
+  strokeWidth: 1
+};
+
+// ../../node_modules/@emotion/memoize/dist/emotion-memoize.esm.js
+function memoize(fn) {
+  var cache = /* @__PURE__ */ Object.create(null);
+  return function(arg) {
+    if (cache[arg] === void 0) cache[arg] = fn(arg);
+    return cache[arg];
+  };
+}
+
+// ../../node_modules/@emotion/serialize/dist/emotion-serialize.esm.js
+var isDevelopment = false;
+var hyphenateRegex = /[A-Z]|^ms/g;
+var animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g;
+var isCustomProperty = function isCustomProperty2(property) {
+  return property.charCodeAt(1) === 45;
+};
+var isProcessableValue = function isProcessableValue2(value) {
+  return value != null && typeof value !== "boolean";
+};
+var processStyleName = /* @__PURE__ */ memoize(function(styleName) {
+  return isCustomProperty(styleName) ? styleName : styleName.replace(hyphenateRegex, "-$&").toLowerCase();
+});
+var processStyleValue = function processStyleValue2(key, value) {
+  switch (key) {
+    case "animation":
+    case "animationName": {
+      if (typeof value === "string") {
+        return value.replace(animationRegex, function(match, p1, p2) {
+          cursor = {
+            name: p1,
+            styles: p2,
+            next: cursor
+          };
+          return p1;
+        });
+      }
+    }
+  }
+  if (unitlessKeys[key] !== 1 && !isCustomProperty(key) && typeof value === "number" && value !== 0) {
+    return value + "px";
+  }
+  return value;
+};
+var noComponentSelectorMessage = "Component selectors can only be used in conjunction with @emotion/babel-plugin, the swc Emotion plugin, or another Emotion-aware compiler transform.";
+function handleInterpolation(mergedProps, registered, interpolation) {
+  if (interpolation == null) {
+    return "";
+  }
+  var componentSelector = interpolation;
+  if (componentSelector.__emotion_styles !== void 0) {
+    return componentSelector;
+  }
+  switch (typeof interpolation) {
+    case "boolean": {
+      return "";
+    }
+    case "object": {
+      var keyframes2 = interpolation;
+      if (keyframes2.anim === 1) {
+        cursor = {
+          name: keyframes2.name,
+          styles: keyframes2.styles,
+          next: cursor
+        };
+        return keyframes2.name;
+      }
+      var serializedStyles = interpolation;
+      if (serializedStyles.styles !== void 0) {
+        var next = serializedStyles.next;
+        if (next !== void 0) {
+          while (next !== void 0) {
+            cursor = {
+              name: next.name,
+              styles: next.styles,
+              next: cursor
+            };
+            next = next.next;
+          }
+        }
+        var styles = serializedStyles.styles + ";";
+        return styles;
+      }
+      return createStringFromObject(mergedProps, registered, interpolation);
+    }
+    case "function": {
+      if (mergedProps !== void 0) {
+        var previousCursor = cursor;
+        var result = interpolation(mergedProps);
+        cursor = previousCursor;
+        return handleInterpolation(mergedProps, registered, result);
+      }
+      break;
+    }
+  }
+  var asString = interpolation;
+  if (registered == null) {
+    return asString;
+  }
+  var cached2 = registered[asString];
+  return cached2 !== void 0 ? cached2 : asString;
+}
+function createStringFromObject(mergedProps, registered, obj) {
+  var string = "";
+  if (Array.isArray(obj)) {
+    for (var i = 0; i < obj.length; i++) {
+      string += handleInterpolation(mergedProps, registered, obj[i]) + ";";
+    }
+  } else {
+    for (var key in obj) {
+      var value = obj[key];
+      if (typeof value !== "object") {
+        var asString = value;
+        if (registered != null && registered[asString] !== void 0) {
+          string += key + "{" + registered[asString] + "}";
+        } else if (isProcessableValue(asString)) {
+          string += processStyleName(key) + ":" + processStyleValue(key, asString) + ";";
+        }
+      } else {
+        if (key === "NO_COMPONENT_SELECTOR" && isDevelopment) {
+          throw new Error(noComponentSelectorMessage);
+        }
+        if (Array.isArray(value) && typeof value[0] === "string" && (registered == null || registered[value[0]] === void 0)) {
+          for (var _i = 0; _i < value.length; _i++) {
+            if (isProcessableValue(value[_i])) {
+              string += processStyleName(key) + ":" + processStyleValue(key, value[_i]) + ";";
+            }
+          }
+        } else {
+          var interpolated = handleInterpolation(mergedProps, registered, value);
+          switch (key) {
+            case "animation":
+            case "animationName": {
+              string += processStyleName(key) + ":" + interpolated + ";";
+              break;
+            }
+            default: {
+              string += key + "{" + interpolated + "}";
+            }
+          }
+        }
+      }
+    }
+  }
+  return string;
+}
+var labelPattern = /label:\s*([^\s;{]+)\s*(;|$)/g;
+var cursor;
+function serializeStyles(args, registered, mergedProps) {
+  if (args.length === 1 && typeof args[0] === "object" && args[0] !== null && args[0].styles !== void 0) {
+    return args[0];
+  }
+  var stringMode = true;
+  var styles = "";
+  cursor = void 0;
+  var strings = args[0];
+  if (strings == null || strings.raw === void 0) {
+    stringMode = false;
+    styles += handleInterpolation(mergedProps, registered, strings);
+  } else {
+    var asTemplateStringsArr = strings;
+    styles += asTemplateStringsArr[0];
+  }
+  for (var i = 1; i < args.length; i++) {
+    styles += handleInterpolation(mergedProps, registered, args[i]);
+    if (stringMode) {
+      var templateStringsArr = strings;
+      styles += templateStringsArr[i];
+    }
+  }
+  labelPattern.lastIndex = 0;
+  var identifierName = "";
+  var match;
+  while ((match = labelPattern.exec(styles)) !== null) {
+    identifierName += "-" + match[1];
+  }
+  var name = murmur2(styles) + identifierName;
+  return {
+    name,
+    styles,
+    next: cursor
+  };
+}
+
+// ../../node_modules/@mui/styled-engine/index.js
 var _react2 = require('@emotion/react');
 function styled(tag, options) {
   const stylesFactory = _styled2.default.call(void 0, tag, options);
@@ -2502,6 +5654,11 @@ var internal_processStyles = (tag, processor) => {
     tag.__emotion_styles = processor(tag.__emotion_styles);
   }
 };
+var wrapper = [];
+function internal_serializeStyles(styles) {
+  wrapper[0] = styles;
+  return serializeStyles(wrapper);
+}
 
 // ../../node_modules/@babel/runtime/helpers/esm/extends.js
 function _extends() {
@@ -2519,7 +5676,7 @@ function _objectWithoutPropertiesLoose(r, e) {
   if (null == r) return {};
   var t = {};
   for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
-    if (e.includes(n)) continue;
+    if (-1 !== e.indexOf(n)) continue;
     t[n] = r[n];
   }
   return t;
@@ -2527,7 +5684,7 @@ function _objectWithoutPropertiesLoose(r, e) {
 
 // ../../node_modules/@mui/utils/esm/deepmerge/deepmerge.js
 
-function isPlainObject(item) {
+function isPlainObject2(item) {
   if (typeof item !== "object" || item === null) {
     return false;
   }
@@ -2535,7 +5692,7 @@ function isPlainObject(item) {
   return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in item) && !(Symbol.iterator in item);
 }
 function deepClone(source) {
-  if (/* @__PURE__ */ React2.isValidElement(source) || !isPlainObject(source)) {
+  if (/* @__PURE__ */ React2.isValidElement(source) || !isPlainObject2(source)) {
     return source;
   }
   const output = {};
@@ -2548,15 +5705,15 @@ function deepmerge(target, source, options = {
   clone: true
 }) {
   const output = options.clone ? _extends({}, target) : target;
-  if (isPlainObject(target) && isPlainObject(source)) {
+  if (isPlainObject2(target) && isPlainObject2(source)) {
     Object.keys(source).forEach((key) => {
       if (/* @__PURE__ */ React2.isValidElement(source[key])) {
         output[key] = source[key];
-      } else if (isPlainObject(source[key]) && // Avoid prototype pollution
-      Object.prototype.hasOwnProperty.call(target, key) && isPlainObject(target[key])) {
+      } else if (isPlainObject2(source[key]) && // Avoid prototype pollution
+      Object.prototype.hasOwnProperty.call(target, key) && isPlainObject2(target[key])) {
         output[key] = deepmerge(target[key], source[key], options);
       } else if (options.clone) {
-        output[key] = isPlainObject(source[key]) ? deepClone(source[key]) : source[key];
+        output[key] = isPlainObject2(source[key]) ? deepClone(source[key]) : source[key];
       } else {
         output[key] = source[key];
       }
@@ -2652,7 +5809,7 @@ var responsivePropType = process.env.NODE_ENV !== "production" ? import_prop_typ
 var responsivePropType_default = responsivePropType;
 
 // ../../node_modules/@mui/system/esm/merge.js
-function merge(acc, item) {
+function merge2(acc, item) {
   if (!item) {
     return acc;
   }
@@ -2661,7 +5818,7 @@ function merge(acc, item) {
     // No need to clone deep, it's way faster.
   });
 }
-var merge_default = merge;
+var merge_default = merge2;
 
 // ../../node_modules/@mui/system/esm/breakpoints.js
 var values = {
@@ -2753,7 +5910,7 @@ function getPath(obj, path, checkVars = true) {
     return null;
   }, obj);
 }
-function getStyleValue(themeMapping, transform, propValueFinal, userValue = propValueFinal) {
+function getStyleValue(themeMapping, transform2, propValueFinal, userValue = propValueFinal) {
   let value;
   if (typeof themeMapping === "function") {
     value = themeMapping(propValueFinal);
@@ -2762,8 +5919,8 @@ function getStyleValue(themeMapping, transform, propValueFinal, userValue = prop
   } else {
     value = getPath(themeMapping, propValueFinal) || userValue;
   }
-  if (transform) {
-    value = transform(value, userValue, themeMapping);
+  if (transform2) {
+    value = transform2(value, userValue, themeMapping);
   }
   return value;
 }
@@ -2772,7 +5929,7 @@ function style(options) {
     prop,
     cssProperty = options.prop,
     themeKey,
-    transform
+    transform: transform2
   } = options;
   const fn = (props) => {
     if (props[prop] == null) {
@@ -2782,9 +5939,9 @@ function style(options) {
     const theme = props.theme;
     const themeMapping = getPath(theme, themeKey) || {};
     const styleFromPropValue = (propValueFinal) => {
-      let value = getStyleValue(themeMapping, transform, propValueFinal);
+      let value = getStyleValue(themeMapping, transform2, propValueFinal);
       if (propValueFinal === value && typeof propValueFinal === "string") {
-        value = getStyleValue(themeMapping, transform, `${prop}${propValueFinal === "default" ? "" : capitalize(propValueFinal)}`, propValueFinal);
+        value = getStyleValue(themeMapping, transform2, `${prop}${propValueFinal === "default" ? "" : capitalize(propValueFinal)}`, propValueFinal);
       }
       if (cssProperty === false) {
         return value;
@@ -2804,7 +5961,7 @@ function style(options) {
 var style_default = style;
 
 // ../../node_modules/@mui/system/esm/memoize.js
-function memoize(fn) {
+function memoize2(fn) {
   const cache = {};
   return (arg) => {
     if (cache[arg] === void 0) {
@@ -2833,7 +5990,7 @@ var aliases = {
   paddingX: "px",
   paddingY: "py"
 };
-var getCssProperties = memoize((prop) => {
+var getCssProperties = memoize2((prop) => {
   if (prop.length > 2) {
     if (aliases[prop]) {
       prop = aliases[prop];
@@ -2954,7 +6111,7 @@ function createSpacing(spacingInput = 8) {
   if (spacingInput.mui) {
     return spacingInput;
   }
-  const transform = createUnarySpacing({
+  const transform2 = createUnarySpacing({
     spacing: spacingInput
   });
   const spacing2 = (...argsInput) => {
@@ -2965,7 +6122,7 @@ function createSpacing(spacingInput = 8) {
     }
     const args = argsInput.length === 0 ? [1] : argsInput;
     return args.map((argument) => {
-      const output = transform(argument);
+      const output = transform2(argument);
       return typeof output === "number" ? `${output}px` : output;
     }).join(" ");
   };
@@ -3002,11 +6159,11 @@ function borderTransform(value) {
   }
   return `${value}px solid`;
 }
-function createBorderStyle(prop, transform) {
+function createBorderStyle(prop, transform2) {
   return style_default({
     prop,
     themeKey: "borders",
-    transform
+    transform: transform2
   });
 }
 var border = createBorderStyle("border", borderTransform);
@@ -3488,19 +6645,19 @@ var defaultSxConfig_default = defaultSxConfig;
 // ../../node_modules/@mui/system/esm/styleFunctionSx/styleFunctionSx.js
 function objectsHaveSameKeys(...objects) {
   const allKeys = objects.reduce((keys, object) => keys.concat(Object.keys(object)), []);
-  const union = new Set(allKeys);
-  return objects.every((object) => union.size === Object.keys(object).length);
+  const union2 = new Set(allKeys);
+  return objects.every((object) => union2.size === Object.keys(object).length);
 }
 function callIfFn(maybeFn, arg) {
   return typeof maybeFn === "function" ? maybeFn(arg) : maybeFn;
 }
 function unstable_createStyleFunctionSx() {
-  function getThemeValue(prop, val, theme, config) {
+  function getThemeValue(prop, val, theme, config2) {
     const props = {
       [prop]: val,
       theme
     };
-    const options = config[prop];
+    const options = config2[prop];
     if (!options) {
       return {
         [prop]: val
@@ -3509,7 +6666,7 @@ function unstable_createStyleFunctionSx() {
     const {
       cssProperty = prop,
       themeKey,
-      transform,
+      transform: transform2,
       style: style3
     } = options;
     if (val == null) {
@@ -3525,9 +6682,9 @@ function unstable_createStyleFunctionSx() {
       return style3(props);
     }
     const styleFromPropValue = (propValueFinal) => {
-      let value = getStyleValue(themeMapping, transform, propValueFinal);
+      let value = getStyleValue(themeMapping, transform2, propValueFinal);
       if (propValueFinal === value && typeof propValueFinal === "string") {
-        value = getStyleValue(themeMapping, transform, `${prop}${propValueFinal === "default" ? "" : capitalize(propValueFinal)}`, propValueFinal);
+        value = getStyleValue(themeMapping, transform2, `${prop}${propValueFinal === "default" ? "" : capitalize(propValueFinal)}`, propValueFinal);
       }
       if (cssProperty === false) {
         return value;
@@ -3542,12 +6699,13 @@ function unstable_createStyleFunctionSx() {
     var _theme$unstable_sxCon;
     const {
       sx,
-      theme = {}
+      theme = {},
+      nested
     } = props || {};
     if (!sx) {
       return null;
     }
-    const config = (_theme$unstable_sxCon = theme.unstable_sxConfig) != null ? _theme$unstable_sxCon : defaultSxConfig_default;
+    const config2 = (_theme$unstable_sxCon = theme.unstable_sxConfig) != null ? _theme$unstable_sxCon : defaultSxConfig_default;
     function traverse(sxInput) {
       let sxObject = sxInput;
       if (typeof sxInput === "function") {
@@ -3565,8 +6723,8 @@ function unstable_createStyleFunctionSx() {
         const value = callIfFn(sxObject[styleKey], theme);
         if (value !== null && value !== void 0) {
           if (typeof value === "object") {
-            if (config[styleKey]) {
-              css2 = merge_default(css2, getThemeValue(styleKey, value, theme, config));
+            if (config2[styleKey]) {
+              css2 = merge_default(css2, getThemeValue(styleKey, value, theme, config2));
             } else {
               const breakpointsValues = handleBreakpoints({
                 theme
@@ -3576,17 +6734,23 @@ function unstable_createStyleFunctionSx() {
               if (objectsHaveSameKeys(breakpointsValues, value)) {
                 css2[styleKey] = styleFunctionSx2({
                   sx: value,
-                  theme
+                  theme,
+                  nested: true
                 });
               } else {
                 css2 = merge_default(css2, breakpointsValues);
               }
             }
           } else {
-            css2 = merge_default(css2, getThemeValue(styleKey, value, theme, config));
+            css2 = merge_default(css2, getThemeValue(styleKey, value, theme, config2));
           }
         }
       });
+      if (!nested && theme.modularCssLayers) {
+        return {
+          "@layer sx": removeUnusedBreakpoints(breakpointsKeys, css2)
+        };
+      }
       return removeUnusedBreakpoints(breakpointsKeys, css2);
     }
     return Array.isArray(sx) ? sx.map(traverse) : traverse(sx);
@@ -3701,6 +6865,12 @@ function isStringTag(tag) {
 function shouldForwardProp(prop) {
   return prop !== "ownerState" && prop !== "theme" && prop !== "sx" && prop !== "as";
 }
+function shallowLayer(serialized, layerName) {
+  if (layerName && serialized && typeof serialized === "object" && serialized.styles && !serialized.styles.startsWith("@layer")) {
+    serialized.styles = `@layer ${layerName}{${String(serialized.styles)}}`;
+  }
+  return serialized;
+}
 var systemDefaultTheme = createTheme_default();
 var lowercaseFirstLetter = (string) => {
   if (!string) {
@@ -3721,7 +6891,7 @@ function defaultOverridesResolver(slot) {
   }
   return (props, styles) => styles[slot];
 }
-function processStyleArg(callableStyle, _ref) {
+function processStyleArg(callableStyle, _ref, layerName) {
   let {
     ownerState
   } = _ref, props = _objectWithoutPropertiesLoose(_ref, _excluded3);
@@ -3731,7 +6901,7 @@ function processStyleArg(callableStyle, _ref) {
   if (Array.isArray(resolvedStylesArg)) {
     return resolvedStylesArg.flatMap((resolvedStyle) => processStyleArg(resolvedStyle, _extends({
       ownerState
-    }, props)));
+    }, props), layerName));
   }
   if (!!resolvedStylesArg && typeof resolvedStylesArg === "object" && Array.isArray(resolvedStylesArg.variants)) {
     const {
@@ -3755,14 +6925,15 @@ function processStyleArg(callableStyle, _ref) {
         if (!Array.isArray(result)) {
           result = [result];
         }
-        result.push(typeof variant.style === "function" ? variant.style(_extends({
+        const variantStyle = typeof variant.style === "function" ? variant.style(_extends({
           ownerState
-        }, props, ownerState)) : variant.style);
+        }, props, ownerState)) : variant.style;
+        result.push(layerName ? shallowLayer(internal_serializeStyles(variantStyle), layerName) : variantStyle);
       }
     });
     return result;
   }
-  return resolvedStylesArg;
+  return layerName ? shallowLayer(internal_serializeStyles(resolvedStylesArg), layerName) : resolvedStylesArg;
 }
 function createStyled(input = {}) {
   const {
@@ -3791,6 +6962,7 @@ function createStyled(input = {}) {
       // For more details: https://github.com/mui/material-ui/pull/37908
       overridesResolver = defaultOverridesResolver(lowercaseFirstLetter(componentSlot))
     } = inputOptions, options = _objectWithoutPropertiesLoose(inputOptions, _excluded32);
+    const layerName = componentName && componentName.startsWith("Mui") || !!componentSlot ? "components" : "custom";
     const skipVariantsResolver = inputSkipVariantsResolver !== void 0 ? inputSkipVariantsResolver : (
       // TODO v6: remove `Root` in the next major release
       // For more details: https://github.com/mui/material-ui/pull/37908
@@ -3816,14 +6988,17 @@ function createStyled(input = {}) {
       label
     }, options));
     const transformStyleArg = (stylesArg) => {
-      if (typeof stylesArg === "function" && stylesArg.__emotion_real !== stylesArg || isPlainObject(stylesArg)) {
-        return (props) => processStyleArg(stylesArg, _extends({}, props, {
-          theme: resolveTheme({
+      if (typeof stylesArg === "function" && stylesArg.__emotion_real !== stylesArg || isPlainObject2(stylesArg)) {
+        return (props) => {
+          const theme = resolveTheme({
             theme: props.theme,
             defaultTheme,
             themeId
-          })
-        }));
+          });
+          return processStyleArg(stylesArg, _extends({}, props, {
+            theme
+          }), theme.modularCssLayers ? layerName : void 0);
+        };
       }
       return stylesArg;
     };
@@ -3844,7 +7019,7 @@ function createStyled(input = {}) {
           Object.entries(styleOverrides).forEach(([slotKey, slotStyle]) => {
             resolvedStyleOverrides[slotKey] = processStyleArg(slotStyle, _extends({}, props, {
               theme
-            }));
+            }), theme.modularCssLayers ? "theme" : void 0);
           });
           return overridesResolver(props, resolvedStyleOverrides);
         });
@@ -3861,7 +7036,7 @@ function createStyled(input = {}) {
             variants: themeVariants
           }, _extends({}, props, {
             theme
-          }));
+          }), theme.modularCssLayers ? "theme" : void 0);
         });
       }
       if (!skipSx) {
@@ -3963,6 +7138,7 @@ function WavelengthDropdownButton({ children, onClick }) {
     renderButtonMenu(children)
   ] }) });
 }
+WavelengthDropdownButton.displayName = "WavelengthDropdownButton";
 
 // src/components/buttons/WavelengthDropdownButton/WavelengthAutocomplete.tsx
 var _material = require('@mui/material');
@@ -4049,6 +7225,7 @@ function WavelengthAutocomplete({ label, width: width2 = 300, variant = "outline
     }
   ) });
 }
+WavelengthAutocomplete.displayName = "WavelengthAutocomplete";
 
 // src/components/buttons/WavelengthFileDownloader.tsx
 var _Download = require('@mui/icons-material/Download'); var _Download2 = _interopRequireDefault(_Download);
@@ -4073,6 +7250,7 @@ function WavelengthFileDownloader({ fileLoc, fileURL, fileName, button, id }) {
     ] });
   }
 }
+WavelengthFileDownloader.displayName = "WavelengthFileDownloader";
 
 // src/components/buttons/WavelengthButton/WavelengthStyledButton.tsx
 var _styledcomponents = require('styled-components'); var _styledcomponents2 = _interopRequireDefault(_styledcomponents);
@@ -4489,6 +7667,7 @@ function WavelengthStyledButton({ type = "default", styles, children, disabled =
     children
   ] });
 }
+WavelengthStyledButton.displayName = "WavelengthStyledButton";
 var WavelengthStyledButton_default = WavelengthStyledButton;
 
 // src/themes/WavelengthAppTheme.tsx
@@ -4560,6 +7739,7 @@ function WavelengthBox({ width: width2, height: height2, children, borderBottomR
     }
   );
 }
+WavelengthBox.displayName = "WavelengthBox";
 
 // src/components/containers/WavelengthContentPlaceholder/WavelengthContentPlaceholder.tsx
 
@@ -4595,6 +7775,7 @@ function WavelengthContentPlaceholder({ type, width: width2, height: height2, tx
     return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { style: divStyleRectangle, id, children });
   }
 }
+WavelengthContentPlaceholder.displayName = "WavelengthContentPlaceholder";
 
 // src/components/example/WavelengthExampleComponent.tsx
 
@@ -4618,6 +7799,7 @@ function WavelengthExampleComponent({ width: width2 = 100, height: height2 = 100
     ] })
   ] }) });
 }
+WavelengthExampleComponent.displayName = "WavelengthExampleComponent";
 
 // src/components/search/WavelengthSearch.tsx
 var _TextField = require('@mui/material/TextField'); var _TextField2 = _interopRequireDefault(_TextField);
@@ -5173,6 +8355,7 @@ function WavelengthSearch({
   }
   return void 0;
 }
+WavelengthSearch.displayName = "WavelengthSearch";
 
 // src/components/search/WavelengthSearchTextField.tsx
 
@@ -5200,6 +8383,7 @@ function WavelengthSearchTextField() {
   }));
   return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, WavelengthSearchTextField2, {});
 }
+WavelengthSearchTextField.displayName = "WavelengthSearchTextField";
 
 // src/components/logos/applogo/WavelengthAppLogo.tsx
 
@@ -5647,6 +8831,7 @@ function WavelengthAppLogo({ width: width2, height: height2, name = "", grayscal
   }
   return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { children: logo });
 }
+WavelengthAppLogo.displayName = "WavelengthAppLogo";
 var WavelengthAppLogo_default = WavelengthAppLogo;
 
 // src/components/PageComponents/WavelengthNotAvailablePage.tsx
@@ -5664,6 +8849,7 @@ function WavelengthNotAvailablePage({ WavelengthAppLogoName, errorMessage, backg
     ] })
   ] }) });
 }
+WavelengthNotAvailablePage.displayName = "WavelengthNotAvailablePage";
 
 // src/components/PageComponents/WavelengthSideBar.tsx
 
@@ -5707,7 +8893,7 @@ function WavelengthSideBar({ sections, txtColor, bgColor, labelColor, arrowColor
           openSections[section.title] ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _iconsmaterial.KeyboardArrowDownRounded, { sx: { color: arrowColor ? arrowColor : palette2.secondary } }) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _iconsmaterial.KeyboardArrowRightRounded, { sx: { color: arrowColor ? arrowColor : palette2.secondary } }),
           /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _Typography2.default, { variant: "h6", sx: { fontSize: 16, color: txtColor ? txtColor : palette2.secondary }, children: section.title })
         ] }),
-        _optionalChain([section, 'access', _16 => _16.subsections, 'optionalAccess', _17 => _17.length]) && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _Collapse2.default, { in: openSections[section.title], timeout: "auto", unmountOnExit: true, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _List2.default, { component: "div", disablePadding: true, sx: { paddingLeft: 4 }, children: section.subsections.map((subsection, subIndex) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, React2.default.Fragment, { children: [
+        _optionalChain([section, 'access', _108 => _108.subsections, 'optionalAccess', _109 => _109.length]) && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _Collapse2.default, { in: openSections[section.title], timeout: "auto", unmountOnExit: true, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _List2.default, { component: "div", disablePadding: true, sx: { paddingLeft: 4 }, children: section.subsections.map((subsection, subIndex) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, React2.default.Fragment, { children: [
           /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
             _Typography2.default,
             {
@@ -5718,7 +8904,7 @@ function WavelengthSideBar({ sections, txtColor, bgColor, labelColor, arrowColor
                 paddingLeft: 0.75,
                 color: labelColor ? labelColor : palette2.secondary
               },
-              children: _optionalChain([subsection, 'access', _18 => _18.title, 'optionalAccess', _19 => _19.toUpperCase, 'call', _20 => _20()])
+              children: _optionalChain([subsection, 'access', _110 => _110.title, 'optionalAccess', _111 => _111.toUpperCase, 'call', _112 => _112()])
             }
           ),
           subsection.items && subsection.items.map((item, itemIndex) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
@@ -5736,6 +8922,7 @@ function WavelengthSideBar({ sections, txtColor, bgColor, labelColor, arrowColor
     }
   );
 }
+WavelengthSideBar.displayName = "WavelengthSideBar";
 
 // src/components/PageComponents/WavelengthSpinningLogo.tsx
 
@@ -5787,6 +8974,7 @@ function WavelengthSpinningOuterCircle({ size, id, clip, color: color2, gradient
     }
   );
 }
+WavelengthSpinningOuterCircle.displayName = "WavelengthSpinningOuterCircle";
 var WavelengthSpinningLogo_default = WavelengthSpinningOuterCircle;
 
 // src/components/PageComponents/WavelengthSpinningLogoComponent.tsx
@@ -5829,6 +9017,7 @@ function WavelengthSpinningLogo({ svg = /* @__PURE__ */ _jsxruntime.jsx.call(voi
   ) });
   return loadingSymbol;
 }
+WavelengthSpinningLogo.displayName = "WavelengthSpinningLogo";
 
 // src/components/PageComponents/WavelengthDragAndDrop.tsx
 
@@ -5895,6 +9084,7 @@ function WavelengthDragAndDrop({
     }
   );
 }
+WavelengthDragAndDrop.displayName = "WavelengthDragAndDrop";
 
 // src/components/PageComponents/WavelengthProgressBar.tsx
 
@@ -5915,6 +9105,7 @@ var WavelengthProgressBar2 = ({ name, value, width: width2, height: height2, fon
   }, [name, value, width2, height2, fontSize, fontColor, progressBorder, progressColor]);
   return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "wavelength-progress-bar", { ref, ...rest });
 };
+WavelengthProgressBar2.displayName = "WavelengthProgressBar";
 
 // src/components/PageComponents/WavelengthCommentDisplay.tsx
 
@@ -5948,7 +9139,7 @@ function WavelengthCommentDisplay(props) {
             {
               onClick: (e) => {
                 setSelected(!selected);
-                _optionalChain([props, 'access', _21 => _21.onClick, 'optionalCall', _22 => _22(e)]);
+                _optionalChain([props, 'access', _113 => _113.onClick, 'optionalCall', _114 => _114(e)]);
               },
               style: { padding: "0px" },
               children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _CheckCircleOutline2.default, { fontSize: "small" })
@@ -5959,7 +9150,7 @@ function WavelengthCommentDisplay(props) {
             {
               onClick: (e) => {
                 setSelected(!selected);
-                _optionalChain([props, 'access', _23 => _23.onClick, 'optionalCall', _24 => _24(e)]);
+                _optionalChain([props, 'access', _115 => _115.onClick, 'optionalCall', _116 => _116(e)]);
               },
               style: { padding: "0px" },
               children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _CheckCircle2.default, { fontSize: "small", sx: { color: props.iconSelectedColor || "rgba(209, 106, 47, 1)" } })
@@ -5972,6 +9163,7 @@ function WavelengthCommentDisplay(props) {
     }
   );
 }
+WavelengthCommentDisplay.displayName = "WavelengthCommentDisplay";
 
 // src/components/PageComponents/WavelengthPermissionAlert.tsx
 
@@ -6034,6 +9226,7 @@ function WavelengthPermissionAlert({
     }
   ) });
 }
+WavelengthPermissionAlert.displayName = "WavelengthPermissionAlert";
 
 // src/components/PageComponents/WavelengthAccessAlert.tsx
 var _Check = require('@mui/icons-material/Check'); var _Check2 = _interopRequireDefault(_Check);
@@ -6167,6 +9360,7 @@ function WavelengthAccessAlert({
     );
   }
 }
+WavelengthAccessAlert.displayName = "WavelengthAccessAlert";
 
 // src/components/PageComponents/WavelengthAlert.tsx
 var _Close = require('@mui/icons-material/Close'); var _Close2 = _interopRequireDefault(_Close);
@@ -6281,6 +9475,7 @@ function WavelengthAlert({
     ] });
   }
 }
+WavelengthAlert.displayName = "WavelengthAlert";
 
 // src/components/footers/WavelengthFooter/WavelengthFooter.tsx
 
@@ -6332,6 +9527,132 @@ function WavelengthFooter({ text, textColor }) {
     }
   );
 }
+WavelengthFooter.displayName = "WavelengthFooter";
+
+// src/components/forms/WavelengthForm.tsx
+
+
+function useStableCallback(fn) {
+  const fnRef = _react.useRef.call(void 0, fn);
+  _react.useEffect.call(void 0, () => {
+    fnRef.current = fn;
+  }, [fn]);
+  return (...args) => _optionalChain([fnRef, 'access', _117 => _117.current, 'optionalCall', _118 => _118(...args)]);
+}
+function WavelengthFormInner(props, ref) {
+  const {
+    schema,
+    value,
+    className,
+    style: style3,
+    onChange,
+    onValid,
+    onInvalid,
+    leftButton,
+    centerButton,
+    rightButton,
+    inputProps,
+    idPrefix,
+    title,
+    titleAlign,
+    titleColor,
+    placeholders,
+    formWidth,
+    layout,
+    onLeft,
+    onCenter,
+    onRight,
+    onSubmit
+  } = props;
+  const hostRef = _react.useRef.call(void 0, null);
+  const onChangeStable = useStableCallback(onChange);
+  const onValidStable = useStableCallback(onValid);
+  const onInvalidStable = useStableCallback(onInvalid);
+  const onLeftStable = useStableCallback(onLeft);
+  const onCenterStable = useStableCallback(onCenter);
+  const onRightStable = useStableCallback(onRight);
+  const onSubmitStable = useStableCallback(onSubmit);
+  _react.useEffect.call(void 0, () => {
+    const el = hostRef.current;
+    if (!el) return;
+    let finalSchema = schema;
+    if (placeholders) {
+      const shape2 = _optionalChain([schema, 'optionalAccess', _119 => _119.shape]);
+      if (shape2) {
+        const overrides = {};
+        for (const [key, ph] of Object.entries(placeholders)) {
+          const field = shape2[key];
+          if (field && typeof field.meta === "function") {
+            const curMeta = field.meta() || {};
+            overrides[key] = field.meta({ ...curMeta, placeholder: ph });
+          }
+        }
+        if (Object.keys(overrides).length > 0 && typeof schema.extend === "function") {
+          finalSchema = schema.extend(overrides);
+        }
+      }
+    }
+    el.schema = finalSchema;
+    if (value) el.value = value;
+    if (leftButton !== void 0) el.leftButton = leftButton;
+    if (centerButton !== void 0) el.centerButton = centerButton;
+    if (rightButton !== void 0) el.rightButton = rightButton;
+    if (inputProps !== void 0) el.inputProps = inputProps;
+    el.idPrefix = idPrefix;
+    if (title !== void 0) el.title = title;
+    if (titleAlign !== void 0) el.titleAlign = titleAlign;
+    if (titleColor !== void 0) el.titleColor = titleColor;
+    if (formWidth !== void 0) el.formWidth = formWidth;
+    if (layout !== void 0) el.layout = layout;
+  }, [schema, value, leftButton, centerButton, rightButton, inputProps, idPrefix, title, titleAlign, titleColor, placeholders, formWidth, layout]);
+  _react.useEffect.call(void 0, () => {
+    const el = hostRef.current;
+    if (!el) return;
+    const handleChange = (e) => {
+      const detail = e.detail;
+      _optionalChain([onChangeStable, 'optionalCall', _120 => _120(_nullishCoalesce(_optionalChain([detail, 'optionalAccess', _121 => _121.value]), () => ( {})), _nullishCoalesce(_optionalChain([detail, 'optionalAccess', _122 => _122.issues]), () => ( [])))]);
+    };
+    const handleValid = (e) => {
+      const detail = e.detail;
+      _optionalChain([onValidStable, 'optionalCall', _123 => _123(_optionalChain([detail, 'optionalAccess', _124 => _124.value]), _nullishCoalesce(_optionalChain([detail, 'optionalAccess', _125 => _125.issues]), () => ( [])))]);
+    };
+    const handleInvalid = (e) => {
+      const detail = e.detail;
+      _optionalChain([onInvalidStable, 'optionalCall', _126 => _126(_nullishCoalesce(_optionalChain([detail, 'optionalAccess', _127 => _127.value]), () => ( {})), _nullishCoalesce(_optionalChain([detail, 'optionalAccess', _128 => _128.issues]), () => ( [])))]);
+    };
+    el.addEventListener("form-change", handleChange);
+    el.addEventListener("form-valid", handleValid);
+    el.addEventListener("form-invalid", handleInvalid);
+    el.addEventListener("form-left", onLeftStable);
+    el.addEventListener("form-center", onCenterStable);
+    el.addEventListener("form-right", onRightStable);
+    el.addEventListener("submit", onSubmitStable);
+    return () => {
+      el.removeEventListener("form-change", handleChange);
+      el.removeEventListener("form-valid", handleValid);
+      el.removeEventListener("form-invalid", handleInvalid);
+      el.removeEventListener("form-left", onLeftStable);
+      el.removeEventListener("form-center", onCenterStable);
+      el.removeEventListener("form-right", onRightStable);
+      el.removeEventListener("submit", onSubmitStable);
+    };
+  }, [onChangeStable, onValidStable, onInvalidStable, onLeftStable, onCenterStable, onRightStable, onSubmitStable]);
+  _react.useImperativeHandle.call(void 0, 
+    ref,
+    () => ({
+      validate: () => _nullishCoalesce(_optionalChain([hostRef, 'access', _129 => _129.current, 'optionalAccess', _130 => _130.validate, 'optionalCall', _131 => _131()]), () => ( false)),
+      getValue: () => _optionalChain([hostRef, 'access', _132 => _132.current, 'optionalAccess', _133 => _133.value]),
+      setValue: (v) => {
+        if (hostRef.current) hostRef.current.value = v;
+      }
+    }),
+    []
+  );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "wavelength-form", { ref: hostRef, className, style: style3 });
+}
+var WavelengthFormForwardRef = React2.default.forwardRef(WavelengthFormInner);
+WavelengthFormForwardRef.displayName = "WavelengthForm";
+var WavelengthForm2 = WavelengthFormForwardRef;
 
 // src/components/headers/WavelengthTitleBar/WavelengthTitleBar.tsx
 
@@ -6348,6 +9669,7 @@ function WavelengthTitleBar2({ titleText, subtitleText, textColor, shadowColor }
   }, [titleText, subtitleText, textColor, shadowColor]);
   return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "wavelength-title-bar", { ref });
 }
+WavelengthTitleBar2.displayName = "WavelengthTitleBar";
 
 // src/components/headers/WavelengthTitleBar/WavelengthBanner.tsx
 
@@ -6368,6 +9690,7 @@ function WavelengthBanner2({ bannerText, bannerColor, textColor, opacity = 1, zI
   }, [bannerText, bannerColor, textColor, classification, control, opacity, zIndex, id]);
   return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "wavelength-banner", { ref });
 }
+WavelengthBanner2.displayName = "WavelengthBanner";
 
 // src/components/logos/default/WavelengthDefaultIcon.tsx
 
@@ -6400,6 +9723,7 @@ function WavelengthDefaultIcon({ width: width2 = "180", height: height2 = 140 })
     ] }) })
   ] }) });
 }
+WavelengthDefaultIcon.displayName = "WavelengthDefaultIcon";
 
 // src/components/CSFD/WavelengthManyPlanes.tsx
 
@@ -6442,6 +9766,7 @@ function WavelengthManyPlanes({ numberOfPlanes = 5, trailDir = "left", color: co
   };
   return PlaneGridWrapper(numberOfPlanes, opacity);
 }
+WavelengthManyPlanes.displayName = "WavelengthManyPlanes";
 
 // src/components/separators/WavelengthPlaneTrail/WavelengthPlaneTrail.tsx
 var _Divider = require('@mui/material/Divider'); var _Divider2 = _interopRequireDefault(_Divider);
@@ -6472,6 +9797,7 @@ function WavelengthPlaneTrail({ trailDir = "right", id, color: color2 }) {
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _Grid2.default, { item: true, style: { width: "75%" }, id: "trailExample", children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _Divider2.default, { variant: "middle", sx: { bgcolor: color2 ? color2 : palette2.primary } }) })
   ] });
 }
+WavelengthPlaneTrail.displayName = "WavelengthPlaneTrail";
 
 // src/components/modals/WavelengthConfirmationModal.tsx
 
@@ -6502,8 +9828,8 @@ function WavelengthConfirmationModal(props) {
         overflow: "scroll"
       },
       children: [
-        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "p", { style: { margin: "0px", fontSize: "28px", fontWeight: 500, padding: "0px", marginBottom: "16px", fontFamily: props.fontFamily }, children: _optionalChain([props, 'access', _25 => _25.textObj, 'optionalAccess', _26 => _26.title]) }),
-        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "p", { style: { margin: "0px", fontSize: "16px", lineHeight: "19.2px", fontFamily: props.fontFamily, fontWeight: 400, height: "60px" }, children: _optionalChain([props, 'access', _27 => _27.textObj, 'optionalAccess', _28 => _28.dialog]) }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "p", { style: { margin: "0px", fontSize: "28px", fontWeight: 500, padding: "0px", marginBottom: "16px", fontFamily: props.fontFamily }, children: _optionalChain([props, 'access', _134 => _134.textObj, 'optionalAccess', _135 => _135.title]) }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "p", { style: { margin: "0px", fontSize: "16px", lineHeight: "19.2px", fontFamily: props.fontFamily, fontWeight: 400, height: "60px" }, children: _optionalChain([props, 'access', _136 => _136.textObj, 'optionalAccess', _137 => _137.dialog]) }),
         /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { style: { display: "flex", flexDirection: "row", justifyContent: "flex-end", marginTop: "40px", gap: "8px" }, children: [
           props.cancelButton,
           props.submitButton
@@ -6512,6 +9838,7 @@ function WavelengthConfirmationModal(props) {
     }
   ) });
 }
+WavelengthConfirmationModal.displayName = "WavelengthConfirmationModal";
 
 // src/components/modals/WavelengthContentModal.tsx
 
@@ -6524,13 +9851,14 @@ function WavelengthContentModal(props) {
   };
   return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _material.Dialog, { "data-testid": "testId-WavelengthContentModal", open: show, onClose: handleClose, "aria-labelledby": "alert-dialog-title", "aria-describedby": "alert-dialog-description", children: [
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.DialogTitle, { alignContent: `center`, id: "alert-dialog-title", children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _material.Box, { display: "flex", alignItems: "center", children: [
-      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Box, { flexGrow: 1, children: _optionalChain([props, 'access', _29 => _29.textObj, 'optionalAccess', _30 => _30.title]) }),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Box, { flexGrow: 1, children: _optionalChain([props, 'access', _138 => _138.textObj, 'optionalAccess', _139 => _139.title]) }),
       /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Box, { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.IconButton, { onClick: handleClose, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _Close2.default, {}) }) })
     ] }) }),
-    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.DialogContent, { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Typography, { align: "center", children: _optionalChain([props, 'access', _31 => _31.textObj, 'optionalAccess', _32 => _32.dialog]) }) }),
-    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.DialogActions, { style: { justifyContent: `center` }, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Button, { "data-testid": "testId-WavelengthContentModalConfirmButton", onClick: handleContentModalOnConfirmProp, color: "primary", variant: "contained", autoFocus: true, children: _optionalChain([props, 'access', _33 => _33.textObj, 'optionalAccess', _34 => _34.purpose]) }) })
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.DialogContent, { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Typography, { align: "center", children: _optionalChain([props, 'access', _140 => _140.textObj, 'optionalAccess', _141 => _141.dialog]) }) }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.DialogActions, { style: { justifyContent: `center` }, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Button, { "data-testid": "testId-WavelengthContentModalConfirmButton", onClick: handleContentModalOnConfirmProp, color: "primary", variant: "contained", autoFocus: true, children: _optionalChain([props, 'access', _142 => _142.textObj, 'optionalAccess', _143 => _143.purpose]) }) })
   ] });
 }
+WavelengthContentModal.displayName = "WavelengthContentModal";
 
 // src/components/modals/WavelengthPopUpMenu.tsx
 
@@ -6578,7 +9906,7 @@ function WavelengthPopUpMenu({ menuItems, customIcon = false, width: width2, men
     icon = /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _iconsmaterial.HelpOutline, { fontSize: "medium", sx: { color: color2 } });
   }
   const anchor = menuDirection === "top" || menuDirection === void 0 ? "top" : "bottom";
-  const transform = menuDirection === "top" || menuDirection === void 0 ? "bottom" : "top";
+  const transform2 = menuDirection === "top" || menuDirection === void 0 ? "bottom" : "top";
   return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _IconButton2.default, { onClick: handleClick, children: icon }),
     /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
@@ -6596,7 +9924,7 @@ function WavelengthPopUpMenu({ menuItems, customIcon = false, width: width2, men
         anchorEl,
         TransitionComponent: _Slide2.default,
         anchorOrigin: { vertical: anchor, horizontal: "center" },
-        transformOrigin: { vertical: transform, horizontal: "center" },
+        transformOrigin: { vertical: transform2, horizontal: "center" },
         children: [
           ...menuItems.map((items, index) => {
             if (items.end === true) {
@@ -6664,6 +9992,7 @@ function WavelengthPopUpMenu({ menuItems, customIcon = false, width: width2, men
     )
   ] });
 }
+WavelengthPopUpMenu.displayName = "WavelengthPopUpMenu";
 
 // src/components/modals/WavelengthDropdown.tsx
 
@@ -6742,7 +10071,7 @@ function WavelengthDropdown({
       borderBottomRightRadius: "8px",
       borderTopRightRadius: "0px",
       borderTopLeftRadius: "0px",
-      boxShadow: _optionalChain([menuSx, 'optionalAccess', _35 => _35.boxShadow]),
+      boxShadow: _optionalChain([menuSx, 'optionalAccess', _144 => _144.boxShadow]),
       width: myMenusx.width,
       backgroundColor: `${myMenusx.backgroundColor}`
     },
@@ -6793,6 +10122,7 @@ function WavelengthDropdown({
   ] });
 }
 var WavelengthDropdownStyled = _material.styled.call(void 0, WavelengthDropdown)``;
+WavelengthDropdown.displayName = "WavelengthDropdown";
 
 // src/components/snackbars/WavelengthSnackbar.tsx
 var _Snackbar = require('@mui/material/Snackbar'); var _Snackbar2 = _interopRequireDefault(_Snackbar);
@@ -6837,6 +10167,7 @@ function WavelengthSnackbar({ show, setShow, closeIcon, message, snackBarColor,
     }
   );
 }
+WavelengthSnackbar.displayName = "WavelengthSnackbar";
 
 // src/components/snackbars/WavelengthStandardSnackbar.tsx
 
@@ -6899,6 +10230,7 @@ function WavelengthStandardSnackbar({ type, show, icon, horryAlign, vertyAlign,
     }
   );
 }
+WavelengthStandardSnackbar.displayName = "WavelengthStandardSnackbar";
 
 // src/components/snackbars/WavelengthTestSnackbar.tsx
 
@@ -6969,6 +10301,7 @@ function WavelengthTestSnackbar({ isPopUpOpen, toggleOpen, type, message, custom
     }
   ) });
 }
+WavelengthTestSnackbar.displayName = "WavelengthTestSnackbar";
 
 // src/components/sliders/WavelengthSlider.tsx
 
@@ -6997,6 +10330,7 @@ function WavelengthSlider({ width: width2 = "300px", color: color2, valueDisplay
     }
   ) });
 }
+WavelengthSlider.displayName = "WavelengthSlider";
 
 // src/components/carousels/WavelengthDefaultCarousel.tsx
 
@@ -7057,6 +10391,7 @@ var DefaultCarousel = ({ items, buttonSize, imageHeight, imageWidth, cardHeight,
     }
   ) }) });
 };
+DefaultCarousel.displayName = "DefaultCarousel";
 
 // src/components/carousels/WavelengthSliderCarousel.tsx
 
@@ -7140,6 +10475,7 @@ var SliderCardCarousel = ({ items, cardHeight, cardWidth, contHeight, contWidth
     }
   ) }) });
 };
+SliderCardCarousel.displayName = "SliderCardCarousel";
 
 // src/components/pagination/WavelengthDefaultPagination.tsx
 
@@ -7253,6 +10589,7 @@ function WavelengthButtonPagination({ totalPages, current, handleChangePage, ite
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _Button2.default, { onClick: () => handleChangePage(current + 1), disabled: current === totalPages, sx: WLButtonPagStyle, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _ArrowForwardIos2.default, {}) })
   ] });
 }
+WavelengthButtonPagination.displayName = "WavelengthButtonPagination";
 var WavelengthButtonPagination_default = WavelengthButtonPagination;
 
 // src/components/pagination/WavelengthVariationPagination.tsx
@@ -7344,6 +10681,7 @@ function WavelengthVariationPagination({ totalPages, current, variant, handleCha
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _Button2.default, { onClick: () => handleChangePage(current + 1), disabled: current === totalPages, variant, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _ArrowForwardIos2.default, {}) })
   ] });
 }
+WavelengthVariationPagination.displayName = "WavelengthVariationPagination";
 var WavelengthVariationPagination_default = WavelengthVariationPagination;
 
 // src/components/pagination/WavelengthDefaultPagination.tsx
@@ -7449,6 +10787,7 @@ function DefaultPagination({ totalPages, currentPageNumber, siblingCount = 1, bo
     );
   }
 }
+DefaultPagination.displayName = "DefaultPagination";
 var WavelengthDefaultPagination_default = DefaultPagination;
 
 // src/components/TextField/WavelengthInput.tsx
@@ -7470,7 +10809,7 @@ var WavelengthInput2 = _react.forwardRef.call(void 0,
     validationType = "none",
     minLength,
     maxLength,
-    required,
+    required: required2,
     forceError,
     disabled,
     width: width2,
@@ -7492,7 +10831,7 @@ var WavelengthInput2 = _react.forwardRef.call(void 0,
     const internalRef = _react.useRef.call(void 0, null);
     _react.useImperativeHandle.call(void 0, ref, () => ({
       ...internalRef.current,
-      validate: () => _optionalChain([internalRef, 'access', _36 => _36.current, 'optionalAccess', _37 => _37.validate, 'optionalCall', _38 => _38(true)])
+      validate: () => _optionalChain([internalRef, 'access', _145 => _145.current, 'optionalAccess', _146 => _146.validate, 'optionalCall', _147 => _147(true)])
     }));
     _react.useEffect.call(void 0, () => {
       const el = internalRef.current;
@@ -7518,7 +10857,7 @@ var WavelengthInput2 = _react.forwardRef.call(void 0,
       set("validation-type", validationType);
       set("min-length", minLength);
       set("max-length", maxLength);
-      set("required", required ? "" : void 0);
+      set("required", required2 ? "" : void 0);
       set("force-error", forceError ? "" : void 0);
       set("width", width2);
       set("height", height2);
@@ -7548,7 +10887,7 @@ var WavelengthInput2 = _react.forwardRef.call(void 0,
       validationType,
       minLength,
       maxLength,
-      required,
+      required2,
       forceError,
       width2,
       height2,
@@ -7568,7 +10907,7 @@ var WavelengthInput2 = _react.forwardRef.call(void 0,
       const el = internalRef.current;
       if (!el || !onChange) return;
       const handler = (e) => {
-        const input = _optionalChain([el, 'access', _39 => _39.shadowRoot, 'optionalAccess', _40 => _40.querySelector, 'call', _41 => _41("input")]);
+        const input = _optionalChain([el, 'access', _148 => _148.shadowRoot, 'optionalAccess', _149 => _149.querySelector, 'call', _150 => _150("input")]);
         if (input) {
           const synthetic = {
             ...e,
@@ -7768,7 +11107,7 @@ var WavelengthDataTable = ({ data, columns, itemsPerPage, totalPages }) => {
   const [noRowsOpen, setNoRowsOpen] = _react.useState.call(void 0, false);
   const [isModalOpen, setIsModalOpen] = _react.useState.call(void 0, false);
   const [searchItem, setSearchItem] = _react.useState.call(void 0, "");
-  const [selectedValue, setSelectedValue] = _react.useState.call(void 0, _optionalChain([columns, 'access', _42 => _42[0], 'optionalAccess', _43 => _43.key]) || "");
+  const [selectedValue, setSelectedValue] = _react.useState.call(void 0, _optionalChain([columns, 'access', _151 => _151[0], 'optionalAccess', _152 => _152.key]) || "");
   const [currentPage, setCurrentPage] = _react.useState.call(void 0, 1);
   const [isOpen, setIsOpen] = _react.useState.call(void 0, false);
   const [editingMenuKey, setEditingMenuKey] = _react.useState.call(void 0, null);
@@ -7922,7 +11261,7 @@ var WavelengthDataTable = ({ data, columns, itemsPerPage, totalPages }) => {
       ] }, index)
     ] }, `headCell-${index}`);
   });
-  const rows = !_optionalChain([currentPageData, 'optionalAccess', _44 => _44.length]) || noRowsOpen ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "tr", { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "td", { title: "NoDataRows", colSpan: columns.length, children: "No data" }) }) : _optionalChain([currentPageData, 'optionalAccess', _45 => _45.map, 'call', _46 => _46((item) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "tr", { children: columns.map((column, index2) => {
+  const rows = !_optionalChain([currentPageData, 'optionalAccess', _153 => _153.length]) || noRowsOpen ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "tr", { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "td", { title: "NoDataRows", colSpan: columns.length, children: "No data" }) }) : _optionalChain([currentPageData, 'optionalAccess', _154 => _154.map, 'call', _155 => _155((item) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "tr", { children: columns.map((column, index2) => {
     return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, StyledTd, { children: editingId === item.id && editedColumnKey === column.key ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
       StyledInput,
       {
@@ -7950,6 +11289,7 @@ var WavelengthDataTable = ({ data, columns, itemsPerPage, totalPages }) => {
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, StyledNavBoxDiv, { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, WavelengthDefaultPagination_default, { totalPages, currentPageNumber: currentPage, onPageChange: setCurrentPage, style: "circular" }) })
   ] });
 };
+WavelengthDataTable.displayName = "WavelengthDataTable";
 
 // src/components/DataTable/SubRowTable/ChildSubTable.tsx
 
@@ -8167,7 +11507,7 @@ var ChildDataTable = ({ data, columns, downloadArrowOnClick, downloadMissionOnCl
     }
     if (sortSubOrder) {
       result.map(
-        (item) => _optionalChain([item, 'access', _47 => _47.Details, 'optionalAccess', _48 => _48.fileObjects, 'access', _49 => _49.sort, 'call', _50 => _50((c, d) => {
+        (item) => _optionalChain([item, 'access', _156 => _156.Details, 'optionalAccess', _157 => _157.fileObjects, 'access', _158 => _158.sort, 'call', _159 => _159((c, d) => {
           const valueC = c[sortSubKey];
           const valueD = d[sortSubKey];
           if (typeof valueC === "string" && typeof valueD === "string") {
@@ -8228,24 +11568,24 @@ var ChildDataTable = ({ data, columns, downloadArrowOnClick, downloadMissionOnCl
     return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "th", { children: renderSortSubButton(column, sortSubOrder, sortSubKey) }, `SubHeadCell-${index}`);
   });
   const subDataRows = (itemId) => {
-    return processedRowData.filter((item) => _optionalChain([item, 'access', _51 => _51.Details, 'optionalAccess', _52 => _52.relationId]) === itemId).map((item) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.Fragment, { children: _optionalChain([item, 'access', _53 => _53.Details, 'optionalAccess', _54 => _54.fileObjects, 'access', _55 => _55.map, 'call', _56 => _56((fileItem, index) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, SubDataTableBodyRowContainer, { children: [
+    return processedRowData.filter((item) => _optionalChain([item, 'access', _160 => _160.Details, 'optionalAccess', _161 => _161.relationId]) === itemId).map((item) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.Fragment, { children: _optionalChain([item, 'access', _162 => _162.Details, 'optionalAccess', _163 => _163.fileObjects, 'access', _164 => _164.map, 'call', _165 => _165((fileItem, index) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, SubDataTableBodyRowContainer, { children: [
       /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "td", { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, DownloadArrow, { onClick: downloadArrowOnClick, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "svg", { width: "17", height: "16", viewBox: "0 0 17 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
         "path",
         {
           d: "M8.5 12L3.5 7L4.9 5.55L7.5 8.15V0H9.5V8.15L12.1 5.55L13.5 7L8.5 12ZM2.5 16C1.95 16 1.47917 15.8042 1.0875 15.4125C0.695833 15.0208 0.5 14.55 0.5 14V11H2.5V14H14.5V11H16.5V14C16.5 14.55 16.3042 15.0208 15.9125 15.4125C15.5208 15.8042 15.05 16 14.5 16H2.5Z",
           fill: "#1C1B1F"
         }
-      ) }) }) }, `td-${_optionalChain([item, 'access', _57 => _57.Details, 'optionalAccess', _58 => _58.relationId])}-${fileItem.id}`),
+      ) }) }) }, `td-${_optionalChain([item, 'access', _166 => _166.Details, 'optionalAccess', _167 => _167.relationId])}-${fileItem.id}`),
       SubDataColumns.map((column) => {
         const columnKey = trimBeforePeriod2(column.key);
         const value = fileItem[columnKey];
         if (value !== void 0) {
-          return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, SubDataTableCell, { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { children: value }, `span-${_optionalChain([item, 'access', _59 => _59.Details, 'optionalAccess', _60 => _60.relationId])}-${fileItem.id}-${index}-${column.title}`) }, `fileitem-${item}-${_optionalChain([item, 'access', _61 => _61.Details, 'optionalAccess', _62 => _62.relationId])}-${fileItem.id}-${index}-${column.title}`);
+          return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, SubDataTableCell, { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { children: value }, `span-${_optionalChain([item, 'access', _168 => _168.Details, 'optionalAccess', _169 => _169.relationId])}-${fileItem.id}-${index}-${column.title}`) }, `fileitem-${item}-${_optionalChain([item, 'access', _170 => _170.Details, 'optionalAccess', _171 => _171.relationId])}-${fileItem.id}-${index}-${column.title}`);
         }
       })
-    ] }, `${item}-${_optionalChain([item, 'access', _63 => _63.Details, 'optionalAccess', _64 => _64.relationId])}-${fileItem.id}-${index}`))]) }, `SDR-${item.id}-${_optionalChain([item, 'access', _65 => _65.Details, 'optionalAccess', _66 => _66.relationId])}`));
+    ] }, `${item}-${_optionalChain([item, 'access', _172 => _172.Details, 'optionalAccess', _173 => _173.relationId])}-${fileItem.id}-${index}`))]) }, `SDR-${item.id}-${_optionalChain([item, 'access', _174 => _174.Details, 'optionalAccess', _175 => _175.relationId])}`));
   };
-  const dataRows = _optionalChain([processedRowData, 'optionalAccess', _67 => _67.map, 'call', _68 => _68((item, index) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, BodyRowContainer, { children: [
+  const dataRows = _optionalChain([processedRowData, 'optionalAccess', _176 => _176.map, 'call', _177 => _177((item, index) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, BodyRowContainer, { children: [
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, TableRow, { $amountofColumns: HeadColumns.length, children: HeadColumns.map((column) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, TableBodyCell, { $primaryBoldState: column.PrimaryBoldText, children: item[column.key] }, `TableBodycell-${item.id}-${column.key}`)) }),
     /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, ButtonStylingRow, { children: [
       /* @__PURE__ */ _jsxruntime.jsx.call(void 0, DownloadMissionButton, { onClick: downloadMissionOnClick, children: "Download Mission" }),
@@ -8268,6 +11608,7 @@ var ChildDataTable = ({ data, columns, downloadArrowOnClick, downloadMissionOnCl
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { title: "tablebodies", children: dataRows })
   ] });
 };
+ChildDataTable.displayName = "ChildDataTable";
 
 // src/components/DataTable/NestedDataTable/NestedDataTable.tsx
 
@@ -8364,9 +11705,9 @@ var NestedDataTable = ({ data, columns }) => {
   const SubDataHeaders = SubDataColumns.map((column, index) => {
     return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "th", { children: column.title }, `SubHeadCell-${index}`);
   });
-  const subDataRows = !_optionalChain([data, 'optionalAccess', _69 => _69.length]) ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "tr", { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "td", { title: "NoSubDataRows", colSpan: columns.length, children: "No data" }) }) : data.map((item, index) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, SubDataTr, { children: SubDataColumns.map((column, colIndex) => {
+  const subDataRows = !_optionalChain([data, 'optionalAccess', _178 => _178.length]) ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "tr", { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "td", { title: "NoSubDataRows", colSpan: columns.length, children: "No data" }) }) : data.map((item, index) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, SubDataTr, { children: SubDataColumns.map((column, colIndex) => {
     const columnKey = trimBeforePeriod(column.key);
-    const value = _optionalChain([item, 'access', _70 => _70.Details, 'optionalAccess', _71 => _71[columnKey]]);
+    const value = _optionalChain([item, 'access', _179 => _179.Details, 'optionalAccess', _180 => _180[columnKey]]);
     console.log("value: ", value);
     if (value !== void 0) {
       return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "td", { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { children: value }) }, `Span-${item.id}-${colIndex}`);
@@ -8376,7 +11717,7 @@ var NestedDataTable = ({ data, columns }) => {
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "thead", { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "tr", { children: SubDataHeaders }) }),
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "tbody", { children: subDataRows })
   ] });
-  const rows = !_optionalChain([data, 'optionalAccess', _72 => _72.length]) ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "tr", { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "td", { title: "NoDataRows", colSpan: columns.length, children: "No data" }) }) : _optionalChain([data, 'optionalAccess', _73 => _73.map, 'call', _74 => _74((item, index) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+  const rows = !_optionalChain([data, 'optionalAccess', _181 => _181.length]) ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "tr", { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "td", { title: "NoDataRows", colSpan: columns.length, children: "No data" }) }) : _optionalChain([data, 'optionalAccess', _182 => _182.map, 'call', _183 => _183((item, index) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
     /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, PrimaryTrRows, { $index: index, children: [
       /* @__PURE__ */ _jsxruntime.jsx.call(void 0, DropdownButton, { onClick: () => toggleDropdown(index), children: isAscending && isOpen && primaryRowIndex === index ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children: "\u2227" }) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children: "\u2228" }) }),
       HeadColumns.map((column, index2) => {
@@ -8393,6 +11734,7 @@ var NestedDataTable = ({ data, columns }) => {
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "tbody", { children: rows })
   ] }) });
 };
+NestedDataTable.displayName = "NestedDataTable";
 
 // src/components/AutoComplete/WlAutoComplete.tsx
 
@@ -8655,6 +11997,7 @@ var WLAutoComplete = ({
     ) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, NoHoverListItem, { "data-testid": "NoOptionsListitem", ref: noItemListRef, id: "No-Option-List-item", onMouseDown: (e) => e.preventDefault(), children: "No Options found" }) })
   ] }) });
 };
+WLAutoComplete.displayName = "WLAutoComplete";
 
 // src/components/inputs/WavelengthInputDatePicketer.tsx
 
@@ -8701,6 +12044,7 @@ var WLInputDatePicker2 = () => {
   }, []);
   return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "wavelength-input-date-picker", { ref });
 };
+WLInputDatePicker2.displayName = "WLInputDatePicker";
 
 // src/components/inputs/WLDatePicker.tsx
 
@@ -8847,6 +12191,7 @@ var WLDatePicker = ({
     }
   );
 };
+WLDatePicker.displayName = "WLDatePicker";
 
 // src/components/samples/SampleComponent.tsx
 
@@ -8867,6 +12212,8 @@ var SampleComponent2 = ({
   }, [testProp]);
   return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "sample-component", { ref, ...rest, children });
 };
+SampleComponent2.displayName = "SampleComponent";
+
 
 
 
@@ -8924,7 +12271,7 @@ var SampleComponent2 = ({
 
 
 
-exports.ButtonIcon = ButtonIcon; exports.ButtonMenu = ButtonMenu; exports.ChildDataTable = ChildDataTable; exports.DefaultCarousel = DefaultCarousel; exports.DefaultPagination = DefaultPagination; exports.NestedDataTable = NestedDataTable; exports.SampleComponent = SampleComponent2; exports.SliderCardCarousel = SliderCardCarousel; exports.WLAutoComplete = WLAutoComplete; exports.WLDatePicker = WLDatePicker; exports.WLInputDatePicker = WLInputDatePicker2; exports.WavelengthAccessAlert = WavelengthAccessAlert; exports.WavelengthAlert = WavelengthAlert; exports.WavelengthAppLogo = WavelengthAppLogo; exports.WavelengthAppTheme = WavelengthAppTheme; exports.WavelengthAutocomplete = WavelengthAutocomplete; exports.WavelengthBanner = WavelengthBanner2; exports.WavelengthBox = WavelengthBox; exports.WavelengthButton = WavelengthButton2; exports.WavelengthCommentDisplay = WavelengthCommentDisplay; exports.WavelengthConfirmationModal = WavelengthConfirmationModal; exports.WavelengthContentModal = WavelengthContentModal; exports.WavelengthContentPlaceholder = WavelengthContentPlaceholder; exports.WavelengthDataTable = WavelengthDataTable; exports.WavelengthDefaultIcon = WavelengthDefaultIcon; exports.WavelengthDragAndDrop = WavelengthDragAndDrop; exports.WavelengthDropdown = WavelengthDropdown; exports.WavelengthDropdownButton = WavelengthDropdownButton; exports.WavelengthExampleComponent = WavelengthExampleComponent; exports.WavelengthFileDownloader = WavelengthFileDownloader; exports.WavelengthFooter = WavelengthFooter; exports.WavelengthInput = WavelengthInput2; exports.WavelengthManyPlanes = WavelengthManyPlanes; exports.WavelengthNotAvailablePage = WavelengthNotAvailablePage; exports.WavelengthPermissionAlert = WavelengthPermissionAlert; exports.WavelengthPlaneTrail = WavelengthPlaneTrail; exports.WavelengthPopUpMenu = WavelengthPopUpMenu; exports.WavelengthProgressBar = WavelengthProgressBar2; exports.WavelengthSearch = WavelengthSearch; exports.WavelengthSearchTextField = WavelengthSearchTextField; exports.WavelengthSideBar = WavelengthSideBar; exports.WavelengthSlider = WavelengthSlider; exports.WavelengthSnackbar = WavelengthSnackbar; exports.WavelengthSpinningLogo = WavelengthSpinningLogo; exports.WavelengthSpinningOuterCircle = WavelengthSpinningOuterCircle; exports.WavelengthStandardSnackbar = WavelengthStandardSnackbar; exports.WavelengthStyledButton = WavelengthStyledButton; exports.WavelengthTestSnackbar = WavelengthTestSnackbar; exports.WavelengthTitleBar = WavelengthTitleBar2; exports.add = add; exports.ascendingRange = ascendingRange; exports.concat = concat; exports.findBestStringMatch = findBestStringMatch; exports.range = range; exports.useOutsideClick = useOutsideClick; exports.useThemeContext = useThemeContext;
+exports.ButtonIcon = ButtonIcon; exports.ButtonMenu = ButtonMenu; exports.ChildDataTable = ChildDataTable; exports.DefaultCarousel = DefaultCarousel; exports.DefaultPagination = DefaultPagination; exports.NestedDataTable = NestedDataTable; exports.SampleComponent = SampleComponent2; exports.SliderCardCarousel = SliderCardCarousel; exports.WLAutoComplete = WLAutoComplete; exports.WLDatePicker = WLDatePicker; exports.WLInputDatePicker = WLInputDatePicker2; exports.WavelengthAccessAlert = WavelengthAccessAlert; exports.WavelengthAlert = WavelengthAlert; exports.WavelengthAppLogo = WavelengthAppLogo; exports.WavelengthAppTheme = WavelengthAppTheme; exports.WavelengthAutocomplete = WavelengthAutocomplete; exports.WavelengthBanner = WavelengthBanner2; exports.WavelengthBox = WavelengthBox; exports.WavelengthButton = WavelengthButton2; exports.WavelengthCommentDisplay = WavelengthCommentDisplay; exports.WavelengthConfirmationModal = WavelengthConfirmationModal; exports.WavelengthContentModal = WavelengthContentModal; exports.WavelengthContentPlaceholder = WavelengthContentPlaceholder; exports.WavelengthDataTable = WavelengthDataTable; exports.WavelengthDefaultIcon = WavelengthDefaultIcon; exports.WavelengthDragAndDrop = WavelengthDragAndDrop; exports.WavelengthDropdown = WavelengthDropdown; exports.WavelengthDropdownButton = WavelengthDropdownButton; exports.WavelengthExampleComponent = WavelengthExampleComponent; exports.WavelengthFileDownloader = WavelengthFileDownloader; exports.WavelengthFooter = WavelengthFooter; exports.WavelengthForm = WavelengthForm2; exports.WavelengthInput = WavelengthInput2; exports.WavelengthManyPlanes = WavelengthManyPlanes; exports.WavelengthNotAvailablePage = WavelengthNotAvailablePage; exports.WavelengthPermissionAlert = WavelengthPermissionAlert; exports.WavelengthPlaneTrail = WavelengthPlaneTrail; exports.WavelengthPopUpMenu = WavelengthPopUpMenu; exports.WavelengthProgressBar = WavelengthProgressBar2; exports.WavelengthSearch = WavelengthSearch; exports.WavelengthSearchTextField = WavelengthSearchTextField; exports.WavelengthSideBar = WavelengthSideBar; exports.WavelengthSlider = WavelengthSlider; exports.WavelengthSnackbar = WavelengthSnackbar; exports.WavelengthSpinningLogo = WavelengthSpinningLogo; exports.WavelengthSpinningOuterCircle = WavelengthSpinningOuterCircle; exports.WavelengthStandardSnackbar = WavelengthStandardSnackbar; exports.WavelengthStyledButton = WavelengthStyledButton; exports.WavelengthTestSnackbar = WavelengthTestSnackbar; exports.WavelengthTitleBar = WavelengthTitleBar2; exports.add = add; exports.ascendingRange = ascendingRange; exports.concat = concat; exports.findBestStringMatch = findBestStringMatch; exports.range = range; exports.useOutsideClick = useOutsideClick; exports.useThemeContext = useThemeContext;
 /*! Bundled license information:
 
 react-is/cjs/react-is.production.min.js:
@@ -8978,7 +12325,7 @@ react-is/cjs/react-is.development.js:
 
 @mui/styled-engine/index.js:
   (**
-   * @mui/styled-engine v5.16.14
+   * @mui/styled-engine v5.18.0
    *
    * @license MIT
    * This source code is licensed under the MIT license found in the