@dynamicforms/vue-forms 0.12.0 → 0.16.0

package/dist/dynamicforms-vue-forms.js

@@ -1,97 +1,69 @@
-var Gt = Object.defineProperty, Yt = Object.defineProperties;
-var Jt = Object.getOwnPropertyDescriptors;
-var W = Object.getOwnPropertySymbols;
-var ft = Object.prototype.hasOwnProperty, pt = Object.prototype.propertyIsEnumerable;
-var mt = (n) => {
-  throw TypeError(n);
-};
-var K = (n, e, t) => e in n ? Gt(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, p = (n, e) => {
-  for (var t in e || (e = {}))
-    ft.call(e, t) && K(n, t, e[t]);
-  if (W)
-    for (var t of W(e))
-      pt.call(e, t) && K(n, t, e[t]);
-  return n;
-}, C = (n, e) => Yt(n, Jt(e));
-var k = (n, e) => {
-  var t = {};
-  for (var s in n)
-    ft.call(n, s) && e.indexOf(s) < 0 && (t[s] = n[s]);
-  if (n != null && W)
-    for (var s of W(n))
-      e.indexOf(s) < 0 && pt.call(n, s) && (t[s] = n[s]);
-  return t;
-};
-var d = (n, e, t) => K(n, typeof e != "symbol" ? e + "" : e, t), bt = (n, e, t) => e.has(n) || mt("Cannot " + t);
-var l = (n, e, t) => (bt(n, e, "read from private field"), t ? t.call(n) : e.get(n)), Z = (n, e, t) => e.has(n) ? mt("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(n) : e.set(n, t), tt = (n, e, t, s) => (bt(n, e, "write to private field"), s ? s.call(n, t) : e.set(n, t), t);
-var vt = (n, e, t) => new Promise((s, i) => {
-  var r = (u) => {
-    try {
-      o(t.next(u));
-    } catch (c) {
-      i(c);
-    }
-  }, a = (u) => {
-    try {
-      o(t.throw(u));
-    } catch (c) {
-      i(c);
-    }
-  }, o = (u) => u.done ? s(u.value) : Promise.resolve(u.value).then(r, a);
-  o((t = t.apply(n, e)).next());
-});
-import { isEqual as nt, isEmpty as L, isBoolean as Kt, isString as j, truncate as Zt, isArray as At, isObject as _t } from "lodash-es";
-import { unref as b, computed as Tt, isRef as te, reactive as ee, ref as se, defineComponent as ie, resolveComponent as Vt, openBlock as ne, createBlock as re, h as R } from "vue";
-var P = /* @__PURE__ */ ((n) => (n[n.SUPPRESS = 1] = "SUPPRESS", n[n.HIDDEN = 5] = "HIDDEN", n[n.INVISIBLE = 8] = "INVISIBLE", n[n.FULL = 10] = "FULL", n))(P || {});
-const wt = 10, yt = new Set(
-  Object.values(P).filter((n) => typeof n == "number")
+import { computed as Y, unref as h, isRef as Vt, reactive as Ut, watch as $t, ref as Wt, defineComponent as qt, resolveComponent as ut, openBlock as zt, createBlock as Ht, h as k } from "vue";
+import { isEqual as R, isEmpty as _, 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, ct = 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 e(i) {
-    return i.toUpperCase() === "SUPPRESS" ? 1 : i.toUpperCase() === "HIDDEN" ? 5 : i.toUpperCase() === "INVISIBLE" ? 8 : wt;
-  }
-  n.fromString = e;
   function t(i) {
-    const r = typeof i == "number" ? i : n.fromString(i);
-    return yt.has(r) ? r : wt;
+    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) {
+    if (typeof i == "number") {
+      if (ct.has(i)) return i;
+      throw z(i);
+    }
+    if (typeof i != "string") throw z(i);
+    return n.fromString(i);
   }
-  n.fromAny = t;
+  n.fromAny = e;
   function s(i) {
-    const r = typeof i == "number" ? i : n.fromString(i);
-    return yt.has(r);
+    return typeof i == "number" ? ct.has(i) : typeof i == "string" ? Yt.has(i.toUpperCase()) : !1;
   }
   n.isDefined = s;
-})(P || (P = {}));
-Object.freeze(P);
-const N = P;
-class y {
-  constructor(e) {
-    d(this, "executorFn");
-    /**
-     * What this action remembers about one of the elements it serves. An action instance is shared - a `List` row
-     * carries the instances the item template carries - so anything an action holds about the element it last ran
-     * over belongs to that element rather than to the action: a verdict, a sequence number, a listener it installed.
-     * The keys are weak, so what an action remembers about a row is released with the row.
-     */
-    d(this, "states", /* @__PURE__ */ new WeakMap());
-    this.executorFn = e;
-  }
+})(x || (x = {}));
+Object.freeze(x);
+const I = x;
+class m {
   static get classIdentifier() {
     throw new Error("classIdentifier must be declared");
   }
   get classIdentifier() {
     return this.constructor.classIdentifier;
   }
+  executorFn;
+  /**
+   * What this action remembers about one of the elements it serves. An action instance is shared - a `List` row
+   * carries the instances the item template carries - so anything an action holds about the element it last ran
+   * over belongs to that element rather than to the action: a verdict, a sequence number, a listener it installed.
+   * The keys are weak, so what an action remembers about a row is released with the row.
+   */
+  states = /* @__PURE__ */ new WeakMap();
+  constructor(t) {
+    this.executorFn = t;
+  }
   /**
    * This action's state for `key`, created by `init` the first time it is asked for. The key is the element the
    * action is running over, or the record that element belongs to where what is remembered is a fact about the
    * whole record.
    */
-  state(e, t) {
-    return this.states.has(e) || this.states.set(e, t()), this.states.get(e);
+  state(t, e) {
+    return this.states.has(t) || this.states.set(t, e()), this.states.get(t);
   }
-  execute(e, t, ...s) {
-    return this.executorFn(e, t, ...s);
+  execute(t, e, ...s) {
+    return this.executorFn(t, e, ...s);
   }
   get eager() {
     return !1;
@@ -102,7 +74,7 @@ class y {
    * copy as it does.
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  boundToBinding(e) {
+  boundToBinding(t) {
   }
   /**
    * Announces that `binding` no longer holds this action, and takes back what running it left there. It names one
@@ -111,89 +83,95 @@ class y {
    * registration and what this took back both back.
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  unregisterFrom(e) {
+  unregisterFrom(t) {
   }
 }
-class Ot extends Error {
+class P extends Error {
 }
-const Ft = /* @__PURE__ */ Symbol("ValueChangedAction");
-class O extends y {
-  constructor(e) {
-    super(e);
+const Ct = /* @__PURE__ */ Symbol("ValueChangedAction");
+class T extends m {
+  constructor(t) {
+    super(t);
   }
   static get classIdentifier() {
-    return Ft;
-  }
-  execute(e, t, s, i) {
-    return super.execute(e, t, s, i);
-  }
-}
-const $ = /* @__PURE__ */ Symbol("Transaction.capture"), jt = /* @__PURE__ */ Symbol("Transaction.restore"), Pt = /* @__PURE__ */ Symbol("Transaction.announceValue"), Nt = /* @__PURE__ */ Symbol("Transaction.settleValidity");
-function Et(n) {
-  let e = 0, t = n.parent;
-  for (; t; )
-    e++, t = t.parent;
-  return e;
-}
-class ae {
-  constructor() {
-    d(this, "participants", /* @__PURE__ */ new Map());
-    /** what a rollback has to put back beyond the state slots, newest last */
-    d(this, "undo", []);
-    /** true once the transaction has been unwound, which is what tells a run started inside it to say nothing */
-    d(this, "unwound", !1);
-    /** the depth the announcement in progress is working at, -1 while none is */
-    d(this, "passDepth", -1);
-    /** set while a pass is running and an element it has already passed the depth of gets enrolled */
-    d(this, "restartPass", !1);
+    return Ct;
   }
+  execute(t, e, s, i) {
+    return super.execute(t, e, s, i);
+  }
+}
+const O = /* @__PURE__ */ Symbol("Transaction.capture"), St = /* @__PURE__ */ Symbol("Transaction.restore"), xt = /* @__PURE__ */ Symbol("Transaction.announceValue"), At = /* @__PURE__ */ Symbol("Transaction.settleValidity");
+function ht(n) {
+  let t = 0, e = n.parent;
+  for (; e; )
+    t++, e = e.parent;
+  return t;
+}
+class Jt {
+  participants = /* @__PURE__ */ new Map();
+  /** what a rollback has to put back beyond the state slots, newest last */
+  undo = [];
+  /** what the commit has to do once the change stands, in the order it was handed in */
+  settled = [];
+  /** true once the transaction has been unwound, which is what tells a run started inside it to say nothing */
+  unwound = !1;
+  /** the depth the announcement in progress is working at, -1 while none is */
+  passDepth = -1;
+  /** set while a pass is running and an element it has already passed the depth of gets enrolled */
+  restartPass = !1;
   /** true for a transaction that was rolled back rather than committed */
   get rolledBack() {
     return this.unwound;
   }
-  participant(e) {
-    let t = this.participants.get(e);
-    return t || (t = { element: e, valueDirty: !1, forceValue: !1, validityDirty: !1 }, this.participants.set(e, t)), t;
+  participant(t) {
+    let e = this.participants.get(t);
+    return e || (e = { element: t, valueDirty: !1, forceValue: !1, validityDirty: !1 }, this.participants.set(t, e)), e;
   }
   /**
    * Records the state of an element the first time the transaction modifies it. The whole of the mutable state
    * goes into the snapshot rather than the part being written: a rollback that restored some of it would leave
    * the element in a state the form never held.
    */
-  touch(e) {
-    const t = this.participant(e);
-    t.snapshot || (t.snapshot = e[$]());
+  touch(t) {
+    const e = this.participant(t);
+    e.snapshot || (e.snapshot = t[O]());
   }
   /** Enrols an element as one whose value the commit has to announce. `force` skips the comparison. */
-  markValueChanged(e, t) {
-    const s = this.participant(e);
-    s.valueDirty = !0, t && (s.forceValue = !0), this.noteDepth(e);
+  markValueChanged(t, e) {
+    const s = this.participant(t);
+    s.valueDirty = !0, e && (s.forceValue = !0), this.noteDepth(t);
   }
   /** Enrols an element as one whose verdict the commit has to re-form. */
-  markValidityDirty(e) {
-    this.participant(e).validityDirty = !0, this.noteDepth(e);
+  markValidityDirty(t) {
+    this.participant(t).validityDirty = !0, this.noteDepth(t);
   }
   /**
    * Queues an event that states an operation rather than a state. Added and removed items have no net over a
    * transaction, so they are neither compared nor coalesced: the commit emits them in the order they happened.
    */
-  recordStructural(e, t) {
-    var i;
-    const s = this.participant(e);
-    ((i = s.structural) != null ? i : s.structural = []).push(t), this.noteDepth(e);
+  recordStructural(t, e) {
+    const s = this.participant(t);
+    (s.structural ??= []).push(e), this.noteDepth(t);
   }
   /** True where the commit still owes this element a value announcement. */
-  willAnnounceValue(e) {
-    var t, s;
-    return (s = (t = this.participants.get(e)) == null ? void 0 : t.valueDirty) != null ? s : !1;
+  willAnnounceValue(t) {
+    return this.participants.get(t)?.valueDirty ?? !1;
   }
   /**
    * Registers what a rollback has to put back beyond the element's state slots. The snapshot covers the slots,
    * which is everything an ordinary write touches; an operation that replaces something else the element carries
    * hands its own undo in here rather than making every snapshot carry the thing.
    */
-  whenRolledBack(e) {
-    this.undo.push(e);
+  whenRolledBack(t) {
+    this.undo.push(t);
+  }
+  /**
+   * Registers work that runs once the transaction has committed, and not at all where it is rolled back. It is
+   * how an operation defers a step that cannot be taken back - cancelling work in flight, for one - until the
+   * change it belongs to actually stands.
+   */
+  whenCommitted(t) {
+    this.settled.push(t);
   }
   /**
    * Notes that an element at or below the depth the pass in progress is working at has been enrolled. The pass
@@ -202,8 +180,8 @@ class ae {
    * whose composed value carries that write. The depth is only measured while a pass is running - outside one
    * there is nothing the answer would change.
    */
-  noteDepth(e) {
-    this.passDepth < 0 || Et(e) >= this.passDepth && (this.restartPass = !0);
+  noteDepth(t) {
+    this.passDepth < 0 || ht(t) >= this.passDepth && (this.restartPass = !0);
   }
   /**
    * Puts every element the transaction modified back as it found it. Nothing is announced: from an observer's
@@ -211,11 +189,11 @@ class ae {
    * that called a server during the transaction already did.
    */
   rollback() {
-    this.unwound = !0, [...this.participants.values()].reverse().forEach((t) => {
-      t.snapshot && t.element[jt](t.snapshot);
+    this.unwound = !0, [...this.participants.values()].reverse().forEach((e) => {
+      e.snapshot && e.element[St](e.snapshot);
     }), this.participants.clear();
-    for (let t = this.undo.length - 1; t >= 0; t--) this.undo[t]();
-    this.undo.length = 0;
+    for (let e = this.undo.length - 1; e >= 0; e--) this.undo[e]();
+    this.undo.length = 0, this.settled.length = 0;
   }
   /**
    * Announces what the transaction did. Values first and verdicts after, because a container's validators run
@@ -228,6 +206,8 @@ class ae {
   commit() {
     for (; !(!this.announceValues() && !this.settleValidity()); )
       ;
+    for (let t = 0; t < this.settled.length; t++) this.settled[t]();
+    this.settled.length = 0;
   }
   /**
    * The dirty participants a pass has to visit, one bucket per nesting depth; ties keep the order they were
@@ -235,14 +215,13 @@ class ae {
    * comparison sort: a whole-list assignment enrols one participant per field, and ordering those by comparison
    * would cost more than the announcement it orders.
    */
-  buckets(e) {
-    const t = [];
+  buckets(t) {
+    const e = [];
     return this.participants.forEach((s) => {
-      var r;
-      if (!e(s)) return;
-      const i = Et(s.element);
-      ((r = t[i]) != null ? r : t[i] = []).push(s);
-    }), t;
+      if (!t(s)) return;
+      const i = ht(s.element);
+      (e[i] ??= []).push(s);
+    }), e;
   }
   /**
    * Runs one pass over the dirty participants, deepest bucket first; the caller repeats it until it answers
@@ -250,8 +229,8 @@ class ae {
    * the depth being drained: that element is not in the bucket being walked, and going on would reach the
    * containers above it first. The caller's next pass takes fresh buckets and finds it at its own depth.
    */
-  pass(e, t) {
-    const s = this.buckets(e);
+  pass(t, e) {
+    const s = this.buckets(t);
     if (!s.length) return !1;
     for (let i = s.length - 1; i >= 0; i--) {
       const r = s[i];
@@ -261,7 +240,7 @@ class ae {
           for (let a = 0; a < r.length; a++) {
             if (this.restartPass) return !0;
             const o = r[a];
-            e(o) && t(o);
+            t(o) && e(o);
           }
         } finally {
           this.passDepth = -1;
@@ -273,34 +252,32 @@ class ae {
   }
   announceValues() {
     return this.pass(
-      (e) => e.valueDirty || e.structural !== void 0,
-      (e) => {
-        const { structural: t } = e, s = e.valueDirty, i = e.forceValue;
-        e.structural = void 0, e.valueDirty = !1, e.forceValue = !1, e.element[Pt](this, s, i, t);
+      (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[xt](this, s, i, e);
       }
     );
   }
   settleValidity() {
     return this.pass(
-      (e) => e.validityDirty,
-      (e) => {
-        e.validityDirty = !1, e.element[Nt](this);
+      (t) => t.validityDirty,
+      (t) => {
+        t.validityDirty = !1, t.element[At](this);
       }
     );
   }
 }
-let _, et;
-function kt() {
-  return _;
+let S, H;
+function It() {
+  return S;
 }
-class Rt {
+class Tt {
 }
-class oe {
-  constructor() {
-    d(this, "open", !0);
-  }
+class Zt {
+  open = !0;
   rollback() {
-    throw this.open ? new Rt() : 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."
     );
   }
@@ -308,60 +285,81 @@ class oe {
     this.open = !1;
   }
 }
-function Ct(n) {
+function dt(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 q(n) {
-  if (_) {
-    const s = n(et);
-    return Ct(s), s;
+function Z(n) {
+  if (S) {
+    const s = n(H);
+    return dt(s), s;
   }
-  const e = new ae(), t = new oe();
-  _ = e, et = t;
+  const t = new Jt(), e = new Zt();
+  S = t, H = e;
   try {
-    const s = n(t);
-    return Ct(s), e.commit(), s;
+    const s = n(e);
+    return dt(s), t.commit(), s;
   } catch (s) {
-    if (e.rollback(), s instanceof Rt) return;
+    if (t.rollback(), s instanceof Tt) return;
     throw s;
   } finally {
-    _ = void 0, et = void 0, t.close();
+    S = void 0, H = void 0, e.close();
   }
 }
-function g(n) {
-  return _ ? n(_) : q(() => n(_));
+function u(n) {
+  return S ? n(S) : Z(() => n(S));
 }
-const Dt = { useMarkdownInValidators: !0 };
-function le() {
-  return Dt;
+const Ot = { useMarkdownInValidators: !0 };
+function Gt() {
+  return Ot;
 }
-function ue(n) {
-  Object.assign(Dt, n);
+function te(n) {
+  Object.assign(Ot, n);
 }
-const Ye = {
-  install(n, e) {
-    e && ue(e);
+const Ue = {
+  install(n, t) {
+    t && te(t);
   }
 };
-class B extends String {
-  constructor(t, s, i) {
-    super(t);
-    d(this, "plugins");
-    d(this, "options");
-    this.plugins = i, this.options = s;
+class j extends String {
+  plugins;
+  options;
+  constructor(t, e, s) {
+    super(t), this.plugins = s, this.options = e;
   }
 }
-function at(n) {
-  const e = b(n);
-  return typeof e == "object" && "componentName" in e;
+function G(n) {
+  const t = h(n);
+  return typeof t == "object" && t !== null && "componentName" in t;
 }
-function z(n) {
-  return typeof b(n) == "function";
+function L(n) {
+  return typeof h(n) == "function";
 }
-class ot {
+class tt {
+  /**
+   * 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
+   * configurable. It is optional: an error built by hand carries whatever its author gives it, or nothing.
+   */
+  constructor(t) {
+    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";
   }
@@ -375,13 +373,12 @@ class ot {
     return "";
   }
 }
-class ce extends ot {
-  constructor(t, s = "") {
-    super();
-    d(this, "text");
-    d(this, "classes");
-    this.text = t, this.classes = s;
+class ee extends tt {
+  constructor(t, e = "", s) {
+    super(s), this.text = t, this.classes = e;
   }
+  text;
+  classes;
   get componentName() {
     return "template";
   }
@@ -392,24 +389,23 @@ class ce extends ot {
     return this.classes;
   }
 }
-class V extends ot {
-  constructor(t, s = "") {
-    super();
-    d(this, "classes");
-    d(this, "text");
-    d(this, "textType");
-    this.classes = s, this.text = t, this.textType = Tt(() => this.getTextType);
+class g extends tt {
+  constructor(t, e = "", s) {
+    super(s), this.classes = e, this.text = t, this.textType = Y(() => this.getTextType);
   }
+  classes;
+  text;
+  textType;
   get resolvedText() {
-    const t = b(this.text);
-    return z(t) ? t() : t;
+    const t = h(this.text);
+    return L(t) ? t() : t;
   }
   get getTextType() {
     const t = this.resolvedText;
-    return t ? t instanceof B ? "md" : at(t) ? "component" : "string" : "string";
+    return t ? t instanceof j ? "md" : G(t) ? "component" : "string" : "string";
   }
   get componentName() {
-    switch (b(this.textType)) {
+    switch (h(this.textType)) {
       case "string":
         return "template";
       case "md":
@@ -421,7 +417,7 @@ class V extends ot {
     }
   }
   get componentBindings() {
-    switch (b(this.textType)) {
+    switch (h(this.textType)) {
       case "string":
         return {};
       case "md": {
@@ -435,7 +431,7 @@ class V extends ot {
     }
   }
   get componentBody() {
-    switch (b(this.textType)) {
+    switch (h(this.textType)) {
       case "string":
         return this.resolvedText;
       case "component":
@@ -448,43 +444,50 @@ class V extends ot {
     return this.classes;
   }
 }
-class he extends V {
+class se extends g {
 }
-function E(n) {
-  return le().useMarkdownInValidators ? new B(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 de = /* @__PURE__ */ Symbol("Validator"), ge = () => E("Validation could not be completed");
-class v extends O {
+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) {
-    super((i, r, a, o) => {
-      const u = this.bindingState(i), c = ++u.run, x = i.validationEpoch, G = kt(), ct = () => u.run === c && i.validationEpoch === x && !(G != null && G.rolledBack), Y = t(a, o, i) || [], J = (S) => q(() => {
-        var ht;
-        const U = (ht = S == null ? void 0 : S.map((F) => this.claim(F))) != null ? ht : [];
-        for (let F = i.errors.length - 1; F >= 0; F--) {
-          const dt = i.errors[F];
-          if (dt.source === this.source) {
-            const gt = U.findIndex((Xt) => nt(Xt, dt));
-            gt >= 0 ? U.splice(gt, 1) : i.errors.splice(F, 1);
+    const e = (s, i, r, a) => {
+      const o = this.bindingState(s), l = o.abandon, v = ++o.run, p = s.validationEpoch, nt = It();
+      let rt = !1;
+      const $ = () => !rt && o.run === v && s.validationEpoch === p && !nt?.rolledBack, at = new AbortController(), B = () => {
+        $() || (rt = !0, o.abandon === B && (o.abandon = void 0), at.abort());
+      };
+      l?.();
+      const W = t(r, a, s, at.signal) || [], q = (E) => Z(() => {
+        const D = E?.map((A) => this.claim(A)) ?? [];
+        for (let A = s.errors.length - 1; A >= 0; A--) {
+          const ot = s.errors[A];
+          if (ot.source === this.source) {
+            const lt = D.findIndex((Mt) => Mt.sameAs(ot));
+            lt >= 0 ? D.splice(lt, 1) : s.errors.splice(A, 1);
           }
         }
-        U.length > 0 && i.errors.push(...U), i.validate();
+        D.length > 0 && s.errors.push(...D), s.validate();
       });
-      return Y instanceof Promise ? (i.beginValidating(), Y.then(
-        (S) => {
-          ct() && J(S);
+      return W instanceof Promise ? (o.abandon = B, nt?.whenRolledBack(B), s.beginValidating(), W.then(
+        (E) => {
+          $() && q(E);
         },
-        (S) => {
-          ct() && (J([new V(ge())]), console.error("Validation failed", S));
+        (E) => {
+          $() && (q([new g(ne(), "", "validation-failed")]), console.error("Validation failed", E));
         }
-      ).finally(() => i.endValidating()).catch((S) => console.error("Validation failed", S))) : J(Y), r(i, a, o);
-    });
-    d(this, "source");
-    this.source = Symbol(this.constructor.name);
+      ).finally(() => {
+        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);
   }
   /**
    * Returns the error instance this validator owns and may later withdraw: the argument itself when it carries no
@@ -494,16 +497,16 @@ class v extends O {
    * including the non-enumerable ones, so it renders exactly like the instance it was made from.
    */
   claim(t) {
-    const s = t.source;
-    if (s === this.source) return t;
-    const i = { value: this.source, enumerable: !1, configurable: !1 };
-    if (s === void 0)
-      return Object.defineProperty(t, "source", i), t;
-    const r = Object.getOwnPropertyDescriptors(t);
-    return Object.create(Object.getPrototypeOf(t), C(p({}, r), { source: i }));
+    const e = t.source;
+    if (e === this.source) return t;
+    const s = { value: this.source, enumerable: !1, configurable: !1 };
+    if (e === void 0)
+      return Object.defineProperty(t, "source", s), t;
+    const i = Object.getOwnPropertyDescriptors(t);
+    return Object.create(Object.getPrototypeOf(t), { ...i, source: s });
   }
   static get classIdentifier() {
-    return de;
+    return ie;
   }
   get eager() {
     return !0;
@@ -512,14 +515,28 @@ class v extends O {
    * Takes this validator off `field`: the errors it put there are withdrawn and the verdict is re-formed over what
    * the validators the field still holds have to say. Withdrawing them is what keeps a field from staying invalid
    * on an error no validator is left to take back.
+   *
+   * A run in flight over the field is cancelled once the removal stands, and not before: a transaction that
+   * unwinds puts the validator and its epoch back, and the run it never cancelled goes on to reach the verdict the
+   * field is then owed. Cancelling it as the removal is made would leave the field reporting itself valid over a
+   * value nothing checked, on the strength of a transaction that never happened.
    */
   unregisterFrom(t) {
-    q(() => {
+    u((e) => {
+      e.whenCommitted(() => this.abandonRun(t));
       for (let s = t.errors.length - 1; s >= 0; s--)
         t.errors[s].source === this.source && t.errors.splice(s, 1);
       t.validate();
     });
   }
+  /**
+   * Cancels the asynchronous run in flight over `field`, where there is one. It is called once the field has
+   * stopped holding this validator: the field's validation epoch has moved on by then, so the run's verdict is
+   * already dropped and the signal it handed its check aborts with it.
+   */
+  abandonRun(t) {
+    this.bindingState(t).abandon?.();
+  }
   /**
    * What this validator remembers about one of the fields it validates. One instance may be registered on several
    * fields - every row of a list carries the instances the item template carries - so each field has a record of
@@ -536,186 +553,194 @@ class v extends O {
   newBindingState() {
     return { run: 0 };
   }
-  replacePlaceholdersFunction(t, s) {
+  replacePlaceholdersFunction(t, e) {
     return () => {
-      let i = b(t);
-      for (; z(i); )
-        i = b(this.replacePlaceholders(i(), s));
-      return i;
+      let s = h(t);
+      for (; L(s); )
+        s = h(this.replacePlaceholders(s(), e));
+      return s;
     };
   }
-  replacePlaceholders(t, s) {
-    if (z(t)) return this.replacePlaceholdersFunction(t, s);
-    if (at(t)) return t;
-    if (te(t))
-      return this.replacePlaceholdersFunction(() => b(t), s);
-    let i = b(t);
-    return Object.keys(s).forEach((r) => {
-      i = i.replaceAll(`{${r}}`, s[r]);
-    }), t instanceof B ? new B(i.toString(), t.options, t.plugins) : i;
+  replacePlaceholders(t, e) {
+    if (L(t)) return this.replacePlaceholdersFunction(t, e);
+    if (G(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 j ? new j(s.toString(), t.options, t.plugins) : s;
   }
 }
-class H {
-  constructor() {
-    /** every action registered here, in registration order across all identifiers */
-    d(this, "registeredActions", []);
-    /** the actions of one identifier, in registration order */
-    d(this, "chains", /* @__PURE__ */ new Map());
-    /** the eager actions of one identifier, in registration order; a subsequence of the chain under that identifier */
-    d(this, "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
    * reaches it through `supr`. That is what lets an action be added to a chain someone else built and still sit
    * inside a handler already there.
    */
-  register(e, t) {
-    if (!(e instanceof y)) throw new Error("Invalid action type");
-    const s = e.classIdentifier;
-    if (t && (t.classIdentifier !== s || !this.registeredActions.includes(t)))
+  register(t, 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(e), this.insert(this.chains, s, e, t), e.eager && this.insert(this.eagerChains, s, e, t);
+    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.
-   */
-  unregister(e) {
-    const t = this.registeredActions.indexOf(e);
-    if (t < 0) return !1;
-    this.registeredActions.splice(t, 1);
-    const s = e.classIdentifier;
-    return this.remove(this.chains, s, e), this.remove(this.eagerChains, s, e), !0;
+  /** Drops `action` and answers whether it was registered here. */
+  unregister(t) {
+    return this.actions.includes(t) ? (this.actions = this.actions.filter((e) => e !== t), !0) : !1;
   }
   /** True where something is registered under `identifier`. */
-  willTrigger(e) {
-    return this.chains.has(e);
+  willTrigger(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(e, t, ...s) {
-    return this.run(this.chains.get(e.classIdentifier), t, s);
+  trigger(t, e, ...s) {
+    return this.run(t.classIdentifier, !1, e, s);
   }
-  /** Runs the eager actions of every identifier, each group on its own. */
-  triggerEager(e, ...t) {
-    this.eagerChains.forEach((s) => this.run(s, e, t));
+  /**
+   * 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) {
+    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(e, t, ...s) {
-    return this.run(this.eagerChains.get(e), t, s);
+  triggerEagerFor(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((e) => e instanceof v);
-  }
-  clone() {
-    const e = new H();
-    return this.registeredActions.forEach((t) => e.register(t)), e;
+    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(e) {
-    this.registeredActions.forEach((t) => t.boundToBinding(e));
+  bindTo(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(e, t, s, i) {
-    if (t < 0) return null;
-    const r = (a, ...o) => this.step(e, t - 1, a, o);
-    return e[t].execute(s, r, ...i);
-  }
-  /** Walks a chain, answering null where there is none. An abort ends the run and is not an error to the caller. */
-  run(e, t, s) {
-    if (!e) return null;
+  run(t, e, s, i) {
+    const r = this.actions;
     try {
-      return this.step(e, e.length - 1, t, s);
-    } catch (i) {
-      if (!(i instanceof Ot)) 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(e, t, s, i) {
-    var o;
-    const r = (o = e.get(t)) != null ? o : [], a = i ? r.indexOf(i) : -1;
-    a < 0 ? r.push(s) : r.splice(a, 0, s), e.set(t, r);
-  }
-  remove(e, t, s) {
-    const i = e.get(t);
-    if (!(i != null && i.includes(s))) return;
-    const r = i.filter((a) => a !== s);
-    r.length ? e.set(t, r) : e.delete(t);
+  /**
+   * 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 T(n) {
+function V(n) {
+  let t = n;
+  for (; t.fieldName !== void 0 && t.parent; ) t = t.parent;
+  return t;
+}
+function gt(n, t) {
   let e = n;
-  for (; e.fieldName !== void 0 && e.parent; ) e = e.parent;
-  return e;
+  for (const s of re(t))
+    if (e = e.field?.(s) ?? void 0, !e) return;
+  return e?.declaration === t ? e : void 0;
 }
-function fe(n) {
-  const e = [];
-  let t = n;
-  for (; t.fieldName !== void 0 && t.parent; )
-    e.unshift(t.fieldName), t = t.parent;
-  return e;
-}
-function lt(n, e) {
-  var s, i;
-  let t = e;
-  for (const r of fe(n))
-    if (t = (i = (s = t.field) == null ? void 0 : s.call(t, r)) != null ? i : void 0, !t) break;
-  return (t == null ? void 0 : t.declaration) === n ? t : T(n) === T(e.declaration) ? void 0 : n;
-}
-function Lt(n, e) {
-  const t = lt(n, e);
-  if (!t) return [];
-  if (t !== n) return [t];
-  const s = e.bindingsOf(n);
-  return s.length > 0 ? s : [n];
+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 pe(n, e) {
-  var s;
-  let t = e.parent;
-  for (; t; ) {
-    const i = (s = t.field) == null ? void 0 : s.call(t, n);
+function et(n, t) {
+  const e = gt(t, n);
+  if (e) return e;
+  let s = t.parent;
+  for (; s; ) {
+    const i = gt(V(s), n);
     if (i) return i;
-    t = t.parent;
-  }
-}
-const me = /* @__PURE__ */ Symbol("ConditionalStatementAction");
-class Q extends O {
-  constructor(t, s) {
-    super((r, a, o, u) => (this.applyIn(T(r)) || r.markRecordIncomplete(), a(r, o, u)));
-    d(this, "statement");
-    d(this, "conditionalExecutor");
-    /**
-     * What the elements this action was registered on were declared as. It holds declarations rather than the
-     * elements themselves, so one entry stands for every row of a list, and the element a result is applied to is
-     * the one that declaration names within the record the change happened in.
-     */
-    d(this, "declarations", /* @__PURE__ */ new Set());
-    /**
-     * The elements this action was registered on. Registration reaches one element at a time - the rows of a list
-     * take the action on one by one, as they are built from the item template that carries it - so this is what
-     * says which of the elements a declaration stands for the action actually drives.
-     */
-    d(this, "registrations", /* @__PURE__ */ new WeakSet());
-    this.statement = t, this.conditionalExecutor = s;
-    const i = new O((r, a, ...o) => (this.applyFrom(r), a(r, ...o)));
-    t.collectFields().forEach((r) => r.registerAction(i));
+    s = s.parent;
+  }
+  return V(n) === V(t.declaration) ? void 0 : n;
+}
+function kt(n, t) {
+  const e = et(n, t);
+  if (!e) return [];
+  if (e !== n) return [e];
+  const s = t.bindingsOf(n);
+  return s.length > 0 ? s : [n];
+}
+function ae(n, t) {
+  let e = t.parent;
+  for (; e; ) {
+    const s = e.field?.(n);
+    if (s) return s;
+    e = e.parent;
+  }
+}
+const oe = /* @__PURE__ */ Symbol("ConditionalStatementAction");
+class U extends T {
+  statement;
+  conditionalExecutor;
+  /**
+   * What the elements this action was registered on were declared as. It holds declarations rather than the
+   * elements themselves, so one entry stands for every row of a list, and the element a result is applied to is
+   * the one that declaration names within the record the change happened in.
+   */
+  declarations = /* @__PURE__ */ new Set();
+  /**
+   * The elements this action was registered on. Registration reaches one element at a time - the rows of a list
+   * take the action on one by one, as they are built from the item template that carries it - so this is what
+   * says which of the elements a declaration stands for the action actually drives.
+   */
+  registrations = /* @__PURE__ */ new WeakSet();
+  constructor(t, e) {
+    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 me;
+    return oe;
   }
   get eager() {
     return !0;
@@ -731,12 +756,12 @@ class Q extends O {
    * those the ones that took the action on. A row of a list that never took it on is not one this action drives.
    */
   targetsIn(t) {
-    const s = [];
+    const e = [];
     return this.declarations.forEach(
-      (i) => Lt(i, t).forEach((r) => {
-        this.registrations.has(r) && s.push(r);
+      (s) => kt(s, t).forEach((i) => {
+        this.registrations.has(i) && e.push(i);
       })
-    ), s;
+    ), e;
   }
   /**
    * Re-evaluates the statement over one record and applies the result where it changed. The result is recorded
@@ -745,12 +770,12 @@ class Q extends O {
    * this action to drive, which is how a caller learns that the record is not assembled yet.
    */
   applyIn(t) {
-    const s = this.targetsIn(t);
-    if (s.length === 0) return !1;
-    const i = this.state(t, () => ({ lastResult: void 0 })), r = this.statement.evaluate(t);
-    if (r === i.lastResult) return !0;
-    const a = i.lastResult;
-    return i.lastResult = r, s.forEach((o) => this.conditionalExecutor(o, r, a)), !0;
+    const e = this.targetsIn(t);
+    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 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
@@ -759,34 +784,34 @@ class Q extends O {
    * where the change reaches none.
    */
   applyFrom(t) {
-    const s = /* @__PURE__ */ new Set();
-    this.targetsIn(T(t)).forEach((i) => s.add(T(i))), s.forEach((i) => this.applyIn(i));
+    const e = /* @__PURE__ */ new Set();
+    this.targetsIn(V(t)).forEach((s) => e.add(V(s))), e.forEach((s) => this.applyIn(s));
   }
 }
-class be extends Q {
-  constructor(e) {
-    super(e, (t, s) => {
-      t.visibility = s ? N.FULL : N.SUPPRESS;
+class le extends U {
+  constructor(t) {
+    super(t, (e, s) => {
+      e.visibility = s ? I.FULL : I.SUPPRESS;
     });
   }
 }
-class ve extends Q {
-  constructor(e) {
-    super(e, (t, s) => {
-      t.enabled = s;
+class ue extends U {
+  constructor(t) {
+    super(t, (e, s) => {
+      e.enabled = s;
     });
   }
 }
-class Ve extends Q {
-  constructor(e, t) {
-    super(e, (s, i) => {
-      i && (s.value = t);
+class ce extends U {
+  constructor(t, e) {
+    super(t, (s, i) => {
+      i && (s.value = e);
     });
   }
 }
-var M = /* @__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))(M || {});
+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 e(r) {
+  function t(r) {
     const a = r.toLowerCase();
     if (a === "not") return 0;
     if (a === "or") return 1;
@@ -806,13 +831,13 @@ var M = /* @__PURE__ */ ((n) => (n[n.NOT = 0] = "NOT", n[n.OR = 1] = "OR", n[n.A
     if (["not_includes", "not-includes", "not includes"].includes(a)) return -10;
     throw new Error(`Unrecognised operator ${a}`);
   }
-  n.fromString = e;
-  function t(r) {
+  n.fromString = t;
+  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 = t;
+  n.fromAny = e;
   function s(r) {
     const a = typeof r == "number" ? r : n.fromString(r);
     return Object.values(n).includes(a);
@@ -822,85 +847,71 @@ var M = /* @__PURE__ */ ((n) => (n[n.NOT = 0] = "NOT", n[n.OR = 1] = "OR", n[n.A
     return r >= 0;
   }
   n.isLogicOperator = i;
-})(M || (M = {}));
-Object.freeze(M);
-const m = M, we = /* @__PURE__ */ Symbol("EnabledChangingAction");
-class Bt extends y {
-  constructor(e) {
-    super(e);
+})(N || (N = {}));
+Object.freeze(N);
+const c = N, he = /* @__PURE__ */ Symbol("EnabledChangingAction");
+class Rt extends m {
+  constructor(t) {
+    super(t);
   }
   static get classIdentifier() {
-    return we;
+    return he;
   }
-  execute(e, t, s, i) {
-    return super.execute(e, t, s, i);
+  execute(t, e, s, i) {
+    return super.execute(t, e, s, i);
   }
 }
-const ye = /* @__PURE__ */ Symbol("EnabledChangedAction");
-class Mt extends y {
-  constructor(e) {
-    super(e);
+const de = /* @__PURE__ */ Symbol("EnabledChangedAction");
+class Ft extends m {
+  constructor(t) {
+    super(t);
   }
   static get classIdentifier() {
-    return ye;
+    return de;
   }
-  execute(e, t, s, i) {
-    return super.execute(e, t, s, i);
+  execute(t, e, s, i) {
+    return super.execute(t, e, s, i);
   }
 }
-const Ee = /* @__PURE__ */ Symbol("ValidChangedAction");
-class Ut extends y {
-  constructor(e) {
-    super(e);
+const ge = /* @__PURE__ */ Symbol("ValidChangedAction");
+class _t extends m {
+  constructor(t) {
+    super(t);
   }
   static get classIdentifier() {
-    return Ee;
+    return ge;
   }
-  execute(e, t, s, i) {
-    return super.execute(e, t, s, i);
+  execute(t, e, s, i) {
+    return super.execute(t, e, s, i);
   }
 }
-const Ce = /* @__PURE__ */ Symbol("VisibilityChangingAction");
-class Wt extends y {
-  constructor(e) {
-    super(e);
+const fe = /* @__PURE__ */ Symbol("VisibilityChangingAction");
+class Pt extends m {
+  constructor(t) {
+    super(t);
   }
   static get classIdentifier() {
-    return Ce;
+    return fe;
   }
-  execute(e, t, s, i) {
-    return super.execute(e, t, s, i);
+  execute(t, e, s, i) {
+    return super.execute(t, e, s, i);
   }
 }
-const xe = /* @__PURE__ */ Symbol("VisibilityChangedAction");
-class $t extends y {
-  constructor(e) {
-    super(e);
+const pe = /* @__PURE__ */ Symbol("VisibilityChangedAction");
+class jt extends m {
+  constructor(t) {
+    super(t);
   }
   static get classIdentifier() {
-    return xe;
-  }
-  execute(e, t, s, i) {
-    return super.execute(e, t, s, i);
-  }
-}
-const xt = /* @__PURE__ */ new WeakMap(), St = /* @__PURE__ */ new Set(["validators", "actions"]);
-let st = 0;
-var h, f;
-class A {
-  constructor(e) {
-    /**
-     * 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.
-     * `#raw` is the same object without the proxy, for the bookkeeping nothing renders from.
-     *
-     * They are private class fields, so no reflection over the element reaches the state or the parent link it
-     * carries, and a subclass reads its own slot type through the accessors below.
-     */
-    Z(this, h);
-    Z(this, f);
-    tt(this, f, e), tt(this, h, ee(e));
+    return pe;
   }
+  execute(t, e, s, i) {
+    return super.execute(t, e, s, i);
+  }
+}
+const ft = /* @__PURE__ */ new WeakMap(), pt = /* @__PURE__ */ new WeakMap(), Q = /* @__PURE__ */ new WeakMap(), mt = /* @__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
@@ -918,13 +929,41 @@ class A {
   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.
+   * `#raw` is the same object without the proxy, for the bookkeeping nothing renders from.
+   *
+   * They are private class fields, so no reflection over the element reaches the state or the parent link it
+   * carries, and a subclass reads its own slot type through the accessors below.
+   */
+  #t;
+  #e;
+  constructor(t) {
+    this.#e = t, this.#t = Ut(t);
+  }
   /** the tracked view of this element's state; a subclass narrows the return type to its own slots */
   get state() {
-    return l(this, h);
+    return this.#t;
   }
   /** the untracked view of this element's state; a subclass narrows the return type to its own slots */
   get raw() {
-    return l(this, f);
+    return this.#e;
   }
   /**
    * Exchanges the data this element holds for `data`, in place. The element is the same instance afterwards - its
@@ -942,19 +981,19 @@ class A {
    * The data is measured against the element's `declaration`, so a key a record leaves out is taken from the
    * declaration rather than left as the previous record had it.
    */
-  rebind(e) {
-    return g((t) => {
-      t.touch(this);
-      const s = t.willAnnounceValue(this), i = l(this, f).announcedValue;
-      this.resetTo(this.declaration, e), l(this, f).announcedValue = s ? i : this.value;
+  rebind(t) {
+    return u((e) => {
+      e.touch(this);
+      const s = e.willAnnounceValue(this), i = this.#e.announcedValue;
+      this.resetTo(this.declaration, t), this.#e.announcedValue = s ? i : this.value;
     }), this;
   }
   /** contains original field value as was provided at creation */
   get originalValue() {
-    return l(this, h).originalValue;
+    return this.#t.originalValue;
   }
-  set originalValue(e) {
-    this.touchState(), l(this, h).originalValue = e;
+  set originalValue(t) {
+    this.touchState(), this.#t.originalValue = t;
   }
   /**
    * The extended properties this element carries: what a consumer attached to it beyond the members the class
@@ -969,14 +1008,14 @@ class A {
    * and one written in place would leave a rollback with nothing to put back.
    */
   get extra() {
-    return l(this, h).extra;
+    return this.#t.extra;
   }
   /**
    * Writes extended properties. The values given are merged over the ones the element carries, so a write of one
    * property leaves the others standing, and the merged set replaces the object the element held.
    */
-  setExtendedValues(e) {
-    this.touchState(), l(this, h).extra = Object.freeze(p(p({}, l(this, f).extra), e));
+  setExtendedValues(t) {
+    this.touchState(), this.#t.extra = Object.freeze({ ...this.#e.extra, ...t });
   }
   /**
    * The extended properties a parameter object carries: every key the element does not answer for itself. A key
@@ -988,22 +1027,22 @@ class A {
    * defined on the instance after the base constructor returns, and the parameters are applied inside it. A
    * subclass that wants a parameter of its own name assigned to it declares that member as an accessor.
    */
-  extendedOf(e) {
-    const t = /* @__PURE__ */ Object.create(null);
-    return Object.entries(e).forEach(([s, i]) => {
-      St.has(s) || (!(s in this) || Object.hasOwn(Object.prototype, s)) && (t[s] = i);
-    }), t;
+  extendedOf(t) {
+    const e = /* @__PURE__ */ Object.create(null);
+    return Object.entries(t).forEach(([s, i]) => {
+      mt.has(s) || (!(s in this) || Object.hasOwn(Object.prototype, s)) && (e[s] = i);
+    }), e;
   }
   /**
    * Applies a parameter object: the members the element answers for are assigned to the element and the rest
    * become its extended properties. Assigning a getter-only member throws a TypeError, which is what a caller
    * naming `valid` or `parent` past the type system gets.
    */
-  assignParams(e) {
-    const t = this.extendedOf(e);
-    Object.entries(e).forEach(([s, i]) => {
-      Object.hasOwn(t, s) || St.has(s) || (this[s] = i);
-    }), L(t) || this.setExtendedValues(t);
+  assignParams(t) {
+    const e = this.extendedOf(t);
+    Object.entries(t).forEach(([s, i]) => {
+      Object.hasOwn(e, s) || mt.has(s) || (this[s] = i);
+    }), _(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
@@ -1011,8 +1050,7 @@ class A {
    * atomic, and inside a transaction it has to be part of what a rollback puts back.
    */
   touchState() {
-    var e;
-    (e = kt()) == null || e.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
@@ -1022,31 +1060,92 @@ class A {
    * What is not in the snapshot is the action map, which no write touches: an operation that replaces it hands
    * the transaction its own undo instead, so this stays the one shape every element captures.
    */
-  [$]() {
-    return C(p({}, l(this, f)), { errors: [...l(this, f).errors] });
+  [O]() {
+    return { ...this.#e, errors: [...this.#e.errors] };
   }
   /**
    * Puts a captured state back. It writes through the tracked view, so an effect that ran on the state the
    * transaction produced runs again on the state it is being returned to, and only for the slots that differ.
    *
-   * validatingCount is the one slot the element keeps: it counts runs that are in flight, and a rollback cannot
-   * un-start one. Put back, the count would no longer match the endValidating calls still to come.
+   * 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.
    */
-  [jt](e) {
-    const t = l(this, f).validatingCount;
-    Object.assign(l(this, h), e), l(this, h).validatingCount = 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;
   }
-  /** true while at least one asynchronous validator is still running for this field */
+  /**
+   * True while an asynchronous validation is in flight on this element or on anything below it, so a form answers
+   * for the whole tree it holds. The answer is a pair of counters rather than a walk: the element's own runs, and
+   * how many of its children answer the same question with true. A child that starts running while it was idle,
+   * or stops while it was the last one running, moves its container's tally, and a tally that changes the
+   * container's own answer moves the one above it - the transition costs the nesting depth and the read costs
+   * nothing.
+   */
   get validating() {
-    return l(this, h).validatingCount > 0;
+    return this.#t.validatingCount > 0 || this.#t.validatingChildren > 0;
   }
   /** announces the start of one asynchronous validation run; validators pair it with endValidating */
   beginValidating() {
-    l(this, h).validatingCount++;
+    const t = !this.validating;
+    this.#t.validatingCount++, t && this.container?.childValidatingChanged(!0);
   }
   /** announces the end of one asynchronous validation run */
   endValidating() {
-    l(this, h).validatingCount = Math.max(0, l(this, h).validatingCount - 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
+   * up where it changes this element's own answer.
+   */
+  childValidatingChanged(t) {
+    const e = this.validating;
+    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
+   * runs; a container answers for the actions below it; anything else answers false, because an element that is
+   * not an action has nothing to execute.
+   *
+   * It states one thing and `validating` states the other, so a form that gates a submit button on the tree being
+   * idle reads both.
+   */
+  get busy() {
+    return !1;
+  }
+  /**
+   * The composed answer a container gives `busy`, memoised by Vue. An `Action` counts its executions in a counter
+   * of its own, which no container is told about, so the answer is composed over the members instead of tallied;
+   * the computed keeps the walk from repeating while nothing it read has moved, and a member that is itself a
+   * container answers from its own computed.
+   */
+  get busyRead() {
+    let t = pt.get(this);
+    return t || (t = Y(() => this.composeBusy()), pt.set(this, t)), t.value;
+  }
+  /** What busyRead computes. A container answers over its members; anything else executes nothing. */
+  composeBusy() {
+    return !1;
+  }
+  /**
+   * Resolves once nothing at or below this element is running - no asynchronous validation, no `Action.execute()`
+   * that has yet to settle. It is what a submit path awaits instead of polling `validating` and `busy`, and it
+   * resolves at once where nothing is running to begin with.
+   *
+   * It answers for the moment it resolves and makes no promise about the one after: work started later leaves the
+   * element running again, so a caller that has to act on a settled tree reads what it needs immediately after
+   * awaiting rather than at its leisure.
+   */
+  settled() {
+    return !this.validating && !this.busy ? Promise.resolve() : new Promise((t) => {
+      const e = $t(
+        () => this.validating || this.busy,
+        (s) => {
+          s || (e(), t());
+        },
+        { flush: "sync" }
+      );
+    });
   }
   /**
    * List of errors. The array handed out is the one the element holds, and a validator writes into it in place,
@@ -1054,23 +1153,34 @@ class A {
    * except the errors would leave a state the form never held.
    */
   get errors() {
-    return this.touchState(), l(this, h).errors;
+    return this.touchState(), this.#t.errors;
   }
-  set errors(e) {
-    this.touchState(), l(this, h).errors = e;
+  set errors(t) {
+    this.touchState(), this.#t.errors = t;
   }
   /**
    * The container that holds this element: the Group it is a member of, or the List whose row it is, and
    * 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 l(this, h).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 l(this, h).fieldName;
+    return this.#t.fieldName;
   }
   /**
    * The element this one was declared as: itself for an element built from parameters, and the element it was
@@ -1079,8 +1189,7 @@ class A {
    * answer with the same element, and an action registered on the template can tell the two apart.
    */
   get declaration() {
-    var e;
-    return (e = l(this, f).declaration) != null ? e : this;
+    return this.#e.declaration ?? this;
   }
   /** The elements this one holds: a Group's members, a List's rows, none for a leaf. */
   get members() {
@@ -1092,9 +1201,9 @@ class A {
    * field that every row of a list reacts to - and it costs the subtree, so it is the path taken only when the
    * cheaper one, resolving within a single record, does not apply.
    */
-  bindingsOf(e) {
-    const t = e.declaration, s = [], i = (r) => {
-      r.declaration === t && s.push(r), r.members.forEach(i);
+  bindingsOf(t) {
+    const e = t.declaration, s = [], i = (r) => {
+      r.declaration === e && s.push(r), r.members.forEach(i);
     };
     return i(this), s;
   }
@@ -1106,33 +1215,66 @@ class A {
    * nothing says so again, so the next container above answers for it.
    */
   markRecordIncomplete() {
-    this._recordPending || (this._recordPending = !0, st++);
+    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
    * container calls it where it has just made a record complete: a Group that has written its members, and a
    * List that has taken a row, which is what gives the row's fields the form above it.
    */
-  completeRecords(e = this) {
-    st !== 0 && g(() => {
-      const t = (s) => {
-        s._recordPending && (s._recordPending = !1, st--, s.rerunEagerActions()), s.members.forEach(t);
+  completeRecords(t = this) {
+    X !== 0 && u(() => {
+      const e = (s) => {
+        s._recordPending && (s._recordPending = !1, X--, s.rerunEagerActions()), s.members.forEach(e);
       };
-      t(e);
+      e(t);
     });
   }
   /** Runs this element's eager actions over the value it holds and re-forms the verdict they reach. */
   rerunEagerActions() {
-    g((e) => {
-      var t;
-      (t = this._actions) == null || t.triggerEager(this, this.value, this.value), e.markValidityDirty(this);
+    u((t) => {
+      this.boundActions?.triggerEager(this, this.value, this.value), t.markValidityDirty(this);
     });
   }
-  get actions() {
-    return this._actions || (this._actions = new H()), 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));
   }
-  set actions(e) {
-    this._actions = e;
+  /**
+   * 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;
+  }
+  /**
+   * 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
@@ -1140,7 +1282,7 @@ class A {
    * cached value still re-runs when a descendant is written.
    */
   get valueVersion() {
-    return l(this, h).valueVersion;
+    return this.#t.valueVersion;
   }
   /**
    * Marks the value of this element and of every ancestor as superseded. It walks the parent chain, so it costs
@@ -1149,11 +1291,11 @@ class A {
    * rollback puts the versions back and no reader is left holding a cache the tree no longer supports.
    */
   bumpValueVersion() {
-    g((e) => {
-      e.touch(this), l(this, h).valueVersion++;
-      let t = this.parent;
-      for (; t; )
-        e.touch(t), l(t, h).valueVersion++, t = t.parent;
+    u((t) => {
+      t.touch(this), this.#t.valueVersion++;
+      let e = this.parent;
+      for (; e; )
+        t.touch(e), e.#t.valueVersion++, e = e.parent;
     });
   }
   /**
@@ -1164,10 +1306,9 @@ class A {
    * `force` states that the caller already knows this element's value changed - one item more or fewer is a
    * different list whatever the items compare as - so the commit announces it without composing a comparison.
    */
-  propagateValueChanged(e = !1) {
-    g((t) => {
-      var s;
-      t.markValueChanged(this, e), t.markValidityDirty(this), (s = this.parent) == null || s.notifyValueChanged();
+  propagateValueChanged(t = !1) {
+    u((e) => {
+      e.markValueChanged(this, t), e.markValidityDirty(this), this.parent?.notifyValueChanged();
     });
   }
   /**
@@ -1184,7 +1325,7 @@ class A {
    * without a validate() call, which is the documented cost of pushing errors by hand.
    */
   get countedValid() {
-    return l(this, f).errors.length === 0 && l(this, f).invalidChildren === 0;
+    return this.#e.errors.length === 0 && this.#e.invalidChildren === 0;
   }
   /**
    * Makes this element the container of `child`: it installs the back-reference, records the name a Group holds
@@ -1193,16 +1334,18 @@ class A {
    * released that way can be handed on. The child's state is unreachable from outside FieldBase, so a container
    * writes the two slots through here rather than on the child.
    */
-  takeChild(e, t) {
-    g((s) => {
-      if (e.parent) throw new TypeError("This element already belongs to a container - pass a bind() of it");
-      s.touch(e), l(e, h).fieldName = t, l(e, h).parent = this, this.adoptChild(e);
+  takeChild(t, e) {
+    u((s) => {
+      if (t.parent) throw new TypeError("This element already belongs to a container - pass a bind() of it");
+      s.touch(t), t.#t.fieldName = e, t.#t.parent = this, this.adoptChild(t);
     });
   }
   /** Takes a child into this element's invalid tally; a container calls it once the child's parent link exists. */
-  adoptChild(e) {
-    g((t) => {
-      t.touch(this), l(e, f).valid || l(this, f).invalidChildren++, t.markValidityDirty(this);
+  adoptChild(t) {
+    u((e) => {
+      e.touch(this), t.#e.valid || this.#e.invalidChildren++, t.validating && this.childValidatingChanged(!0), e.whenRolledBack(() => {
+        t.validating && this.childValidatingChanged(!1);
+      }), e.markValidityDirty(this);
     });
   }
   /**
@@ -1210,9 +1353,11 @@ class A {
    * to a container that no longer holds it: it would go on moving that container's tally, and the link is what
    * stands in the way of the element being taken by another container.
    */
-  releaseChild(e) {
-    g((t) => {
-      t.touch(this), t.touch(e), l(e, f).valid || l(this, f).invalidChildren--, l(e, h).parent = void 0, t.markValidityDirty(this);
+  releaseChild(t) {
+    u((e) => {
+      e.touch(this), e.touch(t), t.#e.valid || this.#e.invalidChildren--, t.validating && this.childValidatingChanged(!1), e.whenRolledBack(() => {
+        t.validating && this.childValidatingChanged(!0);
+      }), t.#t.parent = void 0, t.#t.fieldName = void 0, e.markValidityDirty(this);
     });
   }
   /**
@@ -1222,24 +1367,24 @@ class A {
    * an element at a position it already holds calls it, so the element is indistinguishable from one built for
    * that position.
    */
-  resetTo(e, t) {
-    g(() => {
-      const s = t === void 0 ? e.value : t, i = this.errors.length > 0;
+  resetTo(t, e) {
+    u(() => {
+      const s = e === void 0 ? t.value : e, i = this.errors.length > 0;
       i && (this.errors = []), this.touched = !1;
       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. */
-  resetChild(e, t, s) {
-    e.resetTo(t, s);
+  resetChild(t, e, s) {
+    t.resetTo(e, s);
   }
   /**
    * Records a child's new verdict in this element's tally. The child reports it as it settles, and the commit
    * settles the deepest element first, so the tally a container reads when its own turn comes is finished.
    */
-  childValidityChanged(e) {
-    l(this, f).invalidChildren += e ? -1 : 1;
+  childValidityChanged(t) {
+    this.#e.invalidChildren += t ? -1 : 1;
   }
   /**
    * The composed verdict a container answers `valid` with, memoised by Vue. The walk over the members is what
@@ -1247,35 +1392,39 @@ class A {
    * from repeating while nothing it read has moved.
    */
   get validRead() {
-    let e = xt.get(this);
-    return e || (e = Tt(() => this.composeValid()), xt.set(this, e)), e.value;
+    let t = ft.get(this);
+    return t || (t = Y(() => this.composeValid()), ft.set(this, t)), t.value;
   }
   /** What validRead computes. A leaf answers over its own errors; a container adds its members. */
   composeValid() {
-    return l(this, h).errors.length === 0;
+    return this.#t.errors.length === 0;
   }
   // default property handlers
   get visibility() {
-    return l(this, h).visibility;
-  }
-  set visibility(e) {
-    g((t) => {
-      var r, a;
-      const s = l(this, h).visibility, i = (r = this._actions) == null ? void 0 : r.trigger(Wt, this, e, s);
-      if (!N.isDefined(i != null ? i : e))
-        throw new Error("visibility must be a DisplayMode constant");
-      t.touch(this), l(this, h).visibility = N.fromAny(i != null ? i : e), (a = this._actions) == null || a.trigger($t, this, l(this, h).visibility, s);
+    return this.#t.visibility;
+  }
+  set visibility(t) {
+    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 l(this, h).enabled;
-  }
-  set enabled(e) {
-    g((t) => {
-      var r, a;
-      const s = l(this, h).enabled, i = (r = this._actions) == null ? void 0 : r.trigger(Bt, this, e, s);
-      if (!Kt(i != null ? i : e)) throw new Error("Enabled value must be boolean");
-      t.touch(this), l(this, h).enabled = i != null ? i : e, l(this, h).enabled !== s && this.bumpValueVersion(), (a = this._actions) == null || a.trigger(Mt, this, l(this, h).enabled, s);
+    return this.#t.enabled;
+  }
+  set enabled(t) {
+    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(Ft, this, this.#t.enabled, e);
+      }
     });
   }
   /**
@@ -1288,21 +1437,26 @@ class A {
   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.
    */
-  [Pt](e, t, s, i) {
-    if (i == null || i.forEach((u) => {
-      var c;
-      return (c = this._actions) == null ? void 0 : c.trigger(u.actionClass, this, u.item, u.index);
-    }), !t) return;
-    const r = this._actions;
-    if (this.composesValue && !(r != null && r.willTrigger(Ft) || r != null && r.hasEager)) return;
-    const a = this.value, o = l(this, f).announcedValue;
-    !s && (this.composesValue ? nt(a, o) : a === o) || (e.touch(this), l(this, f).announcedValue = a, this.composesValue && (r == null || r.triggerEager(this, a, o)), r == null || r.trigger(O, this, a, 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
@@ -1311,28 +1465,26 @@ class A {
    * 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.
    */
-  [Nt](e) {
-    var r;
-    const t = l(this, f).valid, s = this.countedValid;
-    if (s === t) return;
-    e.touch(this), l(this, f).valid = s;
-    const i = this.parent;
-    i && (e.touch(i), i.childValidityChanged(s), e.markValidityDirty(i)), (r = this._actions) == null || r.trigger(Ut, this, s, t);
-  }
-  validate(e = !1) {
-    g((t) => {
-      var s;
-      e && ((s = this._actions) == null || s.triggerEager(this, this.value, this.value)), t.markValidityDirty(this);
+  [At](t) {
+    const e = this.#e.valid, s = this.countedValid;
+    if (s === e) return;
+    t.touch(this), this.#e.valid = s;
+    const i = this.container;
+    i && (t.touch(i), i.childValidityChanged(s), t.markValidityDirty(i)), this.boundActions?.trigger(_t, this, s, e);
+  }
+  validate(t = !1) {
+    u((e) => {
+      t && this.boundActions?.triggerEager(this, this.value, this.value), e.markValidityDirty(this);
     });
   }
   get valid() {
-    return l(this, h).errors.length === 0;
+    return this.#t.errors.length === 0;
   }
   get fullValue() {
     return this.value;
   }
   get isChanged() {
-    return !nt(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
@@ -1342,26 +1494,28 @@ class A {
    * actions are the very instances `source` holds - what a binding takes on is data, not behaviour - and each is
    * told about this element as it is taken on, so an action serving several bindings knows all of them.
    */
-  boundFrom(e, t, s, i) {
-    l(this, f).declaration = e.declaration;
-    const r = p(p({}, e.extra), i && this.extendedOf(i));
-    L(r) || this.setExtendedValues(r);
-    const a = e._actions;
-    a && (this._actions = a.clone(), this._actions.bindTo(this), this._actions.triggerEager(this, t, s));
+  boundFrom(t, e, s, i) {
+    this.#e.declaration = t.declaration;
+    const r = { ...t.extra, ...i && this.extendedOf(i) };
+    _(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,
    * because a constructor ends with a single this.actions.triggerEager(...) over the finished value, and an
    * eager action registered here would otherwise also run once per registration, over a half-built field.
    */
-  registerInitialActions(e) {
-    e.forEach((t) => {
-      this.actions.register(t), t.boundToBinding(this);
+  registerInitialActions(t) {
+    t.forEach((e) => {
+      this.actions.register(e), e.boundToBinding(this);
     });
   }
-  registerAction(e) {
-    return g((t) => {
-      t.willAnnounceValue(this) || this.refreshPreviousValue(), this.actions.register(e), this.registered(t, e), e.eager && this.actions.triggerEagerFor(e.classIdentifier, this, this.value, this.originalValue);
+  registerAction(t) {
+    return u((e) => {
+      e.willAnnounceValue(this) || this.refreshPreviousValue(), this.actions.register(t), this.registered(e, t);
     }), this;
   }
   /**
@@ -1370,9 +1524,9 @@ class A {
    * handler already registered, which registration order alone cannot arrange. `before` has to be registered on
    * this element under the same identifier.
    */
-  registerActionBefore(e, t) {
-    return g((s) => {
-      s.willAnnounceValue(this) || this.refreshPreviousValue(), this.actions.register(e, t), this.registered(s, e), e.eager && this.actions.triggerEagerFor(e.classIdentifier, this, this.value, this.originalValue);
+  registerActionBefore(t, e) {
+    return u((s) => {
+      s.willAnnounceValue(this) || this.refreshPreviousValue(), this.actions.register(t, e), this.registered(s, t);
     }), this;
   }
   /**
@@ -1381,27 +1535,33 @@ class A {
    * withdraws the errors it put on this element as it goes, so the verdict the element reports is the one the
    * validators it still holds reach.
    */
-  unregisterAction(e) {
-    let t = !1;
-    return g((s) => {
-      const i = this._actions;
-      i && (t = i.unregister(e), t && (s.touch(this), e instanceof v && l(this, h).validationEpoch++, s.whenRolledBack(() => {
-        i.register(e), e.boundToBinding(this);
-      }), e.unregisterFrom(this)));
-    }), t;
+  unregisterAction(t) {
+    let e = !1;
+    return u((s) => {
+      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;
   }
   /**
    * Records that `action` is now registered on this element, and that a rollback has to take that back. The
    * registration is not one of the state slots the snapshot covers, so it hands its own undo in.
    */
-  registered(e, t) {
-    t.boundToBinding(this), e.whenRolledBack(() => {
-      var s;
-      (s = this._actions) != null && s.unregister(t) && t.unregisterFrom(this);
+  registered(t, e) {
+    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(e, ...t) {
-    return this._actions ? this._actions.trigger(e, this, ...t) : null;
+  triggerAction(t, ...e) {
+    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
@@ -1409,30 +1569,49 @@ class A {
    * cannot push an error onto a field that no longer has the validator that produced it.
    */
   get validationEpoch() {
-    return l(this, h).validationEpoch;
+    return this.#t.validationEpoch;
   }
   clearValidators() {
-    g((e) => {
-      e.touch(this), l(this, h).validationEpoch++;
-      const t = this._actions;
-      t && t.validators.forEach((s) => {
-        t.unregister(s), e.whenRolledBack(() => {
-          t.register(s), s.boundToBinding(this);
-        }), s.unregisterFrom(this);
-      }), this.errors = [], this.validate();
+    u((t) => {
+      t.touch(this), this.#t.validationEpoch++;
+      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();
     });
   }
 }
-h = new WeakMap(), f = new WeakMap();
-function Se(n, e) {
-  return n ? !e : e;
+function me(n, t) {
+  return n ? !t : t;
 }
-class I {
-  constructor(e, t, s) {
-    d(this, "operand1");
-    d(this, "operator");
-    d(this, "operand2");
-    this.operand1 = e, this.operator = t, this.operand2 = s;
+class w {
+  operand1;
+  operator;
+  operand2;
+  /**
+   * An operand is a nested `Statement`, a `FieldBase` whose value is compared, or a literal. `undefined` and a
+   * function are neither: they are what a misspelled field name and a field accessor handed over uncalled answer
+   * with, and a statement built from one compares nothing and never fires. The position names which of the two
+   * operands is at fault, so the error points at the place the name was written.
+   */
+  static validateOperand(t, e) {
+    if (t === void 0)
+      throw new TypeError(
+        `Statement operand ${e} is undefined: an operand is a field, a nested statement or a literal, and a name resolving to nothing is none of them. Compare against null to test for an unset value.`
+      );
+    if (typeof t == "function")
+      throw new TypeError(
+        `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').`
+      );
+  }
+  constructor(t, e, 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:
@@ -1440,66 +1619,65 @@ class I {
    * record of the statement's own - a form field above the list - is read where it stands. A record that does not
    * hold the field yet contributes undefined, which is what a half-built row answers with.
    */
-  static valueOf(e, t) {
-    if (e instanceof I) return e.evaluate(t);
-    if (e instanceof A) {
-      const s = t ? lt(e, t) : e;
-      return s ? b(s.value) : void 0;
+  static valueOf(t, e) {
+    if (t instanceof w) return t.evaluate(e);
+    if (t instanceof y) {
+      const s = e ? et(t, e) : t;
+      return s ? h(s.value) : void 0;
     }
-    return e;
+    return t;
   }
   get operand1Value() {
-    return I.valueOf(this.operand1);
+    return w.valueOf(this.operand1);
   }
   get operand2Value() {
-    return I.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(e) {
-    var i, r;
-    const t = I.valueOf(this.operand1, e), s = I.valueOf(this.operand2, e);
+  evaluate(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
       // coercion evaluate() would hand out the operand itself, so `0` or `''` would reach callers that the
       // signature promises a boolean, and consumers comparing results with !== would see a change where the
       // logical value stayed the same.
-      case m.AND:
-        return !!(t && s);
-      case m.OR:
-        return !!(t || s);
-      case m.NAND:
-        return !(t && s);
-      case m.NOR:
-        return !(t || s);
-      case m.XOR:
-        return Se(!!t, !!s);
-      case m.NOT:
-        return !t;
+      case c.AND:
+        return !!(e && s);
+      case c.OR:
+        return !!(e || s);
+      case c.NAND:
+        return !(e && s);
+      case c.NOR:
+        return !(e || s);
+      case c.XOR:
+        return me(!!e, !!s);
+      case c.NOT:
+        return !e;
       // comparison operators
-      case m.EQUALS:
-        return t == s;
-      case m.NOT_EQUALS:
-        return t != s;
-      case m.LT:
-        return t < s;
-      case m.LE:
-        return t <= s;
-      case m.GE:
-        return t >= s;
-      case m.GT:
-        return t > s;
-      case m.IN:
-        return !!((i = s == null ? void 0 : s.includes) != null && i.call(s, t));
-      case m.NOT_IN:
-        return !((r = s == null ? void 0 : s.includes) != null && r.call(s, t));
-      case m.INCLUDES:
-        return j(t) && j(s) && t.indexOf(s) >= 0;
-      case m.NOT_INCLUDES:
-        return !(j(t) && j(s) && t.indexOf(s) >= 0);
+      case c.EQUALS:
+        return e == s;
+      case c.NOT_EQUALS:
+        return e != s;
+      case c.LT:
+        return e < s;
+      case c.LE:
+        return e <= s;
+      case c.GE:
+        return e >= s;
+      case c.GT:
+        return e > s;
+      case c.IN:
+        return !!s?.includes?.(e);
+      case c.NOT_IN:
+        return !s?.includes?.(e);
+      case c.INCLUDES:
+        return C(e) && C(s) && e.indexOf(s) >= 0;
+      case c.NOT_INCLUDES:
+        return !(C(e) && C(s) && e.indexOf(s) >= 0);
       default:
         throw new Error(`Operator not implemented ${this.operator}`);
     }
@@ -1509,82 +1687,90 @@ class I {
    * @returns A set of all fields used in this statement
    */
   collectFields() {
-    const e = /* @__PURE__ */ new Set();
-    function t(s) {
-      s instanceof A ? e.add(s) : s instanceof I && s.collectFields().forEach((r) => e.add(r));
+    const t = /* @__PURE__ */ new Set();
+    function e(s) {
+      s instanceof y ? t.add(s) : s instanceof w && s.collectFields().forEach((r) => t.add(r));
     }
-    return t(this.operand1), t(this.operand2), e;
+    return e(this.operand1), e(this.operand2), t;
   }
 }
-const Ie = /* @__PURE__ */ Symbol("ExecuteAction");
-class qt extends y {
-  constructor(e) {
-    super(e);
+const be = /* @__PURE__ */ Symbol("ExecuteAction");
+class Nt extends m {
+  constructor(t) {
+    super(t);
   }
   static get classIdentifier() {
-    return Ie;
+    return be;
   }
-  execute(e, t, s) {
-    return super.execute(e, t, s);
+  execute(t, e, s) {
+    return super.execute(t, e, s);
   }
 }
-const Ae = /* @__PURE__ */ Symbol("ListItemAddedAction");
-class rt extends y {
-  constructor(e) {
-    super(e);
+const ve = /* @__PURE__ */ Symbol("ListItemAddedAction");
+class J extends m {
+  constructor(t) {
+    super(t);
   }
   static get classIdentifier() {
-    return Ae;
+    return ve;
   }
-  execute(e, t, s, i) {
-    return super.execute(e, t, s, i);
+  execute(t, e, s, i) {
+    return super.execute(t, e, s, i);
   }
 }
-const _e = /* @__PURE__ */ Symbol("ListItemRemovedAction");
-class zt extends y {
-  constructor(e) {
-    super(e);
+const we = /* @__PURE__ */ Symbol("ListItemRemovedAction");
+class Bt extends m {
+  constructor(t) {
+    super(t);
   }
   static get classIdentifier() {
-    return _e;
+    return we;
   }
-  execute(e, t, s, i) {
-    return super.execute(e, t, s, i);
+  execute(t, e, s, i) {
+    return super.execute(t, e, s, i);
   }
 }
-const Te = Object.freeze({});
-function Ht() {
+const Ve = Object.freeze({});
+function Dt() {
   return {
     originalValue: void 0,
     announcedValue: void 0,
     errors: [],
-    visibility: N.FULL,
+    visibility: I.FULL,
     enabled: !0,
     valueVersion: 0,
     validatingCount: 0,
+    validatingChildren: 0,
     parent: void 0,
     fieldName: void 0,
     validationEpoch: 0,
     declaration: void 0,
-    extra: Te,
+    extra: Ve,
     valid: !0,
     invalidChildren: 0
   };
 }
-function Oe() {
-  return C(p({}, Ht()), { value: void 0, touched: !1 });
+function ye() {
+  return { ...Dt(), value: void 0, touched: !1 };
 }
-function Qt() {
-  return C(p({}, Ht()), {
+function Lt() {
+  return {
+    ...Dt(),
     announcedValue: null,
     cachedValue: null,
     cachedValueVersion: -1
-  });
+  };
+}
+function Ee() {
+  return { ...Lt(), fieldNames: [] };
 }
-function Fe() {
-  return C(p({}, Qt()), { rows: null });
+function Ce() {
+  return { ...Lt(), rows: null, rowsVersion: 0, cachedItems: null, cachedItemsVersion: -1 };
 }
-class X extends A {
+class st extends y {
+  get [Symbol.toStringTag]() {
+    return "Field";
+  }
   get state() {
     return super.state;
   }
@@ -1595,11 +1781,11 @@ class X extends A {
   get _value() {
     return this.state.value;
   }
-  set _value(e) {
-    this.state.value = e;
+  set _value(t) {
+    this.state.value = t;
   }
-  constructor(e) {
-    super(Oe()), this.init(e);
+  constructor(t) {
+    super(ye()), this.init(t);
   }
   /**
    * Applies the constructor parameters. It is a hook so that a subclass needing different parameter handling
@@ -1610,63 +1796,66 @@ class X extends A {
    * subclass initializes read as undefined inside it, and anything it writes to such a member is overwritten
    * the moment the initializer runs.
    */
-  init(e) {
-    g(() => {
-      var s;
-      if (e) {
-        const t = e, { value: i, validators: r, actions: a } = t, o = k(t, ["value", "validators", "actions"]);
-        this.registerInitialActions([...r || [], ...a || []]), this.assignParams(o), this._value = i !== void 0 ? i : this.originalValue, this.originalValue === void 0 && (this.originalValue = this._value);
+  init(t) {
+    u(() => {
+      if (t) {
+        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.originalValue === void 0 && (this.originalValue = this._value);
       }
-      this.raw.announcedValue = this._value, (s = this._actions) == null || s.triggerEager(this, this.value, this.originalValue), this.validate();
+      this.raw.announcedValue = this._value, this.boundActions?.triggerEager(this, this.value, this.originalValue), this.validate();
     });
   }
   get value() {
     return this._value;
   }
-  set value(e) {
-    const t = this._value;
-    !this.enabled || t === e || g((s) => {
-      var i;
-      s.touch(this), this._value = e, this.bumpValueVersion(), (i = this._actions) == null || i.triggerEager(this, e, t), this.propagateValueChanged();
+  set value(t) {
+    const e = this._value;
+    !this.enabled || e === t || u((s) => {
+      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;
   }
-  set touched(e) {
-    this.touchState(), this.state.touched = e;
+  set touched(t) {
+    this.touchState(), this.state.touched = t;
   }
-  bind(e, t) {
-    var r, a;
-    const s = this.constructor, i = new s(C(p({
+  bind(t, e) {
+    const s = this.constructor, i = new s({
       // data is what the caller supplied, and undefined is not supplied; an explicit null is, and clears
-      value: e !== void 0 ? e : this.value
-    }, t && "originalValue" in t ? { originalValue: t.originalValue } : {}), {
-      enabled: (r = t == null ? void 0 : t.enabled) != null ? r : this.enabled,
-      visibility: (a = t == null ? void 0 : t.visibility) != null ? a : this.visibility
-    }));
-    return i.boundFrom(this, i.value, i.originalValue, t), i;
-  }
-}
-const je = new X({ value: "EmptyField" }).registerAction(
-  new O(() => {
-    console.warn("Working with EmptyField! This should not happen");
-  })
-), It = /* @__PURE__ */ new WeakMap();
-function it(n, e) {
-  return (n == null ? void 0 : n.label) == null && (n == null ? void 0 : n.icon) == null ? e : n;
-}
-class Pe extends X {
-  init(e) {
-    g(() => {
-      var s;
-      if (this._value = { label: void 0, icon: void 0 }, e) {
-        const t = e, { value: i, originalValue: r, validators: a, actions: o } = t, u = k(t, ["value", "originalValue", "validators", "actions"]);
-        this.registerInitialActions([...a || [], ...o || []]), this.assignParams(u);
-        const c = it(i, this._value), x = Object.freeze({ label: r == null ? void 0 : r.label, icon: r == null ? void 0 : r.icon });
-        this._value = it(c, p({}, x)), this.originalValue = it(x, c);
+      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.value, i.originalValue, e), i;
+  }
+}
+const bt = /* @__PURE__ */ new WeakMap();
+function K(n, t) {
+  return n?.label == null && n?.icon == null ? t : n;
+}
+class Se extends st {
+  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: r, ...a } = t;
+        this.registerInitialActions([...i || [], ...r || []]), this.assignParams(a);
+        const o = K(e, this._value), l = Object.freeze({ label: s?.label, icon: s?.icon });
+        this._value = K(o, { ...l }), this.originalValue = K(l, o);
       }
-      this.raw.announcedValue = this._value, (s = this._actions) == null || s.triggerEager(this, this.value, this.originalValue), this.validate();
+      this.raw.announcedValue = this._value, this.boundActions?.triggerEager(this, this.value, this.originalValue), this.validate();
     });
   }
   /**
@@ -1675,15 +1864,15 @@ class Pe extends X {
    * JSON, but lodash isEqual compares own-key sets, so writing one would leave the action permanently changed
    * against a baseline that never carried the key.
    */
-  valueWith(e, t) {
-    const s = p({}, this.value);
-    return t === void 0 ? delete s[e] : s[e] = t, s;
+  valueWith(t, e) {
+    const s = { ...this.value };
+    return e === void 0 ? delete s[t] : s[t] = e, s;
   }
   get icon() {
     return this.value.icon;
   }
-  set icon(e) {
-    this.value.icon !== e && (this.value = this.valueWith("icon", e));
+  set icon(t) {
+    this.value.icon !== t && (this.value = this.valueWith("icon", t));
   }
   get label() {
     return this.value.label;
@@ -1695,13 +1884,13 @@ class Pe extends X {
    * identity and every copy is a new object, so without the comparison here a write of the value already held
    * would announce a change and invalidate the value cache of every container above.
    */
-  set label(e) {
-    this.value.label !== e && (this.value = this.valueWith("label", e));
+  set label(t) {
+    this.value.label !== t && (this.value = this.valueWith("label", t));
   }
   /** the counter behind `busy`, allocated for this action the first time it is asked for */
   get busyRuns() {
-    let e = It.get(this);
-    return e || (e = se(0), It.set(this, e)), e;
+    let t = bt.get(this);
+    return t || (t = Wt(0), bt.set(this, t)), t;
   }
   /** true from the moment execute() is called until the handler it ran has settled, however it settles */
   get busy() {
@@ -1717,26 +1906,24 @@ class Pe extends X {
    * out of this call: a caller that does not await the answer and does not attach a catch handler leaves that
    * rejection unhandled.
    */
-  execute(e) {
-    return vt(this, null, function* () {
-      const t = this.busyRuns;
-      t.value++;
-      try {
-        return yield this.triggerAction(qt, e);
-      } finally {
-        t.value--;
-      }
-    });
+  async execute(t) {
+    const e = this.busyRuns;
+    e.value++;
+    try {
+      return await this.triggerAction(Nt, t);
+    } finally {
+      e.value--;
+    }
   }
 }
-const Ne = /* @__PURE__ */ ie({
+const xe = /* @__PURE__ */ qt({
   __name: "messages-widget",
   props: {
     message: {},
     classes: {}
   },
   setup(n) {
-    const e = n, t = Vt("vue-markdown"), s = /* @__PURE__ */ new Set([
+    const t = n, e = ut("vue-markdown"), s = /* @__PURE__ */ new Set([
       "div",
       "span",
       "p",
@@ -1793,23 +1980,23 @@ const Ne = /* @__PURE__ */ ie({
       "dt",
       "dd"
     ]), i = () => {
-      if (typeof e.message == "string") return R("span", { class: e.classes }, e.message);
+      if (typeof t.message == "string") return k("span", { class: t.classes }, t.message);
       const r = [];
-      return e.message.forEach((a) => {
+      return t.message.forEach((a) => {
         switch (a.componentName) {
           case "template":
-            r.push(R("div", { class: [e.classes, a.extraClasses] }, a.componentBody));
+            r.push(k("div", { class: [t.classes, a.extraClasses] }, a.componentBody));
             break;
           case "vue-markdown":
-            if (typeof t == "string")
+            if (typeof e == "string")
               console.warn(
                 "You are using markdown for messages-widget, but you haven't registered a vue-markdown component"
-              ), r.push(R("div", { class: [e.classes, a.extraClasses] }, a.componentBindings.source));
+              ), r.push(k("div", { class: [t.classes, a.extraClasses] }, a.componentBindings.source));
             else {
               const o = a.componentBindings;
               r.push(
-                R(t, {
-                  class: [e.classes, a.extraClasses, "df-messages-widget-markdown"],
+                k(e, {
+                  class: [t.classes, a.extraClasses, "df-messages-widget-markdown"],
                   source: o.source,
                   options: o.options,
                   plugins: o.plugins
@@ -1819,35 +2006,47 @@ const Ne = /* @__PURE__ */ ie({
             break;
           default:
             r.push(
-              R(
-                s.has(a.componentName.toLowerCase()) ? a.componentName : Vt(a.componentName),
-                p(p({
-                  class: [e.classes, a.extraClasses]
-                }, a.componentBindings), a.componentBody ? { innerHTML: a.componentBody } : {})
+              k(
+                s.has(a.componentName.toLowerCase()) ? a.componentName : ut(a.componentName),
+                {
+                  class: [t.classes, a.extraClasses],
+                  ...a.componentBindings,
+                  ...a.componentBody ? { innerHTML: a.componentBody } : {}
+                }
               )
             );
             break;
         }
       }), r;
     };
-    return (r, a) => (ne(), re(i));
+    return (r, a) => (zt(), Ht(i));
+  }
+}), vt = /* @__PURE__ */ new WeakMap(), Ae = (n) => ({
+  get(t, e, s) {
+    return n(), Reflect.get(t, e, s);
+  },
+  has(t, e) {
+    return n(), Reflect.has(t, e);
+  },
+  ownKeys(t) {
+    return n(), Reflect.ownKeys(t);
+  },
+  getOwnPropertyDescriptor(t, e) {
+    return n(), Reflect.getOwnPropertyDescriptor(t, e);
+  },
+  set(t, e) {
+    throw new TypeError(`fields.${String(e)} cannot be assigned: use addField() to give the group a member`);
+  },
+  defineProperty(t, e) {
+    throw new TypeError(`fields.${String(e)} cannot be redefined: use addField() to give the group a member`);
+  },
+  deleteProperty(t, e) {
+    throw new TypeError(`fields.${String(e)} cannot be deleted: use removeField() to take a member out`);
   }
 });
-class w extends A {
-  constructor(t, s) {
-    super(Qt());
-    d(this, "_fields");
-    if (!w.isValidFields(t)) throw new Error("Invalid fields object provided");
-    this._fields = /* @__PURE__ */ Object.create(null), g(() => {
-      var a;
-      if (Object.entries(t).forEach(([o, u]) => this.addField(o, u)), s) {
-        const r = s, { value: o, validators: u, actions: c } = r, x = k(r, ["value", "validators", "actions"]);
-        this.registerInitialActions([...u || [], ...c || []]), this.assignParams(x), o !== void 0 ? this.assignMembers(o) : this.originalValue !== void 0 && this.assignMembers(this.originalValue);
-      }
-      this.completeRecords();
-      const i = this.value;
-      this.originalValue === void 0 && (this.originalValue = w.baseline(i)), this.raw.announcedValue = i, (a = this._actions) == null || a.triggerEager(this, i, this.originalValue), this.validate();
-    });
+class d extends y {
+  get [Symbol.toStringTag]() {
+    return "Group";
   }
   get state() {
     return super.state;
@@ -1855,51 +2054,126 @@ class w extends A {
   get raw() {
     return super.raw;
   }
+  _fields;
+  constructor(t, e) {
+    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, 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();
+      const s = this.value;
+      this.originalValue === void 0 && (this.originalValue = d.baseline(s)), this.raw.announcedValue = s, this.boundActions?.triggerEager(this, s, this.originalValue), this.validate();
+    });
+  }
+  /**
+   * The name array is copied as well: a rollback puts back the set of members the group held, not the array it
+   * went on to hold.
+   */
+  [O]() {
+    const t = super[O]();
+    return t.fieldNames = [...this.raw.fieldNames], t;
+  }
   /**
    * The copy of a built value that serves as a baseline. The value getter hands out one object per version, and
    * a baseline holding that same object would report every value as its own original.
    */
   static baseline(t) {
-    return t == null ? t : p({}, t);
+    return t == null ? t : { ...t };
   }
-  addField(t, s) {
-    if (Object.hasOwn(this._fields, t))
-      throw new Error(`Field ${t} is already in this form`);
-    this.takeChild(s, t), Object.defineProperty(this._fields, t, { get: () => s, configurable: !1, enumerable: !0 });
+  /**
+   * Takes `field` into this group under `fieldName`. The group ends up holding it exactly as it holds a field the
+   * constructor was given: the field carries the back-reference and the name, its verdict counts towards the
+   * group's, and a rule of the field's that names another member of the form reaches it here.
+   *
+   * The change is announced through the ordinary path, so a group whose value the new field adds to says so once
+   * the transaction closes, and its verdict is re-formed over the members it now holds. The baseline behind
+   * `isChanged` is not rewritten: a group that gains a field holds something its original value does not carry,
+   * and reports itself changed until `originalValue` is written.
+   *
+   * @throws Error where this group already holds a field under `fieldName`.
+   * @throws TypeError where `field` already belongs to a container - pass a `bind()` of it instead.
+   */
+  addField(t, e) {
+    return u((s) => {
+      if (Object.hasOwn(this._fields, t))
+        throw new Error(`Field ${t} is already in this form`);
+      this.takeChild(e, t), s.touch(this), d.setEntry(this._fields, t, e), s.whenRolledBack(() => d.dropEntry(this._fields, t)), this.state.fieldNames.push(t), this.completeRecords(e), this.bumpValueVersion(), this.notifyValueChanged();
+    }), this;
+  }
+  /**
+   * Takes the field held under `fieldName` out of this group and hands it back, answering undefined where the
+   * group holds no field of that name. The field is released whole: the back-reference and the name are gone, its
+   * verdict and its runs in flight no longer count towards the group's, and it is free to be taken by another
+   * container. What it holds - its value, its errors, the change history behind `isChanged` - is its own to report.
+   *
+   * The change is announced through the ordinary path, so the group's value and verdict settle over the members it
+   * has left. The baseline behind `isChanged` is not rewritten, the same way it is not on `addField`.
+   */
+  removeField(t) {
+    let e;
+    return u((s) => {
+      if (!Object.hasOwn(this._fields, t)) return;
+      const i = this._fields[t];
+      s.touch(this), this.releaseChild(i), d.dropEntry(this._fields, t), s.whenRolledBack(() => d.setEntry(this._fields, t, i)), this.state.fieldNames.splice(this.state.fieldNames.indexOf(t), 1), this.bumpValueVersion(), this.notifyValueChanged(), e = i;
+    }), e;
+  }
+  /**
+   * Writes one entry of the member map. The map is typed by the fields interface, which names the members a group
+   * of that type holds and no others, so both here and in dropEntry it is reached as the plain record it is.
+   */
+  static setEntry(t, e, s) {
+    t[e] = s;
+  }
+  /** Drops one entry out of the member map. */
+  static dropEntry(t, e) {
+    delete t[e];
   }
   static isValidFields(t) {
-    function s(i) {
-      return i instanceof A;
+    function e(s) {
+      return s instanceof y;
     }
-    return typeof t == "object" && t !== null && Object.entries(t).every(([, i]) => s(i));
+    return typeof t == "object" && t !== null && Object.entries(t).every(([, s]) => e(s));
   }
   static createFromFormData(t) {
-    if (t instanceof A)
+    if (t instanceof y)
       throw new Error("data is already a Form structure, should be a simple object");
-    return new w(
-      t == null ? {} : Object.fromEntries(Object.entries(t).map(([s, i]) => [s, new X({ value: i })]))
+    return new d(
+      t == null ? {} : Object.fromEntries(Object.entries(t).map(([e, s]) => [e, new st({ value: s })]))
     );
   }
   field(t) {
-    var s;
-    return (s = this._fields[t]) != null ? s : null;
+    return this._fields[t] ?? null;
   }
+  /**
+   * The typed map of this group's members. What it hands out is a view over the map the group holds: reading it
+   * reaches the members themselves, and every write to it is refused - addField() and removeField() are what
+   * change the set. The view is built the first time something asks for it.
+   *
+   * Reading through it is a tracked read of the set of members, so a template rendering off `group.fields`
+   * re-renders when a field is added or removed; what a member itself holds is tracked by that member.
+   */
   get fields() {
-    return this._fields;
+    let t = vt.get(this);
+    return t || (t = new Proxy(
+      this._fields,
+      Ae(() => this.state.fieldNames.length)
+    ), vt.set(this, t)), t;
   }
   get members() {
-    return Object.values(this._fields);
+    return this.raw.fieldNames.map((t) => this._fields[t]);
   }
   get value() {
     const t = this.valueVersion;
     if (this.raw.cachedValueVersion === t) return this.raw.cachedValue;
-    const s = /* @__PURE__ */ Object.create(null);
-    Object.entries(this._fields).forEach(([r, a]) => {
-      const o = a.value;
-      (a.enabled || a instanceof w && !L(o)) && (s[r] = o);
+    const e = /* @__PURE__ */ Object.create(null);
+    Object.entries(this._fields).forEach(([i, r]) => {
+      const a = r.value;
+      (r.enabled || this.childComposesValue(r) && !_(a)) && (e[i] = a);
     });
-    const i = L(s) ? null : Object.freeze(p({}, s));
-    return this.raw.cachedValue = i, this.raw.cachedValueVersion = t, i;
+    const s = _(e) ? null : Object.freeze({ ...e });
+    return this.raw.cachedValue = s, this.raw.cachedValueVersion = t, s;
   }
   /**
    * Writes the members that the given value carries. The members are written one by one and the group says
@@ -1907,15 +2181,15 @@ class w extends A {
    * once, over the finished set, and announces each at most once.
    */
   assignMembers(t) {
-    g(() => {
-      Object.entries(this._fields).forEach(([s, i]) => {
-        (t == null || Object.hasOwn(t, s)) && (i.value = t == null ? null : t[s]);
+    u(() => {
+      Object.entries(this._fields).forEach(([e, s]) => {
+        (t == null || Object.hasOwn(t, e)) && (s.value = t == null ? null : t[e]);
       });
     });
   }
   set value(t) {
-    g((s) => {
-      this.assignMembers(t), s.markValidityDirty(this);
+    u((e) => {
+      this.assignMembers(t), e.markValidityDirty(this);
     });
   }
   /**
@@ -1923,33 +2197,32 @@ class w extends A {
    * value carries, while a member the value leaves out has to end up holding what the template gives it. `source`
    * supplies that per member, so a group reset from the template it was bound from matches a fresh binding of it.
    */
-  resetTo(t, s) {
-    const i = t;
-    g((r) => {
-      r.touch(this), this.errors.length && (this.errors = []), Object.entries(this._fields).forEach(([o, u]) => {
-        var x;
-        let c;
-        s === null ? c = null : s !== void 0 && Object.hasOwn(s, o) && (c = s[o]), this.resetChild(u, (x = i.field(o)) != null ? x : u, c);
+  resetTo(t, e) {
+    const s = t;
+    u((i) => {
+      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, a) && (l = e[a]), this.resetChild(o, s.field(a) ?? o, l);
       });
-      const a = this.value;
-      this.raw.announcedValue = a, this.originalValue = w.baseline(a), super.validate(!0);
+      const r = this.value;
+      this.raw.announcedValue = r, this.originalValue = d.baseline(r), super.validate(!0);
     });
   }
   get touched() {
     return Object.values(this._fields).some((t) => t.touched);
   }
   set touched(t) {
-    g(() => {
-      Object.values(this._fields).forEach((s) => {
-        s.touched = t;
+    u(() => {
+      Object.values(this._fields).forEach((e) => {
+        e.touched = t;
       });
     });
   }
   get fullValue() {
     const t = /* @__PURE__ */ Object.create(null);
-    return Object.entries(this._fields).forEach(([s, i]) => {
-      t[s] = i.fullValue;
-    }), p({}, t);
+    return Object.entries(this._fields).forEach(([e, s]) => {
+      t[e] = s.fullValue;
+    }), { ...t };
   }
   /**
    * Records that a member changed its value, so that the transaction in progress works out at commit what this
@@ -1973,27 +2246,45 @@ class w extends A {
     return this.validRead;
   }
   composeValid() {
-    return this.state.errors.length === 0 && Object.values(this._fields).every((t) => t.valid);
+    return this.state.errors.length === 0 && this.state.fieldNames.every((t) => this._fields[t].valid);
+  }
+  get busy() {
+    return this.busyRead;
+  }
+  composeBusy() {
+    return this.state.fieldNames.some((t) => this._fields[t].busy);
   }
   validate(t = !1) {
-    g(() => {
-      t && Object.values(this._fields).forEach((s) => s.validate(!0)), super.validate(t);
+    u(() => {
+      t && Object.values(this._fields).forEach((e) => e.validate(!0)), super.validate(t);
     });
   }
-  bind(t, s) {
-    var a, o;
-    const i = /* @__PURE__ */ Object.create(null);
-    Object.entries(this._fields).forEach(([u, c]) => {
-      i[u] = c.bind();
+  /**
+   * 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, o]) => {
+      s[a] = o.bind();
     });
-    const r = new w(i, C(p({
+    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
-    }, s && "originalValue" in s ? { originalValue: s.originalValue } : {}), {
-      enabled: (a = s == null ? void 0 : s.enabled) != null ? a : this.enabled,
-      visibility: (o = s == null ? void 0 : s.visibility) != null ? o : this.visibility
-    }));
-    return r.boundFrom(this, r.raw.announcedValue, r.originalValue, s), r;
+      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 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
@@ -2003,18 +2294,9 @@ class w extends A {
     return super.rebind(t);
   }
 }
-class D extends A {
-  constructor(t, s) {
-    super(Fe());
-    d(this, "_itemTemplate");
-    this._itemTemplate = t, g(() => {
-      var r;
-      if (s) {
-        const i = s, { value: a, validators: o, actions: u } = i, c = k(i, ["value", "validators", "actions"]);
-        this.registerInitialActions([...o || [], ...u || []]), this.assignParams(c), a != null && this.setValueInternal(a);
-      }
-      this.originalValue === void 0 && (this.originalValue = D.baseline(this.value)), this.raw.announcedValue = this.value, (r = this._actions) == null || r.triggerEager(this, this.value, this.originalValue), this.validate();
-    });
+class F extends y {
+  get [Symbol.toStringTag]() {
+    return "List";
   }
   get state() {
     return super.state;
@@ -2022,9 +2304,19 @@ class D extends A {
   get raw() {
     return super.raw;
   }
+  _itemTemplate;
+  constructor(t, e) {
+    super(Ce()), this._itemTemplate = t, u(() => {
+      if (e) {
+        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 = F.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. */
-  [$]() {
-    const t = super[$]();
+  [O]() {
+    const t = super[O]();
     return t.rows = this.raw.rows ? [...this.raw.rows] : this.raw.rows, t;
   }
   /**
@@ -2035,8 +2327,8 @@ class D extends A {
     return t == null ? t : [...t];
   }
   processSetValueItem(t) {
-    let s;
-    return t instanceof w ? s = t : this._itemTemplate ? s = this._itemTemplate.bind(t) : s = w.createFromFormData(t), this.takeChild(s), this.completeRecords(s), s;
+    let e;
+    return t instanceof d ? e = t : this._itemTemplate ? e = this._itemTemplate.bind(t) : e = d.createFromFormData(t), this.takeChild(e), this.completeRecords(e), e;
   }
   /**
    * Builds the item that fills a gap left by an insert beyond the end of the list: the item template bound to its
@@ -2045,32 +2337,43 @@ class D extends A {
   createPaddingItem() {
     return this.processSetValueItem(this._itemTemplate ? this._itemTemplate.bind() : null);
   }
+  /** Records that the set of rows changed, so `items` rebuilds the frozen array it hands out at the next read. */
+  rowsChanged() {
+    this.state.rowsVersion++;
+  }
+  /** 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((r, a) => r !== i[a]);
+  }
   setValueInternal(t) {
-    g((s) => {
-      var i;
-      if (s.touch(this), t == null)
+    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 r = (i = this.state.rows) != null ? i : [], a = new Array(t.length);
-        for (let o = 0; o < t.length; o++) {
-          const u = t[o], c = r[o];
-          c && this._itemTemplate && !(u instanceof w) ? (this.resetChild(c, this._itemTemplate, u), a[o] = c) : (c && this.releaseChild(c), a[o] = this.processSetValueItem(u));
+      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 o = t.length; o < r.length; o++) this.releaseChild(r[o]);
-        this.state.rows = a;
+        for (let a = t.length; a < i.length; a++) this.releaseChild(i[a]);
+        this.state.rows = r;
       }
-      this.bumpValueVersion();
+      F.rowsDiffer(s, this.raw.rows) && this.rowsChanged(), this.bumpValueVersion();
     });
   }
   get value() {
-    var r;
     const t = this.valueVersion;
     if (this.raw.cachedValueVersion === t) return this.raw.cachedValue;
-    const s = (r = this.state.rows) == null ? void 0 : r.map((a) => a.value), i = L(s) ? null : Object.freeze(s);
-    return this.raw.cachedValue = i, this.raw.cachedValueVersion = t, i;
+    const e = this.state.rows?.map((i) => i.value), s = _(e) ? null : Object.freeze(e);
+    return this.raw.cachedValue = s, this.raw.cachedValueVersion = t, s;
   }
   set value(t) {
-    g(() => {
+    u(() => {
       this.setValueInternal(t), this.propagateValueChanged(!0);
     });
   }
@@ -2078,35 +2381,36 @@ class D extends A {
    * The rows are taken from `source` where the caller supplied no value of its own, so a list nested in a row that
    * a whole-list assignment reuses ends up holding what the template gives it rather than what it held before.
    */
-  resetTo(t, s) {
-    g((i) => {
-      i.touch(this), this.errors.length && (this.errors = []), this.setValueInternal(s === void 0 ? t.value : s);
-      const r = this.value;
-      this.raw.announcedValue = r, this.originalValue = D.baseline(r), super.validate(!0);
+  resetTo(t, e) {
+    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 = F.baseline(i), super.validate(!0);
     });
   }
   get touched() {
-    var t;
-    return ((t = this.state.rows) == null ? void 0 : t.some((s) => s.touched)) || !1;
+    return this.state.rows?.some((t) => t.touched) || !1;
   }
   set touched(t) {
-    g(() => {
-      var s;
-      (s = this.state.rows) == null || s.forEach((i) => {
-        i.touched = t;
+    u(() => {
+      this.state.rows?.forEach((e) => {
+        e.touched = t;
       });
     });
   }
-  bind(t, s) {
-    var r, a, o, u;
-    const i = new D((r = this._itemTemplate) == null ? void 0 : r.bind(), C(p({
+  bind(t, e) {
+    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: [...(a = t !== void 0 ? t : this.value) != null ? a : []]
-    }, s && "originalValue" in s ? { originalValue: s.originalValue } : {}), {
-      enabled: (o = s == null ? void 0 : s.enabled) != null ? o : this.enabled,
-      visibility: (u = s == null ? void 0 : s.visibility) != null ? u : this.visibility
-    }));
-    return i.boundFrom(this, i.value, i.originalValue, s), i;
+      value: [...(t !== void 0 ? t : this.value) ?? []],
+      ...e && "originalValue" in e ? { originalValue: e.originalValue } : {},
+      enabled: e?.enabled ?? this.enabled,
+      visibility: e?.visibility ?? this.visibility
+    });
+    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
@@ -2130,103 +2434,130 @@ class D extends A {
     return this.validRead;
   }
   composeValid() {
-    var t, s;
-    return this.state.errors.length === 0 && ((s = (t = this.state.rows) == null ? void 0 : t.every((i) => i.valid)) != null ? s : !0);
+    return this.state.errors.length === 0 && (this.state.rows?.every((t) => t.valid) ?? !0);
+  }
+  get busy() {
+    return this.busyRead;
+  }
+  composeBusy() {
+    return this.state.rows?.some((t) => t.busy) ?? !1;
   }
   validate(t = !1) {
-    g(() => {
-      var s;
-      t && ((s = this.state.rows) == null || s.forEach((i) => i.validate(!0))), super.validate(t);
+    u(() => {
+      t && this.state.rows?.forEach((e) => e.validate(!0)), super.validate(t);
     });
   }
   get members() {
-    var t;
-    return (t = this.raw.rows) != null ? t : [];
+    return this.raw.rows ?? [];
+  }
+  /**
+   * How many rows this list holds. The read is tracked, so a template rendering off it re-renders as rows come and
+   * go.
+   */
+  /**
+   * Every row of this list, each one built from all of its fields. Where `value` states what the list serializes -
+   * rows composed of the fields that are enabled, and null where the list is empty - this states what the list
+   * holds: the disabled fields are in it too, and an empty list reads back as an empty array rather than as null.
+   */
+  get fullValue() {
+    return (this.state.rows ?? []).map((t) => t.fullValue);
+  }
+  get length() {
+    return this.state.rows?.length ?? 0;
+  }
+  /**
+   * The rows this list holds, oldest position first. The array is a frozen copy: it states what the list held at
+   * the read and nothing writes back through it - `push`, `insert`, `remove` and `clear` are what change the set -
+   * so a caller may hold on to it. The rows in it are the live elements, so reading one reports what it holds now.
+   *
+   * The copy is built once per change of the set and handed to every reader until the next one: a write inside a
+   * row changes what the list serializes without changing which rows it holds, and the array a reader took stays
+   * the same one across such a write.
+   */
+  get items() {
+    const t = this.state.rowsVersion;
+    return this.raw.cachedItemsVersion !== t && (this.raw.cachedItems = Object.freeze([...this.raw.rows ?? []]), this.raw.cachedItemsVersion = t), this.raw.cachedItems;
   }
   get(t) {
     return this.state.rows != null ? this.state.rows[t] : void 0;
   }
   push(t) {
-    var s, i;
-    return this.insert(t, (i = (s = this.state.rows) == null ? void 0 : s.length) != null ? i : 0) + 1;
+    return this.insert(t, this.state.rows?.length ?? 0) + 1;
   }
   pop() {
-    var t, s;
-    return this.remove(((s = (t = this.state.rows) == null ? void 0 : t.length) != null ? s : 0) - 1);
+    return this.remove((this.state.rows?.length ?? 0) - 1);
   }
   remove(t) {
-    let s;
-    return g((i) => {
-      var a;
+    let e;
+    return u((s) => {
       if (this.state.rows == null || t < 0 || this.state.rows.length <= t) return;
-      i.touch(this);
-      const r = (a = this.state.rows.splice(t, 1)) == null ? void 0 : a[0];
-      r && (this.releaseChild(r), this.bumpValueVersion(), s = r, i.recordStructural(this, { actionClass: zt, item: s, index: t }), this.propagateValueChanged(!0));
-    }), s;
-  }
-  insert(t, s) {
-    let i = 0;
-    return g((r) => {
-      for (r.touch(this), this.state.rows == null && (this.state.rows = []), i = s < 0 ? Math.max(this.state.rows.length + s, 0) : s; this.state.rows.length < i; ) {
-        const o = this.createPaddingItem(), u = this.state.rows.push(o) - 1;
-        this.bumpValueVersion(), r.recordStructural(this, { actionClass: rt, item: o, index: u });
+      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: 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 a = this.createPaddingItem(), o = this.state.rows.push(a) - 1;
+        this.bumpValueVersion(), i.recordStructural(this, { actionClass: J, item: a, index: o });
       }
-      const a = this.processSetValueItem(t);
-      this.state.rows.splice(i, 0, a), r.recordStructural(this, { actionClass: rt, item: a, index: i }), this.bumpValueVersion(), this.propagateValueChanged(!0);
-    }), i;
+      const r = this.processSetValueItem(t);
+      this.state.rows.splice(s, 0, r), i.recordStructural(this, { actionClass: J, 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. */
   releaseRows() {
-    var t;
-    (t = this.state.rows) == null || t.forEach((s) => this.releaseChild(s));
+    this.state.rows?.forEach((t) => this.releaseChild(t));
   }
   clear() {
-    g((t) => {
-      var i, r;
-      const s = ((r = (i = this.state.rows) == null ? void 0 : i.length) != null ? r : 0) > 0;
-      t.touch(this), this.releaseRows(), this.state.rows = null, this.bumpValueVersion(), this.propagateValueChanged(s);
+    u((t) => {
+      const e = (this.state.rows?.length ?? 0) > 0;
+      t.touch(this), this.releaseRows(), this.state.rows = null, e && this.rowsChanged(), this.bumpValueVersion(), this.propagateValueChanged(e);
     });
   }
 }
-class ke extends v {
-  constructor(t, s, i) {
-    super((a, o, u) => {
-      this.comparisonState(u).oldValue = o;
-      const c = this.resolve(u);
-      return c ? (this.listenOn(c), this.isValidComparison(b(a), b(c.value)) ? null : [
-        new V(
-          this.replacePlaceholders(i, { newValue: a, oldValue: o, field: u, otherField: c })
+class Ie extends f {
+  constructor(t, e, s) {
+    const i = (r, a, o) => {
+      this.comparisonState(o).oldValue = a;
+      const l = this.resolve(o);
+      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"
         )
-      ]) : (u.markRecordIncomplete(), null);
-    });
-    d(this, "isValidComparison");
-    d(this, "otherField");
-    /**
-     * The fields this validator is registered on. Registration reaches one element at a time - the rows of a list
-     * take the validator on one by one, as they are built from the item template that carries it - so this is what
-     * says which of the fields a declaration stands for actually carry the rule, and a field that never took it on
-     * is left alone by a change of the compared field.
-     */
-    d(this, "registrations", /* @__PURE__ */ new WeakSet());
-    /**
-     * The fields this validator has installed its listener on. A binding of such a field carries the listener too -
-     * a binding takes on the actions of the field it was bound from - so the field it was bound from is what is
-     * asked about as well, and a list of a thousand rows installs one listener rather than a thousand.
-     */
-    d(this, "listening", /* @__PURE__ */ new WeakSet());
-    /**
-     * What the fields this validator was registered on were declared as. One entry stands for every binding of such a
-     * field, so a change of a compared field finds the fields of the record that change happened in without a list
-     * of a thousand rows being held here.
-     */
-    d(this, "declarations", /* @__PURE__ */ new Set());
-    this.isValidComparison = s, this.otherField = t;
+      ]) : (o.markRecordIncomplete(), null);
+    };
+    super(i), this.isValidComparison = e, this.otherField = t;
   }
+  isValidComparison;
+  otherField;
+  /**
+   * The fields this validator is registered on. Registration reaches one element at a time - the rows of a list
+   * take the validator on one by one, as they are built from the item template that carries it - so this is what
+   * says which of the fields a declaration stands for actually carry the rule, and a field that never took it on
+   * is left alone by a change of the compared field.
+   */
+  registrations = /* @__PURE__ */ new WeakSet();
+  /**
+   * The fields this validator has installed its listener on. A binding of such a field carries the listener too -
+   * a binding takes on the actions of the field it was bound from - so the field it was bound from is what is
+   * asked about as well, and a list of a thousand rows installs one listener rather than a thousand.
+   */
+  listening = /* @__PURE__ */ new WeakSet();
+  /**
+   * What the fields this validator was registered on were declared as. One entry stands for every binding of such a
+   * field, so a change of a compared field finds the fields of the record that change happened in without a list
+   * of a thousand rows being held here.
+   */
+  declarations = /* @__PURE__ */ new Set();
   /** The field `field` is compared against, within the record `field` belongs to. */
   resolve(t) {
-    var i;
-    const s = this.otherField;
-    return typeof s == "function" ? (i = s(t)) != null ? i : void 0 : typeof s == "string" ? pe(s, t) : lt(s, T(t));
+    const e = this.otherField;
+    return typeof e == "function" ? e(t) ?? void 0 : typeof e == "string" ? ae(e, t) : et(e, V(t));
   }
   /**
    * Makes a change of `other` re-run this comparison. The listener re-runs it over the fields of the record the
@@ -2235,12 +2566,12 @@ class ke extends v {
    */
   listenOn(t) {
     this.listening.has(t) || this.listening.has(t.declaration) || (this.listening.add(t), t.registerAction(
-      new O((s, i, r, a) => {
-        i(s, r, a);
-        const o = T(s);
+      new T((e, s, i, r) => {
+        s(e, i, r);
+        const a = V(e);
         this.declarations.forEach(
-          (u) => Lt(u, o).forEach((c) => {
-            this.registrations.has(c) && this.execute(c, () => null, c.value, this.comparisonState(c).oldValue);
+          (o) => kt(o, a).forEach((l) => {
+            this.registrations.has(l) && this.execute(l, () => null, l.value, this.comparisonState(l).oldValue);
           })
         );
       })
@@ -2253,196 +2584,242 @@ class ke extends v {
     return this.bindingState(t);
   }
   newBindingState() {
-    return C(p({}, super.newBindingState()), { oldValue: void 0 });
+    return { ...super.newBindingState(), oldValue: void 0 };
   }
   unregisterFrom(t) {
-    this.registrations.delete(t);
+    super.unregisterFrom(t), this.registrations.delete(t);
+  }
+}
+class Te extends f {
+  constructor(t, e) {
+    const s = e || b("Must be one of [**{allowedAsText}**]"), i = () => {
+      const o = h(t);
+      return typeof o == "function" ? o() : o;
+    }, r = (o) => {
+      const l = o.join(", ");
+      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: v,
+            allowedValues: p,
+            allowedAsText: r(p)
+          }),
+          "",
+          "in-allowed-values"
+        )
+      ];
+    };
+    super(a);
   }
 }
-class Re extends v {
-  constructor(e, t) {
-    const s = t || E("Must be one of [**{allowedAsText}**]");
-    let i = e.join(", ");
-    i.length > 60 && (i = Zt(i, {
-      length: 40,
-      separator: ", ",
-      omission: `... (${e.length} items total)`
-    }));
-    const r = (a, o, u) => e.includes(b(a)) ? null : [
-      new V(
-        this.replacePlaceholders(s, { newValue: a, oldValue: o, field: u, allowedValues: e, allowedAsText: i })
-      )
-    ];
-    super(r);
-  }
+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 De(n) {
-  return n == null ? 0 : At(n) || j(n) ? n.length : _t(n) && Object.getPrototypeOf(n) === Object.prototype ? Object.keys(n).length : String(n).length;
+function wt(n) {
+  return typeof n == "object" && n !== null && !Vt(n) && !(n instanceof String) && !("componentName" in n);
 }
-class Le extends v {
-  constructor(e) {
-    const t = e || E("Please enter a value"), s = (i, r, a) => De(b(i)) === 0 ? [new V(this.replacePlaceholders(t, { newValue: i, oldValue: r, field: a }))] : null;
-    super(s);
+class ke extends f {
+  constructor(t, e) {
+    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(a);
   }
 }
-class Be extends v {
-  constructor(e, t) {
-    const s = t || E("Value must be larger or equal to **{minValue}**"), i = (r, a, o) => r < e || r === void 0 ? [
-      new V(this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, minValue: e }))
+class Re extends f {
+  constructor(t, e) {
+    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"
+      )
     ] : null;
     super(i);
   }
 }
-class Me extends v {
-  constructor(e, t) {
-    const s = t || E("Value must be less than or equal to **{maxValue}**"), i = (r, a, o) => r > e || r === void 0 ? [
-      new V(this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, maxValue: e }))
+class Fe extends f {
+  constructor(t, e) {
+    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"
+      )
     ] : null;
     super(i);
   }
 }
-class Ue extends v {
-  constructor(e, t, s) {
-    const i = s || E("Value must be between **{minValue}** and **{maxValue}**"), r = (a, o, u) => a < e || a > t || a === void 0 ? [
-      new V(
-        this.replacePlaceholders(i, { newValue: a, oldValue: o, field: u, minValue: e, maxValue: t })
+class _e extends f {
+  constructor(t, e, s) {
+    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(r);
   }
 }
-function ut(n) {
-  return n == null ? 0 : At(n) || j(n) ? n.length : _t(n) && Object.getPrototypeOf(n) === Object.prototype ? Object.keys(n).length : String(n).length;
+function it(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 We extends v {
-  constructor(e, t) {
-    const s = t || E("Length must be larger or equal to **{minLength}**"), i = (r, a, o) => ut(r) < e ? [
-      new V(this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, minLength: e }))
+class Pe extends f {
+  constructor(t, e) {
+    const s = e || b("Length must be larger or equal to **{minLength}**"), i = (r, a, o) => it(r) < t ? [
+      new g(
+        this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, minLength: t }),
+        "",
+        "min-length"
+      )
     ] : null;
     super(i);
   }
 }
-class $e extends v {
-  constructor(e, t) {
-    const s = t || E("Length must be less than or equal to **{maxLength}**"), i = (r, a, o) => ut(r) > e ? [
-      new V(this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, maxLength: e }))
+class je extends f {
+  constructor(t, e) {
+    const s = e || b("Length must be less than or equal to **{maxLength}**"), i = (r, a, o) => it(r) > t ? [
+      new g(
+        this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, maxLength: t }),
+        "",
+        "max-length"
+      )
     ] : null;
     super(i);
   }
 }
-class qe extends v {
-  constructor(e, t, s) {
-    const i = s || E("Length must be between **{minLength}** and **{maxLength}**"), r = (a, o, u) => {
-      const c = ut(a);
-      return c < e || c > t ? [
-        new V(
-          this.replacePlaceholders(i, { newValue: a, oldValue: o, field: u, minLength: e, maxLength: t })
+class Ne extends f {
+  constructor(t, e, s) {
+    const i = s || b("Length must be between **{minLength}** and **{maxLength}**"), r = (a, o, l) => {
+      const v = it(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(r);
   }
 }
-class ze extends v {
-  constructor(e, t) {
-    const s = t || E('Value must match pattern "**{pattern}**"'), i = (r, a, o) => e.test(String(b(r))) ? null : [
-      new V(this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, pattern: e }))
+class Be extends f {
+  constructor(t, e) {
+    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"
+      )
     ];
     super(i);
   }
 }
-const He = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const De = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  CompareTo: ke,
-  InAllowedValues: Re,
-  LengthInRange: qe,
-  MaxLength: $e,
-  MaxValue: Me,
-  MinLength: We,
-  MinValue: Be,
-  Pattern: ze,
-  Required: Le,
-  Validator: v,
-  ValueInRange: Ue
-}, Symbol.toStringTag, { value: "Module" })), Je = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  CompareTo: Ie,
+  InAllowedValues: Te,
+  LengthInRange: Ne,
+  MaxLength: je,
+  MaxValue: Fe,
+  MinLength: Pe,
+  MinValue: Re,
+  Pattern: Be,
+  Required: ke,
+  Validator: f,
+  ValueInRange: _e
+}, Symbol.toStringTag, { value: "Module" })), $e = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  AbortEventHandlingException: Ot,
-  Action: Pe,
-  ActionsMap: H,
-  ConditionalEnabledAction: ve,
-  ConditionalStatementAction: Q,
-  ConditionalValueAction: Ve,
-  ConditionalVisibilityAction: be,
-  DisplayMode: N,
-  EmptyField: je,
-  EnabledChangedAction: Mt,
-  EnabledChangingAction: Bt,
-  ExecuteAction: qt,
-  Field: X,
-  FieldActionBase: y,
-  FieldBase: A,
-  Group: w,
-  List: D,
-  ListItemAddedAction: rt,
-  ListItemRemovedAction: zt,
-  MdString: B,
-  MessagesWidget: Ne,
-  Operator: m,
-  RenderableValue: he,
-  Statement: I,
-  ValidChangedAction: Ut,
-  ValidationError: ot,
-  ValidationErrorRenderContent: V,
-  ValidationErrorText: ce,
-  Validator: v,
-  Validators: He,
-  ValueChangedAction: O,
-  VisibilityChangedAction: $t,
-  VisibilityChangingAction: Wt,
-  buildErrorMessage: E,
-  isCallableFunction: z,
-  isSimpleComponentDef: at,
-  transaction: q
+  AbortEventHandlingException: P,
+  Action: Se,
+  ActionsMap: M,
+  ConditionalEnabledAction: ue,
+  ConditionalStatementAction: U,
+  ConditionalValueAction: ce,
+  ConditionalVisibilityAction: le,
+  DisplayMode: I,
+  EnabledChangedAction: Ft,
+  EnabledChangingAction: Rt,
+  ExecuteAction: Nt,
+  Field: st,
+  FieldActionBase: m,
+  FieldBase: y,
+  Group: d,
+  List: F,
+  ListItemAddedAction: J,
+  ListItemRemovedAction: Bt,
+  MdString: j,
+  MessagesWidget: xe,
+  Operator: c,
+  RenderableValue: se,
+  Statement: w,
+  ValidChangedAction: _t,
+  ValidationError: tt,
+  ValidationErrorRenderContent: g,
+  ValidationErrorText: ee,
+  Validators: De,
+  ValueChangedAction: T,
+  VisibilityChangedAction: jt,
+  VisibilityChangingAction: Pt,
+  buildErrorMessage: b,
+  defaultDisplayMode: Kt,
+  isCallableFunction: L,
+  isSimpleComponentDef: G,
+  transaction: Z
 }, Symbol.toStringTag, { value: "Module" }));
 export {
-  Ot as AbortEventHandlingException,
-  Pe as Action,
-  H as ActionsMap,
-  ve as ConditionalEnabledAction,
-  Q as ConditionalStatementAction,
-  Ve as ConditionalValueAction,
-  be as ConditionalVisibilityAction,
-  N as DisplayMode,
-  je as EmptyField,
-  Mt as EnabledChangedAction,
-  Bt as EnabledChangingAction,
-  qt as ExecuteAction,
-  X as Field,
-  y as FieldActionBase,
-  A as FieldBase,
-  w as Group,
-  D as List,
-  rt as ListItemAddedAction,
-  zt as ListItemRemovedAction,
-  B as MdString,
-  Ne as MessagesWidget,
-  m as Operator,
-  he as RenderableValue,
-  I as Statement,
-  Ut as ValidChangedAction,
-  ot as ValidationError,
-  V as ValidationErrorRenderContent,
-  ce as ValidationErrorText,
-  v as Validator,
-  He as Validators,
-  O as ValueChangedAction,
-  $t as VisibilityChangedAction,
-  Wt as VisibilityChangingAction,
-  E as buildErrorMessage,
-  Je as default,
-  Ye as forms,
-  z as isCallableFunction,
-  at as isSimpleComponentDef,
-  q as transaction
+  P as AbortEventHandlingException,
+  Se as Action,
+  M as ActionsMap,
+  ue as ConditionalEnabledAction,
+  U as ConditionalStatementAction,
+  ce as ConditionalValueAction,
+  le as ConditionalVisibilityAction,
+  I as DisplayMode,
+  Ft as EnabledChangedAction,
+  Rt as EnabledChangingAction,
+  Nt as ExecuteAction,
+  st as Field,
+  m as FieldActionBase,
+  y as FieldBase,
+  d as Group,
+  F as List,
+  J as ListItemAddedAction,
+  Bt as ListItemRemovedAction,
+  j as MdString,
+  xe as MessagesWidget,
+  c as Operator,
+  se as RenderableValue,
+  w as Statement,
+  _t as ValidChangedAction,
+  tt 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,
+  G as isSimpleComponentDef,
+  te as setConfig,
+  Z as transaction
 };
 //# sourceMappingURL=dynamicforms-vue-forms.js.map