mlform 0.1.0

package/dist/mlform.mjs

@@ -0,0 +1,709 @@
+import { $ as P, g as D, c as z, u as k, d as $, l as I, e as N, s as R, F as O, o as M } from "./FieldStrategy-pPekBtH-.js";
+import { F as U, M as L } from "./ModelTypes-B9_veCKB.js";
+class T {
+  constructor(e) {
+    this.counter = 0, this.metadataRegistry = e?.metadata ?? D, this.target = e?.target ?? "draft-2020-12", this.unrepresentable = e?.unrepresentable ?? "throw", this.override = e?.override ?? (() => {
+    }), this.io = e?.io ?? "output", this.seen = /* @__PURE__ */ new Map();
+  }
+  process(e, r = { path: [], schemaPath: [] }) {
+    var o;
+    const t = e._zod.def, u = {
+      guid: "uuid",
+      url: "uri",
+      datetime: "date-time",
+      json_string: "json-string",
+      regex: ""
+      // do not set
+    }, y = this.seen.get(e);
+    if (y)
+      return y.count++, r.schemaPath.includes(e) && (y.cycle = r.path), y.schema;
+    const p = { schema: {}, count: 1, cycle: void 0, path: r.path };
+    this.seen.set(e, p);
+    const S = e._zod.toJSONSchema?.();
+    if (S)
+      p.schema = S;
+    else {
+      const n = {
+        ...r,
+        schemaPath: [...r.schemaPath, e],
+        path: r.path
+      }, b = e._zod.parent;
+      if (b)
+        p.ref = b, this.process(b, n), this.seen.get(b).isParent = !0;
+      else {
+        const c = p.schema;
+        switch (t.type) {
+          case "string": {
+            const s = c;
+            s.type = "string";
+            const { minimum: i, maximum: a, format: h, patterns: f, contentEncoding: g } = e._zod.bag;
+            if (typeof i == "number" && (s.minLength = i), typeof a == "number" && (s.maxLength = a), h && (s.format = u[h] ?? h, s.format === "" && delete s.format), g && (s.contentEncoding = g), f && f.size > 0) {
+              const v = [...f];
+              v.length === 1 ? s.pattern = v[0].source : v.length > 1 && (p.schema.allOf = [
+                ...v.map((J) => ({
+                  ...this.target === "draft-7" ? { type: "string" } : {},
+                  pattern: J.source
+                }))
+              ]);
+            }
+            break;
+          }
+          case "number": {
+            const s = c, { minimum: i, maximum: a, format: h, multipleOf: f, exclusiveMaximum: g, exclusiveMinimum: v } = e._zod.bag;
+            typeof h == "string" && h.includes("int") ? s.type = "integer" : s.type = "number", typeof v == "number" && (s.exclusiveMinimum = v), typeof i == "number" && (s.minimum = i, typeof v == "number" && (v >= i ? delete s.minimum : delete s.exclusiveMinimum)), typeof g == "number" && (s.exclusiveMaximum = g), typeof a == "number" && (s.maximum = a, typeof g == "number" && (g <= a ? delete s.maximum : delete s.exclusiveMaximum)), typeof f == "number" && (s.multipleOf = f);
+            break;
+          }
+          case "boolean": {
+            const s = c;
+            s.type = "boolean";
+            break;
+          }
+          case "bigint": {
+            if (this.unrepresentable === "throw")
+              throw new Error("BigInt cannot be represented in JSON Schema");
+            break;
+          }
+          case "symbol": {
+            if (this.unrepresentable === "throw")
+              throw new Error("Symbols cannot be represented in JSON Schema");
+            break;
+          }
+          case "null": {
+            c.type = "null";
+            break;
+          }
+          case "any":
+            break;
+          case "unknown":
+            break;
+          case "undefined": {
+            if (this.unrepresentable === "throw")
+              throw new Error("Undefined cannot be represented in JSON Schema");
+            break;
+          }
+          case "void": {
+            if (this.unrepresentable === "throw")
+              throw new Error("Void cannot be represented in JSON Schema");
+            break;
+          }
+          case "never": {
+            c.not = {};
+            break;
+          }
+          case "date": {
+            if (this.unrepresentable === "throw")
+              throw new Error("Date cannot be represented in JSON Schema");
+            break;
+          }
+          case "array": {
+            const s = c, { minimum: i, maximum: a } = e._zod.bag;
+            typeof i == "number" && (s.minItems = i), typeof a == "number" && (s.maxItems = a), s.type = "array", s.items = this.process(t.element, { ...n, path: [...n.path, "items"] });
+            break;
+          }
+          case "object": {
+            const s = c;
+            s.type = "object", s.properties = {};
+            const i = t.shape;
+            for (const f in i)
+              s.properties[f] = this.process(i[f], {
+                ...n,
+                path: [...n.path, "properties", f]
+              });
+            const a = new Set(Object.keys(i)), h = new Set([...a].filter((f) => {
+              const g = t.shape[f]._zod;
+              return this.io === "input" ? g.optin === void 0 : g.optout === void 0;
+            }));
+            h.size > 0 && (s.required = Array.from(h)), t.catchall?._zod.def.type === "never" ? s.additionalProperties = !1 : t.catchall ? t.catchall && (s.additionalProperties = this.process(t.catchall, {
+              ...n,
+              path: [...n.path, "additionalProperties"]
+            })) : this.io === "output" && (s.additionalProperties = !1);
+            break;
+          }
+          case "union": {
+            const s = c;
+            s.anyOf = t.options.map((i, a) => this.process(i, {
+              ...n,
+              path: [...n.path, "anyOf", a]
+            }));
+            break;
+          }
+          case "intersection": {
+            const s = c, i = this.process(t.left, {
+              ...n,
+              path: [...n.path, "allOf", 0]
+            }), a = this.process(t.right, {
+              ...n,
+              path: [...n.path, "allOf", 1]
+            }), h = (g) => "allOf" in g && Object.keys(g).length === 1, f = [
+              ...h(i) ? i.allOf : [i],
+              ...h(a) ? a.allOf : [a]
+            ];
+            s.allOf = f;
+            break;
+          }
+          case "tuple": {
+            const s = c;
+            s.type = "array";
+            const i = t.items.map((f, g) => this.process(f, { ...n, path: [...n.path, "prefixItems", g] }));
+            if (this.target === "draft-2020-12" ? s.prefixItems = i : s.items = i, t.rest) {
+              const f = this.process(t.rest, {
+                ...n,
+                path: [...n.path, "items"]
+              });
+              this.target === "draft-2020-12" ? s.items = f : s.additionalItems = f;
+            }
+            t.rest && (s.items = this.process(t.rest, {
+              ...n,
+              path: [...n.path, "items"]
+            }));
+            const { minimum: a, maximum: h } = e._zod.bag;
+            typeof a == "number" && (s.minItems = a), typeof h == "number" && (s.maxItems = h);
+            break;
+          }
+          case "record": {
+            const s = c;
+            s.type = "object", s.propertyNames = this.process(t.keyType, { ...n, path: [...n.path, "propertyNames"] }), s.additionalProperties = this.process(t.valueType, {
+              ...n,
+              path: [...n.path, "additionalProperties"]
+            });
+            break;
+          }
+          case "map": {
+            if (this.unrepresentable === "throw")
+              throw new Error("Map cannot be represented in JSON Schema");
+            break;
+          }
+          case "set": {
+            if (this.unrepresentable === "throw")
+              throw new Error("Set cannot be represented in JSON Schema");
+            break;
+          }
+          case "enum": {
+            const s = c, i = z(t.entries);
+            i.every((a) => typeof a == "number") && (s.type = "number"), i.every((a) => typeof a == "string") && (s.type = "string"), s.enum = i;
+            break;
+          }
+          case "literal": {
+            const s = c, i = [];
+            for (const a of t.values)
+              if (a === void 0) {
+                if (this.unrepresentable === "throw")
+                  throw new Error("Literal `undefined` cannot be represented in JSON Schema");
+              } else if (typeof a == "bigint") {
+                if (this.unrepresentable === "throw")
+                  throw new Error("BigInt literals cannot be represented in JSON Schema");
+                i.push(Number(a));
+              } else
+                i.push(a);
+            if (i.length !== 0) if (i.length === 1) {
+              const a = i[0];
+              s.type = a === null ? "null" : typeof a, s.const = a;
+            } else
+              i.every((a) => typeof a == "number") && (s.type = "number"), i.every((a) => typeof a == "string") && (s.type = "string"), i.every((a) => typeof a == "boolean") && (s.type = "string"), i.every((a) => a === null) && (s.type = "null"), s.enum = i;
+            break;
+          }
+          case "file": {
+            const s = c, i = {
+              type: "string",
+              format: "binary",
+              contentEncoding: "binary"
+            }, { minimum: a, maximum: h, mime: f } = e._zod.bag;
+            a !== void 0 && (i.minLength = a), h !== void 0 && (i.maxLength = h), f ? f.length === 1 ? (i.contentMediaType = f[0], Object.assign(s, i)) : s.anyOf = f.map((g) => ({ ...i, contentMediaType: g })) : Object.assign(s, i);
+            break;
+          }
+          case "transform": {
+            if (this.unrepresentable === "throw")
+              throw new Error("Transforms cannot be represented in JSON Schema");
+            break;
+          }
+          case "nullable": {
+            const s = this.process(t.innerType, n);
+            c.anyOf = [s, { type: "null" }];
+            break;
+          }
+          case "nonoptional": {
+            this.process(t.innerType, n), p.ref = t.innerType;
+            break;
+          }
+          case "success": {
+            const s = c;
+            s.type = "boolean";
+            break;
+          }
+          case "default": {
+            this.process(t.innerType, n), p.ref = t.innerType, c.default = JSON.parse(JSON.stringify(t.defaultValue));
+            break;
+          }
+          case "prefault": {
+            this.process(t.innerType, n), p.ref = t.innerType, this.io === "input" && (c._prefault = JSON.parse(JSON.stringify(t.defaultValue)));
+            break;
+          }
+          case "catch": {
+            this.process(t.innerType, n), p.ref = t.innerType;
+            let s;
+            try {
+              s = t.catchValue(void 0);
+            } catch {
+              throw new Error("Dynamic catch values are not supported in JSON Schema");
+            }
+            c.default = s;
+            break;
+          }
+          case "nan": {
+            if (this.unrepresentable === "throw")
+              throw new Error("NaN cannot be represented in JSON Schema");
+            break;
+          }
+          case "template_literal": {
+            const s = c, i = e._zod.pattern;
+            if (!i)
+              throw new Error("Pattern not found in template literal");
+            s.type = "string", s.pattern = i.source;
+            break;
+          }
+          case "pipe": {
+            const s = this.io === "input" ? t.in._zod.def.type === "transform" ? t.out : t.in : t.out;
+            this.process(s, n), p.ref = s;
+            break;
+          }
+          case "readonly": {
+            this.process(t.innerType, n), p.ref = t.innerType, c.readOnly = !0;
+            break;
+          }
+          // passthrough types
+          case "promise": {
+            this.process(t.innerType, n), p.ref = t.innerType;
+            break;
+          }
+          case "optional": {
+            this.process(t.innerType, n), p.ref = t.innerType;
+            break;
+          }
+          case "lazy": {
+            const s = e._zod.innerType;
+            this.process(s, n), p.ref = s;
+            break;
+          }
+          case "custom": {
+            if (this.unrepresentable === "throw")
+              throw new Error("Custom types cannot be represented in JSON Schema");
+            break;
+          }
+        }
+      }
+    }
+    const w = this.metadataRegistry.get(e);
+    return w && Object.assign(p.schema, w), this.io === "input" && d(e) && (delete p.schema.examples, delete p.schema.default), this.io === "input" && p.schema._prefault && ((o = p.schema).default ?? (o.default = p.schema._prefault)), delete p.schema._prefault, this.seen.get(e).schema;
+  }
+  emit(e, r) {
+    const o = {
+      cycles: r?.cycles ?? "ref",
+      reused: r?.reused ?? "inline",
+      // unrepresentable: _params?.unrepresentable ?? "throw",
+      // uri: _params?.uri ?? ((id) => `${id}`),
+      external: r?.external ?? void 0
+    }, t = this.seen.get(e);
+    if (!t)
+      throw new Error("Unprocessed schema. This is a bug in Zod.");
+    const u = (l) => {
+      const n = this.target === "draft-2020-12" ? "$defs" : "definitions";
+      if (o.external) {
+        const i = o.external.registry.get(l[0])?.id, a = o.external.uri ?? ((f) => f);
+        if (i)
+          return { ref: a(i) };
+        const h = l[1].defId ?? l[1].schema.id ?? `schema${this.counter++}`;
+        return l[1].defId = h, { defId: h, ref: `${a("__shared")}#/${n}/${h}` };
+      }
+      if (l[1] === t)
+        return { ref: "#" };
+      const c = `#/${n}/`, s = l[1].schema.id ?? `__schema${this.counter++}`;
+      return { defId: s, ref: c + s };
+    }, y = (l) => {
+      if (l[1].schema.$ref)
+        return;
+      const n = l[1], { ref: b, defId: c } = u(l);
+      n.def = { ...n.schema }, c && (n.defId = c);
+      const s = n.schema;
+      for (const i in s)
+        delete s[i];
+      s.$ref = b;
+    };
+    if (o.cycles === "throw")
+      for (const l of this.seen.entries()) {
+        const n = l[1];
+        if (n.cycle)
+          throw new Error(`Cycle detected: #/${n.cycle?.join("/")}/<root>
+
+Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
+      }
+    for (const l of this.seen.entries()) {
+      const n = l[1];
+      if (e === l[0]) {
+        y(l);
+        continue;
+      }
+      if (o.external) {
+        const c = o.external.registry.get(l[0])?.id;
+        if (e !== l[0] && c) {
+          y(l);
+          continue;
+        }
+      }
+      if (this.metadataRegistry.get(l[0])?.id) {
+        y(l);
+        continue;
+      }
+      if (n.cycle) {
+        y(l);
+        continue;
+      }
+      if (n.count > 1 && o.reused === "ref") {
+        y(l);
+        continue;
+      }
+    }
+    const p = (l, n) => {
+      const b = this.seen.get(l), c = b.def ?? b.schema, s = { ...c };
+      if (b.ref === null)
+        return;
+      const i = b.ref;
+      if (b.ref = null, i) {
+        p(i, n);
+        const a = this.seen.get(i).schema;
+        a.$ref && n.target === "draft-7" ? (c.allOf = c.allOf ?? [], c.allOf.push(a)) : (Object.assign(c, a), Object.assign(c, s));
+      }
+      b.isParent || this.override({
+        zodSchema: l,
+        jsonSchema: c,
+        path: b.path ?? []
+      });
+    };
+    for (const l of [...this.seen.entries()].reverse())
+      p(l[0], { target: this.target });
+    const S = {};
+    if (this.target === "draft-2020-12" ? S.$schema = "https://json-schema.org/draft/2020-12/schema" : this.target === "draft-7" ? S.$schema = "http://json-schema.org/draft-07/schema#" : console.warn(`Invalid target: ${this.target}`), o.external?.uri) {
+      const l = o.external.registry.get(e)?.id;
+      if (!l)
+        throw new Error("Schema is missing an `id` property");
+      S.$id = o.external.uri(l);
+    }
+    Object.assign(S, t.def);
+    const w = o.external?.defs ?? {};
+    for (const l of this.seen.entries()) {
+      const n = l[1];
+      n.def && n.defId && (w[n.defId] = n.def);
+    }
+    o.external || Object.keys(w).length > 0 && (this.target === "draft-2020-12" ? S.$defs = w : S.definitions = w);
+    try {
+      return JSON.parse(JSON.stringify(S));
+    } catch {
+      throw new Error("Error converting schema to JSON.");
+    }
+  }
+}
+function H(m, e) {
+  if (m instanceof P) {
+    const o = new T(e), t = {};
+    for (const p of m._idmap.entries()) {
+      const [S, w] = p;
+      o.process(w);
+    }
+    const u = {}, y = {
+      registry: m,
+      uri: e?.uri,
+      defs: t
+    };
+    for (const p of m._idmap.entries()) {
+      const [S, w] = p;
+      u[S] = o.emit(w, {
+        ...e,
+        external: y
+      });
+    }
+    if (Object.keys(t).length > 0) {
+      const p = o.target === "draft-2020-12" ? "$defs" : "definitions";
+      u.__shared = {
+        [p]: t
+      };
+    }
+    return { schemas: u };
+  }
+  const r = new T(e);
+  return r.process(m), r.emit(m, e);
+}
+function d(m, e) {
+  const r = e ?? { seen: /* @__PURE__ */ new Set() };
+  if (r.seen.has(m))
+    return !1;
+  r.seen.add(m);
+  const t = m._zod.def;
+  switch (t.type) {
+    case "string":
+    case "number":
+    case "bigint":
+    case "boolean":
+    case "date":
+    case "symbol":
+    case "undefined":
+    case "null":
+    case "any":
+    case "unknown":
+    case "never":
+    case "void":
+    case "literal":
+    case "enum":
+    case "nan":
+    case "file":
+    case "template_literal":
+      return !1;
+    case "array":
+      return d(t.element, r);
+    case "object": {
+      for (const u in t.shape)
+        if (d(t.shape[u], r))
+          return !0;
+      return !1;
+    }
+    case "union": {
+      for (const u of t.options)
+        if (d(u, r))
+          return !0;
+      return !1;
+    }
+    case "intersection":
+      return d(t.left, r) || d(t.right, r);
+    case "tuple": {
+      for (const u of t.items)
+        if (d(u, r))
+          return !0;
+      return !!(t.rest && d(t.rest, r));
+    }
+    case "record":
+      return d(t.keyType, r) || d(t.valueType, r);
+    case "map":
+      return d(t.keyType, r) || d(t.valueType, r);
+    case "set":
+      return d(t.valueType, r);
+    // inner types
+    case "promise":
+    case "optional":
+    case "nonoptional":
+    case "nullable":
+    case "readonly":
+      return d(t.innerType, r);
+    case "lazy":
+      return d(t.getter(), r);
+    case "default":
+      return d(t.innerType, r);
+    case "prefault":
+      return d(t.innerType, r);
+    case "custom":
+      return !1;
+    case "transform":
+      return !0;
+    case "pipe":
+      return d(t.in, r) || d(t.out, r);
+    case "success":
+      return !1;
+    case "catch":
+      return !1;
+  }
+  throw new Error(`Unknown schema type: ${t.type}`);
+}
+const C = $, x = k, _ = $(
+  I({
+    type: k(Object.values(U).map((m) => N(m)))
+  })
+);
+I({
+  type: k(Object.values(L).map((m) => N(m)))
+});
+R({
+  inputs: _,
+  outputs: _
+});
+const A = "[Registry] The type «{type}» already exists.", E = "[Registry] The type «{type}» does not exist.";
+class F {
+  catalog = /* @__PURE__ */ new Map();
+  combinedSchema = x([]);
+  get schema() {
+    return C(this.combinedSchema);
+  }
+  get(e) {
+    return this.catalog.get(e);
+  }
+  values() {
+    return this.catalog.values();
+  }
+  register(e) {
+    if (this.catalog.has(e.type))
+      throw new Error(A.replace("{type}", e.type));
+    this.catalog.set(e.type, e), this.rebuildSchema();
+  }
+  unregister(e) {
+    if (!this.catalog.delete(e))
+      throw new Error(E.replace("{type}", e));
+    this.rebuildSchema();
+  }
+  update(e) {
+    if (!this.catalog.has(e.type))
+      throw new Error(E.replace("{type}", e.type));
+    this.catalog.set(e.type, e), this.rebuildSchema();
+  }
+  rebuildSchema() {
+    const e = Array.from(this.catalog.values()).map((r) => r.schema);
+    this.combinedSchema = x(e);
+  }
+}
+const V = "[DescriptorService] Unsupported <<type>>";
+class j {
+  registry = new F();
+  loadedTypes = /* @__PURE__ */ new Set();
+  temporalOutputs = null;
+  constructor(e = "") {
+    this.backendUrl = e;
+  }
+  get reg() {
+    return this.registry;
+  }
+  set tmpOutputs(e) {
+    this.temporalOutputs = e;
+  }
+  async mount(e, r) {
+    await this.ensureComponents(e);
+    const o = this.renderDescriptors(e);
+    r.innerHTML = this.descriptorsToInnerHtml(o);
+  }
+  async ensureComponents(e) {
+    const r = [
+      import("./error-card-BwjPChwf.js"),
+      import("./ml-layout-Dx63KKf7.js"),
+      import("./field-wrapper-DqIQl76d.js")
+    ];
+    for (const o of e) {
+      const t = o.type, u = this.reg.get(t);
+      if (!u)
+        throw new Error(V.replace("type", t));
+      this.loadedTypes.has(t) || (this.loadedTypes.add(t), r.push(u.loader()));
+    }
+    await Promise.all(r);
+  }
+  renderDescriptors(e) {
+    this.reg.schema.parse(e);
+    const r = [];
+    for (const o of e) {
+      const t = o.type, u = this.reg.get(t), y = u.parse(o);
+      r.push(
+        u.buildDescriptor(y)
+      );
+    }
+    return r;
+  }
+  descriptorsToInnerHtml(e) {
+    return `<ml-layout>
+  <div slot="inputs">${e.filter((o) => o.slot === "inputs").map((o) => this.renderDescriptor(o)).join("")}</div>
+  <div slot="report"></div>
+  <div slot="error"></div>
+</ml-layout>`;
+  }
+  reportDescriptorsToInnerHtml(e) {
+    return e.filter((r) => r.slot === "report").map((r) => this.renderDescriptor(r)).join("");
+  }
+  async render(e) {
+    const r = this.reg.schema.parse(e);
+    await this.ensureComponents(r);
+    const o = this.renderDescriptors(r), t = document.querySelector('div[slot="report"]');
+    t && (t.innerHTML = this.reportDescriptorsToInnerHtml(o));
+  }
+  async submit(e) {
+    let r;
+    try {
+      const o = await fetch(this.backendUrl, {
+        method: "POST",
+        credentials: "include",
+        body: JSON.stringify(e),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      if (!o.ok) throw new Error(await o.text());
+      r = await o.json();
+      const t = this.reg.schema.parse(this.temporalOutputs);
+      t[0].execution_time = r.outputs[0].execution_time, t[0].type === "regressor" ? t[0].values = r.outputs[0].values : t[0].type === "classifier" && (t[0].probabilities = r.outputs[0].probabilities);
+      const u = this.reg.schema.parse(t);
+      this.render(u), r = u;
+    } catch (o) {
+      throw new Error(
+        `Error al enviar los datos al backend: ${o instanceof Error ? o.message : String(o)}`
+      );
+    }
+    return { outputs: r };
+  }
+  renderDescriptor(e) {
+    const r = this.propsToAttrs(e.props);
+    return e.child ? `<${e.tag} ${r}>${this.renderDescriptor(e.child)}</${e.tag}>` : `<${e.tag} ${r}></${e.tag}>`;
+  }
+  /** Serializa el objeto `props` a atributos HTML. */
+  propsToAttrs(e) {
+    return Object.entries(e).filter(([, r]) => r != null).map(
+      ([r, o]) => typeof o == "boolean" && o ? `${r}=""` : `${r}="${String(o)}"`
+    ).join(" ");
+  }
+}
+class B {
+  backendUrl;
+  fieldService;
+  modelService;
+  _lastInputs = null;
+  _lastResponse = null;
+  _listeners = /* @__PURE__ */ new Set();
+  constructor(e) {
+    this.backendUrl = e, this.fieldService = new j(), this.modelService = new j(this.backendUrl);
+  }
+  register(e) {
+    e instanceof O ? this.fieldService.reg.register(e) : this.modelService.reg.register(e);
+  }
+  update(e) {
+    e instanceof O ? this.fieldService.reg.update(e) : this.modelService.reg.update(e);
+  }
+  unregister(e) {
+    e instanceof O ? this.fieldService.reg.unregister(e.type) : this.modelService.reg.unregister(e.type);
+  }
+  /** Lectura sincrónica del último envío */
+  get lastInputs() {
+    return this._lastInputs;
+  }
+  get lastResponse() {
+    return this._lastResponse;
+  }
+  /** Suscripción reactiva; devuelve la función para des‑suscribirse */
+  onSubmit(e) {
+    return this._listeners.add(e), () => this._listeners.delete(e);
+  }
+  async toHTMLElement(e, r) {
+    const o = this.fieldService.reg.schema.parse(e.inputs);
+    this.modelService.tmpOutputs = e.outputs, await this.fieldService.mount(o, r);
+    const t = r.firstChild;
+    return t.modelService = this.modelService, t.__mlSubmitHandler && t.removeEventListener("ml-submit", t.__mlSubmitHandler), t.__mlSubmitHandler = (u) => {
+      const { inputs: y, response: p } = u.detail;
+      this._lastInputs = y, this._lastResponse = p, this._listeners.forEach((S) => S(y, p));
+    }, t.addEventListener("ml-submit", t.__mlSubmitHandler, {
+      passive: !0
+    }), r;
+  }
+  async validateSchema(e) {
+    return this.fieldService.reg.schema.safeParseAsync(e.inputs);
+  }
+  schema() {
+    return H(
+      R({
+        inputs: this.fieldService.reg.schema,
+        outputs: M(this.modelService.reg.schema)
+      }),
+      { target: "draft-2020-12" }
+    );
+  }
+}
+export {
+  B as MLForm
+};