@dynamicforms/vue-forms 0.6.0 → 0.11.0

package/dist/dynamicforms-vue-forms.js

@@ -1,51 +1,80 @@
-var de = Object.defineProperty, ge = Object.defineProperties;
-var fe = Object.getOwnPropertyDescriptors;
-var P = Object.getOwnPropertySymbols;
-var J = Object.prototype.hasOwnProperty, K = Object.prototype.propertyIsEnumerable;
-var q = (i, s, e) => s in i ? de(i, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[s] = e, y = (i, s) => {
-  for (var e in s || (s = {}))
-    J.call(s, e) && q(i, e, s[e]);
-  if (P)
-    for (var e of P(s))
-      K.call(s, e) && q(i, e, s[e]);
-  return i;
-}, R = (i, s) => ge(i, fe(s));
-var I = (i, s) => {
-  var e = {};
-  for (var t in i)
-    J.call(i, t) && s.indexOf(t) < 0 && (e[t] = i[t]);
-  if (i != null && P)
-    for (var t of P(i))
-      s.indexOf(t) < 0 && K.call(i, t) && (e[t] = i[t]);
-  return e;
+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 o = (i, s, e) => q(i, typeof s != "symbol" ? s + "" : s, e);
-import { isEqual as k, isBoolean as pe, isString as V, isEmpty as H, truncate as be, isArray as te, isObject as se } from "lodash-es";
-import { unref as g, computed as me, reactive as ve, defineComponent as ye, resolveComponent as Z, openBlock as xe, createBlock as Ee, h as S } from "vue";
-var F = /* @__PURE__ */ ((i) => (i[i.SUPPRESS = 1] = "SUPPRESS", i[i.HIDDEN = 5] = "HIDDEN", i[i.INVISIBLE = 8] = "INVISIBLE", i[i.FULL = 10] = "FULL", i))(F || {});
-const ee = 10;
-((i) => {
-  function s(n) {
-    return n.toUpperCase() === "SUPPRESS" ? 1 : n.toUpperCase() === "HIDDEN" ? 5 : n.toUpperCase() === "INVISIBLE" ? 8 : ee;
-  }
-  i.fromString = s;
-  function e(n) {
-    const r = typeof n == "number" ? n : i.fromString(n);
-    return Object.values(i).includes(r) ? r : ee;
-  }
-  i.fromAny = e;
-  function t(n) {
-    const r = typeof n == "number" ? n : i.fromString(n);
-    return Object.values(i).includes(r);
-  }
-  i.isDefined = 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")
+);
+((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;
+  }
+  n.fromAny = t;
+  function s(i) {
+    const r = typeof i == "number" ? i : n.fromString(i);
+    return xt.has(r);
+  }
+  n.isDefined = s;
 })(F || (F = {}));
 Object.freeze(F);
-const C = F;
-class b {
-  constructor(s) {
-    o(this, "executorFn");
-    this.executorFn = s;
+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;
   }
   static get classIdentifier() {
     throw new Error("classIdentifier must be declared");
@@ -53,48 +82,295 @@ class b {
   get classIdentifier() {
     return this.constructor.classIdentifier;
   }
-  execute(s, e, ...t) {
-    return this.executorFn(s, e, ...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);
+  }
+  execute(e, t, ...s) {
+    return this.executorFn(e, t, ...s);
   }
   get eager() {
     return !1;
   }
+  /**
+   * Announces that this action now serves `binding`. It runs once per element the action is registered on, the
+   * copies of that element included: a copy takes on the instances it was copied from and each is told about the
+   * copy as it does.
+   */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  boundToField(s) {
+  boundToBinding(e) {
   }
-  unregister() {
+  /**
+   * 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.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  unregisterFrom(e) {
   }
 }
-class Q extends Error {
+class rt extends Error {
 }
-const ne = /* @__PURE__ */ Symbol("ValueChangedAction");
-class m extends b {
-  constructor(s) {
-    super(s);
+const B = /* @__PURE__ */ Symbol("ValueChangedAction");
+class O extends y {
+  constructor(e) {
+    super(e);
   }
   static get classIdentifier() {
-    return ne;
+    return B;
   }
-  execute(s, e, t, n) {
-    return super.execute(s, e, t, n);
+  execute(e, t, s, i) {
+    return super.execute(e, t, s, i);
   }
 }
-class j extends String {
-  constructor(e, t, n) {
-    super(e);
-    o(this, "plugins");
-    o(this, "options");
-    this.plugins = n, this.options = t;
+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);
+  }
+  /** 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;
+  }
+  /**
+   * 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]());
+  }
+  /** 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);
+  }
+  /** Enrols an element as one whose verdict the commit has to re-form. */
+  markValidityDirty(e) {
+    this.participant(e).validityDirty = !0, this.noteDepth(e);
+  }
+  /**
+   * 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);
+  }
+  /** 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);
+  }
+  /**
+   * 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);
+  }
+  /**
+   * Notes that an element at or below the depth the pass in progress is working at has been enrolled. The pass
+   * then gives up the rest of its batch and is started again over what is now owed, so the newcomer is reached
+   * before the containers above it: an element a handler writes must still be announced before the container
+   * 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);
+  }
+  /**
+   * Puts every element the transaction modified back as it found it. Nothing is announced: from an observer's
+   * point of view the transaction never happened. What a rollback cannot take back are side effects - a handler
+   * 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.participants.clear();
+    for (let t = this.undo.length - 1; t >= 0; t--) this.undo[t]();
+    this.undo.length = 0, this.deferred.length = 0;
+  }
+  /**
+   * Announces what the transaction did. Values first and verdicts after, because a container's validators run
+   * with its value announcement and the verdict they reach is what the validity pass then reports. Both passes
+   * run deepest first - field, then row, then list - which is the order the change travelled in.
+   *
+   * A handler may write while the commit runs; its writes join this transaction, so both passes repeat until
+   * nothing is left dirty.
+   */
+  commit() {
+    for (; !(!this.announceValues() && !this.settleValidity()); )
+      ;
+    this.deferred.splice(0).forEach((t) => t());
+  }
+  /**
+   * The dirty participants a pass has to visit, one bucket per nesting depth; ties keep the order they were
+   * enrolled in. A nesting depth is a small integer, so the elements go into buckets rather than through a
+   * 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 = [];
+    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;
+  }
+  /**
+   * Runs one pass over the dirty participants, deepest bucket first; the caller repeats it until it answers
+   * false. The buckets are taken once, and the pass gives up as soon as a handler enrols an element at or below
+   * 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);
+    if (!s.length) return !1;
+    for (let i = s.length - 1; i >= 0; i--) {
+      const r = s[i];
+      if (r) {
+        this.passDepth = i, this.restartPass = !1;
+        try {
+          for (let a = 0; a < r.length; a++) {
+            if (this.restartPass) return !0;
+            const o = r[a];
+            e(o) && t(o);
+          }
+        } finally {
+          this.passDepth = -1;
+        }
+        if (this.restartPass) return !0;
+      }
+    }
+    return !0;
+  }
+  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);
+      }
+    );
+  }
+  settleValidity() {
+    return this.pass(
+      (e) => e.validityDirty,
+      (e) => {
+        e.validityDirty = !1, e.element[Nt](this);
+      }
+    );
+  }
+}
+let _, et;
+function kt() {
+  return _;
+}
+class Rt {
+}
+class oe {
+  constructor() {
+    d(this, "open", !0);
+  }
+  rollback() {
+    throw this.open ? new Rt() : 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."
+    );
+  }
+  close() {
+    this.open = !1;
+  }
+}
+function St(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;
+  }
+  const e = new ae(), t = new oe();
+  _ = e, et = t;
+  try {
+    const s = n(t);
+    return St(s), e.commit(), s;
+  } catch (s) {
+    if (e.rollback(), s instanceof Rt) return;
+    throw s;
+  } finally {
+    _ = void 0, et = void 0, t.close();
+  }
+}
+function g(n) {
+  return _ ? n(_) : ot(() => n(_));
+}
+const Dt = { useMarkdownInValidators: !0 };
+function le() {
+  return Dt;
+}
+function ce(n) {
+  Object.assign(Dt, n);
+}
+const Ye = {
+  install(n, e) {
+    e && ce(e);
+  }
+};
+class U extends String {
+  constructor(t, s, i) {
+    super(t);
+    d(this, "plugins");
+    d(this, "options");
+    this.plugins = i, this.options = s;
   }
 }
-function W(i) {
-  const s = g(i);
-  return typeof s == "object" && "componentName" in s;
+function lt(n) {
+  const e = b(n);
+  return typeof e == "object" && "componentName" in e;
 }
-function U(i) {
-  return typeof g(i) == "function";
+function H(n) {
+  return typeof b(n) == "function";
 }
-class X {
+class ct {
   get componentName() {
     return "Comment";
   }
@@ -108,12 +384,12 @@ class X {
     return "";
   }
 }
-class _e extends X {
-  constructor(e, t = "") {
+class ue extends ct {
+  constructor(t, s = "") {
     super();
-    o(this, "text");
-    o(this, "classes");
-    this.text = e, this.classes = t;
+    d(this, "text");
+    d(this, "classes");
+    this.text = t, this.classes = s;
   }
   get componentName() {
     return "template";
@@ -125,24 +401,24 @@ class _e extends X {
     return this.classes;
   }
 }
-class p extends X {
-  constructor(e, t = "") {
+class V extends ct {
+  constructor(t, s = "") {
     super();
-    o(this, "classes");
-    o(this, "text");
-    o(this, "textType");
-    this.classes = t, this.text = e, this.textType = me(() => this.getTextType);
+    d(this, "classes");
+    d(this, "text");
+    d(this, "textType");
+    this.classes = s, this.text = t, this.textType = jt(() => this.getTextType);
   }
   get resolvedText() {
-    const e = g(this.text);
-    return U(e) ? e() : e;
+    const t = b(this.text);
+    return H(t) ? t() : t;
   }
   get getTextType() {
-    const e = this.resolvedText;
-    return e ? e instanceof j ? "md" : W(e) ? "component" : "string" : "string";
+    const t = this.resolvedText;
+    return t ? t instanceof U ? "md" : lt(t) ? "component" : "string" : "string";
   }
   get componentName() {
-    switch (g(this.textType)) {
+    switch (b(this.textType)) {
       case "string":
         return "template";
       case "md":
@@ -154,12 +430,12 @@ class p extends X {
     }
   }
   get componentBindings() {
-    switch (g(this.textType)) {
+    switch (b(this.textType)) {
       case "string":
         return {};
       case "md": {
-        const e = this.resolvedText;
-        return { source: e.toString(), options: e.options, plugins: e.plugins };
+        const t = this.resolvedText;
+        return { source: t.toString(), options: t.options, plugins: t.plugins };
       }
       case "component":
         return this.resolvedText.componentProps || {};
@@ -168,7 +444,7 @@ class p extends X {
     }
   }
   get componentBody() {
-    switch (g(this.textType)) {
+    switch (b(this.textType)) {
       case "string":
         return this.resolvedText;
       case "component":
@@ -181,158 +457,308 @@ class p extends X {
     return this.classes;
   }
 }
-class Ve extends p {
+class he extends V {
+}
+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, `
+`);
 }
-const Ce = /* @__PURE__ */ Symbol("Validator");
-class f extends m {
+const de = /* @__PURE__ */ Symbol("Validator"), ge = () => E("Validation could not be completed");
+class v extends O {
   /**
    * Creates a new validator
    * @param validationFn Function that validates the field value and returns errors or null
    */
-  constructor(e) {
-    super((n, r, a, l) => {
-      const c = e(a, l, n) || [], u = (h) => {
-        var A;
-        h == null || h.forEach(
-          (E) => Object.defineProperty(E, "source", { value: this.source, enumerable: !1, configurable: !1 })
-        );
-        for (let E = n.errors.length - 1; E >= 0; E--) {
-          const L = n.errors[E];
-          if (L.source === this.source) {
-            const O = (A = h == null ? void 0 : h.findIndex(($) => k($, L))) != null ? A : -1;
-            O >= 0 ? h == null || h.splice(O, 1) : n.errors.splice(E, 1);
+  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);
           }
         }
-        h && h.length > 0 && n.errors.push(...h), n.validate();
-      };
-      return c instanceof Promise ? (n.beginValidating(), c.then((h) => u(h)).finally(() => n.endValidating())) : u(c), r(n, a, l);
+        $.length > 0 && i.errors.push(...$), i.validate();
+      });
+      return Y instanceof Promise ? (i.beginValidating(), Y.then(
+        (S) => {
+          dt() && J(S);
+        },
+        (S) => {
+          dt() && (J([new V(ge())]), console.error("Validation failed", S));
+        }
+      ).finally(() => i.endValidating()).catch((S) => console.error("Validation failed", S))) : J(Y), r(i, a, o);
     });
-    o(this, "source");
+    d(this, "source");
     this.source = Symbol(this.constructor.name);
   }
+  /**
+   * Returns the error instance this validator owns and may later withdraw: the argument itself when it carries no
+   * ownership stamp or already carries this validator's, a copy of it when it belongs to another validator. The
+   * stamp is not configurable, so an instance one validator owns can never be reassigned to another; the copy is
+   * what makes an error instance shareable between validators, and it keeps the prototype and every own property,
+   * 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 }));
+  }
   static get classIdentifier() {
-    return Ce;
+    return de;
   }
   get eager() {
     return !0;
   }
-  replacePlaceholdersFunction(e, t) {
+  /**
+   * 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
+   * its own. A subclass that remembers more widens the record by overriding `newBindingState`.
+   */
+  bindingState(t) {
+    return this.state(t, () => this.newBindingState());
+  }
+  /**
+   * The record a field starts with. `run` is the sequence number of the newest run over that field: every
+   * execution takes the next one and a result is applied only while its number is still the newest, so a slow run
+   * cannot overwrite the verdict of a faster one that started after it.
+   */
+  newBindingState() {
+    return { run: 0 };
+  }
+  replacePlaceholdersFunction(t, s) {
     return () => {
-      let n = g(e);
-      for (; U(n); )
-        n = g(this.replacePlaceholders(n(), t));
-      return n;
+      let i = b(t);
+      for (; H(i); )
+        i = b(this.replacePlaceholders(i(), s));
+      return i;
     };
   }
-  replacePlaceholders(e, t) {
-    if (U(e)) return this.replacePlaceholdersFunction(e, t);
-    if (W(e)) return e;
-    let n = g(e);
-    return Object.keys(t).forEach((r) => {
-      n = n.replaceAll(`{${r}}`, t[r]);
-    }), e instanceof j ? new j(n.toString(), e.options, e.plugins) : n;
+  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 N extends Map {
+class M extends Map {
   constructor() {
     super(...arguments);
-    o(this, "eagerActions", /* @__PURE__ */ new Set());
-    o(this, "registeredActions", []);
-  }
-  register(e) {
-    if (!(e instanceof b)) throw new Error("Invalid action type");
-    this.registeredActions.push(e);
-    const t = e.classIdentifier, n = this.get(t) || (() => null);
-    function r(a, ...l) {
-      return e.execute(a, n, ...l);
+    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(t, r), e.eager && this.eagerActions.add(e.classIdentifier);
+    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.
+   */
+  willTrigger(t) {
+    return this.has(t) ? !0 : t === B && this.eagerActions.size > 0;
+  }
+  trigger(t, s, ...i) {
+    const r = t.classIdentifier;
+    return r === B && this.triggerEager(s, ...i), this.triggerChain(r, s, ...i);
   }
-  trigger(e, t, ...n) {
-    const r = e.classIdentifier;
-    r === ne && this.triggerEager(t, ...n);
-    const a = this.get(r);
+  /**
+   * 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 (a) return a(t, ...n);
-    } catch (l) {
-      if (!(l instanceof Q)) throw l;
+      if (r) return r(s, ...i);
+    } catch (a) {
+      if (!(a instanceof rt)) throw a;
     }
     return null;
   }
-  triggerEager(e, ...t) {
-    for (const n of this.eagerActions) {
-      const r = this.get(n);
+  triggerEager(t, ...s) {
+    for (const i of this.eagerActions) {
+      const r = this.get(i);
       try {
-        r && r(e, ...t);
+        r && r(t, ...s);
       } catch (a) {
-        if (!(a instanceof Q)) throw a;
+        if (!(a instanceof rt)) throw a;
       }
     }
   }
+  /** the validators registered in this map, in registration order */
+  get validators() {
+    return this.registeredActions.filter((t) => t instanceof v);
+  }
   clone() {
-    const e = new N();
-    return this.registeredActions.forEach((t) => e.register(t)), e;
+    const t = new M();
+    return this.registeredActions.forEach((s) => t.register(s)), t;
   }
+  /**
+   * Tells every action in this map that it serves `owner`. A copied map holds the instances the original holds, so
+   * the element that took the copy on is announced to them here, the way registering an action announces the
+   * element it was registered on.
+   */
+  bindTo(t) {
+    this.registeredActions.forEach((s) => s.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.
+   */
   cloneWithoutValidators() {
-    const e = new N();
-    return this.registeredActions.forEach((t) => {
-      t instanceof f ? t.unregister() : e.register(t);
-    }), e;
+    const t = new M();
+    return this.registeredActions.forEach((s) => {
+      s instanceof v || t.register(s);
+    }), t;
   }
 }
-const Ae = /* @__PURE__ */ Symbol("ConditionalStatementAction");
-class B extends m {
-  constructor(e, t) {
-    const n = (r, a, l, c) => {
-      const u = e.evaluate();
-      if (u !== this.lastResult) {
-        for (const h of this.boundFields)
-          t(h, u, this.lastResult);
-        this.lastResult = u;
-      }
-      return a(r, l, c);
-    };
-    super(n);
-    o(this, "lastResult");
-    // boundField tracks the fields this action is bound to. so that it may perform the executorFn on them and not on the
-    // ValueChangedAction fields that will call the actionExecutor
-    o(this, "boundFields", /* @__PURE__ */ new Set());
-    e.collectFields().forEach((r) => r.registerAction(new m(n)));
+function T(n) {
+  let e = n;
+  for (; e.fieldName !== void 0 && e.parent; ) e = e.parent;
+  return e;
+}
+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);
+  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));
   }
   static get classIdentifier() {
-    return Ae;
+    return me;
   }
   get eager() {
     return !0;
   }
-  boundToField(e) {
-    this.boundFields.add(e);
+  boundToBinding(t) {
+    this.declarations.add(t.declaration), this.registrations.add(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 = [];
+    return this.declarations.forEach(
+      (i) => Lt(i, t).forEach((r) => {
+        this.registrations.has(r) && s.push(r);
+      })
+    ), s;
+  }
+  /**
+   * Re-evaluates the statement over one record and applies the result where it changed. The result is recorded
+   * before the executor runs, because an executor that writes a value re-enters through that value's eager pass
+   * and what it has to find there is the result being applied. It answers whether the record held anything for
+   * 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;
+  }
+  /**
+   * Re-evaluates the records a change of `source` speaks for. A field of the record the targets live in speaks for
+   * that record alone, which is what keeps one row of a list from answering for another; a field above them - a
+   * form field every row reads - speaks for every record below it, and for the record the action was declared in
+   * 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));
   }
 }
-class Ie extends B {
-  constructor(s) {
-    super(s, (e, t) => {
-      e.visibility = t ? C.FULL : C.SUPPRESS;
+class be extends Q {
+  constructor(e) {
+    super(e, (t, s) => {
+      t.visibility = s ? N.FULL : N.SUPPRESS;
     });
   }
 }
-class Se extends B {
-  constructor(s) {
-    super(s, (e, t) => {
-      e.enabled = t;
+class ve extends Q {
+  constructor(e) {
+    super(e, (t, s) => {
+      t.enabled = s;
     });
   }
 }
-class we extends B {
-  constructor(s, e) {
-    super(s, (t, n) => {
-      n && (t.value = e);
+class Ve extends Q {
+  constructor(e, t) {
+    super(e, (s, i) => {
+      i && (s.value = t);
     });
   }
 }
-var T = /* @__PURE__ */ ((i) => (i[i.NOT = 0] = "NOT", i[i.OR = 1] = "OR", i[i.AND = 2] = "AND", i[i.XOR = 3] = "XOR", i[i.NAND = 4] = "NAND", i[i.NOR = 5] = "NOR", i[i.EQUALS = -1] = "EQUALS", i[i.NOT_EQUALS = -2] = "NOT_EQUALS", i[i.GT = -3] = "GT", i[i.LT = -4] = "LT", i[i.GE = -5] = "GE", i[i.LE = -6] = "LE", i[i.IN = -7] = "IN", i[i.NOT_IN = -8] = "NOT_IN", i[i.INCLUDES = -9] = "INCLUDES", i[i.NOT_INCLUDES = -10] = "NOT_INCLUDES", i))(T || {});
-((i) => {
-  function s(r) {
+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 || {});
+((n) => {
+  function e(r) {
     const a = r.toLowerCase();
     if (a === "not") return 0;
     if (a === "or") return 1;
@@ -352,209 +778,664 @@ var T = /* @__PURE__ */ ((i) => (i[i.NOT = 0] = "NOT", i[i.OR = 1] = "OR", i[i.A
     if (["not_includes", "not-includes", "not includes"].includes(a)) return -10;
     throw new Error(`Unrecognised operator ${a}`);
   }
-  i.fromString = s;
-  function e(r) {
-    const a = typeof r == "number" ? r : i.fromString(r);
-    if (Object.values(i).includes(a)) return a;
+  n.fromString = e;
+  function t(r) {
+    const a = typeof r == "number" ? r : n.fromString(r);
+    if (Object.values(n).includes(a)) return a;
     throw new Error(`Unrecognised operator ${r}`);
   }
-  i.fromAny = e;
-  function t(r) {
-    const a = typeof r == "number" ? r : i.fromString(r);
-    return Object.values(i).includes(a);
+  n.fromAny = t;
+  function s(r) {
+    const a = typeof r == "number" ? r : n.fromString(r);
+    return Object.values(n).includes(a);
   }
-  i.isDefined = t;
-  function n(r) {
+  n.isDefined = s;
+  function i(r) {
     return r >= 0;
   }
-  i.isLogicOperator = n;
-})(T || (T = {}));
-Object.freeze(T);
-const d = T, Fe = /* @__PURE__ */ Symbol("EnabledChangingAction");
-class ie extends b {
-  constructor(s) {
-    super(s);
+  n.isLogicOperator = i;
+})(W || (W = {}));
+Object.freeze(W);
+const m = W, we = /* @__PURE__ */ Symbol("EnabledChangingAction");
+class Bt extends y {
+  constructor(e) {
+    super(e);
   }
   static get classIdentifier() {
-    return Fe;
+    return we;
   }
-  execute(s, e, t, n) {
-    return super.execute(s, e, t, n);
+  execute(e, t, s, i) {
+    return super.execute(e, t, s, i);
   }
 }
-const je = /* @__PURE__ */ Symbol("EnabledChangedAction");
-class re extends b {
-  constructor(s) {
-    super(s);
+const ye = /* @__PURE__ */ Symbol("EnabledChangedAction");
+class Ut extends y {
+  constructor(e) {
+    super(e);
   }
   static get classIdentifier() {
-    return je;
+    return ye;
   }
-  execute(s, e, t, n) {
-    return super.execute(s, e, t, n);
+  execute(e, t, s, i) {
+    return super.execute(e, t, s, i);
   }
 }
-const Ne = /* @__PURE__ */ Symbol("ValidChangedAction");
-class ae extends b {
-  constructor(s) {
-    super(s);
+const Ee = /* @__PURE__ */ Symbol("ValidChangedAction");
+class Mt extends y {
+  constructor(e) {
+    super(e);
   }
   static get classIdentifier() {
-    return Ne;
+    return Ee;
   }
-  execute(s, e, t, n) {
-    return super.execute(s, e, t, n);
+  execute(e, t, s, i) {
+    return super.execute(e, t, s, i);
   }
 }
-const Te = /* @__PURE__ */ Symbol("VisibilityChangingAction");
-class le extends b {
-  constructor(s) {
-    super(s);
+const xe = /* @__PURE__ */ Symbol("VisibilityChangingAction");
+class Wt extends y {
+  constructor(e) {
+    super(e);
   }
   static get classIdentifier() {
-    return Te;
+    return xe;
   }
-  execute(s, e, t, n) {
-    return super.execute(s, e, t, n);
+  execute(e, t, s, i) {
+    return super.execute(e, t, s, i);
   }
 }
-const Le = /* @__PURE__ */ Symbol("VisibilityChangedAction");
-class oe extends b {
-  constructor(s) {
-    super(s);
+const Ce = /* @__PURE__ */ Symbol("VisibilityChangedAction");
+class $t extends y {
+  constructor(e) {
+    super(e);
   }
   static get classIdentifier() {
-    return Le;
+    return Ce;
   }
-  execute(s, e, t, n) {
-    return super.execute(s, e, t, n);
+  execute(e, t, s, i) {
+    return super.execute(e, t, s, i);
   }
 }
-class x {
+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));
+  }
   /**
-   * A field is a Vue reactive proxy from construction onwards: the base constructor returns the proxy, and a
-   * derived class's `this` is whatever super() returned, so every subclass constructor, field initializer and
-   * method sees the proxy. Consequence: plain `field.property = value` is tracked, with no wrapper in between.
+   * 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
+   * true because what carries an element's reactivity - its state - is a reactive object.
+   *
+   * Two consequences for a consumer, both silent. watch(field, cb) with a bare element as the source registers
+   * no dependency, because the deep traversal Vue starts for a reactive source stops on __v_skip; the supported
+   * form is watch(() => field.value, cb). And readonly(field) hands the element straight back, so the value it
+   * returns is the element itself and a write through it reaches the field; what a caller hands out instead is
+   * the value, which is frozen, or a computed over it.
    */
-  constructor() {
-    // contains original field value as was provided at creation
-    o(this, "validatingCount", 0);
-    o(this, "_valid", !0);
-    // is current value valid as per FE and BE validators?
-    o(this, "errors", []);
-    // when member of a Group, fieldName specifies the name of this field
-    o(this, "actions", new N());
-    // default property handlers
-    o(this, "_visibility", C.FULL);
-    o(this, "_enabled", !0);
-    return ve(this);
+  get __v_skip() {
+    return !0;
+  }
+  get __v_isReactive() {
+    return !0;
+  }
+  /** the tracked view of this element's state; a subclass narrows the return type to its own slots */
+  get state() {
+    return l(this, h);
+  }
+  /** the untracked view of this element's state; a subclass narrows the return type to its own slots */
+  get raw() {
+    return l(this, f);
+  }
+  /**
+   * Exchanges the data this element holds for `data`, in place. The element is the same instance afterwards - its
+   * identity, its actions, its extended properties and its place in whatever container holds it all stand - and it
+   * ends up in the state `bind(data)` would have produced: the values are written, the change history starts over
+   * and the validators run. It is what recycles one element across records, which is what a virtualised renderer
+   * does with the rows it keeps.
+   *
+   * The element makes no statement of its own about the exchange: no `ValueChangedAction` fires for it, the way
+   * none fires for an element that was just built. Its members do announce theirs, and a verdict that moves is
+   * announced as always - a rebound element that is invalid says so to the container holding it. A change an
+   * open transaction is already owed an announcement for stands: the commit reports the pair measured from
+   * where the element was when the transaction opened.
+   *
+   * 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;
+    }), this;
+  }
+  /** contains original field value as was provided at creation */
+  get originalValue() {
+    return l(this, h).originalValue;
+  }
+  set originalValue(e) {
+    this.touchState(), l(this, h).originalValue = e;
+  }
+  /**
+   * The extended properties this element carries: what a consumer attached to it beyond the members the class
+   * declares, such as the label, hint or css class a UI layer binds to the input it renders the element with.
+   * The read is tracked, so a template rendering off `field.extra.label` re-renders when the property is written.
+   *
+   * Every property is optional here, whatever `X` states: a parameter object need not carry one and
+   * setExtendedValues writes as few as a caller likes, so a property `X` declares as required is present only
+   * once something has written it.
+   *
+   * The object is frozen and setExtendedValues is the way to change it: it is the object a transaction captured,
+   * and one written in place would leave a rollback with nothing to put back.
+   */
+  get extra() {
+    return l(this, h).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));
+  }
+  /**
+   * The extended properties a parameter object carries: every key the element does not answer for itself. A key
+   * the element answers for at the time the parameters are applied - `value`, `enabled`, an accessor a subclass
+   * adds - is the element's own; a key that only Object.prototype answers for is nobody's declaration and counts
+   * as extended, and `validators` and `actions` are neither, since they state what to register on the element.
+   *
+   * A member a subclass declares as a class field is not among the keys the element answers for: class fields are
+   * 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;
+  }
+  /**
+   * 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);
+  }
+  /**
+   * Takes this element into the record of the open transaction, where one is open. A write of a single slot that
+   * announces nothing calls it instead of opening a transaction of its own: on its own such a write is already
+   * 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);
+  }
+  /**
+   * Records the whole of this element's mutable state, so that a rolled-back transaction can put it back exactly
+   * as it found it. The errors array is copied because a validator writes into the array it is handed rather than
+   * replacing it, and a subclass copies whatever else it holds by reference the same way.
+   *
+   * 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] });
+  }
+  /**
+   * 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.
+   */
+  [Pt](e) {
+    const t = l(this, f).validatingCount;
+    Object.assign(l(this, h), e), l(this, h).validatingCount = t;
   }
   /** true while at least one asynchronous validator is still running for this field */
   get validating() {
-    return this.validatingCount > 0;
+    return l(this, h).validatingCount > 0;
   }
   /** announces the start of one asynchronous validation run; validators pair it with endValidating */
   beginValidating() {
-    this.validatingCount++;
+    l(this, h).validatingCount++;
   }
   /** announces the end of one asynchronous validation run */
   endValidating() {
-    this.validatingCount = Math.max(0, this.validatingCount - 1);
+    l(this, h).validatingCount = Math.max(0, l(this, h).validatingCount - 1);
   }
-  get visibility() {
-    return this._visibility;
+  /**
+   * List of errors. The array handed out is the one the element holds, and a validator writes into it in place,
+   * so a transaction that is open takes the element into its record here: a rollback that put back everything
+   * except the errors would leave a state the form never held.
+   */
+  get errors() {
+    return this.touchState(), l(this, h).errors;
+  }
+  set errors(e) {
+    this.touchState(), l(this, h).errors = e;
   }
-  set visibility(s) {
-    const e = this._visibility, t = this.actions.trigger(le, this, s, e);
-    if (!C.isDefined(t != null ? t : s)) throw new Error("visibility must be a DisplayMode constant");
-    this._visibility = C.fromAny(t != null ? t : s), this.actions.trigger(oe, this, this._visibility, e);
+  /**
+   * The container that holds this element: the Group it is a member of, or the List whose row it is, and
+   * undefined while no container holds it. The container writes it; everyone else reads it. The read is tracked,
+   * so an effect rendering off the link - `v-if="field.parent"` - re-runs when a container takes the element or
+   * releases it.
+   */
+  get parent() {
+    return l(this, h).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;
+  }
+  /**
+   * The element this one was declared as: itself for an element built from parameters, and the element it was
+   * bound from for a binding - transitively, so a binding of a binding names the same one. Every row a `List`
+   * builds from an item template is a binding of it, so a row's member and the template's member it stands for
+   * 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;
+  }
+  /** The elements this one holds: a Group's members, a List's rows, none for a leaf. */
+  get members() {
+    return [];
+  }
+  /**
+   * Every element in this element's subtree, this element included, that was declared as `declaration`. It answers
+   * the question a shared action asks when the record it changed in is not the record its targets live in - a form
+   * 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);
+    };
+    return i(this), s;
+  }
+  /**
+   * States that an eager pass over this element reached an element it needs and did not find it, because the
+   * record this element belongs to was not assembled at the time: a `List` row is built member by member and its
+   * members are bound before any of them holds the row, so a validator comparing two of them runs before the
+   * row exists. The container that finishes the record runs the pass again, and a pass that still reaches
+   * nothing says so again, so the next container above answers for it.
+   */
+  markRecordIncomplete() {
+    this._recordPending || (this._recordPending = !0, st++);
+  }
+  /**
+   * 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);
+      };
+      t(e);
+    });
+  }
+  /** 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);
+    });
+  }
+  get actions() {
+    return this._actions || (this._actions = new M()), this._actions;
+  }
+  set actions(e) {
+    this._actions = e;
+  }
+  /**
+   * Counts the writes that have changed the value of this element or of anything below it. A container reads it
+   * before answering from its value cache, and the read is an ordinary tracked one, so an effect that took a
+   * cached value still re-runs when a descendant is written.
+   */
+  get valueVersion() {
+    return l(this, h).valueVersion;
+  }
+  /**
+   * Marks the value of this element and of every ancestor as superseded. It walks the parent chain, so it costs
+   * the nesting depth: an ancestor rebuilds its value the next time one is asked of it, instead of being walked
+   * here for a reader that may never come. The walk also brings each element into the open transaction, so 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;
+    });
+  }
+  /**
+   * States that this element's value changed and that every container above it therefore holds a different value
+   * too. Nothing is announced here: the transaction works out at commit which of the elements enrolled actually
+   * ends up holding a different value, and announces those once each.
+   *
+   * `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();
+    });
+  }
+  /**
+   * Re-reads the value that the next ValueChangedAction will report as the one it replaces. A leaf records what
+   * it announced at every announcement, so its copy is always current and there is nothing to re-read; a
+   * container that skipped composing a value nobody was listening for overrides this.
+   */
+  refreshPreviousValue() {
+  }
+  /**
+   * The verdict validate() records and announces: this element's own errors plus the tally of children that
+   * reported themselves invalid, so a container forms it without walking its members. `valid` is the read path
+   * and answers over the live errors arrays instead; the two differ only for an error written into a member
+   * 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;
+  }
+  /**
+   * Makes this element the container of `child`: it installs the back-reference, records the name a Group holds
+   * the child under, and takes the child into the invalid tally. An element belongs to one container at a time,
+   * so a child that already carries the link is refused; releaseChild() takes the link away again, and an element
+   * 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);
+    });
+  }
+  /** 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);
+    });
+  }
+  /**
+   * Drops a child out of this element's invalid tally and takes its back-reference away. An element keeps no link
+   * 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);
+    });
+  }
+  /**
+   * Brings this element to the state a fresh binding of `source` carrying `value` would be in: `value` is written
+   * where the caller supplied one and `source`'s own value where it did not, the change history - originalValue,
+   * touched - starts over and the errors are dropped and re-established by the validators. A container that reuses
+   * 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;
+      i && (this.errors = []), this.touched = !1;
+      const r = this.enabled && this.value !== s;
+      this.value = s, this.originalValue = this.value, this.validate(!r && i);
+    });
+  }
+  /** Resets a member. It is what lets a container reach the reset of a child whose class it does not know. */
+  resetChild(e, t, s) {
+    e.resetTo(t, s);
+  }
+  /**
+   * 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;
+  }
+  /**
+   * The composed verdict a container answers `valid` with, memoised by Vue. The walk over the members is what
+   * makes an error pushed into one of them visible without a validate() call, and the computed keeps that walk
+   * 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;
+  }
+  /** What validRead computes. A leaf answers over its own errors; a container adds its members. */
+  composeValid() {
+    return l(this, h).errors.length === 0;
+  }
+  // default property handlers
+  get visibility() {
+    return l(this, h).visibility;
+  }
+  set visibility(e) {
+    g((t) => {
+      var r, a;
+      const s = l(this, h).visibility, i = (r = this._actions) == null ? void 0 : r.trigger(Wt, this, e, s);
+      if (!N.isDefined(i != null ? i : e))
+        throw new Error("visibility must be a DisplayMode constant");
+      t.touch(this), l(this, h).visibility = N.fromAny(i != null ? i : e), (a = this._actions) == null || a.trigger($t, this, l(this, h).visibility, s);
+    });
   }
   get enabled() {
-    return this._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);
+    });
+  }
+  /**
+   * True for an element whose value is composed of its members'. The commit builds such a value only where
+   * something receives it, compares it by content rather than by identity, and runs the element's own validators
+   * with the announcement: a container's validators read the composed value, which exists only once the members
+   * have been written. A leaf's validators have run at the write instead, so its announcement carries no eager
+   * pass of its own.
+   */
+  get composesValue() {
+    return !1;
   }
-  set enabled(s) {
-    const e = this._enabled, t = this.actions.trigger(ie, this, s, e);
-    if (!pe(t != null ? t : s)) throw new Error("Enabled value must be boolean");
-    this._enabled = t != null ? t : s, this.actions.trigger(re, this, this._enabled, e);
+  /**
+   * Announces what this element's value became over the transaction. The pair carried is (value now, value at the
+   * last announcement), so a value that went A -> B -> A within the transaction says nothing, and the events an
+   * operation states rather than an element's state - an item added, an item removed - are emitted first, in the
+   * order the operations happened.
+   */
+  [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));
+  }
+  /**
+   * Forms the verdict this element ends the transaction with and announces a transition of it. The container is
+   * told first, so a handler reads a tally that already includes this verdict, and it is enrolled in the same
+   * transaction: its own verdict is composed of its members', so a member that moves without a value change - an
+   * asynchronous validator, an error pushed in by hand - is what makes the container re-form its own. The
+   * transaction settles the deepest element first, so a container is reached only once its members have decided.
+   */
+  [Nt](e) {
+    var r;
+    const t = l(this, f).valid, s = this.countedValid;
+    if (s === t) return;
+    e.touch(this), l(this, f).valid = s;
+    const i = this.parent;
+    i && (e.touch(i), i.childValidityChanged(s), e.markValidityDirty(i)), (r = this._actions) == null || r.trigger(Mt, this, s, t);
   }
-  validate(s = !1) {
-    s && this.actions.triggerEager(this, this.value, this.value);
-    const e = this._valid;
-    this._valid = this.valid, this._valid !== e && this.actions.trigger(ae, this, this.valid, e);
+  validate(e = !1) {
+    g((t) => {
+      var s;
+      e && ((s = this._actions) == null || s.triggerEager(this, this.value, this.value)), t.markValidityDirty(this);
+    });
   }
   get valid() {
-    return this.errors.length === 0;
+    return l(this, h).errors.length === 0;
   }
   get fullValue() {
     return this.value;
   }
   get isChanged() {
-    return !k(this.value, this.originalValue);
+    return !nt(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
+   * on the extended properties and the actions `source` carries, and runs the eager ones over the value it was
+   * built with. The extended properties `overrides` states are written over the ones `source` carries, and they
+   * are in place before the eager pass, so an action reading one sees what the binding ends up carrying. The
+   * 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));
   }
-  registerAction(s) {
-    return this.actions.register(s), s.boundToField(this), s.eager && this.actions.trigger(Object.getPrototypeOf(s).constructor, this, this.value, this.originalValue), this;
+  /**
+   * 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);
+    });
   }
-  triggerAction(s, ...e) {
-    return this.actions.trigger(s, this, ...e);
+  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);
+    }), this;
+  }
+  triggerAction(e, ...t) {
+    return this._actions ? this._actions.trigger(e, this, ...t) : null;
+  }
+  /**
+   * Generation counter of the validators attached to this field. A Validator reads it when a run starts and drops
+   * a result whose epoch no longer matches, so a validation still in flight when clearValidators() is called
+   * cannot push an error onto a field that no longer has the validator that produced it.
+   */
+  get validationEpoch() {
+    return l(this, h).validationEpoch;
   }
   clearValidators() {
-    this.actions = this.actions.cloneWithoutValidators(), this.errors = [], this._valid = !0;
+    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();
+    });
   }
 }
-function Oe(i, s) {
-  return i ? !s : s;
+h = new WeakMap(), f = new WeakMap();
+function Se(n, e) {
+  return n ? !e : e;
 }
-class w {
-  constructor(s, e, t) {
-    o(this, "operand1");
-    o(this, "operator");
-    o(this, "operand2");
-    this.operand1 = s, this.operator = e, this.operand2 = 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;
+  }
+  /**
+   * The value an operand contributes. A field operand names a field of the record the statement is evaluated in:
+   * the same statement over a `List` reads row 3's field while row 3 is the record, and a field belonging to no
+   * 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;
+    }
+    return e;
   }
   get operand1Value() {
-    return this.operand1 instanceof w ? this.operand1.evaluate() : this.operand1 instanceof x ? g(this.operand1.value) : this.operand1;
+    return I.valueOf(this.operand1);
   }
   get operand2Value() {
-    return this.operand2 instanceof w ? this.operand2.evaluate() : this.operand2 instanceof x ? g(this.operand2.value) : this.operand2;
+    return I.valueOf(this.operand2);
   }
-  evaluate() {
-    var t, n, r, a;
-    const s = this.operand1Value, e = this.operand2Value;
+  /**
+   * 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);
     switch (this.operator) {
       // logical operators
-      case d.AND:
-        return s && e;
-      case d.OR:
-        return s || e;
-      case d.NAND:
-        return !(s && e);
-      case d.NOR:
-        return !(s || e);
-      case d.XOR:
-        return Oe(s, e);
-      case d.NOT:
-        return !s;
+      // `&&` 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;
       // comparison operators
-      case d.EQUALS:
-        return s == e;
-      case d.NOT_EQUALS:
-        return s != e;
-      case d.LT:
-        return s < e;
-      case d.LE:
-        return s <= e;
-      case d.GE:
-        return s >= e;
-      case d.GT:
-        return s > e;
-      case d.IN:
-        return (n = (t = e == null ? void 0 : e.includes) == null ? void 0 : t.call(e, s)) != null ? n : !1;
-      case d.NOT_IN:
-        return !((a = (r = e == null ? void 0 : e.includes) == null ? void 0 : r.call(e, s)) == null || a);
-      case d.INCLUDES:
-        return V(s) && V(e) && s.indexOf(e) >= 0;
-      case d.NOT_INCLUDES:
-        return !(V(s) && V(e) && s.indexOf(e) >= 0);
+      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);
       default:
         throw new Error(`Operator not implemented ${this.operator}`);
     }
@@ -564,55 +1445,97 @@ class w {
    * @returns A set of all fields used in this statement
    */
   collectFields() {
-    const s = /* @__PURE__ */ new Set();
-    function e(t) {
-      t instanceof x ? s.add(t) : t instanceof w && t.collectFields().forEach((r) => s.add(r));
+    const e = /* @__PURE__ */ new Set();
+    function t(s) {
+      s instanceof A ? e.add(s) : s instanceof I && s.collectFields().forEach((r) => e.add(r));
     }
-    return e(this.operand1), e(this.operand2), s;
+    return t(this.operand1), t(this.operand2), e;
   }
 }
-const Pe = /* @__PURE__ */ Symbol("ExecuteAction");
-class ce extends b {
-  constructor(s) {
-    super(s);
+const Ie = /* @__PURE__ */ Symbol("ExecuteAction");
+class qt extends y {
+  constructor(e) {
+    super(e);
   }
   static get classIdentifier() {
-    return Pe;
+    return Ie;
   }
-  execute(s, e, t) {
-    return super.execute(s, e, t);
+  execute(e, t, s) {
+    return super.execute(e, t, s);
   }
 }
-const Re = /* @__PURE__ */ Symbol("ListItemAddedAction");
-class z extends b {
-  constructor(s) {
-    super(s);
+const Ae = /* @__PURE__ */ Symbol("ListItemAddedAction");
+class at extends y {
+  constructor(e) {
+    super(e);
   }
   static get classIdentifier() {
-    return Re;
+    return Ae;
   }
-  execute(s, e, t, n) {
-    return super.execute(s, e, t, n);
+  execute(e, t, s, i) {
+    return super.execute(e, t, s, i);
   }
 }
-const Ue = /* @__PURE__ */ Symbol("ListItemRemovedAction");
-class ue extends b {
-  constructor(s) {
-    super(s);
+const _e = /* @__PURE__ */ Symbol("ListItemRemovedAction");
+class zt extends y {
+  constructor(e) {
+    super(e);
   }
   static get classIdentifier() {
-    return Ue;
+    return _e;
   }
-  execute(s, e, t, n) {
-    return super.execute(s, e, t, n);
+  execute(e, t, s, i) {
+    return super.execute(e, t, s, i);
   }
 }
-class D extends x {
+const Te = Object.freeze({});
+function Ht() {
+  return {
+    originalValue: void 0,
+    announcedValue: void 0,
+    errors: [],
+    visibility: N.FULL,
+    enabled: !0,
+    valueVersion: 0,
+    validatingCount: 0,
+    parent: void 0,
+    fieldName: void 0,
+    validationEpoch: 0,
+    declaration: void 0,
+    extra: Te,
+    valid: !0,
+    invalidChildren: 0
+  };
+}
+function Oe() {
+  return x(p({}, Ht()), { value: void 0, touched: !1 });
+}
+function Qt() {
+  return x(p({}, Ht()), {
+    announcedValue: null,
+    cachedValue: null,
+    cachedValueVersion: -1
+  });
+}
+function je() {
+  return x(p({}, Qt()), { rows: null });
+}
+class X extends A {
+  get state() {
+    return super.state;
+  }
+  get raw() {
+    return super.raw;
+  }
+  /** the value slot itself, without the notifications the value setter carries around a write */
+  get _value() {
+    return this.state.value;
+  }
+  set _value(e) {
+    this.state.value = e;
+  }
   constructor(e) {
-    super();
-    o(this, "_value");
-    o(this, "_touched", !1);
-    this.init(e);
+    super(Oe()), this.init(e);
   }
   /**
    * Applies the constructor parameters. It is a hook so that a subclass needing different parameter handling
@@ -624,78 +1547,132 @@ class D extends x {
    * the moment the initializer runs.
    */
   init(e) {
-    if (e) {
-      const t = e, { value: n, validators: r, actions: a } = t, l = I(t, ["value", "validators", "actions"]);
-      [...r || [], ...a || []].forEach((c) => this.registerAction(c)), Object.assign(this, l), this._value = n != null ? n : this.originalValue, this.originalValue === void 0 && (this.originalValue = this._value);
-    }
-    this.actions.triggerEager(this, this.value, this.originalValue), this.validate();
+    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);
+      }
+      this.raw.announcedValue = this._value, (s = this._actions) == null || s.triggerEager(this, this.value, this.originalValue), this.validate();
+    });
   }
   get value() {
     return this._value;
   }
   set value(e) {
     const t = this._value;
-    !this.enabled || t === e || (this._value = e, this.actions.trigger(m, this, this._value, t), this.parent && this.parent.notifyValueChanged(), this.validate());
+    !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();
+    });
   }
   get touched() {
-    return this._touched;
+    return this.state.touched;
   }
   set touched(e) {
-    this._touched = e;
-  }
-  clone(e) {
-    var r, a, l;
-    const t = this.constructor, n = new t(R(y({
-      value: (r = e == null ? void 0 : e.value) != null ? r : this.value
-    }, e && "originalValue" in e ? { originalValue: e.originalValue } : {}), {
-      enabled: (a = e == null ? void 0 : e.enabled) != null ? a : this.enabled,
-      visibility: (l = e == null ? void 0 : e.visibility) != null ? l : this.visibility
+    this.touchState(), this.state.touched = e;
+  }
+  bind(e, t) {
+    var r, a;
+    const s = this.constructor, i = new s(x(p({
+      // 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 n.actions = this.actions.clone(), n.actions.triggerEager(n, n.value, n.originalValue), n;
+    return i.boundFrom(this, i.value, i.originalValue, t), i;
   }
 }
-const ke = new D({ value: "EmptyField" }).registerAction(
-  new m(() => {
+const Pe = new X({ value: "EmptyField" }).registerAction(
+  new O(() => {
     console.warn("Working with EmptyField! This should not happen");
   })
-);
-function M(i, s) {
-  return (i == null ? void 0 : i.label) == null && (i == null ? void 0 : i.icon) == null ? s : i;
-}
-class Be extends D {
-  init(s) {
-    if (this._value = { label: void 0, icon: void 0 }, s) {
-      const e = s, { value: t, originalValue: n, validators: r, actions: a } = e, l = I(e, ["value", "originalValue", "validators", "actions"]);
-      [...r || [], ...a || []].forEach((h) => this.registerAction(h)), Object.assign(this, l);
-      const c = M(t, this._value), u = Object.freeze({ label: n == null ? void 0 : n.label, icon: n == null ? void 0 : n.icon });
-      this._value = M(c, y({}, u)), this.originalValue = M(u, c);
-    }
-    this.actions.triggerEager(this, this.value, this.originalValue), this.validate();
+), _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);
+      }
+      this.raw.announcedValue = this._value, (s = this._actions) == null || s.triggerEager(this, this.value, this.originalValue), this.validate();
+    });
+  }
+  /**
+   * A copy of the value this action holds, carrying one member rewritten. A member handed undefined is dropped
+   * from the copy rather than written into it: an own key holding undefined is invisible to a reader and to
+   * 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;
   }
   get icon() {
     return this.value.icon;
   }
-  set icon(s) {
-    this.value.icon = s;
+  set icon(e) {
+    this.value.icon !== e && (this.value = this.valueWith("icon", e));
   }
   get label() {
     return this.value.label;
   }
-  set label(s) {
-    this.value.label = s;
+  /**
+   * The two setters hand the value setter a new object rather than writing into the one the action holds, so each
+   * is an ordinary value change: the handlers fire, isChanged answers over it, and a disabled action refuses it.
+   * The new object is built only for a member that differs from the one held - the value setter compares by
+   * 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));
   }
-  execute(s) {
-    this.actions.trigger(ce, this, s);
+  /** 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;
+  }
+  /** true from the moment execute() is called until the handler it ran has settled, however it settles */
+  get busy() {
+    return this.busyRuns.value > 0;
+  }
+  /**
+   * Runs the ExecuteAction chain registered on this action and answers what the chain returned. `busy` stands for
+   * the length of the run: the chain is entered synchronously, and the flag is cleared once the value it produced
+   * has settled - a handler that returns a promise holds it for as long as that promise takes, and one that
+   * rejects clears it as it rejects.
+   *
+   * The answer is a promise whatever the handler returns, so a handler that throws rejects it rather than throwing
+   * 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--;
+      }
+    });
   }
 }
-const De = /* @__PURE__ */ ye({
+const Ne = /* @__PURE__ */ ie({
   __name: "messages-widget",
   props: {
     message: {},
     classes: {}
   },
-  setup(i) {
-    const s = i, e = Z("vue-markdown"), t = /* @__PURE__ */ new Set([
+  setup(n) {
+    const e = n, t = yt("vue-markdown"), s = /* @__PURE__ */ new Set([
       "div",
       "span",
       "p",
@@ -751,37 +1728,37 @@ const De = /* @__PURE__ */ ye({
       "dl",
       "dt",
       "dd"
-    ]), n = () => {
-      if (typeof s.message == "string") return S("span", { class: s.classes }, s.message);
+    ]), i = () => {
+      if (typeof e.message == "string") return R("span", { class: e.classes }, e.message);
       const r = [];
-      return s.message.forEach((a) => {
+      return e.message.forEach((a) => {
         switch (a.componentName) {
           case "template":
-            r.push(S("div", { class: [s.classes, a.extraClasses] }, a.componentBody));
+            r.push(R("div", { class: [e.classes, a.extraClasses] }, a.componentBody));
             break;
           case "vue-markdown":
-            if (typeof e == "string")
+            if (typeof t == "string")
               console.warn(
                 "You are using markdown for messages-widget, but you haven't registered a vue-markdown component"
-              ), r.push(S("div", { class: [s.classes, a.extraClasses] }, a.componentBindings.source));
+              ), r.push(R("div", { class: [e.classes, a.extraClasses] }, a.componentBindings.source));
             else {
-              const l = a.componentBindings;
+              const o = a.componentBindings;
               r.push(
-                S(e, {
-                  class: [s.classes, a.extraClasses, "df-messages-widget-markdown"],
-                  source: l.source,
-                  options: l.options,
-                  plugins: l.plugins
+                R(t, {
+                  class: [e.classes, a.extraClasses, "df-messages-widget-markdown"],
+                  source: o.source,
+                  options: o.options,
+                  plugins: o.plugins
                 })
               );
             }
             break;
           default:
             r.push(
-              S(
-                t.has(a.componentName.toLowerCase()) ? a.componentName : Z(a.componentName),
-                y(y({
-                  class: [s.classes, a.extraClasses]
+              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 } : {})
               )
             );
@@ -789,419 +1766,619 @@ const De = /* @__PURE__ */ ye({
         }
       }), r;
     };
-    return (r, a) => (xe(), Ee(n));
+    return (r, a) => (ne(), re(i));
   }
 });
-class _ extends x {
-  constructor(e, t) {
-    super();
-    o(this, "_fields");
-    o(this, "_value", null);
-    o(this, "suppressNotifyValueChanged", !1);
-    if (!_.isValidFields(e)) throw new Error("Invalid fields object provided");
-    if (this._fields = /* @__PURE__ */ Object.create(null), Object.entries(e).forEach(([r, a]) => this.addField(r, a)), t) {
-      const n = t, { value: r, validators: a, actions: l } = n, c = I(n, ["value", "validators", "actions"]);
-      [...a || [], ...l || []].forEach((u) => this.registerAction(u)), Object.assign(this, c), this.value = r != null ? r : this.originalValue;
-    }
-    this.originalValue === void 0 && (this.originalValue = this.value), this.actions.triggerEager(this, this.value, this.originalValue), this.validate();
+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();
+    });
+  }
+  get state() {
+    return super.state;
+  }
+  get raw() {
+    return super.raw;
+  }
+  /**
+   * 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);
   }
-  addField(e, t) {
-    if (Object.hasOwn(this._fields, e))
-      throw new Error(`Field ${e} is already in this form`);
-    Object.defineProperty(t, "parent", { get: () => this, configurable: !1, enumerable: !1 }), Object.defineProperty(t, "fieldName", { get: () => e, configurable: !1, enumerable: !1 }), Object.defineProperty(this._fields, e, { get: () => t, configurable: !1, enumerable: !0 });
+  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 });
   }
-  static isValidFields(e) {
-    function t(n) {
-      return n instanceof x;
+  static isValidFields(t) {
+    function s(i) {
+      return i instanceof A;
     }
-    return typeof e == "object" && e !== null && Object.entries(e).every(([, n]) => t(n));
+    return typeof t == "object" && t !== null && Object.entries(t).every(([, i]) => s(i));
   }
-  static createFromFormData(e) {
-    if (e instanceof x)
+  static createFromFormData(t) {
+    if (t instanceof A)
       throw new Error("data is already a Form structure, should be a simple object");
-    return new _(
-      e == null ? {} : Object.fromEntries(Object.entries(e).map(([t, n]) => [t, new D({ value: n })]))
+    return new w(
+      t == null ? {} : Object.fromEntries(Object.entries(t).map(([s, i]) => [s, new X({ value: i })]))
     );
   }
-  field(e) {
-    var t;
-    return (t = this._fields[e]) != null ? t : null;
+  field(t) {
+    var s;
+    return (s = this._fields[t]) != null ? s : null;
   }
   get fields() {
     return this._fields;
   }
+  get members() {
+    return Object.values(this._fields);
+  }
   get value() {
-    const e = /* @__PURE__ */ Object.create(null);
-    return Object.entries(this._fields).forEach(([t, n]) => {
-      const r = n.value;
-      (n.enabled || n instanceof _ && !H(r)) && (e[t] = r);
-    }), H(e) ? null : y({}, e);
+    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 i = L(s) ? null : Object.freeze(p({}, s));
+    return this.raw.cachedValue = i, this.raw.cachedValueVersion = t, i;
   }
-  set value(e) {
-    this.suppressNotifyValueChanged = !0;
-    try {
-      Object.entries(this._fields).forEach(([t, n]) => {
-        (e == null || Object.hasOwn(e, t)) && (n.value = e == null ? null : e[t]);
+  /**
+   * Writes the members that the given value carries. The members are written one by one and the group says
+   * nothing in between: the transaction the assignment runs in measures the group's own value and its own verdict
+   * 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]);
       });
-    } finally {
-      this.suppressNotifyValueChanged = !1;
-    }
-    this.notifyValueChanged(), this.validate();
+    });
+  }
+  set value(t) {
+    g((s) => {
+      this.assignMembers(t), s.markValidityDirty(this);
+    });
+  }
+  /**
+   * Members are reset one by one rather than assigned as a whole value: the value setter writes only the keys the
+   * 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);
+      });
+      const a = this.value;
+      this.raw.announcedValue = a, this.originalValue = w.baseline(a), super.validate(!0);
+    });
   }
   get touched() {
-    return Object.values(this._fields).some((e) => e.touched);
+    return Object.values(this._fields).some((t) => t.touched);
   }
-  set touched(e) {
-    Object.values(this._fields).forEach((t) => {
-      t.touched = e;
+  set touched(t) {
+    g(() => {
+      Object.values(this._fields).forEach((s) => {
+        s.touched = t;
+      });
     });
   }
   get fullValue() {
-    const e = /* @__PURE__ */ Object.create(null);
-    return Object.entries(this._fields).forEach(([t, n]) => {
-      e[t] = n.fullValue;
-    }), y({}, e);
+    const t = /* @__PURE__ */ Object.create(null);
+    return Object.entries(this._fields).forEach(([s, i]) => {
+      t[s] = i.fullValue;
+    }), p({}, t);
   }
+  /**
+   * Records that a member changed its value, so that the transaction in progress works out at commit what this
+   * group's own value became and announces it once. A mutation method calls it itself; you rarely need to.
+   */
   notifyValueChanged() {
-    if (this.suppressNotifyValueChanged) return;
-    const e = this.value;
-    if (!k(e, this._value)) {
-      const t = this._value;
-      this._value = e, this.actions.trigger(m, this, e, t), this.parent && this.parent.notifyValueChanged(), this.validate();
-    }
+    this.propagateValueChanged();
+  }
+  get composesValue() {
+    return !0;
+  }
+  /**
+   * A group with nothing listening for its value does not compose one at all, so the copy it holds is from before
+   * the changes nobody received. A registration that adds a listener brings it up to date here, and what the
+   * listener is then told about is the change that follows it.
+   */
+  refreshPreviousValue() {
+    this.raw.announcedValue = this.value;
   }
   get valid() {
-    return super.valid && Object.values(this._fields).every((e) => e.valid);
+    return this.validRead;
   }
-  validate(e = !1) {
-    e && Object.values(this._fields).forEach((t) => t.validate(!0)), super.validate(e);
+  composeValid() {
+    return this.state.errors.length === 0 && Object.values(this._fields).every((t) => t.valid);
   }
-  clone(e) {
-    var r, a, l;
-    const t = /* @__PURE__ */ Object.create(null);
+  validate(t = !1) {
+    g(() => {
+      t && Object.values(this._fields).forEach((s) => s.validate(!0)), super.validate(t);
+    });
+  }
+  bind(t, s) {
+    var a, o;
+    const i = /* @__PURE__ */ Object.create(null);
     Object.entries(this._fields).forEach(([c, u]) => {
-      t[c] = u.clone();
+      i[c] = u.bind();
     });
-    const n = new _(t, R(y({
-      value: (r = e == null ? void 0 : e.value) != null ? r : this.value
-    }, e && "originalValue" in e ? { originalValue: e.originalValue } : {}), {
-      enabled: (a = e == null ? void 0 : e.enabled) != null ? a : this.enabled,
-      visibility: (l = e == null ? void 0 : e.visibility) != null ? l : this.visibility
+    const r = new w(i, x(p({
+      // 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 n.actions = this.actions.clone(), n.actions.triggerEager(n, n.value, n.originalValue), n;
+    return r.boundFrom(this, r.raw.announcedValue, r.originalValue, s), r;
+  }
+  /**
+   * A record need not name every member: a key it leaves out is taken from the declaration, the same way a member
+   * the constructor is given no value for takes the one it was declared with.
+   */
+  rebind(t) {
+    return super.rebind(t);
   }
 }
-class G extends x {
-  constructor(e, t) {
-    super();
-    o(this, "_value", null);
-    o(this, "_itemTemplate");
-    o(this, "_previousValue");
-    if (this._itemTemplate = e, t) {
-      const n = t, { value: r, validators: a, actions: l } = n, c = I(n, ["value", "validators", "actions"]);
-      [...a || [], ...l || []].forEach((u) => this.registerAction(u)), Object.assign(this, c), r && this.setValueInternal(r);
-    }
-    this.originalValue === void 0 && (this.originalValue = this.value), this._previousValue = this.value, this.actions.triggerEager(this, this.value, this.originalValue), this.validate();
+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();
+    });
+  }
+  get state() {
+    return super.state;
+  }
+  get raw() {
+    return super.raw;
+  }
+  /** 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]();
+    return t.rows = this.raw.rows ? [...this.raw.rows] : this.raw.rows, t;
+  }
+  /**
+   * The copy of a built value that serves as a baseline. The value getter hands out one array per version, and a
+   * baseline holding that same array would report every value as its own original.
+   */
+  static baseline(t) {
+    return t == null ? t : [...t];
   }
-  processSetValueItem(e) {
-    let t;
-    return e instanceof _ ? t = e : this._itemTemplate ? t = this._itemTemplate.clone({ value: e }) : t = _.createFromFormData(e), Object.defineProperty(t, "parent", { get: () => this, configurable: !1, enumerable: !1 }), 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;
   }
-  setValueInternal(e) {
-    Array.isArray(e) && (this._value = e.map((t) => this.processSetValueItem(t)));
+  /**
+   * Builds the item that fills a gap left by an insert beyond the end of the list: the item template bound to its
+   * own values, or an empty group when the list has no template.
+   */
+  createPaddingItem() {
+    return this.processSetValueItem(this._itemTemplate ? this._itemTemplate.bind() : null);
+  }
+  setValueInternal(t) {
+    g((s) => {
+      var i;
+      if (s.touch(this), 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));
+        }
+        for (let o = t.length; o < r.length; o++) this.releaseChild(r[o]);
+        this.state.rows = a;
+      }
+      this.bumpValueVersion();
+    });
   }
   get value() {
-    var t;
-    const e = (t = this._value) == null ? void 0 : t.map((n) => n.value);
-    return H(e) ? null : e;
+    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;
+  }
+  set value(t) {
+    g(() => {
+      this.setValueInternal(t), this.propagateValueChanged(!0);
+    });
   }
-  set value(e) {
-    const t = this.value;
-    this.setValueInternal(e), this.actions.trigger(m, this, this.value, t), this.parent && this.parent.notifyValueChanged(), this.validate();
+  /**
+   * 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);
+    });
   }
   get touched() {
-    var e;
-    return ((e = this._value) == null ? void 0 : e.some((t) => t.touched)) || !1;
-  }
-  set touched(e) {
     var t;
-    (t = this._value) == null || t.forEach((n) => {
-      n.touched = e;
+    return ((t = this.state.rows) == null ? void 0 : t.some((s) => s.touched)) || !1;
+  }
+  set touched(t) {
+    g(() => {
+      var s;
+      (s = this.state.rows) == null || s.forEach((i) => {
+        i.touched = t;
+      });
     });
   }
-  clone(e) {
-    var n, r, a, l, c;
-    const t = new G((n = this._itemTemplate) == null ? void 0 : n.clone(), R(y({
-      value: [...(a = (r = e == null ? void 0 : e.value) != null ? r : this.value) != null ? a : []]
-    }, e && "originalValue" in e ? { originalValue: e.originalValue } : {}), {
-      enabled: (l = e == null ? void 0 : e.enabled) != null ? l : this.enabled,
-      visibility: (c = e == null ? void 0 : e.visibility) != null ? c : this.visibility
+  bind(t, s) {
+    var r, a, o, c;
+    const i = new D((r = this._itemTemplate) == null ? void 0 : r.bind(), x(p({
+      // 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 t.actions = this.actions.clone(), t.actions.triggerEager(t, t.value, t.originalValue), t;
+    return i.boundFrom(this, i.value, i.originalValue, s), i;
   }
+  /**
+   * Records that a row changed its value, so that the transaction in progress works out at commit what this
+   * list's own value became and announces it once. The mutation methods call it themselves; you rarely need to.
+   */
   notifyValueChanged() {
-    const e = this.value;
-    if (!k(e, this._previousValue)) {
-      const t = this._previousValue;
-      this._previousValue = e, this.actions.trigger(m, this, e, t), this.parent && this.parent.notifyValueChanged(), this.validate();
-    }
+    this.propagateValueChanged();
+  }
+  get composesValue() {
+    return !0;
+  }
+  /**
+   * A list with nothing listening for its value does not compose one at all, so the copy it holds is from before
+   * the changes nobody received. A registration that adds a listener brings it up to date here, and what the
+   * listener is then told about is the change that follows it.
+   */
+  refreshPreviousValue() {
+    this.raw.announcedValue = this.value;
   }
   get valid() {
-    var e, t;
-    return super.valid && ((t = (e = this._value) == null ? void 0 : e.every((n) => n.valid)) != null ? t : !0);
+    return this.validRead;
   }
-  validate(e = !1) {
+  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);
+  }
+  validate(t = !1) {
+    g(() => {
+      var s;
+      t && ((s = this.state.rows) == null || s.forEach((i) => i.validate(!0))), super.validate(t);
+    });
+  }
+  get members() {
     var t;
-    e && ((t = this._value) == null || t.forEach((n) => n.validate(!0))), super.validate(e);
+    return (t = this.raw.rows) != null ? t : [];
   }
-  get(e) {
-    return this._value != null ? this._value[e] : void 0;
+  get(t) {
+    return this.state.rows != null ? this.state.rows[t] : void 0;
   }
-  push(e) {
-    var t, n;
-    return this.insert(e, (n = (t = this._value) == null ? void 0 : t.length) != null ? n : 0) + 1;
+  push(t) {
+    var s, i;
+    return this.insert(t, (i = (s = this.state.rows) == null ? void 0 : s.length) != null ? i : 0) + 1;
   }
   pop() {
-    var e, t;
-    return this.remove(((t = (e = this._value) == null ? void 0 : e.length) != null ? t : 0) - 1);
-  }
-  remove(e) {
-    var n;
-    if (this._value == null || e < 0 || this._value.length <= e) return;
-    let t = (n = this._value.splice(e, 1)) == null ? void 0 : n[0];
-    return t && (t = t.clone(), this.actions.trigger(ue, this, t, e), this.notifyValueChanged()), t;
-  }
-  insert(e, t) {
-    for (this._value == null && (this._value = []); this._value.length < t; ) {
-      const r = this.processSetValueItem(null), a = this._value.push(r);
-      this.actions.trigger(z, this, r, a);
-    }
-    const n = this.processSetValueItem(e);
-    return this._value.splice(t, 0, n), this.actions.trigger(z, this, n, t), this.notifyValueChanged(), t;
+    var t, s;
+    return this.remove(((s = (t = this.state.rows) == null ? void 0 : t.length) != null ? s : 0) - 1);
+  }
+  remove(t) {
+    let s;
+    return g((i) => {
+      var a;
+      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 });
+      }
+      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;
+  }
+  /** 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));
   }
   clear() {
-    this._value = null, this.notifyValueChanged();
+    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);
+    });
   }
 }
-const he = { useMarkdownInValidators: !0 };
-function $e() {
-  return he;
-}
-function qe(i) {
-  Object.assign(he, i);
-}
-const it = {
-  install(i, s) {
-    s && qe(s);
+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 })
+        )
+      ]) : (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;
+  }
+  /** 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));
   }
-};
-function v(i) {
-  return $e().useMarkdownInValidators ? new j(i) : i.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, `
-`);
-}
-class Me extends f {
-  constructor(e, t, n) {
-    let r = !1, a, l;
-    super((u, h, A) => (a = u, l = h, r || (r = !0, this.otherField.registerAction(
-      new m((E, L, O, $) => {
-        L(E, O, $), this.unregistered || this.execute(A, () => null, a, l);
+  /**
+   * Makes a change of `other` re-run this comparison. The listener re-runs it over the fields of the record the
+   * change happened in rather than over the field that installed it, so the listener a row inherits with the field
+   * it was bound from serves that row; and it re-runs this one validator, not the chain around it.
+   */
+  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);
+        this.declarations.forEach(
+          (c) => Lt(c, o).forEach((u) => {
+            this.registrations.has(u) && this.execute(u, () => null, u.value, this.comparisonState(u).oldValue);
+          })
+        );
       })
-    )), this.isValidComparison(g(u), g(this.otherField.value)) ? null : [
-      new p(
-        this.replacePlaceholders(n, { newValue: u, oldValue: h, field: A, otherField: this.otherField })
-      )
-    ]));
-    o(this, "otherField");
-    o(this, "isValidComparison");
-    o(this, "unregistered", !1);
-    this.otherField = e, this.isValidComparison = t;
+    ));
+  }
+  boundToBinding(t) {
+    this.declarations.add(t.declaration), this.registrations.add(t);
+  }
+  comparisonState(t) {
+    return this.bindingState(t);
   }
-  unregister() {
-    this.unregistered = !0;
+  newBindingState() {
+    return x(p({}, super.newBindingState()), { oldValue: void 0 });
+  }
+  unregisterFrom(t) {
+    this.registrations.delete(t);
   }
 }
-class He extends f {
-  constructor(s, e) {
-    const t = e || v("Must be one of [**{allowedAsText}**]");
-    let n = s.join(", ");
-    n.length > 60 && (n = be(n, {
+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: `... (${s.length} items total)`
+      omission: `... (${e.length} items total)`
     }));
-    const r = (a, l, c) => s.includes(g(a)) ? null : [
-      new p(
-        this.replacePlaceholders(t, { newValue: a, oldValue: l, field: c, allowedValues: s, allowedAsText: n })
+    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(r);
   }
 }
-function Qe(i) {
-  return i == null ? 0 : te(i) || V(i) ? i.length : se(i) && Object.getPrototypeOf(i) === Object.prototype ? Object.keys(i).length : String(i).length;
+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;
 }
-class ze extends f {
-  constructor(s) {
-    const e = s || v("Please enter a value"), t = (n, r, a) => Qe(g(n)) === 0 ? [new p(this.replacePlaceholders(e, { newValue: n, oldValue: r, field: a }))] : null;
-    super(t);
+class Le extends v {
+  constructor(e) {
+    const t = e || E("Please enter a value"), s = (i, r, a) => De(b(i)) === 0 ? [new V(this.replacePlaceholders(t, { newValue: i, oldValue: r, field: a }))] : null;
+    super(s);
   }
 }
-class We extends f {
-  constructor(s, e) {
-    const t = e || v("Value must be larger or equal to **{minValue}**"), n = (r, a, l) => r < s || r === void 0 ? [
-      new p(this.replacePlaceholders(t, { newValue: r, oldValue: a, field: l, minValue: s }))
+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 }))
     ] : null;
-    super(n);
+    super(i);
   }
 }
-class Xe extends f {
-  constructor(s, e) {
-    const t = e || v("Value must be less than or equal to **{maxValue}**"), n = (r, a, l) => r > s || r === void 0 ? [
-      new p(this.replacePlaceholders(t, { newValue: r, oldValue: a, field: l, maxValue: s }))
+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 }))
     ] : null;
-    super(n);
+    super(i);
   }
 }
-class Ge extends f {
-  constructor(s, e, t) {
-    const n = t || v("Value must be between **{minValue}** and **{maxValue}**"), r = (a, l, c) => a < s || a > e || a === void 0 ? [
-      new p(
-        this.replacePlaceholders(n, { newValue: a, oldValue: l, field: c, minValue: s, maxValue: e })
+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 })
       )
     ] : null;
     super(r);
   }
 }
-function Y(i) {
-  return i == null ? 0 : te(i) || V(i) ? i.length : se(i) && Object.getPrototypeOf(i) === Object.prototype ? Object.keys(i).length : String(i).length;
+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;
 }
-class Ye extends f {
-  constructor(s, e) {
-    const t = e || v("Length must be larger or equal to **{minLength}**"), n = (r, a, l) => Y(r) < s ? [
-      new p(this.replacePlaceholders(t, { newValue: r, oldValue: a, field: l, minLength: s }))
+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 }))
     ] : null;
-    super(n);
+    super(i);
   }
 }
-class Je extends f {
-  constructor(s, e) {
-    const t = e || v("Length must be less than or equal to **{maxLength}**"), n = (r, a, l) => Y(r) > s ? [
-      new p(this.replacePlaceholders(t, { newValue: r, oldValue: a, field: l, maxLength: s }))
+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 }))
     ] : null;
-    super(n);
+    super(i);
   }
 }
-class Ke extends f {
-  constructor(s, e, t) {
-    const n = t || v("Length must be between **{minLength}** and **{maxLength}**"), r = (a, l, c) => {
-      const u = Y(a);
-      return u < s || u > e ? [
-        new p(
-          this.replacePlaceholders(n, { newValue: a, oldValue: l, field: c, minLength: s, maxLength: e })
+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 })
         )
       ] : null;
     };
     super(r);
   }
 }
-class Ze extends f {
-  constructor(s, e) {
-    const t = e || v('Value must match pattern "**{pattern}**"'), n = (r, a, l) => s.test(String(g(r))) ? null : [
-      new p(this.replacePlaceholders(t, { newValue: r, oldValue: a, field: l, pattern: s }))
+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 }))
     ];
-    super(n);
+    super(i);
   }
 }
-const et = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const He = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  CompareTo: Me,
-  InAllowedValues: He,
-  LengthInRange: Ke,
-  MaxLength: Je,
-  MaxValue: Xe,
-  MinLength: Ye,
-  MinValue: We,
-  Pattern: Ze,
-  Required: ze,
-  Validator: f,
-  ValueInRange: Ge
-}, Symbol.toStringTag, { value: "Module" })), rt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  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({
   __proto__: null,
-  AbortEventHandlingException: Q,
-  Action: Be,
-  ActionsMap: N,
-  ConditionalEnabledAction: Se,
-  ConditionalStatementAction: B,
-  ConditionalValueAction: we,
-  ConditionalVisibilityAction: Ie,
-  DisplayMode: C,
-  EmptyField: ke,
-  EnabledChangedAction: re,
-  EnabledChangingAction: ie,
-  ExecuteAction: ce,
-  Field: D,
-  FieldActionBase: b,
-  FieldBase: x,
-  Group: _,
-  List: G,
-  ListItemAddedAction: z,
-  ListItemRemovedAction: ue,
-  MdString: j,
-  MessagesWidget: De,
-  Operator: d,
-  RenderableValue: Ve,
-  Statement: w,
-  ValidChangedAction: ae,
-  ValidationError: X,
-  ValidationErrorRenderContent: p,
-  ValidationErrorText: _e,
-  Validator: f,
-  Validators: et,
-  ValueChangedAction: m,
-  VisibilityChangedAction: oe,
-  VisibilityChangingAction: le,
-  buildErrorMessage: v,
-  isCallableFunction: U,
-  isSimpleComponentDef: W
+  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
 }, Symbol.toStringTag, { value: "Module" }));
 export {
-  Q as AbortEventHandlingException,
-  Be as Action,
-  N as ActionsMap,
-  Se as ConditionalEnabledAction,
-  B as ConditionalStatementAction,
-  we as ConditionalValueAction,
-  Ie as ConditionalVisibilityAction,
-  C as DisplayMode,
-  ke as EmptyField,
-  re as EnabledChangedAction,
-  ie as EnabledChangingAction,
-  ce as ExecuteAction,
-  D as Field,
-  b as FieldActionBase,
-  x as FieldBase,
-  _ as Group,
-  G as List,
-  z as ListItemAddedAction,
-  ue as ListItemRemovedAction,
-  j as MdString,
-  De as MessagesWidget,
-  d as Operator,
-  Ve as RenderableValue,
-  w as Statement,
-  ae as ValidChangedAction,
-  X as ValidationError,
-  p as ValidationErrorRenderContent,
-  _e as ValidationErrorText,
-  f as Validator,
-  et as Validators,
-  m as ValueChangedAction,
-  oe as VisibilityChangedAction,
-  le as VisibilityChangingAction,
-  v as buildErrorMessage,
-  rt as default,
-  it as forms,
-  U as isCallableFunction,
-  W as isSimpleComponentDef
+  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
 };
 //# sourceMappingURL=dynamicforms-vue-forms.js.map