@dynamicforms/vue-forms 0.11.0 → 0.13.0

package/dist/dynamicforms-vue-forms.js

@@ -1,97 +1,55 @@
-var Gt = Object.defineProperty, Yt = Object.defineProperties;
-var Jt = Object.getOwnPropertyDescriptors;
-var q = Object.getOwnPropertySymbols;
-var mt = Object.prototype.hasOwnProperty, bt = Object.prototype.propertyIsEnumerable;
-var vt = (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 = {}))
-    mt.call(e, t) && K(n, t, e[t]);
-  if (q)
-    for (var t of q(e))
-      bt.call(e, t) && K(n, t, e[t]);
-  return n;
-}, x = (n, e) => Yt(n, Jt(e));
-var k = (n, e) => {
-  var t = {};
-  for (var s in n)
-    mt.call(n, s) && e.indexOf(s) < 0 && (t[s] = n[s]);
-  if (n != null && q)
-    for (var s of q(n))
-      e.indexOf(s) < 0 && bt.call(n, s) && (t[s] = n[s]);
-  return t;
-};
-var d = (n, e, t) => K(n, typeof e != "symbol" ? e + "" : e, t), Vt = (n, e, t) => e.has(n) || vt("Cannot " + t);
-var l = (n, e, t) => (Vt(n, e, "read from private field"), t ? t.call(n) : e.get(n)), Z = (n, e, t) => e.has(n) ? vt("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(n) : e.set(n, t), tt = (n, e, t, s) => (Vt(n, e, "write to private field"), s ? s.call(n, t) : e.set(n, t), t);
-var wt = (n, e, t) => new Promise((s, i) => {
-  var r = (c) => {
-    try {
-      o(t.next(c));
-    } catch (u) {
-      i(u);
-    }
-  }, a = (c) => {
-    try {
-      o(t.throw(c));
-    } catch (u) {
-      i(u);
-    }
-  }, o = (c) => c.done ? s(c.value) : Promise.resolve(c.value).then(r, a);
-  o((t = t.apply(n, e)).next());
-});
-import { isEqual as nt, isEmpty as L, isBoolean as Kt, isString as P, truncate as Zt, isArray as Tt, isObject as Ot } from "lodash-es";
-import { unref as b, computed as jt, isRef as te, reactive as ee, ref as se, defineComponent as ie, resolveComponent as yt, openBlock as ne, createBlock as re, h as R } from "vue";
-var F = /* @__PURE__ */ ((n) => (n[n.SUPPRESS = 1] = "SUPPRESS", n[n.HIDDEN = 5] = "HIDDEN", n[n.INVISIBLE = 8] = "INVISIBLE", n[n.FULL = 10] = "FULL", n))(F || {});
-const Et = 10, xt = new Set(
-  Object.values(F).filter((n) => typeof n == "number")
+import { isEqual as Q, isEmpty as R, isBoolean as Lt, isString as C, truncate as Mt, isArray as vt, isObject as bt } from "lodash-es";
+import { unref as h, computed as X, isRef as wt, reactive as Ut, watch as $t, ref as Wt, defineComponent as qt, resolveComponent as at, openBlock as zt, createBlock as Ht, h as F } from "vue";
+var T = /* @__PURE__ */ ((n) => (n[n.SUPPRESS = 1] = "SUPPRESS", n[n.HIDDEN = 5] = "HIDDEN", n[n.INVISIBLE = 8] = "INVISIBLE", n[n.FULL = 10] = "FULL", n))(T || {});
+const ot = 10, lt = new Set(
+  Object.values(T).filter((n) => typeof n == "number")
 );
 ((n) => {
-  function e(i) {
-    return i.toUpperCase() === "SUPPRESS" ? 1 : i.toUpperCase() === "HIDDEN" ? 5 : i.toUpperCase() === "INVISIBLE" ? 8 : Et;
-  }
-  n.fromString = e;
   function t(i) {
-    const r = typeof i == "number" ? i : n.fromString(i);
-    return xt.has(r) ? r : Et;
+    return i.toUpperCase() === "SUPPRESS" ? 1 : i.toUpperCase() === "HIDDEN" ? 5 : i.toUpperCase() === "INVISIBLE" ? 8 : ot;
+  }
+  n.fromString = t;
+  function e(i) {
+    const a = typeof i == "number" ? i : n.fromString(i);
+    return lt.has(a) ? a : ot;
   }
-  n.fromAny = t;
+  n.fromAny = e;
   function s(i) {
-    const r = typeof i == "number" ? i : n.fromString(i);
-    return xt.has(r);
+    const a = typeof i == "number" ? i : n.fromString(i);
+    return lt.has(a);
   }
   n.isDefined = s;
-})(F || (F = {}));
-Object.freeze(F);
-const N = F;
-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;
-  }
+})(T || (T = {}));
+Object.freeze(T);
+const _ = T;
+class p {
   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,106 +60,104 @@ 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. It names one element rather than the action as a whole,
-   * because the instance goes on serving every other element it was registered on.
+   * Announces that `binding` no longer holds this action, and takes back what running it left there. It names one
+   * element rather than the action as a whole, because the instance goes on serving every other element it was
+   * registered on. It runs inside the operation that drops the registration, so an operation that unwinds puts the
+   * registration and what this took back both back.
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  unregisterFrom(e) {
+  unregisterFrom(t) {
   }
 }
-class rt extends Error {
+class Vt extends Error {
 }
-const B = /* @__PURE__ */ Symbol("ValueChangedAction");
-class O extends y {
-  constructor(e) {
-    super(e);
+const yt = /* @__PURE__ */ Symbol("ValueChangedAction");
+class S extends p {
+  constructor(t) {
+    super(t);
   }
   static get classIdentifier() {
-    return B;
-  }
-  execute(e, t, s, i) {
-    return super.execute(e, t, s, i);
-  }
-}
-const z = /* @__PURE__ */ Symbol("Transaction.capture"), Pt = /* @__PURE__ */ Symbol("Transaction.restore"), Ft = /* @__PURE__ */ Symbol("Transaction.announceValue"), Nt = /* @__PURE__ */ Symbol("Transaction.settleValidity");
-function Ct(n) {
-  let e = 0, t = n.parent;
-  for (; t; )
-    e++, t = t.parent;
-  return e;
-}
-class ae {
-  constructor() {
-    d(this, "participants", /* @__PURE__ */ new Map());
-    /** work that stands only where the transaction commits; a rollback simply never does it */
-    d(this, "deferred", []);
-    /** 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 yt;
   }
+  execute(t, e, s, i) {
+    return super.execute(t, e, s, i);
+  }
+}
+const O = /* @__PURE__ */ Symbol("Transaction.capture"), Ct = /* @__PURE__ */ Symbol("Transaction.restore"), Et = /* @__PURE__ */ Symbol("Transaction.announceValue"), xt = /* @__PURE__ */ Symbol("Transaction.settleValidity");
+function ut(n) {
+  let t = 0, e = n.parent;
+  for (; e; )
+    t++, e = e.parent;
+  return t;
+}
+class Qt {
+  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[z]());
+  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;
-  }
-  /**
-   * Registers work the commit does once everything has been announced. It is for what a rollback could not take
-   * back: releasing a listener, dropping a registration. Held until the commit, it is simply never done where the
-   * transaction unwinds instead.
-   */
-  whenCommitted(e) {
-    this.deferred.push(e);
+  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
@@ -210,8 +166,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 || Ct(e) >= this.passDepth && (this.restartPass = !0);
+  noteDepth(t) {
+    this.passDepth < 0 || ut(t) >= this.passDepth && (this.restartPass = !0);
   }
   /**
    * Puts every element the transaction modified back as it found it. Nothing is announced: from an observer's
@@ -219,11 +175,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[Pt](t.snapshot);
+    this.unwound = !0, [...this.participants.values()].reverse().forEach((e) => {
+      e.snapshot && e.element[Ct](e.snapshot);
     }), this.participants.clear();
-    for (let t = this.undo.length - 1; t >= 0; t--) this.undo[t]();
-    this.undo.length = 0, this.deferred.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
@@ -236,7 +192,8 @@ class ae {
   commit() {
     for (; !(!this.announceValues() && !this.settleValidity()); )
       ;
-    this.deferred.splice(0).forEach((t) => t());
+    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
@@ -244,14 +201,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 = Ct(s.element);
-      ((r = t[i]) != null ? r : t[i] = []).push(s);
-    }), t;
+      if (!t(s)) return;
+      const i = ut(s.element);
+      (e[i] ??= []).push(s);
+    }), e;
   }
   /**
    * Runs one pass over the dirty participants, deepest bucket first; the caller repeats it until it answers
@@ -259,18 +215,18 @@ 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];
-      if (r) {
+      const a = s[i];
+      if (a) {
         this.passDepth = i, this.restartPass = !1;
         try {
-          for (let a = 0; a < r.length; a++) {
+          for (let r = 0; r < a.length; r++) {
             if (this.restartPass) return !0;
-            const o = r[a];
-            e(o) && t(o);
+            const o = a[r];
+            t(o) && e(o);
           }
         } finally {
           this.passDepth = -1;
@@ -282,34 +238,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[Ft](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[Et](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[xt](this);
       }
     );
   }
 }
-let _, et;
-function kt() {
-  return _;
+let E, q;
+function St() {
+  return E;
 }
-class Rt {
+class It {
 }
-class oe {
-  constructor() {
-    d(this, "open", !0);
-  }
+class Xt {
+  open = !0;
   rollback() {
-    throw this.open ? new Rt() : new TypeError(
+    throw this.open ? new It() : 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."
     );
   }
@@ -317,60 +271,68 @@ class oe {
     this.open = !1;
   }
 }
-function St(n) {
+function ct(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 ot(n) {
-  if (_) {
-    const s = n(et);
-    return St(s), s;
+function Y(n) {
+  if (E) {
+    const s = n(q);
+    return ct(s), s;
   }
-  const e = new ae(), t = new oe();
-  _ = e, et = t;
+  const t = new Qt(), e = new Xt();
+  E = t, q = e;
   try {
-    const s = n(t);
-    return St(s), e.commit(), s;
+    const s = n(e);
+    return ct(s), t.commit(), s;
   } catch (s) {
-    if (e.rollback(), s instanceof Rt) return;
+    if (t.rollback(), s instanceof It) return;
     throw s;
   } finally {
-    _ = void 0, et = void 0, t.close();
+    E = void 0, q = void 0, e.close();
   }
 }
-function g(n) {
-  return _ ? n(_) : ot(() => n(_));
+function u(n) {
+  return E ? n(E) : Y(() => n(E));
 }
-const Dt = { useMarkdownInValidators: !0 };
-function le() {
-  return Dt;
+const At = { useMarkdownInValidators: !0 };
+function Kt() {
+  return At;
 }
-function ce(n) {
-  Object.assign(Dt, n);
+function Yt(n) {
+  Object.assign(At, n);
 }
-const Ye = {
-  install(n, e) {
-    e && ce(e);
+const De = {
+  install(n, t) {
+    t && Yt(t);
   }
 };
-class U extends String {
-  constructor(t, s, i) {
-    super(t);
-    d(this, "plugins");
-    d(this, "options");
-    this.plugins = i, this.options = s;
+class P extends String {
+  plugins;
+  options;
+  constructor(t, e, s) {
+    super(t), this.plugins = s, this.options = e;
   }
 }
-function lt(n) {
-  const e = b(n);
-  return typeof e == "object" && "componentName" in e;
+function J(n) {
+  const t = h(n);
+  return typeof t == "object" && "componentName" in t;
 }
-function H(n) {
-  return typeof b(n) == "function";
+function B(n) {
+  return typeof h(n) == "function";
 }
-class ct {
+class Z {
+  /**
+   * 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;
   get componentName() {
     return "Comment";
   }
@@ -384,13 +346,12 @@ class ct {
     return "";
   }
 }
-class ue extends ct {
-  constructor(t, s = "") {
-    super();
-    d(this, "text");
-    d(this, "classes");
-    this.text = t, this.classes = s;
+class Jt extends Z {
+  constructor(t, e = "", s) {
+    super(s), this.text = t, this.classes = e;
   }
+  text;
+  classes;
   get componentName() {
     return "template";
   }
@@ -401,24 +362,23 @@ class ue extends ct {
     return this.classes;
   }
 }
-class V extends ct {
-  constructor(t, s = "") {
-    super();
-    d(this, "classes");
-    d(this, "text");
-    d(this, "textType");
-    this.classes = s, this.text = t, this.textType = jt(() => this.getTextType);
+class f extends Z {
+  constructor(t, e = "", s) {
+    super(s), this.classes = e, this.text = t, this.textType = X(() => this.getTextType);
   }
+  classes;
+  text;
+  textType;
   get resolvedText() {
-    const t = b(this.text);
-    return H(t) ? t() : t;
+    const t = h(this.text);
+    return B(t) ? t() : t;
   }
   get getTextType() {
     const t = this.resolvedText;
-    return t ? t instanceof U ? "md" : lt(t) ? "component" : "string" : "string";
+    return t ? t instanceof P ? "md" : J(t) ? "component" : "string" : "string";
   }
   get componentName() {
-    switch (b(this.textType)) {
+    switch (h(this.textType)) {
       case "string":
         return "template";
       case "md":
@@ -430,7 +390,7 @@ class V extends ct {
     }
   }
   get componentBindings() {
-    switch (b(this.textType)) {
+    switch (h(this.textType)) {
       case "string":
         return {};
       case "md": {
@@ -444,7 +404,7 @@ class V extends ct {
     }
   }
   get componentBody() {
-    switch (b(this.textType)) {
+    switch (h(this.textType)) {
       case "string":
         return this.resolvedText;
       case "component":
@@ -457,43 +417,50 @@ class V extends ct {
     return this.classes;
   }
 }
-class he extends V {
+class Zt extends f {
 }
-function E(n) {
-  return le().useMarkdownInValidators ? new U(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 m(n) {
+  return Kt().useMarkdownInValidators ? new P(n) : n.replace(/[*_~`]/g, "").replace(/!\[(.*?)\]\(.*?\)/g, "$1").replace(/\[(.*?)\]\((.*?)\)/g, "$1").replace(/#+\s?/g, "").replace(/>\s?/g, "").replace(/(\*|-|\d+\.)\s+/g, "").replace(/`{3}[\s\S]*?`{3}/g, "").replace(/`([^`]+)`/g, "$1").replace(/\n{2,}/g, `
 `);
 }
-const de = /* @__PURE__ */ Symbol("Validator"), ge = () => E("Validation could not be completed");
-class v extends O {
+const Gt = /* @__PURE__ */ Symbol("Validator"), te = () => m("Validation could not be completed");
+class g extends S {
+  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 c = this.bindingState(i), u = ++c.run, C = i.validationEpoch, G = kt(), dt = () => c.run === u && i.validationEpoch === C && !(G != null && G.rolledBack), Y = t(a, o, i) || [], J = (S) => ot(() => {
-        var gt;
-        const $ = (gt = S == null ? void 0 : S.map((j) => this.claim(j))) != null ? gt : [];
-        for (let j = i.errors.length - 1; j >= 0; j--) {
-          const ft = i.errors[j];
-          if (ft.source === this.source) {
-            const pt = $.findIndex((Xt) => nt(Xt, ft));
-            pt >= 0 ? $.splice(pt, 1) : i.errors.splice(j, 1);
+    const e = (s, i, a, r) => {
+      const o = this.bindingState(s), l = o.abandon, w = ++o.run, b = s.validationEpoch, et = St();
+      let st = !1;
+      const U = () => !st && o.run === w && s.validationEpoch === b && !et?.rolledBack, it = new AbortController(), N = () => {
+        U() || (st = !0, o.abandon === N && (o.abandon = void 0), it.abort());
+      };
+      l?.();
+      const $ = t(a, r, s, it.signal) || [], W = (y) => Y(() => {
+        const k = y?.map((I) => this.claim(I)) ?? [];
+        for (let I = s.errors.length - 1; I >= 0; I--) {
+          const nt = s.errors[I];
+          if (nt.source === this.source) {
+            const rt = k.findIndex((Dt) => Q(Dt, nt));
+            rt >= 0 ? k.splice(rt, 1) : s.errors.splice(I, 1);
           }
         }
-        $.length > 0 && i.errors.push(...$), i.validate();
+        k.length > 0 && s.errors.push(...k), s.validate();
       });
-      return Y instanceof Promise ? (i.beginValidating(), Y.then(
-        (S) => {
-          dt() && J(S);
+      return $ instanceof Promise ? (o.abandon = N, et?.whenRolledBack(N), s.beginValidating(), $.then(
+        (y) => {
+          U() && W(y);
         },
-        (S) => {
-          dt() && (J([new V(ge())]), console.error("Validation failed", S));
+        (y) => {
+          U() && (W([new f(te(), "", "validation-failed")]), console.error("Validation failed", y));
         }
-      ).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 === N && (o.abandon = void 0), s.endValidating();
+      }).catch((y) => console.error("Validation failed", y))) : W($), i(s, a, r);
+    };
+    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
@@ -503,20 +470,46 @@ 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), x(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 Gt;
   }
   get eager() {
     return !0;
   }
+  /**
+   * 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) {
+    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
@@ -533,84 +526,84 @@ class v extends O {
   newBindingState() {
     return { run: 0 };
   }
-  replacePlaceholdersFunction(t, s) {
+  replacePlaceholdersFunction(t, e) {
     return () => {
-      let i = b(t);
-      for (; H(i); )
-        i = b(this.replacePlaceholders(i(), s));
-      return i;
+      let s = h(t);
+      for (; B(s); )
+        s = h(this.replacePlaceholders(s(), e));
+      return s;
     };
   }
-  replacePlaceholders(t, s) {
-    if (H(t)) return this.replacePlaceholdersFunction(t, s);
-    if (lt(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 U ? new U(i.toString(), t.options, t.plugins) : i;
-  }
-}
-class M extends Map {
-  constructor() {
-    super(...arguments);
-    d(this, "eagerActions", /* @__PURE__ */ new Set());
-    d(this, "registeredActions", []);
-  }
-  register(t) {
-    if (!(t instanceof y)) throw new Error("Invalid action type");
-    this.registeredActions.push(t);
-    const s = t.classIdentifier, i = this.get(s) || (() => null);
-    function r(a, ...o) {
-      return t.execute(a, i, ...o);
-    }
-    this.set(s, r), t.eager && this.eagerActions.add(t.classIdentifier);
-  }
-  /**
-   * True when triggering this action would run something: a handler registered under the identifier, or - on the
-   * value change identifier, which trigger() answers with an eager pass as well - any eager action at all. A
-   * caller that has to build the parameters before it can trigger asks this first and skips building them when
-   * there is nothing to receive them.
-   */
+  replacePlaceholders(t, e) {
+    if (B(t)) return this.replacePlaceholdersFunction(t, e);
+    if (J(t)) return t;
+    if (wt(t))
+      return this.replacePlaceholdersFunction(() => h(t), e);
+    let s = h(t);
+    return Object.keys(e).forEach((i) => {
+      s = s.replaceAll(`{${i}}`, e[i]);
+    }), t instanceof P ? new P(s.toString(), t.options, t.plugins) : s;
+  }
+}
+class D {
+  /** every action registered here, in registration order across all identifiers */
+  registeredActions = [];
+  /** the actions of one identifier, in registration order */
+  chains = /* @__PURE__ */ new Map();
+  /** the eager actions of one identifier, in registration order; a subsequence of the chain under that identifier */
+  eagerChains = /* @__PURE__ */ new Map();
+  /**
+   * 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(t, e) {
+    if (!(t instanceof p)) throw new Error("Invalid action type");
+    const s = t.classIdentifier;
+    if (e && (e.classIdentifier !== s || !this.registeredActions.includes(e)))
+      throw new Error("Action to register before is not registered under the same identifier");
+    this.registeredActions.push(t), this.insert(this.chains, s, t, e), t.eager && this.insert(this.eagerChains, s, t, e);
+  }
+  /**
+   * 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(t) {
+    const e = this.registeredActions.indexOf(t);
+    if (e < 0) return !1;
+    this.registeredActions.splice(e, 1);
+    const s = t.classIdentifier;
+    return this.remove(this.chains, s, t), this.remove(this.eagerChains, s, t), !0;
+  }
+  /** True where something is registered under `identifier`. */
   willTrigger(t) {
-    return this.has(t) ? !0 : t === B && this.eagerActions.size > 0;
+    return this.chains.has(t);
   }
-  trigger(t, s, ...i) {
-    const r = t.classIdentifier;
-    return r === B && this.triggerEager(s, ...i), this.triggerChain(r, s, ...i);
+  /** True where any eager action is registered, whatever identifier it stands under. */
+  get hasEager() {
+    return this.eagerChains.size > 0;
   }
-  /**
-   * Runs the chain registered under one identifier and nothing else. A caller that has already run the eager
-   * pass - a transaction runs it at the write, so that the validators have decided before it commits - reaches
-   * the handlers through here, so the eager actions are not run a second time at the announcement.
-   */
-  triggerChain(t, s, ...i) {
-    const r = this.get(t);
-    try {
-      if (r) return r(s, ...i);
-    } catch (a) {
-      if (!(a instanceof rt)) throw a;
-    }
-    return null;
+  /** Runs the actions registered under `ActionClass` and answers with what the outermost of them returned. */
+  trigger(t, e, ...s) {
+    return this.run(this.chains.get(t.classIdentifier), e, s);
   }
-  triggerEager(t, ...s) {
-    for (const i of this.eagerActions) {
-      const r = this.get(i);
-      try {
-        r && r(t, ...s);
-      } catch (a) {
-        if (!(a instanceof rt)) throw a;
-      }
-    }
+  /** Runs the eager actions of every identifier, each group on its own. */
+  triggerEager(t, ...e) {
+    this.eagerChains.forEach((s) => this.run(s, t, e));
+  }
+  /** Runs the eager actions registered under `identifier` and nothing else. */
+  triggerEagerFor(t, e, ...s) {
+    return this.run(this.eagerChains.get(t), e, s);
   }
   /** the validators registered in this map, in registration order */
   get validators() {
-    return this.registeredActions.filter((t) => t instanceof v);
+    return this.registeredActions.filter((t) => t instanceof g);
   }
   clone() {
-    const t = new M();
-    return this.registeredActions.forEach((s) => t.register(s)), t;
+    const t = new D();
+    return this.registeredActions.forEach((e) => t.register(e)), t;
   }
   /**
    * Tells every action in this map that it serves `owner`. A copied map holds the instances the original holds, so
@@ -618,79 +611,95 @@ class M extends Map {
    * element it was registered on.
    */
   bindTo(t) {
-    this.registeredActions.forEach((s) => s.boundToBinding(t));
+    this.registeredActions.forEach((e) => e.boundToBinding(t));
   }
   /**
-   * A copy of this map carrying everything but the validators. It only leaves them out: releasing what a
-   * validator installed elsewhere is the caller's to do, and only once the transaction that dropped them has
-   * committed, because a rollback puts this map back with its validators in it.
+   * 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.
    */
-  cloneWithoutValidators() {
-    const t = new M();
-    return this.registeredActions.forEach((s) => {
-      s instanceof v || t.register(s);
-    }), t;
+  step(t, e, s, i) {
+    if (e < 0) return null;
+    const a = (r, ...o) => this.step(t, e - 1, r, o);
+    return t[e].execute(s, a, ...i);
+  }
+  /** Walks a chain, answering null where there is none. An abort ends the run and is not an error to the caller. */
+  run(t, e, s) {
+    if (!t) return null;
+    try {
+      return this.step(t, t.length - 1, e, s);
+    } catch (i) {
+      if (!(i instanceof Vt)) throw i;
+    }
+    return null;
   }
+  insert(t, e, s, i) {
+    const a = t.get(e) ?? [], r = i ? a.indexOf(i) : -1;
+    r < 0 ? a.push(s) : a.splice(r, 0, s), t.set(e, a);
+  }
+  remove(t, e, s) {
+    const i = t.get(e);
+    if (!i?.includes(s)) return;
+    const a = i.filter((r) => r !== s);
+    a.length ? t.set(e, a) : t.delete(e);
+  }
+}
+function x(n) {
+  let t = n;
+  for (; t.fieldName !== void 0 && t.parent; ) t = t.parent;
+  return t;
 }
-function T(n) {
+function ee(n) {
+  const t = [];
   let e = n;
-  for (; e.fieldName !== void 0 && e.parent; ) e = e.parent;
-  return e;
+  for (; e.fieldName !== void 0 && e.parent; )
+    t.unshift(e.fieldName), e = e.parent;
+  return t;
 }
-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 ut(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 = ut(n, e);
-  if (!t) return [];
-  if (t !== n) return [t];
-  const s = e.bindingsOf(n);
+function G(n, t) {
+  let e = t;
+  for (const s of ee(n))
+    if (e = e.field?.(s) ?? void 0, !e) break;
+  return e?.declaration === n ? e : x(n) === x(t.declaration) ? void 0 : n;
+}
+function Tt(n, t) {
+  const e = G(n, t);
+  if (!e) return [];
+  if (e !== n) return [e];
+  const s = t.bindingsOf(n);
   return s.length > 0 ? s : [n];
 }
-function pe(n, e) {
-  var s;
-  let t = e.parent;
-  for (; t; ) {
-    const i = (s = t.field) == null ? void 0 : s.call(t, n);
-    if (i) return i;
-    t = t.parent;
-  }
-}
-const me = /* @__PURE__ */ Symbol("ConditionalStatementAction");
-class Q extends O {
-  constructor(t, s) {
-    super((r, a, o, c) => (this.applyIn(T(r)) || r.markRecordIncomplete(), a(r, o, c)));
-    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));
+function se(n, t) {
+  let e = t.parent;
+  for (; e; ) {
+    const s = e.field?.(n);
+    if (s) return s;
+    e = e.parent;
+  }
+}
+const ie = /* @__PURE__ */ Symbol("ConditionalStatementAction");
+class L extends S {
+  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, a, r, o) => (this.applyIn(x(i)) || i.markRecordIncomplete(), a(i, r, o))), this.statement = t, this.conditionalExecutor = e;
+    const s = new S((i, a, ...r) => (this.applyFrom(i), a(i, ...r)));
+    t.collectFields().forEach((i) => i.registerAction(s));
   }
   static get classIdentifier() {
-    return me;
+    return ie;
   }
   get eager() {
     return !0;
@@ -698,17 +707,20 @@ class Q extends O {
   boundToBinding(t) {
     this.declarations.add(t.declaration), this.registrations.add(t);
   }
+  unregisterFrom(t) {
+    this.registrations.delete(t);
+  }
   /**
    * The elements of `scope` this action controls: what each declaration it serves names within that record, and of
    * 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) => Tt(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
@@ -717,12 +729,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 a = s.lastResult;
+    return s.lastResult = i, e.forEach((r) => this.conditionalExecutor(r, i, a)), !0;
   }
   /**
    * Re-evaluates the records a change of `source` speaks for. A field of the record the targets live in speaks for
@@ -731,148 +743,134 @@ 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(x(t)).forEach((s) => e.add(x(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 ne extends L {
+  constructor(t) {
+    super(t, (e, s) => {
+      e.visibility = s ? _.FULL : _.SUPPRESS;
     });
   }
 }
-class ve extends Q {
-  constructor(e) {
-    super(e, (t, s) => {
-      t.enabled = s;
+class re extends L {
+  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 ae extends L {
+  constructor(t, e) {
+    super(t, (s, i) => {
+      i && (s.value = e);
     });
   }
 }
-var W = /* @__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))(W || {});
+var j = /* @__PURE__ */ ((n) => (n[n.NOT = 0] = "NOT", n[n.OR = 1] = "OR", n[n.AND = 2] = "AND", n[n.XOR = 3] = "XOR", n[n.NAND = 4] = "NAND", n[n.NOR = 5] = "NOR", n[n.EQUALS = -1] = "EQUALS", n[n.NOT_EQUALS = -2] = "NOT_EQUALS", n[n.GT = -3] = "GT", n[n.LT = -4] = "LT", n[n.GE = -5] = "GE", n[n.LE = -6] = "LE", n[n.IN = -7] = "IN", n[n.NOT_IN = -8] = "NOT_IN", n[n.INCLUDES = -9] = "INCLUDES", n[n.NOT_INCLUDES = -10] = "NOT_INCLUDES", n))(j || {});
 ((n) => {
-  function e(r) {
-    const a = r.toLowerCase();
-    if (a === "not") return 0;
-    if (a === "or") return 1;
-    if (a === "and") return 2;
-    if (a === "xor") return 3;
-    if (a === "nand") return 4;
-    if (a === "nor") return 5;
-    if (a === "equals") return -1;
-    if (["not_equals", "not-equals", "not equals"].includes(a)) return -2;
-    if (a === "gt") return -3;
-    if (a === "lt") return -4;
-    if (a === "ge") return -5;
-    if (a === "le") return -6;
-    if (a === "in") return -7;
-    if (["not_in", "not-in", "not in"].includes(a)) return -8;
-    if (a === "includes") return -9;
-    if (["not_includes", "not-includes", "not includes"].includes(a)) return -10;
-    throw new Error(`Unrecognised operator ${a}`);
-  }
-  n.fromString = e;
-  function t(r) {
-    const a = typeof r == "number" ? r : n.fromString(r);
-    if (Object.values(n).includes(a)) return a;
+  function t(a) {
+    const r = a.toLowerCase();
+    if (r === "not") return 0;
+    if (r === "or") return 1;
+    if (r === "and") return 2;
+    if (r === "xor") return 3;
+    if (r === "nand") return 4;
+    if (r === "nor") return 5;
+    if (r === "equals") return -1;
+    if (["not_equals", "not-equals", "not equals"].includes(r)) return -2;
+    if (r === "gt") return -3;
+    if (r === "lt") return -4;
+    if (r === "ge") return -5;
+    if (r === "le") return -6;
+    if (r === "in") return -7;
+    if (["not_in", "not-in", "not in"].includes(r)) return -8;
+    if (r === "includes") return -9;
+    if (["not_includes", "not-includes", "not includes"].includes(r)) return -10;
     throw new Error(`Unrecognised operator ${r}`);
   }
-  n.fromAny = t;
-  function s(r) {
-    const a = typeof r == "number" ? r : n.fromString(r);
-    return Object.values(n).includes(a);
+  n.fromString = t;
+  function e(a) {
+    const r = typeof a == "number" ? a : n.fromString(a);
+    if (Object.values(n).includes(r)) return r;
+    throw new Error(`Unrecognised operator ${a}`);
+  }
+  n.fromAny = e;
+  function s(a) {
+    const r = typeof a == "number" ? a : n.fromString(a);
+    return Object.values(n).includes(r);
   }
   n.isDefined = s;
-  function i(r) {
-    return r >= 0;
+  function i(a) {
+    return a >= 0;
   }
   n.isLogicOperator = i;
-})(W || (W = {}));
-Object.freeze(W);
-const m = W, we = /* @__PURE__ */ Symbol("EnabledChangingAction");
-class Bt extends y {
-  constructor(e) {
-    super(e);
+})(j || (j = {}));
+Object.freeze(j);
+const c = j, oe = /* @__PURE__ */ Symbol("EnabledChangingAction");
+class _t extends p {
+  constructor(t) {
+    super(t);
   }
   static get classIdentifier() {
-    return we;
+    return oe;
   }
-  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 Ut extends y {
-  constructor(e) {
-    super(e);
+const le = /* @__PURE__ */ Symbol("EnabledChangedAction");
+class Ot extends p {
+  constructor(t) {
+    super(t);
   }
   static get classIdentifier() {
-    return ye;
+    return le;
   }
-  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 Mt extends y {
-  constructor(e) {
-    super(e);
+const ue = /* @__PURE__ */ Symbol("ValidChangedAction");
+class Ft extends p {
+  constructor(t) {
+    super(t);
   }
   static get classIdentifier() {
-    return Ee;
+    return ue;
   }
-  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("VisibilityChangingAction");
-class Wt extends y {
-  constructor(e) {
-    super(e);
+const ce = /* @__PURE__ */ Symbol("VisibilityChangingAction");
+class Rt extends p {
+  constructor(t) {
+    super(t);
   }
   static get classIdentifier() {
-    return xe;
+    return ce;
   }
-  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("VisibilityChangedAction");
-class $t extends y {
-  constructor(e) {
-    super(e);
+const he = /* @__PURE__ */ Symbol("VisibilityChangedAction");
+class Pt extends p {
+  constructor(t) {
+    super(t);
   }
   static get classIdentifier() {
-    return Ce;
-  }
-  execute(e, t, s, i) {
-    return super.execute(e, t, s, i);
-  }
-}
-const It = /* @__PURE__ */ new WeakMap(), At = /* @__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 he;
   }
+  execute(t, e, s, i) {
+    return super.execute(t, e, s, i);
+  }
+}
+const ht = /* @__PURE__ */ new WeakMap(), dt = /* @__PURE__ */ new WeakMap(), gt = /* @__PURE__ */ new Set(["validators", "actions"]);
+let z = 0;
+class V {
   /**
    * 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
@@ -890,13 +888,26 @@ class A {
   get __v_isReactive() {
     return !0;
   }
+  /**
+   * 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
@@ -914,19 +925,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
@@ -941,14 +952,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
@@ -960,22 +971,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]) => {
-      At.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]) => {
+      gt.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) || At.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) || gt.has(s) || (this[s] = i);
+    }), R(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
@@ -983,8 +994,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);
+    St()?.touch(this);
   }
   /**
    * Records the whole of this element's mutable state, so that a rolled-back transaction can put it back exactly
@@ -994,31 +1004,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.
    */
-  [z]() {
-    return x(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.
    */
-  [Pt](e) {
-    const t = l(this, f).validatingCount;
-    Object.assign(l(this, h), e), l(this, h).validatingCount = t;
+  [Ct](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.parent?.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.parent?.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.parent?.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 = dt.get(this);
+    return t || (t = X(() => this.composeBusy()), dt.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,
@@ -1026,10 +1097,10 @@ 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
@@ -1038,11 +1109,11 @@ class A {
    * releases it.
    */
   get parent() {
-    return l(this, h).parent;
+    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
@@ -1051,8 +1122,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() {
@@ -1064,9 +1134,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 = (a) => {
+      a.declaration === e && s.push(a), a.members.forEach(i);
     };
     return i(this), s;
   }
@@ -1078,33 +1148,32 @@ 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, z++);
   }
   /**
    * 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) {
+    z !== 0 && u(() => {
+      const e = (s) => {
+        s._recordPending && (s._recordPending = !1, z--, 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._actions?.triggerEager(this, this.value, this.value), t.markValidityDirty(this);
     });
   }
   get actions() {
-    return this._actions || (this._actions = new M()), this._actions;
+    return this._actions || (this._actions = new D()), this._actions;
   }
-  set actions(e) {
-    this._actions = e;
+  set actions(t) {
+    this._actions = t;
   }
   /**
    * Counts the writes that have changed the value of this element or of anything below it. A container reads it
@@ -1112,7 +1181,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
@@ -1121,11 +1190,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;
     });
   }
   /**
@@ -1136,10 +1205,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();
     });
   }
   /**
@@ -1156,7 +1224,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
@@ -1165,16 +1233,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);
     });
   }
   /**
@@ -1182,9 +1252,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);
     });
   }
   /**
@@ -1194,24 +1266,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);
+      const a = this.enabled && this.value !== s;
+      this.value = s, this.originalValue = this.value, this.validate(!a && 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
@@ -1219,35 +1291,33 @@ class A {
    * from repeating while nothing it read has moved.
    */
   get validRead() {
-    let e = It.get(this);
-    return e || (e = jt(() => this.composeValid()), It.set(this, e)), e.value;
+    let t = ht.get(this);
+    return t || (t = X(() => this.composeValid()), ht.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;
+    return this.#t.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))
+  set visibility(t) {
+    u((e) => {
+      const s = this.#t.visibility, i = this._actions?.trigger(Rt, this, t, s);
+      if (!_.isDefined(i ?? t))
         throw new Error("visibility must be a DisplayMode constant");
-      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);
+      e.touch(this), this.#t.visibility = _.fromAny(i ?? t), this._actions?.trigger(Pt, this, this.#t.visibility, s);
     });
   }
   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(Ut, this, l(this, h).enabled, s);
+    return this.#t.enabled;
+  }
+  set enabled(t) {
+    u((e) => {
+      const s = this.#t.enabled, i = this._actions?.trigger(_t, this, t, s);
+      if (!Lt(i ?? t)) throw new Error("Enabled value must be boolean");
+      e.touch(this), this.#t.enabled = i ?? t, this.#t.enabled !== s && this.bumpValueVersion(), this._actions?.trigger(Ot, this, this.#t.enabled, s);
     });
   }
   /**
@@ -1266,15 +1336,12 @@ class A {
    * operation states rather than an element's state - an item added, an item removed - are emitted first, in the
    * order the operations happened.
    */
-  [Ft](e, t, s, i) {
-    if (i == null || i.forEach((c) => {
-      var u;
-      return (u = this._actions) == null ? void 0 : u.trigger(c.actionClass, this, c.item, c.index);
-    }), !t) return;
-    const r = this._actions;
-    if (this.composesValue && !(r != null && r.willTrigger(B))) 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.trigger(O, this, a, o) : r == null || r.triggerChain(B, this, a, o));
+  [Et](t, e, s, i) {
+    if (i?.forEach((l) => this._actions?.trigger(l.actionClass, this, l.item, l.index)), !e) return;
+    const a = this._actions;
+    if (this.composesValue && !(a?.willTrigger(yt) || a?.hasEager)) return;
+    const r = this.value, o = this.#e.announcedValue;
+    !s && (this.composesValue ? Q(r, o) : r === o) || (t.touch(this), this.#e.announcedValue = r, this.composesValue && a?.triggerEager(this, r, o), a?.trigger(S, this, r, o));
   }
   /**
    * Forms the verdict this element ends the transaction with and announces a transition of it. The container is
@@ -1283,28 +1350,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;
+  [xt](t) {
+    const e = this.#e.valid, s = this.countedValid;
+    if (s === e) return;
+    t.touch(this), this.#e.valid = s;
     const i = this.parent;
-    i && (e.touch(i), i.childValidityChanged(s), e.markValidityDirty(i)), (r = this._actions) == null || r.trigger(Mt, this, s, t);
+    i && (t.touch(i), i.childValidityChanged(s), t.markValidityDirty(i)), this._actions?.trigger(Ft, this, s, e);
   }
-  validate(e = !1) {
-    g((t) => {
-      var s;
-      e && ((s = this._actions) == null || s.triggerEager(this, this.value, this.value)), t.markValidityDirty(this);
+  validate(t = !1) {
+    u((e) => {
+      t && this._actions?.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 !Q(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
@@ -1314,30 +1379,65 @@ 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 a = { ...t.extra, ...i && this.extendedOf(i) };
+    R(a) || this.setExtendedValues(a);
+    const r = t._actions;
+    r && (this._actions = r.clone(), this._actions.bindTo(this), this._actions.triggerEager(this, e, s));
   }
   /**
    * 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), e.boundToBinding(this), e.eager && this.actions.trigger(Object.getPrototypeOf(e).constructor, this, this.value, this.originalValue);
+  registerAction(t) {
+    return u((e) => {
+      e.willAnnounceValue(this) || this.refreshPreviousValue(), this.actions.register(t), this.registered(e, t), t.eager && this.actions.triggerEagerFor(t.classIdentifier, this, this.value, this.originalValue);
     }), this;
   }
-  triggerAction(e, ...t) {
-    return this._actions ? this._actions.trigger(e, this, ...t) : null;
+  /**
+   * Registers `action` so that `before` wraps it: `before` reaches it through the `supr` it is handed, instead of
+   * ending the run there. It is how an action is added to a chain someone else built and still sits inside a
+   * handler already registered, which registration order alone cannot arrange. `before` has to be registered on
+   * this element under the same identifier.
+   */
+  registerActionBefore(t, e) {
+    return u((s) => {
+      s.willAnnounceValue(this) || this.refreshPreviousValue(), this.actions.register(t, e), this.registered(s, t), t.eager && this.actions.triggerEagerFor(t.classIdentifier, this, this.value, this.originalValue);
+    }), this;
+  }
+  /**
+   * Drops `action` from this element and answers whether it held it. The instance goes on serving every other
+   * element it was registered on: what is dropped is this element's registration, not the action. A validator
+   * 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(t) {
+    let e = !1;
+    return u((s) => {
+      const i = this._actions;
+      i && (e = i.unregister(t), e && (s.touch(this), t instanceof g && this.#t.validationEpoch++, s.whenRolledBack(() => {
+        i.register(t), t.boundToBinding(this);
+      }), t.unregisterFrom(this)));
+    }), 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(t, e) {
+    e.boundToBinding(this), t.whenRolledBack(() => {
+      this._actions?.unregister(e) && e.unregisterFrom(this);
+    });
+  }
+  triggerAction(t, ...e) {
+    return this._actions ? this._actions.trigger(t, this, ...e) : null;
   }
   /**
    * Generation counter of the validators attached to this field. A Validator reads it when a run starts and drops
@@ -1345,30 +1445,46 @@ 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) => {
-      if (e.touch(this), l(this, h).validationEpoch++, this._actions) {
-        const t = this._actions, s = t.validators;
-        e.whenRolledBack(() => {
-          this._actions = t;
-        }), this.actions = t.cloneWithoutValidators(), e.whenCommitted(() => s.forEach((i) => i.unregisterFrom(this)));
-      }
-      this.errors = [], this.validate();
+    u((t) => {
+      t.touch(this), this.#t.validationEpoch++;
+      const e = this._actions;
+      e && e.validators.forEach((s) => {
+        e.unregister(s), t.whenRolledBack(() => {
+          e.register(s), s.boundToBinding(this);
+        }), s.unregisterFrom(this);
+      }), this.errors = [], this.validate();
     });
   }
 }
-h = new WeakMap(), f = new WeakMap();
-function Se(n, e) {
-  return n ? !e : e;
+function de(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 v {
+  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').`
+      );
+  }
+  /** @throws TypeError where an operand the statement reads is undefined or a function. */
+  constructor(t, e, s) {
+    v.validateOperand(t, 1), e !== c.NOT && v.validateOperand(s, 2), this.operand1 = t, this.operator = e, this.operand2 = s;
   }
   /**
    * The value an operand contributes. A field operand names a field of the record the statement is evaluated in:
@@ -1376,66 +1492,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 ? ut(e, t) : e;
-      return s ? b(s.value) : void 0;
+  static valueOf(t, e) {
+    if (t instanceof v) return t.evaluate(e);
+    if (t instanceof V) {
+      const s = e ? G(t, e) : t;
+      return s ? h(s.value) : void 0;
     }
-    return e;
+    return t;
   }
   get operand1Value() {
-    return I.valueOf(this.operand1);
+    return v.valueOf(this.operand1);
   }
   get operand2Value() {
-    return I.valueOf(this.operand2);
+    return v.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 = v.valueOf(this.operand1, t), s = v.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 de(!!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 P(t) && P(s) && t.indexOf(s) >= 0;
-      case m.NOT_INCLUDES:
-        return !(P(t) && P(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}`);
     }
@@ -1445,82 +1560,87 @@ 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 V ? t.add(s) : s instanceof v && s.collectFields().forEach((a) => t.add(a));
     }
-    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 ge = /* @__PURE__ */ Symbol("ExecuteAction");
+class jt extends p {
+  constructor(t) {
+    super(t);
   }
   static get classIdentifier() {
-    return Ie;
+    return ge;
   }
-  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 at extends y {
-  constructor(e) {
-    super(e);
+const fe = /* @__PURE__ */ Symbol("ListItemAddedAction");
+class K extends p {
+  constructor(t) {
+    super(t);
   }
   static get classIdentifier() {
-    return Ae;
+    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 _e = /* @__PURE__ */ Symbol("ListItemRemovedAction");
-class zt extends y {
-  constructor(e) {
-    super(e);
+const pe = /* @__PURE__ */ Symbol("ListItemRemovedAction");
+class Nt extends p {
+  constructor(t) {
+    super(t);
   }
   static get classIdentifier() {
-    return _e;
+    return pe;
   }
-  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 me = Object.freeze({});
+function kt() {
   return {
     originalValue: void 0,
     announcedValue: void 0,
     errors: [],
-    visibility: N.FULL,
+    visibility: _.FULL,
     enabled: !0,
     valueVersion: 0,
     validatingCount: 0,
+    validatingChildren: 0,
     parent: void 0,
     fieldName: void 0,
     validationEpoch: 0,
     declaration: void 0,
-    extra: Te,
+    extra: me,
     valid: !0,
     invalidChildren: 0
   };
 }
-function Oe() {
-  return x(p({}, Ht()), { value: void 0, touched: !1 });
+function ve() {
+  return { ...kt(), value: void 0, touched: !1 };
 }
-function Qt() {
-  return x(p({}, Ht()), {
+function Bt() {
+  return {
+    ...kt(),
     announcedValue: null,
     cachedValue: null,
     cachedValueVersion: -1
-  });
+  };
 }
-function je() {
-  return x(p({}, Qt()), { rows: null });
+function be() {
+  return { ...Bt(), fieldNames: [] };
 }
-class X extends A {
+function we() {
+  return { ...Bt(), rows: null, rowsVersion: 0, cachedItems: null, cachedItemsVersion: -1 };
+}
+class M extends V {
   get state() {
     return super.state;
   }
@@ -1531,11 +1651,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(ve()), this.init(t);
   }
   /**
    * Applies the constructor parameters. It is a hook so that a subclass needing different parameter handling
@@ -1546,63 +1666,59 @@ 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, ...a } = t;
+        this.registerInitialActions([...s || [], ...i || []]), this.assignParams(a), this._value = e !== void 0 ? e : this.originalValue, this.originalValue === void 0 && (this.originalValue = this._value);
       }
-      this.raw.announcedValue = this._value, (s = this._actions) == null || s.triggerEager(this, this.value, this.originalValue), this.validate();
+      this.raw.announcedValue = this._value, this._actions?.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._actions?.triggerEager(this, t, e), this.propagateValueChanged();
     });
   }
   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(x(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;
+      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 Pe = new X({ value: "EmptyField" }).registerAction(
-  new O(() => {
+const Ve = new M({ value: "EmptyField" }).registerAction(
+  new S(() => {
     console.warn("Working with EmptyField! This should not happen");
   })
-), _t = /* @__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 Fe 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, c = k(t, ["value", "originalValue", "validators", "actions"]);
-        this.registerInitialActions([...a || [], ...o || []]), this.assignParams(c);
-        const u = it(i, this._value), C = Object.freeze({ label: r == null ? void 0 : r.label, icon: r == null ? void 0 : r.icon });
-        this._value = it(u, p({}, C)), this.originalValue = it(C, u);
+), ft = /* @__PURE__ */ new WeakMap();
+function H(n, t) {
+  return n?.label == null && n?.icon == null ? t : n;
+}
+class ye extends M {
+  init(t) {
+    u(() => {
+      if (this._value = { label: void 0, icon: void 0 }, t) {
+        const { value: e, originalValue: s, validators: i, actions: a, ...r } = t;
+        this.registerInitialActions([...i || [], ...a || []]), this.assignParams(r);
+        const o = H(e, this._value), l = Object.freeze({ label: s?.label, icon: s?.icon });
+        this._value = H(o, { ...l }), this.originalValue = H(l, o);
       }
-      this.raw.announcedValue = this._value, (s = this._actions) == null || s.triggerEager(this, this.value, this.originalValue), this.validate();
+      this.raw.announcedValue = this._value, this._actions?.triggerEager(this, this.value, this.originalValue), this.validate();
     });
   }
   /**
@@ -1611,15 +1727,15 @@ class Fe 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;
@@ -1631,13 +1747,13 @@ class Fe 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 = _t.get(this);
-    return e || (e = se(0), _t.set(this, e)), e;
+    let t = ft.get(this);
+    return t || (t = Wt(0), ft.set(this, t)), t;
   }
   /** true from the moment execute() is called until the handler it ran has settled, however it settles */
   get busy() {
@@ -1653,26 +1769,24 @@ class Fe 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 wt(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(jt, t);
+    } finally {
+      e.value--;
+    }
   }
 }
-const Ne = /* @__PURE__ */ ie({
+const Ce = /* @__PURE__ */ qt({
   __name: "messages-widget",
   props: {
     message: {},
     classes: {}
   },
   setup(n) {
-    const e = n, t = yt("vue-markdown"), s = /* @__PURE__ */ new Set([
+    const t = n, e = at("vue-markdown"), s = /* @__PURE__ */ new Set([
       "div",
       "span",
       "p",
@@ -1729,23 +1843,23 @@ const Ne = /* @__PURE__ */ ie({
       "dt",
       "dd"
     ]), i = () => {
-      if (typeof e.message == "string") return R("span", { class: e.classes }, e.message);
-      const r = [];
-      return e.message.forEach((a) => {
-        switch (a.componentName) {
+      if (typeof t.message == "string") return F("span", { class: t.classes }, t.message);
+      const a = [];
+      return t.message.forEach((r) => {
+        switch (r.componentName) {
           case "template":
-            r.push(R("div", { class: [e.classes, a.extraClasses] }, a.componentBody));
+            a.push(F("div", { class: [t.classes, r.extraClasses] }, r.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));
+              ), a.push(F("div", { class: [t.classes, r.extraClasses] }, r.componentBindings.source));
             else {
-              const o = a.componentBindings;
-              r.push(
-                R(t, {
-                  class: [e.classes, a.extraClasses, "df-messages-widget-markdown"],
+              const o = r.componentBindings;
+              a.push(
+                F(e, {
+                  class: [t.classes, r.extraClasses, "df-messages-widget-markdown"],
                   source: o.source,
                   options: o.options,
                   plugins: o.plugins
@@ -1754,88 +1868,172 @@ const Ne = /* @__PURE__ */ ie({
             }
             break;
           default:
-            r.push(
-              R(
-                s.has(a.componentName.toLowerCase()) ? a.componentName : yt(a.componentName),
-                p(p({
-                  class: [e.classes, a.extraClasses]
-                }, a.componentBindings), a.componentBody ? { innerHTML: a.componentBody } : {})
+            a.push(
+              F(
+                s.has(r.componentName.toLowerCase()) ? r.componentName : at(r.componentName),
+                {
+                  class: [t.classes, r.extraClasses],
+                  ...r.componentBindings,
+                  ...r.componentBody ? { innerHTML: r.componentBody } : {}
+                }
               )
             );
             break;
         }
-      }), r;
+      }), a;
     };
-    return (r, a) => (ne(), re(i));
+    return (a, r) => (zt(), Ht(i));
   }
-});
-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, c]) => this.addField(o, c)), s) {
-        const r = s, { value: o, validators: c, actions: u } = r, C = k(r, ["value", "validators", "actions"]);
-        this.registerInitialActions([...c || [], ...u || []]), this.assignParams(C), 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();
-    });
+}), pt = /* @__PURE__ */ new WeakMap(), Ee = (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 d extends V {
   get state() {
     return super.state;
   }
   get raw() {
     return super.raw;
   }
+  _fields;
+  constructor(t, e) {
+    if (super(be()), !d.isValidFields(t)) throw new Error("Invalid fields object provided");
+    this._fields = /* @__PURE__ */ Object.create(null), u(() => {
+      if (Object.entries(t).forEach(([i, a]) => this.addField(i, a)), e) {
+        const { value: i, validators: a, actions: r, ...o } = e;
+        this.registerInitialActions([...a || [], ...r || []]), this.assignParams(o), i !== void 0 ? this.assignMembers(i) : this.originalValue !== void 0 && this.assignMembers(this.originalValue);
+      }
+      this.completeRecords();
+      const s = this.value;
+      this.originalValue === void 0 && (this.originalValue = d.baseline(s)), this.raw.announcedValue = s, this._actions?.triggerEager(this, s, this.originalValue), this.validate();
+    });
+  }
+  /**
+   * 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 };
+  }
+  /**
+   * 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;
   }
-  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 });
+  /** 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 V;
     }
-    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 V)
       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 M({ 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 = pt.get(this);
+    return t || (t = new Proxy(
+      this._fields,
+      Ee(() => this.state.fieldNames.length)
+    ), pt.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, a]) => {
+      const r = a.value;
+      (a.enabled || a instanceof d && !R(r)) && (e[i] = r);
     });
-    const i = L(s) ? null : Object.freeze(p({}, s));
-    return this.raw.cachedValue = i, this.raw.cachedValueVersion = t, i;
+    const s = R(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
@@ -1843,15 +2041,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);
     });
   }
   /**
@@ -1859,33 +2057,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, c]) => {
-        var C;
-        let u;
-        s === null ? u = null : s !== void 0 && Object.hasOwn(s, o) && (u = s[o]), this.resetChild(c, (C = i.field(o)) != null ? C : c, u);
+  resetTo(t, e) {
+    const s = t;
+    u((i) => {
+      i.touch(this), this.errors.length && (this.errors = []), Object.entries(this._fields).forEach(([r, o]) => {
+        let l;
+        e === null ? l = null : e !== void 0 && Object.hasOwn(e, r) && (l = e[r]), this.resetChild(o, s.field(r) ?? o, l);
       });
       const a = this.value;
-      this.raw.announcedValue = a, this.originalValue = w.baseline(a), super.validate(!0);
+      this.raw.announcedValue = a, this.originalValue = d.baseline(a), 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
@@ -1909,27 +2106,32 @@ 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(([c, u]) => {
-      i[c] = u.bind();
+  bind(t, e) {
+    const s = /* @__PURE__ */ Object.create(null);
+    Object.entries(this._fields).forEach(([a, r]) => {
+      s[a] = r.bind();
     });
-    const r = new w(i, x(p({
+    const i = new d(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 i.boundFrom(this, i.raw.announcedValue, i.originalValue, e), i;
   }
   /**
    * A record need not name every member: a key it leaves out is taken from the declaration, the same way a member
@@ -1939,28 +2141,26 @@ class w extends A {
     return super.rebind(t);
   }
 }
-class D extends A {
-  constructor(t, s) {
-    super(je());
-    d(this, "_itemTemplate");
-    this._itemTemplate = t, g(() => {
-      var r;
-      if (s) {
-        const i = s, { value: a, validators: o, actions: c } = i, u = k(i, ["value", "validators", "actions"]);
-        this.registerInitialActions([...o || [], ...c || []]), this.assignParams(u), 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 A extends V {
   get state() {
     return super.state;
   }
   get raw() {
     return super.raw;
   }
+  _itemTemplate;
+  constructor(t, e) {
+    super(we()), this._itemTemplate = t, u(() => {
+      if (e) {
+        const { value: s, validators: i, actions: a, ...r } = e;
+        this.registerInitialActions([...i || [], ...a || []]), this.assignParams(r), s != null && this.setValueInternal(s);
+      }
+      this.originalValue === void 0 && (this.originalValue = A.baseline(this.value)), this.raw.announcedValue = this.value, this._actions?.triggerEager(this, this.value, this.originalValue), this.validate();
+    });
+  }
   /** The row array is copied as well: a rollback puts back the set the list held, not the array it went on to hold. */
-  [z]() {
-    const t = super[z]();
+  [O]() {
+    const t = super[O]();
     return t.rows = this.raw.rows ? [...this.raw.rows] : this.raw.rows, t;
   }
   /**
@@ -1971,8 +2171,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
@@ -1981,32 +2181,41 @@ 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((a, r) => a !== i[r]);
+  }
   setValueInternal(t) {
-    g((s) => {
-      var i;
-      if (s.touch(this), t == null)
+    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 c = t[o], u = r[o];
-          u && this._itemTemplate && !(c instanceof w) ? (this.resetChild(u, this._itemTemplate, c), a[o] = u) : (u && this.releaseChild(u), a[o] = this.processSetValueItem(c));
+        const i = this.state.rows ?? [], a = new Array(t.length);
+        for (let r = 0; r < t.length; r++) {
+          const o = t[r], l = i[r];
+          l && this._itemTemplate && !(o instanceof d) ? (this.resetChild(l, this._itemTemplate, o), a[r] = l) : (l && this.releaseChild(l), a[r] = this.processSetValueItem(o));
         }
-        for (let o = t.length; o < r.length; o++) this.releaseChild(r[o]);
+        for (let r = t.length; r < i.length; r++) this.releaseChild(i[r]);
         this.state.rows = a;
       }
-      this.bumpValueVersion();
+      A.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 = R(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);
     });
   }
@@ -2014,35 +2223,32 @@ 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 = A.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, c;
-    const i = new D((r = this._itemTemplate) == null ? void 0 : r.bind(), x(p({
+  bind(t, e) {
+    const s = new A(this._itemTemplate?.bind(), {
       // 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: (c = s == null ? void 0 : s.visibility) != null ? c : 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
+    });
+    return s.boundFrom(this, s.value, s.originalValue, e), s;
   }
   /**
    * Records that a row changed its value, so that the transaction in progress works out at commit what this
@@ -2066,103 +2272,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(), c = this.state.rows.push(o) - 1;
-        this.bumpValueVersion(), r.recordStructural(this, { actionClass: at, item: o, index: c });
+      s.touch(this);
+      const i = this.state.rows.splice(t, 1)?.[0];
+      i && (this.releaseChild(i), this.rowsChanged(), this.bumpValueVersion(), e = i, s.recordStructural(this, { actionClass: Nt, item: e, index: t }), this.propagateValueChanged(!0));
+    }), e;
+  }
+  insert(t, e) {
+    let s = 0;
+    return u((i) => {
+      for (i.touch(this), this.state.rows == null && (this.state.rows = []), s = e < 0 ? Math.max(this.state.rows.length + e, 0) : e; this.state.rows.length < s; ) {
+        const r = this.createPaddingItem(), o = this.state.rows.push(r) - 1;
+        this.bumpValueVersion(), i.recordStructural(this, { actionClass: K, item: r, index: o });
       }
       const a = this.processSetValueItem(t);
-      this.state.rows.splice(i, 0, a), r.recordStructural(this, { actionClass: at, item: a, index: i }), this.bumpValueVersion(), this.propagateValueChanged(!0);
-    }), i;
+      this.state.rows.splice(s, 0, a), i.recordStructural(this, { actionClass: K, item: a, 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, c) => {
-      this.comparisonState(c).oldValue = o;
-      const u = this.resolve(c);
-      return u ? (this.listenOn(u), this.isValidComparison(b(a), b(u.value)) ? null : [
-        new V(
-          this.replacePlaceholders(i, { newValue: a, oldValue: o, field: c, otherField: u })
+class xe extends g {
+  constructor(t, e, s) {
+    const i = (a, r, o) => {
+      this.comparisonState(o).oldValue = r;
+      const l = this.resolve(o);
+      return l ? (this.listenOn(l), this.isValidComparison(h(a), h(l.value)) ? null : [
+        new f(
+          this.replacePlaceholders(s, { newValue: a, oldValue: r, field: o, otherField: l }),
+          "",
+          "compare-to"
         )
-      ]) : (c.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) : ut(s, T(t));
+    const e = this.otherField;
+    return typeof e == "function" ? e(t) ?? void 0 : typeof e == "string" ? se(e, t) : G(e, x(t));
   }
   /**
    * Makes a change of `other` re-run this comparison. The listener re-runs it over the fields of the record the
@@ -2171,12 +2404,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 S((e, s, i, a) => {
+        s(e, i, a);
+        const r = x(e);
         this.declarations.forEach(
-          (c) => Lt(c, o).forEach((u) => {
-            this.registrations.has(u) && this.execute(u, () => null, u.value, this.comparisonState(u).oldValue);
+          (o) => Tt(o, r).forEach((l) => {
+            this.registrations.has(l) && this.execute(l, () => null, l.value, this.comparisonState(l).oldValue);
           })
         );
       })
@@ -2189,196 +2422,244 @@ class ke extends v {
     return this.bindingState(t);
   }
   newBindingState() {
-    return x(p({}, super.newBindingState()), { oldValue: void 0 });
+    return { ...super.newBindingState(), oldValue: void 0 };
   }
   unregisterFrom(t) {
-    this.registrations.delete(t);
-  }
-}
-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, c) => e.includes(b(a)) ? null : [
-      new V(
-        this.replacePlaceholders(s, { newValue: a, oldValue: o, field: c, allowedValues: e, allowedAsText: i })
-      )
-    ];
+    super.unregisterFrom(t), this.registrations.delete(t);
+  }
+}
+class Se extends g {
+  constructor(t, e) {
+    const s = e || m("Must be one of [**{allowedAsText}**]"), i = () => {
+      const o = h(t);
+      return typeof o == "function" ? o() : o;
+    }, a = (o) => {
+      const l = o.join(", ");
+      return l.length <= 60 ? l : Mt(l, { length: 40, separator: ", ", omission: `... (${o.length} items total)` });
+    }, r = (o, l, w) => {
+      const b = i();
+      return b.includes(h(o)) ? null : [
+        new f(
+          this.replacePlaceholders(s, {
+            newValue: o,
+            oldValue: l,
+            field: w,
+            allowedValues: b,
+            allowedAsText: a(b)
+          }),
+          "",
+          "in-allowed-values"
+        )
+      ];
+    };
     super(r);
   }
 }
-function De(n) {
-  return n == null ? 0 : Tt(n) || P(n) ? n.length : Ot(n) && Object.getPrototypeOf(n) === Object.prototype ? Object.keys(n).length : String(n).length;
+function Ie(n) {
+  return n == null ? 0 : vt(n) || C(n) ? n.length : bt(n) && Object.getPrototypeOf(n) === Object.prototype ? Object.keys(n).length : String(n).length;
 }
-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);
+function mt(n) {
+  return typeof n == "object" && n !== null && !wt(n) && !(n instanceof String) && !("componentName" in n);
+}
+class Ae extends g {
+  constructor(t, e) {
+    const s = mt(t) ? void 0 : t, i = (mt(t) ? t : e)?.trim ?? !0, a = s || m("Please enter a value"), r = (o, l, w) => {
+      const b = h(o);
+      return Ie(i && C(b) ? b.trim() : b) === 0 ? [
+        new f(
+          this.replacePlaceholders(a, { newValue: o, oldValue: l, field: w }),
+          "",
+          "required"
+        )
+      ] : null;
+    };
+    super(r);
   }
 }
-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 Te extends g {
+  constructor(t, e) {
+    const s = e || m("Value must be larger or equal to **{minValue}**"), i = (a, r, o) => a < t || a === void 0 ? [
+      new f(
+        this.replacePlaceholders(s, { newValue: a, oldValue: r, field: o, minValue: t }),
+        "",
+        "min"
+      )
     ] : null;
     super(i);
   }
 }
-class Ue 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 _e extends g {
+  constructor(t, e) {
+    const s = e || m("Value must be less than or equal to **{maxValue}**"), i = (a, r, o) => a > t || a === void 0 ? [
+      new f(
+        this.replacePlaceholders(s, { newValue: a, oldValue: r, field: o, maxValue: t }),
+        "",
+        "max"
+      )
     ] : null;
     super(i);
   }
 }
-class Me extends v {
-  constructor(e, t, s) {
-    const i = s || E("Value must be between **{minValue}** and **{maxValue}**"), r = (a, o, c) => a < e || a > t || a === void 0 ? [
-      new V(
-        this.replacePlaceholders(i, { newValue: a, oldValue: o, field: c, minValue: e, maxValue: t })
+class Oe extends g {
+  constructor(t, e, s) {
+    const i = s || m("Value must be between **{minValue}** and **{maxValue}**"), a = (r, o, l) => r < t || r > e || r === void 0 ? [
+      new f(
+        this.replacePlaceholders(i, { newValue: r, oldValue: o, field: l, minValue: t, maxValue: e }),
+        "",
+        "range"
       )
     ] : null;
-    super(r);
+    super(a);
   }
 }
-function ht(n) {
-  return n == null ? 0 : Tt(n) || P(n) ? n.length : Ot(n) && Object.getPrototypeOf(n) === Object.prototype ? Object.keys(n).length : String(n).length;
+function tt(n) {
+  return n == null ? 0 : vt(n) || C(n) ? n.length : bt(n) && Object.getPrototypeOf(n) === Object.prototype ? Object.keys(n).length : String(n).length;
 }
-class We extends v {
-  constructor(e, t) {
-    const s = t || E("Length must be larger or equal to **{minLength}**"), i = (r, a, o) => ht(r) < e ? [
-      new V(this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, minLength: e }))
+class Fe extends g {
+  constructor(t, e) {
+    const s = e || m("Length must be larger or equal to **{minLength}**"), i = (a, r, o) => tt(a) < t ? [
+      new f(
+        this.replacePlaceholders(s, { newValue: a, oldValue: r, field: o, minLength: t }),
+        "",
+        "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) => ht(r) > e ? [
-      new V(this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, maxLength: e }))
+class Re extends g {
+  constructor(t, e) {
+    const s = e || m("Length must be less than or equal to **{maxLength}**"), i = (a, r, o) => tt(a) > t ? [
+      new f(
+        this.replacePlaceholders(s, { newValue: a, oldValue: r, field: o, maxLength: t }),
+        "",
+        "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, c) => {
-      const u = ht(a);
-      return u < e || u > t ? [
-        new V(
-          this.replacePlaceholders(i, { newValue: a, oldValue: o, field: c, minLength: e, maxLength: t })
+class Pe extends g {
+  constructor(t, e, s) {
+    const i = s || m("Length must be between **{minLength}** and **{maxLength}**"), a = (r, o, l) => {
+      const w = tt(r);
+      return w < t || w > e ? [
+        new f(
+          this.replacePlaceholders(i, { newValue: r, oldValue: o, field: l, minLength: t, maxLength: e }),
+          "",
+          "range-length"
         )
       ] : null;
     };
-    super(r);
+    super(a);
   }
 }
-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 je extends g {
+  constructor(t, e) {
+    const s = e || m('Value must match pattern "**{pattern}**"'), i = (a, r, o) => t.test(String(h(a))) ? null : [
+      new f(
+        this.replacePlaceholders(s, { newValue: a, oldValue: r, field: o, pattern: t }),
+        "",
+        "pattern"
+      )
     ];
     super(i);
   }
 }
-const He = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const Ne = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  CompareTo: ke,
-  InAllowedValues: Re,
-  LengthInRange: qe,
-  MaxLength: $e,
-  MaxValue: Ue,
-  MinLength: We,
-  MinValue: Be,
-  Pattern: ze,
-  Required: Le,
-  Validator: v,
-  ValueInRange: Me
-}, Symbol.toStringTag, { value: "Module" })), Je = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  CompareTo: xe,
+  InAllowedValues: Se,
+  LengthInRange: Pe,
+  MaxLength: Re,
+  MaxValue: _e,
+  MinLength: Fe,
+  MinValue: Te,
+  Pattern: je,
+  Required: Ae,
+  Validator: g,
+  ValueInRange: Oe
+}, Symbol.toStringTag, { value: "Module" })), Le = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  AbortEventHandlingException: rt,
-  Action: Fe,
-  ActionsMap: M,
-  ConditionalEnabledAction: ve,
-  ConditionalStatementAction: Q,
-  ConditionalValueAction: Ve,
-  ConditionalVisibilityAction: be,
-  DisplayMode: N,
-  EmptyField: Pe,
-  EnabledChangedAction: Ut,
-  EnabledChangingAction: Bt,
-  ExecuteAction: qt,
-  Field: X,
-  FieldActionBase: y,
-  FieldBase: A,
-  Group: w,
-  List: D,
-  ListItemAddedAction: at,
-  ListItemRemovedAction: zt,
-  MdString: U,
-  MessagesWidget: Ne,
-  Operator: m,
-  RenderableValue: he,
-  Statement: I,
-  ValidChangedAction: Mt,
-  ValidationError: ct,
-  ValidationErrorRenderContent: V,
-  ValidationErrorText: ue,
-  Validator: v,
-  Validators: He,
-  ValueChangedAction: O,
-  VisibilityChangedAction: $t,
-  VisibilityChangingAction: Wt,
-  buildErrorMessage: E,
-  isCallableFunction: H,
-  isSimpleComponentDef: lt,
-  transaction: ot
+  AbortEventHandlingException: Vt,
+  Action: ye,
+  ActionsMap: D,
+  ConditionalEnabledAction: re,
+  ConditionalStatementAction: L,
+  ConditionalValueAction: ae,
+  ConditionalVisibilityAction: ne,
+  DisplayMode: _,
+  EmptyField: Ve,
+  EnabledChangedAction: Ot,
+  EnabledChangingAction: _t,
+  ExecuteAction: jt,
+  Field: M,
+  FieldActionBase: p,
+  FieldBase: V,
+  Group: d,
+  List: A,
+  ListItemAddedAction: K,
+  ListItemRemovedAction: Nt,
+  MdString: P,
+  MessagesWidget: Ce,
+  Operator: c,
+  RenderableValue: Zt,
+  Statement: v,
+  ValidChangedAction: Ft,
+  ValidationError: Z,
+  ValidationErrorRenderContent: f,
+  ValidationErrorText: Jt,
+  Validator: g,
+  Validators: Ne,
+  ValueChangedAction: S,
+  VisibilityChangedAction: Pt,
+  VisibilityChangingAction: Rt,
+  buildErrorMessage: m,
+  isCallableFunction: B,
+  isSimpleComponentDef: J,
+  transaction: Y
 }, Symbol.toStringTag, { value: "Module" }));
 export {
-  rt as AbortEventHandlingException,
-  Fe as Action,
-  M as ActionsMap,
-  ve as ConditionalEnabledAction,
-  Q as ConditionalStatementAction,
-  Ve as ConditionalValueAction,
-  be as ConditionalVisibilityAction,
-  N as DisplayMode,
-  Pe as EmptyField,
-  Ut as EnabledChangedAction,
-  Bt as EnabledChangingAction,
-  qt as ExecuteAction,
-  X as Field,
-  y as FieldActionBase,
-  A as FieldBase,
-  w as Group,
-  D as List,
-  at as ListItemAddedAction,
-  zt as ListItemRemovedAction,
-  U as MdString,
-  Ne as MessagesWidget,
-  m as Operator,
-  he as RenderableValue,
-  I as Statement,
-  Mt as ValidChangedAction,
-  ct as ValidationError,
-  V as ValidationErrorRenderContent,
-  ue 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,
-  H as isCallableFunction,
-  lt as isSimpleComponentDef,
-  ot as transaction
+  Vt as AbortEventHandlingException,
+  ye as Action,
+  D as ActionsMap,
+  re as ConditionalEnabledAction,
+  L as ConditionalStatementAction,
+  ae as ConditionalValueAction,
+  ne as ConditionalVisibilityAction,
+  _ as DisplayMode,
+  Ve as EmptyField,
+  Ot as EnabledChangedAction,
+  _t as EnabledChangingAction,
+  jt as ExecuteAction,
+  M as Field,
+  p as FieldActionBase,
+  V as FieldBase,
+  d as Group,
+  A as List,
+  K as ListItemAddedAction,
+  Nt as ListItemRemovedAction,
+  P as MdString,
+  Ce as MessagesWidget,
+  c as Operator,
+  Zt as RenderableValue,
+  v as Statement,
+  Ft as ValidChangedAction,
+  Z as ValidationError,
+  f as ValidationErrorRenderContent,
+  Jt as ValidationErrorText,
+  g as Validator,
+  Ne as Validators,
+  S as ValueChangedAction,
+  Pt as VisibilityChangedAction,
+  Rt as VisibilityChangingAction,
+  m as buildErrorMessage,
+  Le as default,
+  De as forms,
+  Kt as getConfig,
+  B as isCallableFunction,
+  J as isSimpleComponentDef,
+  Yt as setConfig,
+  Y as transaction
 };
 //# sourceMappingURL=dynamicforms-vue-forms.js.map