@dynamicforms/vue-forms 0.13.0 → 0.16.1

package/dist/dynamicforms-vue-forms.js

@@ -1,28 +1,42 @@
-import { isEqual as Q, isEmpty as R, isBoolean as Lt, isString as C, truncate as Mt, isArray as vt, isObject as bt } from "lodash-es";
-import { unref as h, computed as X, isRef as wt, reactive as Ut, watch as $t, ref as Wt, defineComponent as qt, resolveComponent as at, openBlock as zt, createBlock as Ht, h as F } from "vue";
-var T = /* @__PURE__ */ ((n) => (n[n.SUPPRESS = 1] = "SUPPRESS", n[n.HIDDEN = 5] = "HIDDEN", n[n.INVISIBLE = 8] = "INVISIBLE", n[n.FULL = 10] = "FULL", n))(T || {});
-const ot = 10, lt = new Set(
-  Object.values(T).filter((n) => typeof n == "number")
+import { computed as K, unref as h, isRef as Vt, reactive as Ut, watch as $t, ref as Wt, defineComponent as qt, resolveComponent as lt, openBlock as zt, createBlock as Ht, h as k } from "vue";
+import { isEqual as R, isEmpty as F, isBoolean as Qt, isString as C, truncate as Xt, isArray as yt, isObject as Et } from "lodash-es";
+var x = /* @__PURE__ */ ((n) => (n[n.SUPPRESS = 1] = "SUPPRESS", n[n.HIDDEN = 5] = "HIDDEN", n[n.INVISIBLE = 8] = "INVISIBLE", n[n.FULL = 10] = "FULL", n))(x || {});
+const Kt = 10, ut = new Set(
+  Object.values(x).filter((n) => typeof n == "number")
+), Yt = new Set(
+  Object.values(x).filter((n) => typeof n == "string")
 );
+function z(n) {
+  const t = typeof n == "string" ? `'${n}'` : String(n);
+  return new Error(`${t} is not a DisplayMode constant`);
+}
 ((n) => {
   function t(i) {
-    return i.toUpperCase() === "SUPPRESS" ? 1 : i.toUpperCase() === "HIDDEN" ? 5 : i.toUpperCase() === "INVISIBLE" ? 8 : ot;
+    const r = typeof i == "string" ? i.toUpperCase() : "";
+    if (r === "SUPPRESS") return 1;
+    if (r === "HIDDEN") return 5;
+    if (r === "INVISIBLE") return 8;
+    if (r === "FULL") return 10;
+    throw z(i);
   }
   n.fromString = t;
   function e(i) {
-    const a = typeof i == "number" ? i : n.fromString(i);
-    return lt.has(a) ? a : ot;
+    if (typeof i == "number") {
+      if (ut.has(i)) return i;
+      throw z(i);
+    }
+    if (typeof i != "string") throw z(i);
+    return n.fromString(i);
   }
   n.fromAny = e;
   function s(i) {
-    const a = typeof i == "number" ? i : n.fromString(i);
-    return lt.has(a);
+    return typeof i == "number" ? ut.has(i) : typeof i == "string" ? Yt.has(i.toUpperCase()) : !1;
   }
   n.isDefined = s;
-})(T || (T = {}));
-Object.freeze(T);
-const _ = T;
-class p {
+})(x || (x = {}));
+Object.freeze(x);
+const I = x;
+class m {
   static get classIdentifier() {
     throw new Error("classIdentifier must be declared");
   }
@@ -72,28 +86,28 @@ class p {
   unregisterFrom(t) {
   }
 }
-class Vt extends Error {
+class P extends Error {
 }
-const yt = /* @__PURE__ */ Symbol("ValueChangedAction");
-class S extends p {
+const Ct = /* @__PURE__ */ Symbol("ValueChangedAction");
+class T extends m {
   constructor(t) {
     super(t);
   }
   static get classIdentifier() {
-    return yt;
+    return Ct;
   }
   execute(t, e, s, i) {
     return super.execute(t, e, s, i);
   }
 }
-const O = /* @__PURE__ */ Symbol("Transaction.capture"), Ct = /* @__PURE__ */ Symbol("Transaction.restore"), Et = /* @__PURE__ */ Symbol("Transaction.announceValue"), xt = /* @__PURE__ */ Symbol("Transaction.settleValidity");
-function ut(n) {
+const O = /* @__PURE__ */ Symbol("Transaction.capture"), St = /* @__PURE__ */ Symbol("Transaction.restore"), xt = /* @__PURE__ */ Symbol("Transaction.announceValue"), At = /* @__PURE__ */ Symbol("Transaction.settleValidity");
+function ct(n) {
   let t = 0, e = n.parent;
   for (; e; )
     t++, e = e.parent;
   return t;
 }
-class Qt {
+class Jt {
   participants = /* @__PURE__ */ new Map();
   /** what a rollback has to put back beyond the state slots, newest last */
   undo = [];
@@ -167,7 +181,7 @@ class Qt {
    * there is nothing the answer would change.
    */
   noteDepth(t) {
-    this.passDepth < 0 || ut(t) >= this.passDepth && (this.restartPass = !0);
+    this.passDepth < 0 || ct(t) >= this.passDepth && (this.restartPass = !0);
   }
   /**
    * Puts every element the transaction modified back as it found it. Nothing is announced: from an observer's
@@ -176,7 +190,7 @@ class Qt {
    */
   rollback() {
     this.unwound = !0, [...this.participants.values()].reverse().forEach((e) => {
-      e.snapshot && e.element[Ct](e.snapshot);
+      e.snapshot && e.element[St](e.snapshot);
     }), this.participants.clear();
     for (let e = this.undo.length - 1; e >= 0; e--) this.undo[e]();
     this.undo.length = 0, this.settled.length = 0;
@@ -205,7 +219,7 @@ class Qt {
     const e = [];
     return this.participants.forEach((s) => {
       if (!t(s)) return;
-      const i = ut(s.element);
+      const i = ct(s.element);
       (e[i] ??= []).push(s);
     }), e;
   }
@@ -219,13 +233,13 @@ class Qt {
     const s = this.buckets(t);
     if (!s.length) return !1;
     for (let i = s.length - 1; i >= 0; i--) {
-      const a = s[i];
-      if (a) {
+      const r = s[i];
+      if (r) {
         this.passDepth = i, this.restartPass = !1;
         try {
-          for (let r = 0; r < a.length; r++) {
+          for (let a = 0; a < r.length; a++) {
             if (this.restartPass) return !0;
-            const o = a[r];
+            const o = r[a];
             t(o) && e(o);
           }
         } finally {
@@ -241,7 +255,7 @@ class Qt {
       (t) => t.valueDirty || t.structural !== void 0,
       (t) => {
         const { structural: e } = t, s = t.valueDirty, i = t.forceValue;
-        t.structural = void 0, t.valueDirty = !1, t.forceValue = !1, t.element[Et](this, s, i, e);
+        t.structural = void 0, t.valueDirty = !1, t.forceValue = !1, t.element[xt](this, s, i, e);
       }
     );
   }
@@ -249,21 +263,21 @@ class Qt {
     return this.pass(
       (t) => t.validityDirty,
       (t) => {
-        t.validityDirty = !1, t.element[xt](this);
+        t.validityDirty = !1, t.element[At](this);
       }
     );
   }
 }
-let E, q;
-function St() {
-  return E;
+let S, H;
+function It() {
+  return S;
 }
-class It {
+class Tt {
 }
-class Xt {
+class Zt {
   open = !0;
   rollback() {
-    throw this.open ? new It() : new TypeError(
+    throw this.open ? new Tt() : new TypeError(
       "this transaction handle is spent: the transaction that handed it out has closed. A handle is only usable inside the call that received it."
     );
   }
@@ -271,59 +285,59 @@ class Xt {
     this.open = !1;
   }
 }
-function ct(n) {
+function ht(n) {
   if (n != null && typeof n.then == "function")
     throw new TypeError(
       "a transaction may not be asynchronous: the callback returned a thenable. Do the awaiting outside and open a transaction for each synchronous part."
     );
 }
-function Y(n) {
-  if (E) {
-    const s = n(q);
-    return ct(s), s;
+function J(n) {
+  if (S) {
+    const s = n(H);
+    return ht(s), s;
   }
-  const t = new Qt(), e = new Xt();
-  E = t, q = e;
+  const t = new Jt(), e = new Zt();
+  S = t, H = e;
   try {
     const s = n(e);
-    return ct(s), t.commit(), s;
+    return ht(s), t.commit(), s;
   } catch (s) {
-    if (t.rollback(), s instanceof It) return;
+    if (t.rollback(), s instanceof Tt) return;
     throw s;
   } finally {
-    E = void 0, q = void 0, e.close();
+    S = void 0, H = void 0, e.close();
   }
 }
 function u(n) {
-  return E ? n(E) : Y(() => n(E));
+  return S ? n(S) : J(() => n(S));
 }
-const At = { useMarkdownInValidators: !0 };
-function Kt() {
-  return At;
+const Ot = { useMarkdownInValidators: !0 };
+function Gt() {
+  return Ot;
 }
-function Yt(n) {
-  Object.assign(At, n);
+function te(n) {
+  Object.assign(Ot, n);
 }
-const De = {
+const Ue = {
   install(n, t) {
-    t && Yt(t);
+    t && te(t);
   }
 };
-class P extends String {
+class j extends String {
   plugins;
   options;
   constructor(t, e, s) {
     super(t), this.plugins = s, this.options = e;
   }
 }
-function J(n) {
+function Z(n) {
   const t = h(n);
-  return typeof t == "object" && "componentName" in t;
+  return typeof t == "object" && t !== null && "componentName" in t;
 }
-function B(n) {
+function L(n) {
   return typeof h(n) == "function";
 }
-class Z {
+class G {
   /**
    * Machine-readable identifier of what failed, in kebab-case. Every validator this library ships states one, so
    * code that reacts to a particular failure does not have to match the message text, which is translated and
@@ -333,6 +347,19 @@ class Z {
     this.code = t;
   }
   code;
+  /**
+   * True where `other` is an error of this class that renders exactly as this one does and reports the same code.
+   * Two runs of one validator over an unchanged value produce two instances of one message, and this is what lets
+   * the validator hand the field back the instance it already holds rather than a fresh one: an equal error is not
+   * a new error, and nothing re-renders over a verdict that did not move.
+   *
+   * The comparison is over what renders - the component, its bindings, its body and the classes - because that is
+   * what a reader of `field.errors` sees. A structural comparison of the errors themselves answers nothing useful:
+   * `ValidationErrorRenderContent` holds a Vue `computed`, and two of those are never structurally equal.
+   */
+  sameAs(t) {
+    return Object.getPrototypeOf(this) === Object.getPrototypeOf(t) && this.code === t.code && this.componentName === t.componentName && R(this.componentBody, t.componentBody) && R(this.componentBindings, t.componentBindings) && R(this.extraClasses, t.extraClasses);
+  }
   get componentName() {
     return "Comment";
   }
@@ -346,7 +373,7 @@ class Z {
     return "";
   }
 }
-class Jt extends Z {
+class ee extends G {
   constructor(t, e = "", s) {
     super(s), this.text = t, this.classes = e;
   }
@@ -362,20 +389,20 @@ class Jt extends Z {
     return this.classes;
   }
 }
-class f extends Z {
+class g extends G {
   constructor(t, e = "", s) {
-    super(s), this.classes = e, this.text = t, this.textType = X(() => this.getTextType);
+    super(s), this.classes = e, this.text = t, this.textType = K(() => this.getTextType);
   }
   classes;
   text;
   textType;
   get resolvedText() {
     const t = h(this.text);
-    return B(t) ? t() : t;
+    return L(t) ? t() : t;
   }
   get getTextType() {
     const t = this.resolvedText;
-    return t ? t instanceof P ? "md" : J(t) ? "component" : "string" : "string";
+    return t ? t instanceof j ? "md" : Z(t) ? "component" : "string" : "string";
   }
   get componentName() {
     switch (h(this.textType)) {
@@ -417,48 +444,48 @@ class f extends Z {
     return this.classes;
   }
 }
-class Zt extends f {
+class se extends g {
 }
-function m(n) {
-  return Kt().useMarkdownInValidators ? new P(n) : n.replace(/[*_~`]/g, "").replace(/!\[(.*?)\]\(.*?\)/g, "$1").replace(/\[(.*?)\]\((.*?)\)/g, "$1").replace(/#+\s?/g, "").replace(/>\s?/g, "").replace(/(\*|-|\d+\.)\s+/g, "").replace(/`{3}[\s\S]*?`{3}/g, "").replace(/`([^`]+)`/g, "$1").replace(/\n{2,}/g, `
+function b(n) {
+  return Gt().useMarkdownInValidators ? new j(n) : n.replace(/[*_~`]/g, "").replace(/!\[(.*?)\]\(.*?\)/g, "$1").replace(/\[(.*?)\]\((.*?)\)/g, "$1").replace(/#+\s?/g, "").replace(/>\s?/g, "").replace(/(\*|-|\d+\.)\s+/g, "").replace(/`{3}[\s\S]*?`{3}/g, "").replace(/`([^`]+)`/g, "$1").replace(/\n{2,}/g, `
 `);
 }
-const Gt = /* @__PURE__ */ Symbol("Validator"), te = () => m("Validation could not be completed");
-class g extends S {
+const ie = /* @__PURE__ */ Symbol("Validator"), ne = () => b("Validation could not be completed");
+class f extends T {
   source;
   /**
    * Creates a new validator
    * @param validationFn Function that validates the field value and returns errors or null
    */
   constructor(t) {
-    const e = (s, i, a, r) => {
-      const o = this.bindingState(s), l = o.abandon, w = ++o.run, b = s.validationEpoch, et = St();
-      let st = !1;
-      const U = () => !st && o.run === w && s.validationEpoch === b && !et?.rolledBack, it = new AbortController(), N = () => {
-        U() || (st = !0, o.abandon === N && (o.abandon = void 0), it.abort());
+    const e = (s, i, r, a) => {
+      const o = this.bindingState(s), l = o.abandon, v = ++o.run, p = s.validationEpoch, it = It();
+      let nt = !1;
+      const $ = () => !nt && o.run === v && s.validationEpoch === p && !it?.rolledBack, rt = new AbortController(), B = () => {
+        $() || (nt = !0, o.abandon === B && (o.abandon = void 0), rt.abort());
       };
       l?.();
-      const $ = t(a, r, s, it.signal) || [], W = (y) => Y(() => {
-        const k = y?.map((I) => this.claim(I)) ?? [];
-        for (let I = s.errors.length - 1; I >= 0; I--) {
-          const nt = s.errors[I];
-          if (nt.source === this.source) {
-            const rt = k.findIndex((Dt) => Q(Dt, nt));
-            rt >= 0 ? k.splice(rt, 1) : s.errors.splice(I, 1);
+      const W = t(r, a, s, rt.signal) || [], q = (E) => J(() => {
+        const D = E?.map((A) => this.claim(A)) ?? [];
+        for (let A = s.errors.length - 1; A >= 0; A--) {
+          const at = s.errors[A];
+          if (at.source === this.source) {
+            const ot = D.findIndex((Mt) => Mt.sameAs(at));
+            ot >= 0 ? D.splice(ot, 1) : s.errors.splice(A, 1);
           }
         }
-        k.length > 0 && s.errors.push(...k), s.validate();
+        D.length > 0 && s.errors.push(...D), s.validate();
       });
-      return $ instanceof Promise ? (o.abandon = N, et?.whenRolledBack(N), s.beginValidating(), $.then(
-        (y) => {
-          U() && W(y);
+      return W instanceof Promise ? (o.abandon = B, it?.whenRolledBack(B), s.beginValidating(), W.then(
+        (E) => {
+          $() && q(E);
         },
-        (y) => {
-          U() && (W([new f(te(), "", "validation-failed")]), console.error("Validation failed", y));
+        (E) => {
+          $() && (q([new g(ne(), "", "validation-failed")]), console.error("Validation failed", E));
         }
       ).finally(() => {
-        o.abandon === N && (o.abandon = void 0), s.endValidating();
-      }).catch((y) => console.error("Validation failed", y))) : W($), i(s, a, r);
+        o.abandon === B && (o.abandon = void 0), s.endValidating();
+      }).catch((E) => console.error("Validation failed", E))) : q(W), i(s, r, a);
     };
     super(e), this.source = Symbol(this.constructor.name);
   }
@@ -479,7 +506,7 @@ class g extends S {
     return Object.create(Object.getPrototypeOf(t), { ...i, source: s });
   }
   static get classIdentifier() {
-    return Gt;
+    return ie;
   }
   get eager() {
     return !0;
@@ -529,29 +556,29 @@ class g extends S {
   replacePlaceholdersFunction(t, e) {
     return () => {
       let s = h(t);
-      for (; B(s); )
+      for (; L(s); )
         s = h(this.replacePlaceholders(s(), e));
       return s;
     };
   }
   replacePlaceholders(t, e) {
-    if (B(t)) return this.replacePlaceholdersFunction(t, e);
-    if (J(t)) return t;
-    if (wt(t))
+    if (L(t)) return this.replacePlaceholdersFunction(t, e);
+    if (Z(t)) return t;
+    if (Vt(t))
       return this.replacePlaceholdersFunction(() => h(t), e);
     let s = h(t);
     return Object.keys(e).forEach((i) => {
       s = s.replaceAll(`{${i}}`, e[i]);
-    }), t instanceof P ? new P(s.toString(), t.options, t.plugins) : s;
+    }), t instanceof j ? new j(s.toString(), t.options, t.plugins) : s;
   }
 }
-class D {
-  /** every action registered here, in registration order across all identifiers */
-  registeredActions = [];
-  /** the actions of one identifier, in registration order */
-  chains = /* @__PURE__ */ new Map();
-  /** the eager actions of one identifier, in registration order; a subsequence of the chain under that identifier */
-  eagerChains = /* @__PURE__ */ new Map();
+class M {
+  /**
+   * Every action registered here, in registration order. It is replaced rather than written when an action is
+   * dropped, so a run already walking it finishes on the array it started with and the removal takes effect from
+   * the next trigger.
+   */
+  actions = [];
   /**
    * Registers `action`. It becomes the outermost handler of its identifier, or - where `before` is given and is
    * registered here under the same identifier - takes that action's place in the order, so `before` wraps it and
@@ -559,117 +586,131 @@ class D {
    * inside a handler already there.
    */
   register(t, e) {
-    if (!(t instanceof p)) throw new Error("Invalid action type");
-    const s = t.classIdentifier;
-    if (e && (e.classIdentifier !== s || !this.registeredActions.includes(e)))
+    if (!(t instanceof m)) throw new Error("Invalid action type");
+    const s = e ? this.actions.indexOf(e) : -1;
+    if (e && (e.classIdentifier !== t.classIdentifier || s < 0))
       throw new Error("Action to register before is not registered under the same identifier");
-    this.registeredActions.push(t), this.insert(this.chains, s, t, e), t.eager && this.insert(this.eagerChains, s, t, e);
+    s < 0 ? this.actions.push(t) : this.actions.splice(s, 0, t);
   }
-  /**
-   * Drops `action` from this map and answers whether it was in it. The lists it stood in are replaced rather than
-   * written, so a run already walking one finishes on the list it started with and the removal takes effect from
-   * the next trigger.
-   */
+  /** Drops `action` and answers whether it was registered here. */
   unregister(t) {
-    const e = this.registeredActions.indexOf(t);
-    if (e < 0) return !1;
-    this.registeredActions.splice(e, 1);
-    const s = t.classIdentifier;
-    return this.remove(this.chains, s, t), this.remove(this.eagerChains, s, t), !0;
+    return this.actions.includes(t) ? (this.actions = this.actions.filter((e) => e !== t), !0) : !1;
   }
   /** True where something is registered under `identifier`. */
   willTrigger(t) {
-    return this.chains.has(t);
+    return this.actions.some((e) => e.classIdentifier === t);
   }
   /** True where any eager action is registered, whatever identifier it stands under. */
   get hasEager() {
-    return this.eagerChains.size > 0;
+    return this.actions.some((t) => t.eager);
   }
   /** Runs the actions registered under `ActionClass` and answers with what the outermost of them returned. */
   trigger(t, e, ...s) {
-    return this.run(this.chains.get(t.classIdentifier), e, s);
+    return this.run(t.classIdentifier, !1, e, s);
   }
-  /** Runs the eager actions of every identifier, each group on its own. */
+  /**
+   * Runs the eager actions of every identifier, each group on its own. A group is entered at its outermost eager
+   * action, which is the last one registered under that identifier.
+   */
   triggerEager(t, ...e) {
-    this.eagerChains.forEach((s) => this.run(s, t, e));
+    const s = this.actions;
+    for (let i = s.length - 1; i >= 0; i--) {
+      const r = s[i];
+      if (r.eager && M.outermostEager(s, i))
+        try {
+          this.walk(s, i, r.classIdentifier, !0, t, e);
+        } catch (a) {
+          if (!(a instanceof P)) throw a;
+        }
+    }
   }
   /** Runs the eager actions registered under `identifier` and nothing else. */
   triggerEagerFor(t, e, ...s) {
-    return this.run(this.eagerChains.get(t), e, s);
+    return this.run(t, !0, e, s);
   }
-  /** the validators registered in this map, in registration order */
+  /** the validators registered here, in registration order */
   get validators() {
-    return this.registeredActions.filter((t) => t instanceof g);
-  }
-  clone() {
-    const t = new D();
-    return this.registeredActions.forEach((e) => t.register(e)), t;
+    return this.actions.filter((t) => t instanceof f);
   }
   /**
-   * Tells every action in this map that it serves `owner`. A copied map holds the instances the original holds, so
-   * the element that took the copy on is announced to them here, the way registering an action announces the
-   * element it was registered on.
+   * Tells every action here that it serves `owner`. A binding reads the map its declaration holds, so this is what
+   * announces the new element to the actions already in it - the way registering an action announces the elements
+   * it comes to serve.
    */
   bindTo(t) {
-    this.registeredActions.forEach((e) => e.boundToBinding(t));
+    this.actions.forEach((e) => e.boundToBinding(t));
+  }
+  /** True where no eager action of `identifier` stands after `index`, which makes `index` the group's entry. */
+  static outermostEager(t, e) {
+    const s = t[e].classIdentifier;
+    for (let i = t.length - 1; i > e; i--)
+      if (t[i].eager && t[i].classIdentifier === s) return !1;
+    return !0;
   }
   /**
-   * Walks `chain` from the end backwards, handing each action a `supr` that continues at the one before it. The
-   * closures exist for the length of the run and only as deep as the run actually goes, so a chain nobody walks to
-   * the bottom costs nothing for the part left unreached.
+   * Enters a group at its outermost action. An abort ends the run and is answered with rather than raised: the
+   * exception is what the caller receives, so a run a handler ended is told apart from one that reached no handler
+   * and from one whose handler answered null.
    */
-  step(t, e, s, i) {
-    if (e < 0) return null;
-    const a = (r, ...o) => this.step(t, e - 1, r, o);
-    return t[e].execute(s, a, ...i);
-  }
-  /** Walks a chain, answering null where there is none. An abort ends the run and is not an error to the caller. */
-  run(t, e, s) {
-    if (!t) return null;
+  run(t, e, s, i) {
+    const r = this.actions;
     try {
-      return this.step(t, t.length - 1, e, s);
-    } catch (i) {
-      if (!(i instanceof Vt)) throw i;
+      return this.walk(r, r.length - 1, t, e, s, i);
+    } catch (a) {
+      if (a instanceof P) return a;
+      throw a;
     }
-    return null;
-  }
-  insert(t, e, s, i) {
-    const a = t.get(e) ?? [], r = i ? a.indexOf(i) : -1;
-    r < 0 ? a.push(s) : a.splice(r, 0, s), t.set(e, a);
   }
-  remove(t, e, s) {
-    const i = t.get(e);
-    if (!i?.includes(s)) return;
-    const a = i.filter((r) => r !== s);
-    a.length ? t.set(e, a) : t.delete(e);
+  /**
+   * Walks from `index` backwards to the first action of `identifier`, handing it a `supr` that continues at the one
+   * before it. The actions registered under other identifiers are passed over, so the array needs no grouping of
+   * its own; the closures exist for the length of the run and only as deep as the run actually goes.
+   */
+  walk(t, e, s, i, r, a) {
+    let o = e;
+    for (; o >= 0 && (t[o].classIdentifier !== s || i && !t[o].eager); ) o--;
+    if (o < 0) return null;
+    const l = (v, ...p) => this.walk(t, o - 1, s, i, v, p);
+    return t[o].execute(r, l, ...a);
   }
 }
-function x(n) {
+function V(n) {
   let t = n;
   for (; t.fieldName !== void 0 && t.parent; ) t = t.parent;
   return t;
 }
-function ee(n) {
+function dt(n, t) {
+  let e = n;
+  for (const s of re(t))
+    if (e = e.field?.(s) ?? void 0, !e) return;
+  return e?.declaration === t ? e : void 0;
+}
+function re(n) {
   const t = [];
   let e = n;
   for (; e.fieldName !== void 0 && e.parent; )
     t.unshift(e.fieldName), e = e.parent;
   return t;
 }
-function G(n, t) {
-  let e = t;
-  for (const s of ee(n))
-    if (e = e.field?.(s) ?? void 0, !e) break;
-  return e?.declaration === n ? e : x(n) === x(t.declaration) ? void 0 : n;
+function tt(n, t) {
+  const e = dt(t, n);
+  if (e) return e;
+  let s = t.parent;
+  for (; s; ) {
+    const i = dt(V(s), n);
+    if (i) return i;
+    s = s.parent;
+  }
+  return V(n) === V(t.declaration) ? void 0 : n;
 }
-function Tt(n, t) {
-  const e = G(n, t);
+function kt(n, t) {
+  const e = tt(n, t);
   if (!e) return [];
   if (e !== n) return [e];
   const s = t.bindingsOf(n);
   return s.length > 0 ? s : [n];
 }
-function se(n, t) {
+function ae(n, t) {
   let e = t.parent;
   for (; e; ) {
     const s = e.field?.(n);
@@ -677,8 +718,8 @@ function se(n, t) {
     e = e.parent;
   }
 }
-const ie = /* @__PURE__ */ Symbol("ConditionalStatementAction");
-class L extends S {
+const oe = /* @__PURE__ */ Symbol("ConditionalStatementAction");
+class U extends T {
   statement;
   conditionalExecutor;
   /**
@@ -694,12 +735,12 @@ class L extends S {
    */
   registrations = /* @__PURE__ */ new WeakSet();
   constructor(t, e) {
-    super((i, a, r, o) => (this.applyIn(x(i)) || i.markRecordIncomplete(), a(i, r, o))), this.statement = t, this.conditionalExecutor = e;
-    const s = new S((i, a, ...r) => (this.applyFrom(i), a(i, ...r)));
+    super((i, r, a, o) => (this.applyIn(V(i)) || i.markRecordIncomplete(), r(i, a, o))), this.statement = t, this.conditionalExecutor = e;
+    const s = new T((i, r, ...a) => (this.applyFrom(i), r(i, ...a)));
     t.collectFields().forEach((i) => i.registerAction(s));
   }
   static get classIdentifier() {
-    return ie;
+    return oe;
   }
   get eager() {
     return !0;
@@ -717,7 +758,7 @@ class L extends S {
   targetsIn(t) {
     const e = [];
     return this.declarations.forEach(
-      (s) => Tt(s, t).forEach((i) => {
+      (s) => kt(s, t).forEach((i) => {
         this.registrations.has(i) && e.push(i);
       })
     ), e;
@@ -733,8 +774,8 @@ class L extends S {
     if (e.length === 0) return !1;
     const s = this.state(t, () => ({ lastResult: void 0 })), i = this.statement.evaluate(t);
     if (i === s.lastResult) return !0;
-    const a = s.lastResult;
-    return s.lastResult = i, e.forEach((r) => this.conditionalExecutor(r, i, a)), !0;
+    const r = s.lastResult;
+    return s.lastResult = i, e.forEach((a) => this.conditionalExecutor(a, i, r)), !0;
   }
   /**
    * Re-evaluates the records a change of `source` speaks for. A field of the record the targets live in speaks for
@@ -744,133 +785,133 @@ class L extends S {
    */
   applyFrom(t) {
     const e = /* @__PURE__ */ new Set();
-    this.targetsIn(x(t)).forEach((s) => e.add(x(s))), e.forEach((s) => this.applyIn(s));
+    this.targetsIn(V(t)).forEach((s) => e.add(V(s))), e.forEach((s) => this.applyIn(s));
   }
 }
-class ne extends L {
+class le extends U {
   constructor(t) {
     super(t, (e, s) => {
-      e.visibility = s ? _.FULL : _.SUPPRESS;
+      e.visibility = s ? I.FULL : I.SUPPRESS;
     });
   }
 }
-class re extends L {
+class ue extends U {
   constructor(t) {
     super(t, (e, s) => {
       e.enabled = s;
     });
   }
 }
-class ae extends L {
+class ce extends U {
   constructor(t, e) {
     super(t, (s, i) => {
       i && (s.value = e);
     });
   }
 }
-var j = /* @__PURE__ */ ((n) => (n[n.NOT = 0] = "NOT", n[n.OR = 1] = "OR", n[n.AND = 2] = "AND", n[n.XOR = 3] = "XOR", n[n.NAND = 4] = "NAND", n[n.NOR = 5] = "NOR", n[n.EQUALS = -1] = "EQUALS", n[n.NOT_EQUALS = -2] = "NOT_EQUALS", n[n.GT = -3] = "GT", n[n.LT = -4] = "LT", n[n.GE = -5] = "GE", n[n.LE = -6] = "LE", n[n.IN = -7] = "IN", n[n.NOT_IN = -8] = "NOT_IN", n[n.INCLUDES = -9] = "INCLUDES", n[n.NOT_INCLUDES = -10] = "NOT_INCLUDES", n))(j || {});
+var N = /* @__PURE__ */ ((n) => (n[n.NOT = 0] = "NOT", n[n.OR = 1] = "OR", n[n.AND = 2] = "AND", n[n.XOR = 3] = "XOR", n[n.NAND = 4] = "NAND", n[n.NOR = 5] = "NOR", n[n.EQUALS = -1] = "EQUALS", n[n.NOT_EQUALS = -2] = "NOT_EQUALS", n[n.GT = -3] = "GT", n[n.LT = -4] = "LT", n[n.GE = -5] = "GE", n[n.LE = -6] = "LE", n[n.IN = -7] = "IN", n[n.NOT_IN = -8] = "NOT_IN", n[n.INCLUDES = -9] = "INCLUDES", n[n.NOT_INCLUDES = -10] = "NOT_INCLUDES", n))(N || {});
 ((n) => {
-  function t(a) {
-    const r = a.toLowerCase();
-    if (r === "not") return 0;
-    if (r === "or") return 1;
-    if (r === "and") return 2;
-    if (r === "xor") return 3;
-    if (r === "nand") return 4;
-    if (r === "nor") return 5;
-    if (r === "equals") return -1;
-    if (["not_equals", "not-equals", "not equals"].includes(r)) return -2;
-    if (r === "gt") return -3;
-    if (r === "lt") return -4;
-    if (r === "ge") return -5;
-    if (r === "le") return -6;
-    if (r === "in") return -7;
-    if (["not_in", "not-in", "not in"].includes(r)) return -8;
-    if (r === "includes") return -9;
-    if (["not_includes", "not-includes", "not includes"].includes(r)) return -10;
-    throw new Error(`Unrecognised operator ${r}`);
+  function t(r) {
+    const a = r.toLowerCase();
+    if (a === "not") return 0;
+    if (a === "or") return 1;
+    if (a === "and") return 2;
+    if (a === "xor") return 3;
+    if (a === "nand") return 4;
+    if (a === "nor") return 5;
+    if (a === "equals") return -1;
+    if (["not_equals", "not-equals", "not equals"].includes(a)) return -2;
+    if (a === "gt") return -3;
+    if (a === "lt") return -4;
+    if (a === "ge") return -5;
+    if (a === "le") return -6;
+    if (a === "in") return -7;
+    if (["not_in", "not-in", "not in"].includes(a)) return -8;
+    if (a === "includes") return -9;
+    if (["not_includes", "not-includes", "not includes"].includes(a)) return -10;
+    throw new Error(`Unrecognised operator ${a}`);
   }
   n.fromString = t;
-  function e(a) {
-    const r = typeof a == "number" ? a : n.fromString(a);
-    if (Object.values(n).includes(r)) return r;
-    throw new Error(`Unrecognised operator ${a}`);
+  function e(r) {
+    const a = typeof r == "number" ? r : n.fromString(r);
+    if (Object.values(n).includes(a)) return a;
+    throw new Error(`Unrecognised operator ${r}`);
   }
   n.fromAny = e;
-  function s(a) {
-    const r = typeof a == "number" ? a : n.fromString(a);
-    return Object.values(n).includes(r);
+  function s(r) {
+    const a = typeof r == "number" ? r : n.fromString(r);
+    return Object.values(n).includes(a);
   }
   n.isDefined = s;
-  function i(a) {
-    return a >= 0;
+  function i(r) {
+    return r >= 0;
   }
   n.isLogicOperator = i;
-})(j || (j = {}));
-Object.freeze(j);
-const c = j, oe = /* @__PURE__ */ Symbol("EnabledChangingAction");
-class _t extends p {
+})(N || (N = {}));
+Object.freeze(N);
+const c = N, he = /* @__PURE__ */ Symbol("EnabledChangingAction");
+class Rt extends m {
   constructor(t) {
     super(t);
   }
   static get classIdentifier() {
-    return oe;
+    return he;
   }
   execute(t, e, s, i) {
     return super.execute(t, e, s, i);
   }
 }
-const le = /* @__PURE__ */ Symbol("EnabledChangedAction");
-class Ot extends p {
+const de = /* @__PURE__ */ Symbol("EnabledChangedAction");
+class _t extends m {
   constructor(t) {
     super(t);
   }
   static get classIdentifier() {
-    return le;
+    return de;
   }
   execute(t, e, s, i) {
     return super.execute(t, e, s, i);
   }
 }
-const ue = /* @__PURE__ */ Symbol("ValidChangedAction");
-class Ft extends p {
+const ge = /* @__PURE__ */ Symbol("ValidChangedAction");
+class Ft extends m {
   constructor(t) {
     super(t);
   }
   static get classIdentifier() {
-    return ue;
+    return ge;
   }
   execute(t, e, s, i) {
     return super.execute(t, e, s, i);
   }
 }
-const ce = /* @__PURE__ */ Symbol("VisibilityChangingAction");
-class Rt extends p {
+const fe = /* @__PURE__ */ Symbol("VisibilityChangingAction");
+class Pt extends m {
   constructor(t) {
     super(t);
   }
   static get classIdentifier() {
-    return ce;
+    return fe;
   }
   execute(t, e, s, i) {
     return super.execute(t, e, s, i);
   }
 }
-const he = /* @__PURE__ */ Symbol("VisibilityChangedAction");
-class Pt extends p {
+const pe = /* @__PURE__ */ Symbol("VisibilityChangedAction");
+class jt extends m {
   constructor(t) {
     super(t);
   }
   static get classIdentifier() {
-    return he;
+    return pe;
   }
   execute(t, e, s, i) {
     return super.execute(t, e, s, i);
   }
 }
-const ht = /* @__PURE__ */ new WeakMap(), dt = /* @__PURE__ */ new WeakMap(), gt = /* @__PURE__ */ new Set(["validators", "actions"]);
-let z = 0;
-class V {
+const gt = /* @__PURE__ */ new WeakMap(), ft = /* @__PURE__ */ new WeakMap(), Q = /* @__PURE__ */ new WeakMap(), pt = /* @__PURE__ */ new Set(["validators", "actions"]);
+let X = 0;
+class y {
   /**
    * Vue's getTargetType answers INVALID for an object that carries __v_skip, so reactive() hands an element back
    * unwrapped and no element is ever behind a proxy of its own. isReactive() reads the second flag, and it stays
@@ -888,6 +929,21 @@ class V {
   get __v_isReactive() {
     return !0;
   }
+  /**
+   * Names the element's class, which is what a structural comparison of two elements answers on. An element keeps
+   * its state in private class fields, so a walk over own keys reaches none of it; lodash reads this tag through
+   * Object.prototype.toString before it compares anything, and a tag it does not know ends the comparison there.
+   * Two elements are therefore equal only where they are the same element. What they hold is compared as
+   * isEqual(a.value, b.value).
+   *
+   * It is an accessor on the prototype, so an element carries nothing for it, and `Object.prototype.toString`
+   * answers `[object Field]` rather than `[object Object]`. Each class states its own name as a literal: a
+   * minifier renames the class itself, so reading the constructor's name would report whatever the build called
+   * it.
+   */
+  get [Symbol.toStringTag]() {
+    return "FormElement";
+  }
   /**
    * The element's mutable state, in an object beside the element. `#state` is the tracked view of it: a slot read
    * through it inside an effect subscribes the effect to that slot, and a write to the slot re-runs the effect.
@@ -974,7 +1030,7 @@ class V {
   extendedOf(t) {
     const e = /* @__PURE__ */ Object.create(null);
     return Object.entries(t).forEach(([s, i]) => {
-      gt.has(s) || (!(s in this) || Object.hasOwn(Object.prototype, s)) && (e[s] = i);
+      pt.has(s) || (!(s in this) || Object.hasOwn(Object.prototype, s)) && (e[s] = i);
     }), e;
   }
   /**
@@ -985,8 +1041,8 @@ class V {
   assignParams(t) {
     const e = this.extendedOf(t);
     Object.entries(t).forEach(([s, i]) => {
-      Object.hasOwn(e, s) || gt.has(s) || (this[s] = i);
-    }), R(e) || this.setExtendedValues(e);
+      Object.hasOwn(e, s) || pt.has(s) || (this[s] = i);
+    }), F(e) || this.setExtendedValues(e);
   }
   /**
    * Takes this element into the record of the open transaction, where one is open. A write of a single slot that
@@ -994,7 +1050,7 @@ class V {
    * atomic, and inside a transaction it has to be part of what a rollback puts back.
    */
   touchState() {
-    St()?.touch(this);
+    It()?.touch(this);
   }
   /**
    * Records the whole of this element's mutable state, so that a rolled-back transaction can put it back exactly
@@ -1014,7 +1070,7 @@ class V {
    * The two validation counters are the slots the element keeps: they count runs that are in flight, and a
    * rollback cannot un-start one. Put back, the counts would no longer match the endValidating calls still to come.
    */
-  [Ct](t) {
+  [St](t) {
     const e = this.#e.validatingCount, s = this.#e.validatingChildren;
     Object.assign(this.#t, t), this.#t.validatingCount = e, this.#t.validatingChildren = s;
   }
@@ -1032,11 +1088,11 @@ class V {
   /** announces the start of one asynchronous validation run; validators pair it with endValidating */
   beginValidating() {
     const t = !this.validating;
-    this.#t.validatingCount++, t && this.parent?.childValidatingChanged(!0);
+    this.#t.validatingCount++, t && this.container?.childValidatingChanged(!0);
   }
   /** announces the end of one asynchronous validation run */
   endValidating() {
-    this.#e.validatingCount !== 0 && (this.#t.validatingCount--, this.validating || this.parent?.childValidatingChanged(!1));
+    this.#e.validatingCount !== 0 && (this.#t.validatingCount--, this.validating || this.container?.childValidatingChanged(!1));
   }
   /**
    * Records that a child started or stopped answering `validating` with true, and carries the transition further
@@ -1044,7 +1100,7 @@ class V {
    */
   childValidatingChanged(t) {
     const e = this.validating;
-    this.#t.validatingChildren += t ? 1 : -1, this.validating !== e && this.parent?.childValidatingChanged(t);
+    this.#t.validatingChildren += t ? 1 : -1, this.validating !== e && this.container?.childValidatingChanged(t);
   }
   /**
    * True while an `Action.execute()` at or below this element has yet to settle. An `Action` answers for its own
@@ -1064,8 +1120,8 @@ class V {
    * container answers from its own computed.
    */
   get busyRead() {
-    let t = dt.get(this);
-    return t || (t = X(() => this.composeBusy()), dt.set(this, t)), t.value;
+    let t = ft.get(this);
+    return t || (t = K(() => this.composeBusy()), ft.set(this, t)), t.value;
   }
   /** What busyRead computes. A container answers over its members; anything else executes nothing. */
   composeBusy() {
@@ -1107,10 +1163,21 @@ class V {
    * undefined while no container holds it. The container writes it; everyone else reads it. The read is tracked,
    * so an effect rendering off the link - `v-if="field.parent"` - re-runs when a container takes the element or
    * releases it.
+   *
+   * A `List` holds rows and a row is a `Group`, so only a container can be a `List`'s child: `Field` narrows the
+   * type to `Group | undefined`, and the sibling lookup `field.parent?.fields.other` is typed on a field.
    */
   get parent() {
     return this.#t.parent;
   }
+  /**
+   * The same link at the type the internals reach through. The protected members a container is told things
+   * through - childValidatingChanged, childValidityChanged - are declared here, and a union of two subclasses is
+   * not an instance of this class, which is what a protected access needs.
+   */
+  get container() {
+    return this.#t.parent;
+  }
   /** when member of a Group, fieldName specifies the name of this field. Written by the group, read-only after */
   get fieldName() {
     return this.#t.fieldName;
@@ -1135,8 +1202,8 @@ class V {
    * cheaper one, resolving within a single record, does not apply.
    */
   bindingsOf(t) {
-    const e = t.declaration, s = [], i = (a) => {
-      a.declaration === e && s.push(a), a.members.forEach(i);
+    const e = t.declaration, s = [], i = (r) => {
+      r.declaration === e && s.push(r), r.members.forEach(i);
     };
     return i(this), s;
   }
@@ -1148,7 +1215,7 @@ class V {
    * nothing says so again, so the next container above answers for it.
    */
   markRecordIncomplete() {
-    this._recordPending || (this._recordPending = !0, z++);
+    this._recordPending || (this._recordPending = !0, X++);
   }
   /**
    * Runs the eager passes outstanding in `element`'s subtree, now that the record it belongs to is assembled. A
@@ -1156,9 +1223,9 @@ class V {
    * List that has taken a row, which is what gives the row's fields the form above it.
    */
   completeRecords(t = this) {
-    z !== 0 && u(() => {
+    X !== 0 && u(() => {
       const e = (s) => {
-        s._recordPending && (s._recordPending = !1, z--, s.rerunEagerActions()), s.members.forEach(e);
+        s._recordPending && (s._recordPending = !1, X--, s.rerunEagerActions()), s.members.forEach(e);
       };
       e(t);
     });
@@ -1166,14 +1233,48 @@ class V {
   /** Runs this element's eager actions over the value it holds and re-forms the verdict they reach. */
   rerunEagerActions() {
     u((t) => {
-      this._actions?.triggerEager(this, this.value, this.value), t.markValidityDirty(this);
+      this.boundActions?.triggerEager(this, this.value, this.value), t.markValidityDirty(this);
     });
   }
-  get actions() {
-    return this._actions || (this._actions = new D()), this._actions;
+  /**
+   * The actions this element answers to, absent where nothing is registered. A binding holds the very map its
+   * declaration holds rather than a copy of it, so the slot is read directly: what a trigger costs is one property
+   * read, and a rule registered on a `List`'s item template reaches every row through the map they share - the
+   * rows built before the registration as much as the ones built after.
+   */
+  get boundActions() {
+    return this._actions;
+  }
+  /** Records that `binding` was made from this element, so a later registration can reach it. */
+  noteBinding(t) {
+    let e = Q.get(this);
+    e || (e = /* @__PURE__ */ new Set(), Q.set(this, e)), e.add(new WeakRef(t));
+  }
+  /**
+   * The bindings made from this element that are still alive, and this element itself. The dead references are
+   * dropped as they are found, which is what keeps the set from growing over the life of a long-lived declaration.
+   */
+  get boundElements() {
+    const t = this.declaration, e = Q.get(t), s = [t];
+    return e && e.forEach((i) => {
+      const r = i.deref();
+      r ? s.push(r) : e.delete(i);
+    }), s;
   }
-  set actions(t) {
-    this._actions = t;
+  /**
+   * The map registrations go into: the declaration's, since that is where behaviour lives. The map is made on the
+   * first registration and handed to every binding already made from the declaration, so all of them go on reading
+   * one map through a slot of their own.
+   */
+  get actions() {
+    const t = this.declaration;
+    if (!t._actions) {
+      const e = new M();
+      t.boundElements.forEach((s) => {
+        s._actions = e;
+      });
+    }
+    return t._actions;
   }
   /**
    * Counts the writes that have changed the value of this element or of anything below it. A container reads it
@@ -1210,6 +1311,27 @@ class V {
       e.markValueChanged(this, t), e.markValidityDirty(this), this.parent?.notifyValueChanged();
     });
   }
+  /**
+   * The last step of a construction: it runs inside the transaction the construction is, with the parameters
+   * applied and the value in place, before the element records what it was built as.
+   *
+   * A subclass overrides it to complete what the element was built with. What it writes here is part of the
+   * construction rather than a change of it: the element announces no ValueChangedAction, and what the hook
+   * leaves is what its eager actions and its validators run over, once. An element whose parameters named no
+   * `originalValue` is baselined on the value the hook left and so starts unchanged; one that named a baseline is
+   * measured against it, as any element is. A `Field` writes
+   * `_value`, which reaches the slot on an element built `enabled: false` as well - the value setter, which a
+   * disabled field refuses, states a change, and this is not one.
+   *
+   * A container completes itself through its members, and a member carries a construction of its own: the write
+   * reaches it as any later one would, so the member announces it and reports itself changed. A member that is to
+   * start unchanged is baselined here as well - `this.fields.x.originalValue = this.fields.x.value`.
+   *
+   * `params` is the parameter object the constructor received, where it received one.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  constructed(t) {
+  }
   /**
    * Re-reads the value that the next ValueChangedAction will report as the one it replaces. A leaf records what
    * it announced at every announcement, so its copy is always current and there is nothing to re-read; a
@@ -1270,8 +1392,8 @@ class V {
     u(() => {
       const s = e === void 0 ? t.value : e, i = this.errors.length > 0;
       i && (this.errors = []), this.touched = !1;
-      const a = this.enabled && this.value !== s;
-      this.value = s, this.originalValue = this.value, this.validate(!a && i);
+      const r = this.enabled && this.value !== s;
+      this.value = s, this.originalValue = this.value, this.validate(!r && i);
     });
   }
   /** Resets a member. It is what lets a container reach the reset of a child whose class it does not know. */
@@ -1291,8 +1413,8 @@ class V {
    * from repeating while nothing it read has moved.
    */
   get validRead() {
-    let t = ht.get(this);
-    return t || (t = X(() => this.composeValid()), ht.set(this, t)), t.value;
+    let t = gt.get(this);
+    return t || (t = K(() => this.composeValid()), gt.set(this, t)), t.value;
   }
   /** What validRead computes. A leaf answers over its own errors; a container adds its members. */
   composeValid() {
@@ -1303,21 +1425,27 @@ class V {
     return this.#t.visibility;
   }
   set visibility(t) {
-    u((e) => {
-      const s = this.#t.visibility, i = this._actions?.trigger(Rt, this, t, s);
-      if (!_.isDefined(i ?? t))
-        throw new Error("visibility must be a DisplayMode constant");
-      e.touch(this), this.#t.visibility = _.fromAny(i ?? t), this._actions?.trigger(Pt, this, this.#t.visibility, s);
+    const e = this.#t.visibility;
+    t !== e && u((s) => {
+      const i = this.boundActions?.trigger(Pt, this, t, e);
+      if (!(i instanceof P)) {
+        if (!I.isDefined(i ?? t))
+          throw new Error("visibility must be a DisplayMode constant");
+        s.touch(this), this.#t.visibility = I.fromAny(i ?? t), this.boundActions?.trigger(jt, this, this.#t.visibility, e);
+      }
     });
   }
   get enabled() {
     return this.#t.enabled;
   }
   set enabled(t) {
-    u((e) => {
-      const s = this.#t.enabled, i = this._actions?.trigger(_t, this, t, s);
-      if (!Lt(i ?? t)) throw new Error("Enabled value must be boolean");
-      e.touch(this), this.#t.enabled = i ?? t, this.#t.enabled !== s && this.bumpValueVersion(), this._actions?.trigger(Ot, this, this.#t.enabled, s);
+    const e = this.#t.enabled;
+    t !== e && u((s) => {
+      const i = this.boundActions?.trigger(Rt, this, t, e);
+      if (!(i instanceof P)) {
+        if (!Qt(i ?? t)) throw new Error("Enabled value must be boolean");
+        s.touch(this), this.#t.enabled = i ?? t, this.#t.enabled !== e && this.bumpValueVersion(), this.boundActions?.trigger(_t, this, this.#t.enabled, e);
+      }
     });
   }
   /**
@@ -1330,18 +1458,26 @@ class V {
   get composesValue() {
     return !1;
   }
+  /**
+   * Whether `child` composes its value from members of its own. It is what lets a container tell a nested
+   * container from a leaf without knowing the classes below it, the way `resetChild` reaches a reset it does not
+   * know the shape of.
+   */
+  childComposesValue(t) {
+    return t.composesValue;
+  }
   /**
    * Announces what this element's value became over the transaction. The pair carried is (value now, value at the
    * last announcement), so a value that went A -> B -> A within the transaction says nothing, and the events an
    * operation states rather than an element's state - an item added, an item removed - are emitted first, in the
    * order the operations happened.
    */
-  [Et](t, e, s, i) {
-    if (i?.forEach((l) => this._actions?.trigger(l.actionClass, this, l.item, l.index)), !e) return;
-    const a = this._actions;
-    if (this.composesValue && !(a?.willTrigger(yt) || a?.hasEager)) return;
-    const r = this.value, o = this.#e.announcedValue;
-    !s && (this.composesValue ? Q(r, o) : r === o) || (t.touch(this), this.#e.announcedValue = r, this.composesValue && a?.triggerEager(this, r, o), a?.trigger(S, this, r, o));
+  [xt](t, e, s, i) {
+    if (i?.forEach((l) => this.boundActions?.trigger(l.actionClass, this, l.item, l.index)), !e) return;
+    const r = this.boundActions;
+    if (this.composesValue && !(r?.willTrigger(Ct) || r?.hasEager)) return;
+    const a = this.value, o = this.#e.announcedValue;
+    !s && (this.composesValue ? R(a, o) : a === o) || (t.touch(this), this.#e.announcedValue = a, this.composesValue && r?.triggerEager(this, a, o), r?.trigger(T, this, a, o));
   }
   /**
    * Forms the verdict this element ends the transaction with and announces a transition of it. The container is
@@ -1350,16 +1486,16 @@ class V {
    * asynchronous validator, an error pushed in by hand - is what makes the container re-form its own. The
    * transaction settles the deepest element first, so a container is reached only once its members have decided.
    */
-  [xt](t) {
+  [At](t) {
     const e = this.#e.valid, s = this.countedValid;
     if (s === e) return;
     t.touch(this), this.#e.valid = s;
-    const i = this.parent;
-    i && (t.touch(i), i.childValidityChanged(s), t.markValidityDirty(i)), this._actions?.trigger(Ft, this, s, e);
+    const i = this.container;
+    i && (t.touch(i), i.childValidityChanged(s), t.markValidityDirty(i)), this.boundActions?.trigger(Ft, this, s, e);
   }
   validate(t = !1) {
     u((e) => {
-      t && this._actions?.triggerEager(this, this.value, this.value), e.markValidityDirty(this);
+      t && this.boundActions?.triggerEager(this, this.value, this.value), e.markValidityDirty(this);
     });
   }
   get valid() {
@@ -1369,7 +1505,7 @@ class V {
     return this.value;
   }
   get isChanged() {
-    return !Q(this.value, this.originalValue);
+    return !R(this.value, this.originalValue);
   }
   /**
    * Brings a fresh element into the state a binding of `source` is in: it records what it was declared as, takes
@@ -1381,10 +1517,12 @@ class V {
    */
   boundFrom(t, e, s, i) {
     this.#e.declaration = t.declaration;
-    const a = { ...t.extra, ...i && this.extendedOf(i) };
-    R(a) || this.setExtendedValues(a);
-    const r = t._actions;
-    r && (this._actions = r.clone(), this._actions.bindTo(this), this._actions.triggerEager(this, e, s));
+    const r = { ...t.extra, ...i && this.extendedOf(i) };
+    F(r) || this.setExtendedValues(r);
+    const a = this.declaration;
+    a.noteBinding(this);
+    const o = a._actions;
+    o && (this._actions = o, o.bindTo(this), o.triggerEager(this, e, s));
   }
   /**
    * Registers the actions a constructor received in its parameters: registration without the eager trigger,
@@ -1398,7 +1536,7 @@ class V {
   }
   registerAction(t) {
     return u((e) => {
-      e.willAnnounceValue(this) || this.refreshPreviousValue(), this.actions.register(t), this.registered(e, t), t.eager && this.actions.triggerEagerFor(t.classIdentifier, this, this.value, this.originalValue);
+      e.willAnnounceValue(this) || this.refreshPreviousValue(), this.actions.register(t), this.registered(e, t);
     }), this;
   }
   /**
@@ -1409,7 +1547,7 @@ class V {
    */
   registerActionBefore(t, e) {
     return u((s) => {
-      s.willAnnounceValue(this) || this.refreshPreviousValue(), this.actions.register(t, e), this.registered(s, t), t.eager && this.actions.triggerEagerFor(t.classIdentifier, this, this.value, this.originalValue);
+      s.willAnnounceValue(this) || this.refreshPreviousValue(), this.actions.register(t, e), this.registered(s, t);
     }), this;
   }
   /**
@@ -1421,10 +1559,13 @@ class V {
   unregisterAction(t) {
     let e = !1;
     return u((s) => {
-      const i = this._actions;
-      i && (e = i.unregister(t), e && (s.touch(this), t instanceof g && this.#t.validationEpoch++, s.whenRolledBack(() => {
-        i.register(t), t.boundToBinding(this);
-      }), t.unregisterFrom(this)));
+      const i = this.boundActions;
+      if (!i || (e = i.unregister(t), !e)) return;
+      s.touch(this), t instanceof f && this.#t.validationEpoch++;
+      const r = this.boundElements;
+      s.whenRolledBack(() => {
+        i.register(t), r.forEach((a) => t.boundToBinding(a));
+      }), r.forEach((a) => t.unregisterFrom(a));
     }), e;
   }
   /**
@@ -1432,12 +1573,16 @@ class V {
    * registration is not one of the state slots the snapshot covers, so it hands its own undo in.
    */
   registered(t, e) {
-    e.boundToBinding(this), t.whenRolledBack(() => {
-      this._actions?.unregister(e) && e.unregisterFrom(this);
+    const s = this.boundElements;
+    s.forEach((i) => {
+      e.boundToBinding(i), e.eager && this.actions.triggerEagerFor(e.classIdentifier, i, i.value, i.originalValue);
+    }), t.whenRolledBack(() => {
+      this.boundActions?.unregister(e) && s.forEach((i) => e.unregisterFrom(i));
     });
   }
   triggerAction(t, ...e) {
-    return this._actions ? this._actions.trigger(t, this, ...e) : null;
+    const s = this.boundActions;
+    return s ? s.trigger(t, this, ...e) : null;
   }
   /**
    * Generation counter of the validators attached to this field. A Validator reads it when a run starts and drops
@@ -1450,19 +1595,23 @@ class V {
   clearValidators() {
     u((t) => {
       t.touch(this), this.#t.validationEpoch++;
-      const e = this._actions;
-      e && e.validators.forEach((s) => {
-        e.unregister(s), t.whenRolledBack(() => {
-          e.register(s), s.boundToBinding(this);
-        }), s.unregisterFrom(this);
-      }), this.errors = [], this.validate();
+      const e = this.boundActions;
+      if (e) {
+        const s = this.boundElements;
+        e.validators.forEach((i) => {
+          e.unregister(i), t.whenRolledBack(() => {
+            e.register(i), s.forEach((r) => i.boundToBinding(r));
+          }), s.forEach((r) => i.unregisterFrom(r));
+        });
+      }
+      this.errors = [], this.validate();
     });
   }
 }
-function de(n, t) {
+function me(n, t) {
   return n ? !t : t;
 }
-class v {
+class w {
   operand1;
   operator;
   operand2;
@@ -1482,9 +1631,8 @@ class v {
         `Statement operand ${e} is a function: an operand is a field, a nested statement or a literal, and a function is none of them. An accessor states the field it answers with: group.field('name').`
       );
   }
-  /** @throws TypeError where an operand the statement reads is undefined or a function. */
   constructor(t, e, s) {
-    v.validateOperand(t, 1), e !== c.NOT && v.validateOperand(s, 2), this.operand1 = t, this.operator = e, this.operand2 = s;
+    w.validateOperand(t, 1), e !== c.NOT && w.validateOperand(s, 2), this.operand1 = t, this.operator = e, this.operand2 = s;
   }
   /**
    * The value an operand contributes. A field operand names a field of the record the statement is evaluated in:
@@ -1493,25 +1641,25 @@ class v {
    * hold the field yet contributes undefined, which is what a half-built row answers with.
    */
   static valueOf(t, e) {
-    if (t instanceof v) return t.evaluate(e);
-    if (t instanceof V) {
-      const s = e ? G(t, e) : t;
+    if (t instanceof w) return t.evaluate(e);
+    if (t instanceof y) {
+      const s = e ? tt(t, e) : t;
       return s ? h(s.value) : void 0;
     }
     return t;
   }
   get operand1Value() {
-    return v.valueOf(this.operand1);
+    return w.valueOf(this.operand1);
   }
   get operand2Value() {
-    return v.valueOf(this.operand2);
+    return w.valueOf(this.operand2);
   }
   /**
    * The result of the statement, over the record `scope` belongs to where one is given and over the fields the
    * statement was built from where it is not.
    */
   evaluate(t) {
-    const e = v.valueOf(this.operand1, t), s = v.valueOf(this.operand2, t);
+    const e = w.valueOf(this.operand1, t), s = w.valueOf(this.operand2, t);
     switch (this.operator) {
       // logical operators
       // `&&` and `||` evaluate to one of their operands, and the operands are of any type. Without the
@@ -1527,7 +1675,7 @@ class v {
       case c.NOR:
         return !(e || s);
       case c.XOR:
-        return de(!!e, !!s);
+        return me(!!e, !!s);
       case c.NOT:
         return !e;
       // comparison operators
@@ -1562,54 +1710,54 @@ class v {
   collectFields() {
     const t = /* @__PURE__ */ new Set();
     function e(s) {
-      s instanceof V ? t.add(s) : s instanceof v && s.collectFields().forEach((a) => t.add(a));
+      s instanceof y ? t.add(s) : s instanceof w && s.collectFields().forEach((r) => t.add(r));
     }
     return e(this.operand1), e(this.operand2), t;
   }
 }
-const ge = /* @__PURE__ */ Symbol("ExecuteAction");
-class jt extends p {
+const be = /* @__PURE__ */ Symbol("ExecuteAction");
+class Nt extends m {
   constructor(t) {
     super(t);
   }
   static get classIdentifier() {
-    return ge;
+    return be;
   }
   execute(t, e, s) {
     return super.execute(t, e, s);
   }
 }
-const fe = /* @__PURE__ */ Symbol("ListItemAddedAction");
-class K extends p {
+const ve = /* @__PURE__ */ Symbol("ListItemAddedAction");
+class Y extends m {
   constructor(t) {
     super(t);
   }
   static get classIdentifier() {
-    return fe;
+    return ve;
   }
   execute(t, e, s, i) {
     return super.execute(t, e, s, i);
   }
 }
-const pe = /* @__PURE__ */ Symbol("ListItemRemovedAction");
-class Nt extends p {
+const we = /* @__PURE__ */ Symbol("ListItemRemovedAction");
+class Bt extends m {
   constructor(t) {
     super(t);
   }
   static get classIdentifier() {
-    return pe;
+    return we;
   }
   execute(t, e, s, i) {
     return super.execute(t, e, s, i);
   }
 }
-const me = Object.freeze({});
-function kt() {
+const Ve = Object.freeze({});
+function Dt() {
   return {
     originalValue: void 0,
     announcedValue: void 0,
     errors: [],
-    visibility: _.FULL,
+    visibility: I.FULL,
     enabled: !0,
     valueVersion: 0,
     validatingCount: 0,
@@ -1618,29 +1766,32 @@ function kt() {
     fieldName: void 0,
     validationEpoch: 0,
     declaration: void 0,
-    extra: me,
+    extra: Ve,
     valid: !0,
     invalidChildren: 0
   };
 }
-function ve() {
-  return { ...kt(), value: void 0, touched: !1 };
+function ye() {
+  return { ...Dt(), value: void 0, touched: !1 };
 }
-function Bt() {
+function Lt() {
   return {
-    ...kt(),
+    ...Dt(),
     announcedValue: null,
     cachedValue: null,
     cachedValueVersion: -1
   };
 }
-function be() {
-  return { ...Bt(), fieldNames: [] };
+function Ee() {
+  return { ...Lt(), fieldNames: [] };
 }
-function we() {
-  return { ...Bt(), rows: null, rowsVersion: 0, cachedItems: null, cachedItemsVersion: -1 };
+function Ce() {
+  return { ...Lt(), rows: null, rowsVersion: 0, cachedItems: null, cachedItemsVersion: -1 };
 }
-class M extends V {
+class et extends y {
+  get [Symbol.toStringTag]() {
+    return "Field";
+  }
   get state() {
     return super.state;
   }
@@ -1655,7 +1806,7 @@ class M extends V {
     this.state.value = t;
   }
   constructor(t) {
-    super(ve()), this.init(t);
+    super(ye()), this.init(t);
   }
   /**
    * Applies the constructor parameters. It is a hook so that a subclass needing different parameter handling
@@ -1669,10 +1820,10 @@ class M extends V {
   init(t) {
     u(() => {
       if (t) {
-        const { value: e, validators: s, actions: i, ...a } = t;
-        this.registerInitialActions([...s || [], ...i || []]), this.assignParams(a), this._value = e !== void 0 ? e : this.originalValue, this.originalValue === void 0 && (this.originalValue = this._value);
+        const { value: e, validators: s, actions: i, ...r } = t;
+        this.registerInitialActions([...s || [], ...i || []]), this.assignParams(r), this._value = e !== void 0 ? e : this.originalValue;
       }
-      this.raw.announcedValue = this._value, this._actions?.triggerEager(this, this.value, this.originalValue), this.validate();
+      this.constructed(t), this.originalValue === void 0 && (this.originalValue = this._value), this.raw.announcedValue = this._value, this.boundActions?.triggerEager(this, this.value, this.originalValue), this.validate();
     });
   }
   get value() {
@@ -1681,9 +1832,17 @@ class M extends V {
   set value(t) {
     const e = this._value;
     !this.enabled || e === t || u((s) => {
-      s.touch(this), this._value = t, this.bumpValueVersion(), this._actions?.triggerEager(this, t, e), this.propagateValueChanged();
+      s.touch(this), this._value = t, this.bumpValueVersion(), this.boundActions?.triggerEager(this, t, e), this.propagateValueChanged();
     });
   }
+  /**
+   * The container that holds this field. A `List` holds rows and a row is a `Group`, so a field is never a `List`'s
+   * child and the link is a `Group` wherever there is one: `field.parent?.fields.other` is the sibling lookup, and
+   * it is typed here.
+   */
+  get parent() {
+    return super.parent;
+  }
   get touched() {
     return this.state.touched;
   }
@@ -1701,24 +1860,24 @@ class M extends V {
     return i.boundFrom(this, i.value, i.originalValue, e), i;
   }
 }
-const Ve = new M({ value: "EmptyField" }).registerAction(
-  new S(() => {
-    console.warn("Working with EmptyField! This should not happen");
-  })
-), ft = /* @__PURE__ */ new WeakMap();
-function H(n, t) {
-  return n?.label == null && n?.icon == null ? t : n;
+const mt = /* @__PURE__ */ new WeakMap();
+function bt(n) {
+  if (n != null)
+    return Object.values(n).some((t) => t != null) ? n : void 0;
 }
-class ye extends M {
+class Se extends et {
+  get [Symbol.toStringTag]() {
+    return "Action";
+  }
   init(t) {
     u(() => {
       if (this._value = { label: void 0, icon: void 0 }, t) {
-        const { value: e, originalValue: s, validators: i, actions: a, ...r } = t;
-        this.registerInitialActions([...i || [], ...a || []]), this.assignParams(r);
-        const o = H(e, this._value), l = Object.freeze({ label: s?.label, icon: s?.icon });
-        this._value = H(o, { ...l }), this.originalValue = H(l, o);
+        const { value: e, originalValue: s, validators: i, actions: r, ...a } = t;
+        this.registerInitialActions([...i || [], ...r || []]), this.assignParams(a);
+        const o = bt(e), l = bt(s);
+        o ? this._value = o : l && (this._value = { ...l }), l && (this.originalValue = Object.freeze({ ...l }));
       }
-      this.raw.announcedValue = this._value, this._actions?.triggerEager(this, this.value, this.originalValue), this.validate();
+      this.constructed(t), this.originalValue === void 0 && (this.originalValue = this._value), this.raw.announcedValue = this._value, this.boundActions?.triggerEager(this, this.value, this.originalValue), this.validate();
     });
   }
   /**
@@ -1752,8 +1911,8 @@ class ye extends M {
   }
   /** the counter behind `busy`, allocated for this action the first time it is asked for */
   get busyRuns() {
-    let t = ft.get(this);
-    return t || (t = Wt(0), ft.set(this, t)), t;
+    let t = mt.get(this);
+    return t || (t = Wt(0), mt.set(this, t)), t;
   }
   /** true from the moment execute() is called until the handler it ran has settled, however it settles */
   get busy() {
@@ -1773,20 +1932,20 @@ class ye extends M {
     const e = this.busyRuns;
     e.value++;
     try {
-      return await this.triggerAction(jt, t);
+      return await this.triggerAction(Nt, t);
     } finally {
       e.value--;
     }
   }
 }
-const Ce = /* @__PURE__ */ qt({
+const xe = /* @__PURE__ */ qt({
   __name: "messages-widget",
   props: {
     message: {},
     classes: {}
   },
   setup(n) {
-    const t = n, e = at("vue-markdown"), s = /* @__PURE__ */ new Set([
+    const t = n, e = lt("vue-markdown"), s = /* @__PURE__ */ new Set([
       "div",
       "span",
       "p",
@@ -1843,23 +2002,23 @@ const Ce = /* @__PURE__ */ qt({
       "dt",
       "dd"
     ]), i = () => {
-      if (typeof t.message == "string") return F("span", { class: t.classes }, t.message);
-      const a = [];
-      return t.message.forEach((r) => {
-        switch (r.componentName) {
+      if (typeof t.message == "string") return k("span", { class: t.classes }, t.message);
+      const r = [];
+      return t.message.forEach((a) => {
+        switch (a.componentName) {
           case "template":
-            a.push(F("div", { class: [t.classes, r.extraClasses] }, r.componentBody));
+            r.push(k("div", { class: [t.classes, a.extraClasses] }, a.componentBody));
             break;
           case "vue-markdown":
             if (typeof e == "string")
               console.warn(
                 "You are using markdown for messages-widget, but you haven't registered a vue-markdown component"
-              ), a.push(F("div", { class: [t.classes, r.extraClasses] }, r.componentBindings.source));
+              ), r.push(k("div", { class: [t.classes, a.extraClasses] }, a.componentBindings.source));
             else {
-              const o = r.componentBindings;
-              a.push(
-                F(e, {
-                  class: [t.classes, r.extraClasses, "df-messages-widget-markdown"],
+              const o = a.componentBindings;
+              r.push(
+                k(e, {
+                  class: [t.classes, a.extraClasses, "df-messages-widget-markdown"],
                   source: o.source,
                   options: o.options,
                   plugins: o.plugins
@@ -1868,23 +2027,23 @@ const Ce = /* @__PURE__ */ qt({
             }
             break;
           default:
-            a.push(
-              F(
-                s.has(r.componentName.toLowerCase()) ? r.componentName : at(r.componentName),
+            r.push(
+              k(
+                s.has(a.componentName.toLowerCase()) ? a.componentName : lt(a.componentName),
                 {
-                  class: [t.classes, r.extraClasses],
-                  ...r.componentBindings,
-                  ...r.componentBody ? { innerHTML: r.componentBody } : {}
+                  class: [t.classes, a.extraClasses],
+                  ...a.componentBindings,
+                  ...a.componentBody ? { innerHTML: a.componentBody } : {}
                 }
               )
             );
             break;
         }
-      }), a;
+      }), r;
     };
-    return (a, r) => (zt(), Ht(i));
+    return (r, a) => (zt(), Ht(i));
   }
-}), pt = /* @__PURE__ */ new WeakMap(), Ee = (n) => ({
+}), vt = /* @__PURE__ */ new WeakMap(), Ae = (n) => ({
   get(t, e, s) {
     return n(), Reflect.get(t, e, s);
   },
@@ -1907,7 +2066,10 @@ const Ce = /* @__PURE__ */ qt({
     throw new TypeError(`fields.${String(e)} cannot be deleted: use removeField() to take a member out`);
   }
 });
-class d extends V {
+class d extends y {
+  get [Symbol.toStringTag]() {
+    return "Group";
+  }
   get state() {
     return super.state;
   }
@@ -1916,15 +2078,15 @@ class d extends V {
   }
   _fields;
   constructor(t, e) {
-    if (super(be()), !d.isValidFields(t)) throw new Error("Invalid fields object provided");
+    if (super(Ee()), !d.isValidFields(t)) throw new Error("Invalid fields object provided");
     this._fields = /* @__PURE__ */ Object.create(null), u(() => {
-      if (Object.entries(t).forEach(([i, a]) => this.addField(i, a)), e) {
-        const { value: i, validators: a, actions: r, ...o } = e;
-        this.registerInitialActions([...a || [], ...r || []]), this.assignParams(o), i !== void 0 ? this.assignMembers(i) : this.originalValue !== void 0 && this.assignMembers(this.originalValue);
+      if (Object.entries(t).forEach(([i, r]) => this.addField(i, r)), e) {
+        const { value: i, validators: r, actions: a, ...o } = e;
+        this.registerInitialActions([...r || [], ...a || []]), this.assignParams(o), i !== void 0 ? this.assignMembers(i) : this.originalValue !== void 0 && this.assignMembers(this.originalValue);
       }
-      this.completeRecords();
+      this.completeRecords(), this.constructed(e);
       const s = this.value;
-      this.originalValue === void 0 && (this.originalValue = d.baseline(s)), this.raw.announcedValue = s, this._actions?.triggerEager(this, s, this.originalValue), this.validate();
+      this.originalValue === void 0 && (this.originalValue = d.baseline(s)), this.raw.announcedValue = s, this.boundActions?.triggerEager(this, s, this.originalValue), this.validate();
     });
   }
   /**
@@ -1992,15 +2154,15 @@ class d extends V {
   }
   static isValidFields(t) {
     function e(s) {
-      return s instanceof V;
+      return s instanceof y;
     }
     return typeof t == "object" && t !== null && Object.entries(t).every(([, s]) => e(s));
   }
   static createFromFormData(t) {
-    if (t instanceof V)
+    if (t instanceof y)
       throw new Error("data is already a Form structure, should be a simple object");
     return new d(
-      t == null ? {} : Object.fromEntries(Object.entries(t).map(([e, s]) => [e, new M({ value: s })]))
+      t == null ? {} : Object.fromEntries(Object.entries(t).map(([e, s]) => [e, new et({ value: s })]))
     );
   }
   field(t) {
@@ -2015,11 +2177,11 @@ class d extends V {
    * re-renders when a field is added or removed; what a member itself holds is tracked by that member.
    */
   get fields() {
-    let t = pt.get(this);
+    let t = vt.get(this);
     return t || (t = new Proxy(
       this._fields,
-      Ee(() => this.state.fieldNames.length)
-    ), pt.set(this, t)), t;
+      Ae(() => this.state.fieldNames.length)
+    ), vt.set(this, t)), t;
   }
   get members() {
     return this.raw.fieldNames.map((t) => this._fields[t]);
@@ -2028,11 +2190,11 @@ class d extends V {
     const t = this.valueVersion;
     if (this.raw.cachedValueVersion === t) return this.raw.cachedValue;
     const e = /* @__PURE__ */ Object.create(null);
-    Object.entries(this._fields).forEach(([i, a]) => {
-      const r = a.value;
-      (a.enabled || a instanceof d && !R(r)) && (e[i] = r);
+    Object.entries(this._fields).forEach(([i, r]) => {
+      const a = r.value;
+      (r.enabled || this.childComposesValue(r) && !F(a)) && (e[i] = a);
     });
-    const s = R(e) ? null : Object.freeze({ ...e });
+    const s = F(e) ? null : Object.freeze({ ...e });
     return this.raw.cachedValue = s, this.raw.cachedValueVersion = t, s;
   }
   /**
@@ -2060,12 +2222,12 @@ class d extends V {
   resetTo(t, e) {
     const s = t;
     u((i) => {
-      i.touch(this), this.errors.length && (this.errors = []), Object.entries(this._fields).forEach(([r, o]) => {
+      i.touch(this), this.errors.length && (this.errors = []), Object.entries(this._fields).forEach(([a, o]) => {
         let l;
-        e === null ? l = null : e !== void 0 && Object.hasOwn(e, r) && (l = e[r]), this.resetChild(o, s.field(r) ?? o, l);
+        e === null ? l = null : e !== void 0 && Object.hasOwn(e, a) && (l = e[a]), this.resetChild(o, s.field(a) ?? o, l);
       });
-      const a = this.value;
-      this.raw.announcedValue = a, this.originalValue = d.baseline(a), super.validate(!0);
+      const r = this.value;
+      this.raw.announcedValue = r, this.originalValue = d.baseline(r), super.validate(!0);
     });
   }
   get touched() {
@@ -2119,19 +2281,32 @@ class d extends V {
       t && Object.values(this._fields).forEach((e) => e.validate(!0)), super.validate(t);
     });
   }
+  /**
+   * States that `res` was built from the members handed to it. A subclass whose constructor takes something other
+   * than `(fields, params)` - one that composes its own members and passes them to super - never sees them, and
+   * would answer with a binding carrying the declaration's data instead of the record's. That is a difference no
+   * reader would find, so it is refused here rather than returned.
+   */
+  static assertTookFields(t, e, s) {
+    const i = Object.entries(e), r = t.raw.fieldNames;
+    if (!(i.length === r.length && i.every(([a, o]) => t._fields[a] === o)))
+      throw new TypeError(
+        `${s}.bind() built an element that did not take the members it was given, so the binding would carry the declaration's data. A subclass whose constructor does not take (fields, params) has to override bind() and construct itself.`
+      );
+  }
   bind(t, e) {
     const s = /* @__PURE__ */ Object.create(null);
-    Object.entries(this._fields).forEach(([a, r]) => {
-      s[a] = r.bind();
+    Object.entries(this._fields).forEach(([a, o]) => {
+      s[a] = o.bind();
     });
-    const i = new d(s, {
+    const i = this.constructor, r = new i(s, {
       // data is what the caller supplied, and undefined is not supplied; an explicit null is, and clears
       value: t !== void 0 ? t : this.value,
       ...e && "originalValue" in e ? { originalValue: e.originalValue } : {},
       enabled: e?.enabled ?? this.enabled,
       visibility: e?.visibility ?? this.visibility
     });
-    return i.boundFrom(this, i.raw.announcedValue, i.originalValue, e), i;
+    return d.assertTookFields(r, s, this.constructor.name), r.boundFrom(this, r.raw.announcedValue, r.originalValue, e), r;
   }
   /**
    * A record need not name every member: a key it leaves out is taken from the declaration, the same way a member
@@ -2141,7 +2316,10 @@ class d extends V {
     return super.rebind(t);
   }
 }
-class A extends V {
+class _ extends y {
+  get [Symbol.toStringTag]() {
+    return "List";
+  }
   get state() {
     return super.state;
   }
@@ -2150,12 +2328,12 @@ class A extends V {
   }
   _itemTemplate;
   constructor(t, e) {
-    super(we()), this._itemTemplate = t, u(() => {
+    super(Ce()), this._itemTemplate = t, u(() => {
       if (e) {
-        const { value: s, validators: i, actions: a, ...r } = e;
-        this.registerInitialActions([...i || [], ...a || []]), this.assignParams(r), s != null && this.setValueInternal(s);
+        const { value: s, validators: i, actions: r, ...a } = e;
+        this.registerInitialActions([...i || [], ...r || []]), this.assignParams(a), s !== void 0 ? this.setValueInternal(s) : this.originalValue !== void 0 && this.setValueInternal(this.originalValue);
       }
-      this.originalValue === void 0 && (this.originalValue = A.baseline(this.value)), this.raw.announcedValue = this.value, this._actions?.triggerEager(this, this.value, this.originalValue), this.validate();
+      this.constructed(e), this.originalValue === void 0 && (this.originalValue = _.baseline(this.value)), this.raw.announcedValue = this.value, this.boundActions?.triggerEager(this, this.value, this.originalValue), this.validate();
     });
   }
   /** The row array is copied as well: a rollback puts back the set the list held, not the array it went on to hold. */
@@ -2188,30 +2366,32 @@ class A extends V {
   /** True where `next` is a different set of rows than `previous`: another count, or another row at a position. */
   static rowsDiffer(t, e) {
     const s = t ?? [], i = e ?? [];
-    return s.length !== i.length || s.some((a, r) => a !== i[r]);
+    return s.length !== i.length || s.some((r, a) => r !== i[a]);
   }
   setValueInternal(t) {
+    if (t != null && !Array.isArray(t))
+      throw new TypeError("Invalid value provided: a list takes an array of rows, or null to empty it");
     u((e) => {
       e.touch(this);
       const s = this.raw.rows;
       if (t == null)
         this.releaseRows(), this.state.rows = null;
-      else if (Array.isArray(t)) {
-        const i = this.state.rows ?? [], a = new Array(t.length);
-        for (let r = 0; r < t.length; r++) {
-          const o = t[r], l = i[r];
-          l && this._itemTemplate && !(o instanceof d) ? (this.resetChild(l, this._itemTemplate, o), a[r] = l) : (l && this.releaseChild(l), a[r] = this.processSetValueItem(o));
+      else {
+        const i = this.state.rows ?? [], r = new Array(t.length);
+        for (let a = 0; a < t.length; a++) {
+          const o = t[a], l = i[a];
+          l && this._itemTemplate && !(o instanceof d) ? (this.resetChild(l, this._itemTemplate, o), r[a] = l) : (l && this.releaseChild(l), r[a] = this.processSetValueItem(o));
         }
-        for (let r = t.length; r < i.length; r++) this.releaseChild(i[r]);
-        this.state.rows = a;
+        for (let a = t.length; a < i.length; a++) this.releaseChild(i[a]);
+        this.state.rows = r;
       }
-      A.rowsDiffer(s, this.raw.rows) && this.rowsChanged(), this.bumpValueVersion();
+      _.rowsDiffer(s, this.raw.rows) && this.rowsChanged(), this.bumpValueVersion();
     });
   }
   get value() {
     const t = this.valueVersion;
     if (this.raw.cachedValueVersion === t) return this.raw.cachedValue;
-    const e = this.state.rows?.map((i) => i.value), s = R(e) ? null : Object.freeze(e);
+    const e = this.state.rows?.map((i) => i.value), s = F(e) ? null : Object.freeze(e);
     return this.raw.cachedValue = s, this.raw.cachedValueVersion = t, s;
   }
   set value(t) {
@@ -2227,7 +2407,7 @@ class A extends V {
     u((s) => {
       s.touch(this), this.errors.length && (this.errors = []), this.setValueInternal(e === void 0 ? t.value : e);
       const i = this.value;
-      this.raw.announcedValue = i, this.originalValue = A.baseline(i), super.validate(!0);
+      this.raw.announcedValue = i, this.originalValue = _.baseline(i), super.validate(!0);
     });
   }
   get touched() {
@@ -2241,14 +2421,18 @@ class A extends V {
     });
   }
   bind(t, e) {
-    const s = new A(this._itemTemplate?.bind(), {
+    const s = this._itemTemplate?.bind(), i = this.constructor, r = new i(s, {
       // data is what the caller supplied, and undefined is not supplied; an explicit null is, and clears
       value: [...(t !== void 0 ? t : this.value) ?? []],
       ...e && "originalValue" in e ? { originalValue: e.originalValue } : {},
       enabled: e?.enabled ?? this.enabled,
       visibility: e?.visibility ?? this.visibility
     });
-    return s.boundFrom(this, s.value, s.originalValue, e), s;
+    if (r._itemTemplate !== s)
+      throw new TypeError(
+        `${this.constructor.name}.bind() built a list that did not take the item template it was given, so the binding would carry the declaration's rows. A subclass whose constructor does not take (itemTemplate, params) has to override bind() and construct itself.`
+      );
+    return r.boundFrom(this, r.value, r.originalValue, e), r;
   }
   /**
    * Records that a row changed its value, so that the transaction in progress works out at commit what this
@@ -2331,18 +2515,18 @@ class A extends V {
       if (this.state.rows == null || t < 0 || this.state.rows.length <= t) return;
       s.touch(this);
       const i = this.state.rows.splice(t, 1)?.[0];
-      i && (this.releaseChild(i), this.rowsChanged(), this.bumpValueVersion(), e = i, s.recordStructural(this, { actionClass: Nt, item: e, index: t }), this.propagateValueChanged(!0));
+      i && (this.releaseChild(i), this.rowsChanged(), this.bumpValueVersion(), e = i, s.recordStructural(this, { actionClass: Bt, item: e, index: t }), this.propagateValueChanged(!0));
     }), e;
   }
   insert(t, e) {
     let s = 0;
     return u((i) => {
       for (i.touch(this), this.state.rows == null && (this.state.rows = []), s = e < 0 ? Math.max(this.state.rows.length + e, 0) : e; this.state.rows.length < s; ) {
-        const r = this.createPaddingItem(), o = this.state.rows.push(r) - 1;
-        this.bumpValueVersion(), i.recordStructural(this, { actionClass: K, item: r, index: o });
+        const a = this.createPaddingItem(), o = this.state.rows.push(a) - 1;
+        this.bumpValueVersion(), i.recordStructural(this, { actionClass: Y, item: a, index: o });
       }
-      const a = this.processSetValueItem(t);
-      this.state.rows.splice(s, 0, a), i.recordStructural(this, { actionClass: K, item: a, index: s }), this.rowsChanged(), this.bumpValueVersion(), this.propagateValueChanged(!0);
+      const r = this.processSetValueItem(t);
+      this.state.rows.splice(s, 0, r), i.recordStructural(this, { actionClass: Y, item: r, index: s }), this.rowsChanged(), this.bumpValueVersion(), this.propagateValueChanged(!0);
     }), s;
   }
   /** Drops every row this list holds out of its tally, so a row that changes its verdict later is not counted. */
@@ -2356,14 +2540,14 @@ class A extends V {
     });
   }
 }
-class xe extends g {
+class Ie extends f {
   constructor(t, e, s) {
-    const i = (a, r, o) => {
-      this.comparisonState(o).oldValue = r;
+    const i = (r, a, o) => {
+      this.comparisonState(o).oldValue = a;
       const l = this.resolve(o);
-      return l ? (this.listenOn(l), this.isValidComparison(h(a), h(l.value)) ? null : [
-        new f(
-          this.replacePlaceholders(s, { newValue: a, oldValue: r, field: o, otherField: l }),
+      return l ? (this.listenOn(l), this.isValidComparison(h(r), h(l.value)) ? null : [
+        new g(
+          this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, otherField: l }),
           "",
           "compare-to"
         )
@@ -2395,7 +2579,7 @@ class xe extends g {
   /** The field `field` is compared against, within the record `field` belongs to. */
   resolve(t) {
     const e = this.otherField;
-    return typeof e == "function" ? e(t) ?? void 0 : typeof e == "string" ? se(e, t) : G(e, x(t));
+    return typeof e == "function" ? e(t) ?? void 0 : typeof e == "string" ? ae(e, t) : tt(e, V(t));
   }
   /**
    * Makes a change of `other` re-run this comparison. The listener re-runs it over the fields of the record the
@@ -2404,11 +2588,11 @@ class xe extends g {
    */
   listenOn(t) {
     this.listening.has(t) || this.listening.has(t.declaration) || (this.listening.add(t), t.registerAction(
-      new S((e, s, i, a) => {
-        s(e, i, a);
-        const r = x(e);
+      new T((e, s, i, r) => {
+        s(e, i, r);
+        const a = V(e);
         this.declarations.forEach(
-          (o) => Tt(o, r).forEach((l) => {
+          (o) => kt(o, a).forEach((l) => {
             this.registrations.has(l) && this.execute(l, () => null, l.value, this.comparisonState(l).oldValue);
           })
         );
@@ -2428,59 +2612,59 @@ class xe extends g {
     super.unregisterFrom(t), this.registrations.delete(t);
   }
 }
-class Se extends g {
+class Te extends f {
   constructor(t, e) {
-    const s = e || m("Must be one of [**{allowedAsText}**]"), i = () => {
+    const s = e || b("Must be one of [**{allowedAsText}**]"), i = () => {
       const o = h(t);
       return typeof o == "function" ? o() : o;
-    }, a = (o) => {
+    }, r = (o) => {
       const l = o.join(", ");
-      return l.length <= 60 ? l : Mt(l, { length: 40, separator: ", ", omission: `... (${o.length} items total)` });
-    }, r = (o, l, w) => {
-      const b = i();
-      return b.includes(h(o)) ? null : [
-        new f(
+      return l.length <= 60 ? l : Xt(l, { length: 40, separator: ", ", omission: `... (${o.length} items total)` });
+    }, a = (o, l, v) => {
+      const p = i();
+      return p.includes(h(o)) ? null : [
+        new g(
           this.replacePlaceholders(s, {
             newValue: o,
             oldValue: l,
-            field: w,
-            allowedValues: b,
-            allowedAsText: a(b)
+            field: v,
+            allowedValues: p,
+            allowedAsText: r(p)
           }),
           "",
           "in-allowed-values"
         )
       ];
     };
-    super(r);
+    super(a);
   }
 }
-function Ie(n) {
-  return n == null ? 0 : vt(n) || C(n) ? n.length : bt(n) && Object.getPrototypeOf(n) === Object.prototype ? Object.keys(n).length : String(n).length;
+function Oe(n) {
+  return n == null ? 0 : yt(n) || C(n) ? n.length : Et(n) && Object.getPrototypeOf(n) === Object.prototype ? Object.keys(n).length : String(n).length;
 }
-function mt(n) {
-  return typeof n == "object" && n !== null && !wt(n) && !(n instanceof String) && !("componentName" in n);
+function wt(n) {
+  return typeof n == "object" && n !== null && !Vt(n) && !(n instanceof String) && !("componentName" in n);
 }
-class Ae extends g {
+class ke extends f {
   constructor(t, e) {
-    const s = mt(t) ? void 0 : t, i = (mt(t) ? t : e)?.trim ?? !0, a = s || m("Please enter a value"), r = (o, l, w) => {
-      const b = h(o);
-      return Ie(i && C(b) ? b.trim() : b) === 0 ? [
-        new f(
-          this.replacePlaceholders(a, { newValue: o, oldValue: l, field: w }),
+    const s = wt(t) ? void 0 : t, i = (wt(t) ? t : e)?.trim ?? !0, r = s || b("Please enter a value"), a = (o, l, v) => {
+      const p = h(o);
+      return Oe(i && C(p) ? p.trim() : p) === 0 ? [
+        new g(
+          this.replacePlaceholders(r, { newValue: o, oldValue: l, field: v }),
           "",
           "required"
         )
       ] : null;
     };
-    super(r);
+    super(a);
   }
 }
-class Te extends g {
+class Re extends f {
   constructor(t, e) {
-    const s = e || m("Value must be larger or equal to **{minValue}**"), i = (a, r, o) => a < t || a === void 0 ? [
-      new f(
-        this.replacePlaceholders(s, { newValue: a, oldValue: r, field: o, minValue: t }),
+    const s = e || b("Value must be larger or equal to **{minValue}**"), i = (r, a, o) => r < t || r === void 0 ? [
+      new g(
+        this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, minValue: t }),
         "",
         "min"
       )
@@ -2488,11 +2672,11 @@ class Te extends g {
     super(i);
   }
 }
-class _e extends g {
+class _e extends f {
   constructor(t, e) {
-    const s = e || m("Value must be less than or equal to **{maxValue}**"), i = (a, r, o) => a > t || a === void 0 ? [
-      new f(
-        this.replacePlaceholders(s, { newValue: a, oldValue: r, field: o, maxValue: t }),
+    const s = e || b("Value must be less than or equal to **{maxValue}**"), i = (r, a, o) => r > t || r === void 0 ? [
+      new g(
+        this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, maxValue: t }),
         "",
         "max"
       )
@@ -2500,26 +2684,26 @@ class _e extends g {
     super(i);
   }
 }
-class Oe extends g {
+class Fe extends f {
   constructor(t, e, s) {
-    const i = s || m("Value must be between **{minValue}** and **{maxValue}**"), a = (r, o, l) => r < t || r > e || r === void 0 ? [
-      new f(
-        this.replacePlaceholders(i, { newValue: r, oldValue: o, field: l, minValue: t, maxValue: e }),
+    const i = s || b("Value must be between **{minValue}** and **{maxValue}**"), r = (a, o, l) => a < t || a > e || a === void 0 ? [
+      new g(
+        this.replacePlaceholders(i, { newValue: a, oldValue: o, field: l, minValue: t, maxValue: e }),
         "",
         "range"
       )
     ] : null;
-    super(a);
+    super(r);
   }
 }
-function tt(n) {
-  return n == null ? 0 : vt(n) || C(n) ? n.length : bt(n) && Object.getPrototypeOf(n) === Object.prototype ? Object.keys(n).length : String(n).length;
+function st(n) {
+  return n == null ? 0 : yt(n) || C(n) ? n.length : Et(n) && Object.getPrototypeOf(n) === Object.prototype ? Object.keys(n).length : String(n).length;
 }
-class Fe extends g {
+class Pe extends f {
   constructor(t, e) {
-    const s = e || m("Length must be larger or equal to **{minLength}**"), i = (a, r, o) => tt(a) < t ? [
-      new f(
-        this.replacePlaceholders(s, { newValue: a, oldValue: r, field: o, minLength: t }),
+    const s = e || b("Length must be larger or equal to **{minLength}**"), i = (r, a, o) => st(r) < t ? [
+      new g(
+        this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, minLength: t }),
         "",
         "min-length"
       )
@@ -2527,11 +2711,11 @@ class Fe extends g {
     super(i);
   }
 }
-class Re extends g {
+class je extends f {
   constructor(t, e) {
-    const s = e || m("Length must be less than or equal to **{maxLength}**"), i = (a, r, o) => tt(a) > t ? [
-      new f(
-        this.replacePlaceholders(s, { newValue: a, oldValue: r, field: o, maxLength: t }),
+    const s = e || b("Length must be less than or equal to **{maxLength}**"), i = (r, a, o) => st(r) > t ? [
+      new g(
+        this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, maxLength: t }),
         "",
         "max-length"
       )
@@ -2539,26 +2723,26 @@ class Re extends g {
     super(i);
   }
 }
-class Pe extends g {
+class Ne extends f {
   constructor(t, e, s) {
-    const i = s || m("Length must be between **{minLength}** and **{maxLength}**"), a = (r, o, l) => {
-      const w = tt(r);
-      return w < t || w > e ? [
-        new f(
-          this.replacePlaceholders(i, { newValue: r, oldValue: o, field: l, minLength: t, maxLength: e }),
+    const i = s || b("Length must be between **{minLength}** and **{maxLength}**"), r = (a, o, l) => {
+      const v = st(a);
+      return v < t || v > e ? [
+        new g(
+          this.replacePlaceholders(i, { newValue: a, oldValue: o, field: l, minLength: t, maxLength: e }),
           "",
           "range-length"
         )
       ] : null;
     };
-    super(a);
+    super(r);
   }
 }
-class je extends g {
+class Be extends f {
   constructor(t, e) {
-    const s = e || m('Value must match pattern "**{pattern}**"'), i = (a, r, o) => t.test(String(h(a))) ? null : [
-      new f(
-        this.replacePlaceholders(s, { newValue: a, oldValue: r, field: o, pattern: t }),
+    const s = e || b('Value must match pattern "**{pattern}**"'), i = (r, a, o) => t.test(String(h(r))) ? null : [
+      new g(
+        this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, pattern: t }),
         "",
         "pattern"
       )
@@ -2566,100 +2750,98 @@ class je extends g {
     super(i);
   }
 }
-const Ne = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const De = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  CompareTo: xe,
-  InAllowedValues: Se,
-  LengthInRange: Pe,
-  MaxLength: Re,
+  CompareTo: Ie,
+  InAllowedValues: Te,
+  LengthInRange: Ne,
+  MaxLength: je,
   MaxValue: _e,
-  MinLength: Fe,
-  MinValue: Te,
-  Pattern: je,
-  Required: Ae,
-  Validator: g,
-  ValueInRange: Oe
-}, Symbol.toStringTag, { value: "Module" })), Le = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  MinLength: Pe,
+  MinValue: Re,
+  Pattern: Be,
+  Required: ke,
+  Validator: f,
+  ValueInRange: Fe
+}, Symbol.toStringTag, { value: "Module" })), $e = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  AbortEventHandlingException: Vt,
-  Action: ye,
-  ActionsMap: D,
-  ConditionalEnabledAction: re,
-  ConditionalStatementAction: L,
-  ConditionalValueAction: ae,
-  ConditionalVisibilityAction: ne,
-  DisplayMode: _,
-  EmptyField: Ve,
-  EnabledChangedAction: Ot,
-  EnabledChangingAction: _t,
-  ExecuteAction: jt,
-  Field: M,
-  FieldActionBase: p,
-  FieldBase: V,
+  AbortEventHandlingException: P,
+  Action: Se,
+  ActionsMap: M,
+  ConditionalEnabledAction: ue,
+  ConditionalStatementAction: U,
+  ConditionalValueAction: ce,
+  ConditionalVisibilityAction: le,
+  DisplayMode: I,
+  EnabledChangedAction: _t,
+  EnabledChangingAction: Rt,
+  ExecuteAction: Nt,
+  Field: et,
+  FieldActionBase: m,
+  FieldBase: y,
   Group: d,
-  List: A,
-  ListItemAddedAction: K,
-  ListItemRemovedAction: Nt,
-  MdString: P,
-  MessagesWidget: Ce,
+  List: _,
+  ListItemAddedAction: Y,
+  ListItemRemovedAction: Bt,
+  MdString: j,
+  MessagesWidget: xe,
   Operator: c,
-  RenderableValue: Zt,
-  Statement: v,
+  RenderableValue: se,
+  Statement: w,
   ValidChangedAction: Ft,
-  ValidationError: Z,
-  ValidationErrorRenderContent: f,
-  ValidationErrorText: Jt,
-  Validator: g,
-  Validators: Ne,
-  ValueChangedAction: S,
-  VisibilityChangedAction: Pt,
-  VisibilityChangingAction: Rt,
-  buildErrorMessage: m,
-  isCallableFunction: B,
-  isSimpleComponentDef: J,
-  transaction: Y
+  ValidationError: G,
+  ValidationErrorRenderContent: g,
+  ValidationErrorText: ee,
+  Validators: De,
+  ValueChangedAction: T,
+  VisibilityChangedAction: jt,
+  VisibilityChangingAction: Pt,
+  buildErrorMessage: b,
+  defaultDisplayMode: Kt,
+  isCallableFunction: L,
+  isSimpleComponentDef: Z,
+  transaction: J
 }, Symbol.toStringTag, { value: "Module" }));
 export {
-  Vt as AbortEventHandlingException,
-  ye as Action,
-  D as ActionsMap,
-  re as ConditionalEnabledAction,
-  L as ConditionalStatementAction,
-  ae as ConditionalValueAction,
-  ne as ConditionalVisibilityAction,
-  _ as DisplayMode,
-  Ve as EmptyField,
-  Ot as EnabledChangedAction,
-  _t as EnabledChangingAction,
-  jt as ExecuteAction,
-  M as Field,
-  p as FieldActionBase,
-  V as FieldBase,
+  P as AbortEventHandlingException,
+  Se as Action,
+  M as ActionsMap,
+  ue as ConditionalEnabledAction,
+  U as ConditionalStatementAction,
+  ce as ConditionalValueAction,
+  le as ConditionalVisibilityAction,
+  I as DisplayMode,
+  _t as EnabledChangedAction,
+  Rt as EnabledChangingAction,
+  Nt as ExecuteAction,
+  et as Field,
+  m as FieldActionBase,
+  y as FieldBase,
   d as Group,
-  A as List,
-  K as ListItemAddedAction,
-  Nt as ListItemRemovedAction,
-  P as MdString,
-  Ce as MessagesWidget,
+  _ as List,
+  Y as ListItemAddedAction,
+  Bt as ListItemRemovedAction,
+  j as MdString,
+  xe as MessagesWidget,
   c as Operator,
-  Zt as RenderableValue,
-  v as Statement,
+  se as RenderableValue,
+  w as Statement,
   Ft as ValidChangedAction,
-  Z as ValidationError,
-  f as ValidationErrorRenderContent,
-  Jt as ValidationErrorText,
-  g as Validator,
-  Ne as Validators,
-  S as ValueChangedAction,
-  Pt as VisibilityChangedAction,
-  Rt as VisibilityChangingAction,
-  m as buildErrorMessage,
-  Le as default,
-  De as forms,
-  Kt as getConfig,
-  B as isCallableFunction,
-  J as isSimpleComponentDef,
-  Yt as setConfig,
-  Y as transaction
+  G as ValidationError,
+  g as ValidationErrorRenderContent,
+  ee as ValidationErrorText,
+  De as Validators,
+  T as ValueChangedAction,
+  jt as VisibilityChangedAction,
+  Pt as VisibilityChangingAction,
+  b as buildErrorMessage,
+  $e as default,
+  Kt as defaultDisplayMode,
+  Ue as forms,
+  Gt as getConfig,
+  L as isCallableFunction,
+  Z as isSimpleComponentDef,
+  te as setConfig,
+  J as transaction
 };
 //# sourceMappingURL=dynamicforms-vue-forms.js.map