@dynamicforms/vue-forms 0.6.1 → 0.12.0

package/dist/dynamicforms-vue-forms.js

@@ -1,51 +1,80 @@
-var bt = Object.defineProperty, vt = Object.defineProperties;
-var yt = Object.getOwnPropertyDescriptors;
-var U = Object.getOwnPropertySymbols;
-var et = Object.prototype.hasOwnProperty, it = Object.prototype.propertyIsEnumerable;
-var q = (n, i, t) => i in n ? bt(n, i, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[i] = t, v = (n, i) => {
-  for (var t in i || (i = {}))
-    et.call(i, t) && q(n, t, i[t]);
-  if (U)
-    for (var t of U(i))
-      it.call(i, t) && q(n, t, i[t]);
+var Gt = Object.defineProperty, Yt = Object.defineProperties;
+var Jt = Object.getOwnPropertyDescriptors;
+var W = Object.getOwnPropertySymbols;
+var ft = Object.prototype.hasOwnProperty, pt = Object.prototype.propertyIsEnumerable;
+var mt = (n) => {
+  throw TypeError(n);
+};
+var K = (n, e, t) => e in n ? Gt(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, p = (n, e) => {
+  for (var t in e || (e = {}))
+    ft.call(e, t) && K(n, t, e[t]);
+  if (W)
+    for (var t of W(e))
+      pt.call(e, t) && K(n, t, e[t]);
   return n;
-}, w = (n, i) => vt(n, yt(i));
-var F = (n, i) => {
+}, C = (n, e) => Yt(n, Jt(e));
+var k = (n, e) => {
   var t = {};
-  for (var e in n)
-    et.call(n, e) && i.indexOf(e) < 0 && (t[e] = n[e]);
-  if (n != null && U)
-    for (var e of U(n))
-      i.indexOf(e) < 0 && it.call(n, e) && (t[e] = n[e]);
+  for (var s in n)
+    ft.call(n, s) && e.indexOf(s) < 0 && (t[s] = n[s]);
+  if (n != null && W)
+    for (var s of W(n))
+      e.indexOf(s) < 0 && pt.call(n, s) && (t[s] = n[s]);
   return t;
 };
-var o = (n, i, t) => q(n, typeof i != "symbol" ? i + "" : i, t);
-import { isEqual as D, isBoolean as Vt, isString as A, isEmpty as Q, truncate as Ct, isArray as rt, isObject as at } from "lodash-es";
-import { unref as h, computed as xt, isRef as _t, reactive as Et, defineComponent as It, resolveComponent as st, openBlock as At, createBlock as St, h as j } from "vue";
-var T = /* @__PURE__ */ ((n) => (n[n.SUPPRESS = 1] = "SUPPRESS", n[n.HIDDEN = 5] = "HIDDEN", n[n.INVISIBLE = 8] = "INVISIBLE", n[n.FULL = 10] = "FULL", n))(T || {});
-const nt = 10;
+var d = (n, e, t) => K(n, typeof e != "symbol" ? e + "" : e, t), bt = (n, e, t) => e.has(n) || mt("Cannot " + t);
+var l = (n, e, t) => (bt(n, e, "read from private field"), t ? t.call(n) : e.get(n)), Z = (n, e, t) => e.has(n) ? mt("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(n) : e.set(n, t), tt = (n, e, t, s) => (bt(n, e, "write to private field"), s ? s.call(n, t) : e.set(n, t), t);
+var vt = (n, e, t) => new Promise((s, i) => {
+  var r = (u) => {
+    try {
+      o(t.next(u));
+    } catch (c) {
+      i(c);
+    }
+  }, a = (u) => {
+    try {
+      o(t.throw(u));
+    } catch (c) {
+      i(c);
+    }
+  }, o = (u) => u.done ? s(u.value) : Promise.resolve(u.value).then(r, a);
+  o((t = t.apply(n, e)).next());
+});
+import { isEqual as nt, isEmpty as L, isBoolean as Kt, isString as j, truncate as Zt, isArray as At, isObject as _t } from "lodash-es";
+import { unref as b, computed as Tt, isRef as te, reactive as ee, ref as se, defineComponent as ie, resolveComponent as Vt, openBlock as ne, createBlock as re, h as R } from "vue";
+var P = /* @__PURE__ */ ((n) => (n[n.SUPPRESS = 1] = "SUPPRESS", n[n.HIDDEN = 5] = "HIDDEN", n[n.INVISIBLE = 8] = "INVISIBLE", n[n.FULL = 10] = "FULL", n))(P || {});
+const wt = 10, yt = new Set(
+  Object.values(P).filter((n) => typeof n == "number")
+);
 ((n) => {
-  function i(s) {
-    return s.toUpperCase() === "SUPPRESS" ? 1 : s.toUpperCase() === "HIDDEN" ? 5 : s.toUpperCase() === "INVISIBLE" ? 8 : nt;
+  function e(i) {
+    return i.toUpperCase() === "SUPPRESS" ? 1 : i.toUpperCase() === "HIDDEN" ? 5 : i.toUpperCase() === "INVISIBLE" ? 8 : wt;
   }
-  n.fromString = i;
-  function t(s) {
-    const r = typeof s == "number" ? s : n.fromString(s);
-    return Object.values(n).includes(r) ? r : nt;
+  n.fromString = e;
+  function t(i) {
+    const r = typeof i == "number" ? i : n.fromString(i);
+    return yt.has(r) ? r : wt;
   }
   n.fromAny = t;
-  function e(s) {
-    const r = typeof s == "number" ? s : n.fromString(s);
-    return Object.values(n).includes(r);
-  }
-  n.isDefined = e;
-})(T || (T = {}));
-Object.freeze(T);
-const S = T;
-class m {
-  constructor(i) {
-    o(this, "executorFn");
-    this.executorFn = i;
+  function s(i) {
+    const r = typeof i == "number" ? i : n.fromString(i);
+    return yt.has(r);
+  }
+  n.isDefined = s;
+})(P || (P = {}));
+Object.freeze(P);
+const N = P;
+class y {
+  constructor(e) {
+    d(this, "executorFn");
+    /**
+     * What this action remembers about one of the elements it serves. An action instance is shared - a `List` row
+     * carries the instances the item template carries - so anything an action holds about the element it last ran
+     * over belongs to that element rather than to the action: a verdict, a sequence number, a listener it installed.
+     * The keys are weak, so what an action remembers about a row is released with the row.
+     */
+    d(this, "states", /* @__PURE__ */ new WeakMap());
+    this.executorFn = e;
   }
   static get classIdentifier() {
     throw new Error("classIdentifier must be declared");
@@ -53,60 +82,286 @@ class m {
   get classIdentifier() {
     return this.constructor.classIdentifier;
   }
-  execute(i, t, ...e) {
-    return this.executorFn(i, t, ...e);
+  /**
+   * 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(i) {
+  boundToBinding(e) {
   }
-  unregister() {
+  /**
+   * Announces that `binding` no longer holds this action, and takes back what running it left there. It names one
+   * element rather than the action as a whole, because the instance goes on serving every other element it was
+   * registered on. It runs inside the operation that drops the registration, so an operation that unwinds puts the
+   * registration and what this took back both back.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  unregisterFrom(e) {
   }
 }
-class W extends Error {
+class Ot extends Error {
 }
-const lt = /* @__PURE__ */ Symbol("ValueChangedAction");
-class y extends m {
-  constructor(i) {
-    super(i);
+const Ft = /* @__PURE__ */ Symbol("ValueChangedAction");
+class O extends y {
+  constructor(e) {
+    super(e);
   }
   static get classIdentifier() {
-    return lt;
+    return Ft;
+  }
+  execute(e, t, s, i) {
+    return super.execute(e, t, s, i);
+  }
+}
+const $ = /* @__PURE__ */ Symbol("Transaction.capture"), jt = /* @__PURE__ */ Symbol("Transaction.restore"), Pt = /* @__PURE__ */ Symbol("Transaction.announceValue"), Nt = /* @__PURE__ */ Symbol("Transaction.settleValidity");
+function Et(n) {
+  let e = 0, t = n.parent;
+  for (; t; )
+    e++, t = t.parent;
+  return e;
+}
+class ae {
+  constructor() {
+    d(this, "participants", /* @__PURE__ */ new Map());
+    /** what a rollback has to put back beyond the state slots, newest last */
+    d(this, "undo", []);
+    /** true once the transaction has been unwound, which is what tells a run started inside it to say nothing */
+    d(this, "unwound", !1);
+    /** the depth the announcement in progress is working at, -1 while none is */
+    d(this, "passDepth", -1);
+    /** set while a pass is running and an element it has already passed the depth of gets enrolled */
+    d(this, "restartPass", !1);
+  }
+  /** 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[$]());
+  }
+  /** 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 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 || Et(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[jt](t.snapshot);
+    }), this.participants.clear();
+    for (let t = this.undo.length - 1; t >= 0; t--) this.undo[t]();
+    this.undo.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()); )
+      ;
+  }
+  /**
+   * 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 = Et(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[Pt](this, s, i, t);
+      }
+    );
+  }
+  settleValidity() {
+    return this.pass(
+      (e) => e.validityDirty,
+      (e) => {
+        e.validityDirty = !1, e.element[Nt](this);
+      }
+    );
   }
-  execute(i, t, e, s) {
-    return super.execute(i, t, e, s);
+}
+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 Ct(n) {
+  if (n != null && typeof n.then == "function")
+    throw new TypeError(
+      "a transaction may not be asynchronous: the callback returned a thenable. Do the awaiting outside and open a transaction for each synchronous part."
+    );
+}
+function q(n) {
+  if (_) {
+    const s = n(et);
+    return Ct(s), s;
+  }
+  const e = new ae(), t = new oe();
+  _ = e, et = t;
+  try {
+    const s = n(t);
+    return Ct(s), e.commit(), s;
+  } catch (s) {
+    if (e.rollback(), s instanceof Rt) return;
+    throw s;
+  } finally {
+    _ = void 0, et = void 0, t.close();
   }
 }
-const ot = { useMarkdownInValidators: !0 };
-function Pt() {
-  return ot;
+function g(n) {
+  return _ ? n(_) : q(() => n(_));
+}
+const Dt = { useMarkdownInValidators: !0 };
+function le() {
+  return Dt;
 }
-function wt(n) {
-  Object.assign(ot, n);
+function ue(n) {
+  Object.assign(Dt, n);
 }
-const he = {
-  install(n, i) {
-    i && wt(i);
+const Ye = {
+  install(n, e) {
+    e && ue(e);
   }
 };
-class O extends String {
-  constructor(t, e, s) {
+class B extends String {
+  constructor(t, s, i) {
     super(t);
-    o(this, "plugins");
-    o(this, "options");
-    this.plugins = s, this.options = e;
+    d(this, "plugins");
+    d(this, "options");
+    this.plugins = i, this.options = s;
   }
 }
-function X(n) {
-  const i = h(n);
-  return typeof i == "object" && "componentName" in i;
+function at(n) {
+  const e = b(n);
+  return typeof e == "object" && "componentName" in e;
 }
-function k(n) {
-  return typeof h(n) == "function";
+function z(n) {
+  return typeof b(n) == "function";
 }
-class G {
+class ot {
   get componentName() {
     return "Comment";
   }
@@ -120,12 +375,12 @@ class G {
     return "";
   }
 }
-class Ft extends G {
-  constructor(t, e = "") {
+class ce extends ot {
+  constructor(t, s = "") {
     super();
-    o(this, "text");
-    o(this, "classes");
-    this.text = t, this.classes = e;
+    d(this, "text");
+    d(this, "classes");
+    this.text = t, this.classes = s;
   }
   get componentName() {
     return "template";
@@ -137,24 +392,24 @@ class Ft extends G {
     return this.classes;
   }
 }
-class g extends G {
-  constructor(t, e = "") {
+class V extends ot {
+  constructor(t, s = "") {
     super();
-    o(this, "classes");
-    o(this, "text");
-    o(this, "textType");
-    this.classes = e, this.text = t, this.textType = xt(() => this.getTextType);
+    d(this, "classes");
+    d(this, "text");
+    d(this, "textType");
+    this.classes = s, this.text = t, this.textType = Tt(() => this.getTextType);
   }
   get resolvedText() {
-    const t = h(this.text);
-    return k(t) ? t() : t;
+    const t = b(this.text);
+    return z(t) ? t() : t;
   }
   get getTextType() {
     const t = this.resolvedText;
-    return t ? t instanceof O ? "md" : X(t) ? "component" : "string" : "string";
+    return t ? t instanceof B ? "md" : at(t) ? "component" : "string" : "string";
   }
   get componentName() {
-    switch (h(this.textType)) {
+    switch (b(this.textType)) {
       case "string":
         return "template";
       case "md":
@@ -166,7 +421,7 @@ class g extends G {
     }
   }
   get componentBindings() {
-    switch (h(this.textType)) {
+    switch (b(this.textType)) {
       case "string":
         return {};
       case "md": {
@@ -180,7 +435,7 @@ class g extends G {
     }
   }
   get componentBody() {
-    switch (h(this.textType)) {
+    switch (b(this.textType)) {
       case "string":
         return this.resolvedText;
       case "component":
@@ -193,52 +448,42 @@ class g extends G {
     return this.classes;
   }
 }
-class jt extends g {
+class he extends V {
 }
-function b(n) {
-  return Pt().useMarkdownInValidators ? new O(n) : n.replace(/[*_~`]/g, "").replace(/!\[(.*?)\]\(.*?\)/g, "$1").replace(/\[(.*?)\]\((.*?)\)/g, "$1").replace(/#+\s?/g, "").replace(/>\s?/g, "").replace(/(\*|-|\d+\.)\s+/g, "").replace(/`{3}[\s\S]*?`{3}/g, "").replace(/`([^`]+)`/g, "$1").replace(/\n{2,}/g, `
+function E(n) {
+  return le().useMarkdownInValidators ? new B(n) : n.replace(/[*_~`]/g, "").replace(/!\[(.*?)\]\(.*?\)/g, "$1").replace(/\[(.*?)\]\((.*?)\)/g, "$1").replace(/#+\s?/g, "").replace(/>\s?/g, "").replace(/(\*|-|\d+\.)\s+/g, "").replace(/`{3}[\s\S]*?`{3}/g, "").replace(/`([^`]+)`/g, "$1").replace(/\n{2,}/g, `
 `);
 }
-const Nt = /* @__PURE__ */ Symbol("Validator"), Tt = () => b("Validation could not be completed");
-class f extends y {
+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(t) {
-    super((s, r, a, l) => {
-      var B;
-      const u = ((B = this.runs.get(s)) != null ? B : 0) + 1;
-      this.runs.set(s, u);
-      const d = s.validationEpoch, x = () => this.runs.get(s) === u && s.validationEpoch === d, _ = t(a, l, s) || [], P = (p) => {
-        var K;
-        const E = (K = p == null ? void 0 : p.map((I) => this.claim(I))) != null ? K : [];
-        for (let I = s.errors.length - 1; I >= 0; I--) {
-          const Z = s.errors[I];
-          if (Z.source === this.source) {
-            const tt = E.findIndex((mt) => D(mt, Z));
-            tt >= 0 ? E.splice(tt, 1) : s.errors.splice(I, 1);
+    super((i, r, a, o) => {
+      const u = this.bindingState(i), c = ++u.run, x = i.validationEpoch, G = kt(), ct = () => u.run === c && i.validationEpoch === x && !(G != null && G.rolledBack), Y = t(a, o, i) || [], J = (S) => q(() => {
+        var ht;
+        const U = (ht = S == null ? void 0 : S.map((F) => this.claim(F))) != null ? ht : [];
+        for (let F = i.errors.length - 1; F >= 0; F--) {
+          const dt = i.errors[F];
+          if (dt.source === this.source) {
+            const gt = U.findIndex((Xt) => nt(Xt, dt));
+            gt >= 0 ? U.splice(gt, 1) : i.errors.splice(F, 1);
           }
         }
-        E.length > 0 && s.errors.push(...E), s.validate();
-      };
-      return _ instanceof Promise ? (s.beginValidating(), _.then(
-        (p) => {
-          x() && P(p);
+        U.length > 0 && i.errors.push(...U), i.validate();
+      });
+      return Y instanceof Promise ? (i.beginValidating(), Y.then(
+        (S) => {
+          ct() && J(S);
         },
-        (p) => {
-          x() && (P([new g(Tt())]), console.error("Validation failed", p));
+        (S) => {
+          ct() && (J([new V(ge())]), console.error("Validation failed", S));
         }
-      ).finally(() => s.endValidating()).catch((p) => console.error("Validation failed", p))) : P(_), r(s, a, l);
+      ).finally(() => i.endValidating()).catch((S) => console.error("Validation failed", S))) : J(Y), r(i, a, o);
     });
-    o(this, "source");
-    /**
-     * Sequence number of the newest run of this validator, per field. Every execution takes the next number, and a
-     * result is applied only while its number is still the newest one, so a slow run cannot overwrite the verdict of
-     * a faster one that started after it. The key is the field because one validator instance may be registered on
-     * several fields, each with a sequence of its own.
-     */
-    o(this, "runs", /* @__PURE__ */ new WeakMap());
+    d(this, "source");
     this.source = Symbol(this.constructor.name);
   }
   /**
@@ -249,139 +494,299 @@ class f extends y {
    * including the non-enumerable ones, so it renders exactly like the instance it was made from.
    */
   claim(t) {
-    const e = t.source;
-    if (e === this.source) return t;
-    const s = { value: this.source, enumerable: !1, configurable: !1 };
-    if (e === void 0)
-      return Object.defineProperty(t, "source", s), t;
+    const 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), w(v({}, r), { source: s }));
+    return Object.create(Object.getPrototypeOf(t), C(p({}, r), { source: i }));
   }
   static get classIdentifier() {
-    return Nt;
+    return de;
   }
   get eager() {
     return !0;
   }
-  replacePlaceholdersFunction(t, e) {
+  /**
+   * Takes this validator off `field`: the errors it put there are withdrawn and the verdict is re-formed over what
+   * the validators the field still holds have to say. Withdrawing them is what keeps a field from staying invalid
+   * on an error no validator is left to take back.
+   */
+  unregisterFrom(t) {
+    q(() => {
+      for (let s = t.errors.length - 1; s >= 0; s--)
+        t.errors[s].source === this.source && t.errors.splice(s, 1);
+      t.validate();
+    });
+  }
+  /**
+   * 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 s = h(t);
-      for (; k(s); )
-        s = h(this.replacePlaceholders(s(), e));
-      return s;
+      let i = b(t);
+      for (; z(i); )
+        i = b(this.replacePlaceholders(i(), s));
+      return i;
     };
   }
-  replacePlaceholders(t, e) {
-    if (k(t)) return this.replacePlaceholdersFunction(t, e);
-    if (X(t)) return t;
-    if (_t(t))
-      return this.replacePlaceholdersFunction(() => h(t), e);
-    let s = h(t);
-    return Object.keys(e).forEach((r) => {
-      s = s.replaceAll(`{${r}}`, e[r]);
-    }), t instanceof O ? new O(s.toString(), t.options, t.plugins) : s;
+  replacePlaceholders(t, s) {
+    if (z(t)) return this.replacePlaceholdersFunction(t, s);
+    if (at(t)) return t;
+    if (te(t))
+      return this.replacePlaceholdersFunction(() => b(t), s);
+    let i = b(t);
+    return Object.keys(s).forEach((r) => {
+      i = i.replaceAll(`{${r}}`, s[r]);
+    }), t instanceof B ? new B(i.toString(), t.options, t.plugins) : i;
   }
 }
-class L extends Map {
+class H {
   constructor() {
-    super(...arguments);
-    o(this, "eagerActions", /* @__PURE__ */ new Set());
-    o(this, "registeredActions", []);
-  }
-  register(t) {
-    if (!(t instanceof m)) throw new Error("Invalid action type");
-    this.registeredActions.push(t);
-    const e = t.classIdentifier, s = this.get(e) || (() => null);
-    function r(a, ...l) {
-      return t.execute(a, s, ...l);
-    }
-    this.set(e, r), t.eager && this.eagerActions.add(t.classIdentifier);
+    /** every action registered here, in registration order across all identifiers */
+    d(this, "registeredActions", []);
+    /** the actions of one identifier, in registration order */
+    d(this, "chains", /* @__PURE__ */ new Map());
+    /** the eager actions of one identifier, in registration order; a subsequence of the chain under that identifier */
+    d(this, "eagerChains", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Registers `action`. It becomes the outermost handler of its identifier, or - where `before` is given and is
+   * registered here under the same identifier - takes that action's place in the order, so `before` wraps it and
+   * reaches it through `supr`. That is what lets an action be added to a chain someone else built and still sit
+   * inside a handler already there.
+   */
+  register(e, t) {
+    if (!(e instanceof y)) throw new Error("Invalid action type");
+    const s = e.classIdentifier;
+    if (t && (t.classIdentifier !== s || !this.registeredActions.includes(t)))
+      throw new Error("Action to register before is not registered under the same identifier");
+    this.registeredActions.push(e), this.insert(this.chains, s, e, t), e.eager && this.insert(this.eagerChains, s, e, t);
+  }
+  /**
+   * Drops `action` from this map and answers whether it was in it. The lists it stood in are replaced rather than
+   * written, so a run already walking one finishes on the list it started with and the removal takes effect from
+   * the next trigger.
+   */
+  unregister(e) {
+    const t = this.registeredActions.indexOf(e);
+    if (t < 0) return !1;
+    this.registeredActions.splice(t, 1);
+    const s = e.classIdentifier;
+    return this.remove(this.chains, s, e), this.remove(this.eagerChains, s, e), !0;
+  }
+  /** True where something is registered under `identifier`. */
+  willTrigger(e) {
+    return this.chains.has(e);
+  }
+  /** True where any eager action is registered, whatever identifier it stands under. */
+  get hasEager() {
+    return this.eagerChains.size > 0;
+  }
+  /** Runs the actions registered under `ActionClass` and answers with what the outermost of them returned. */
+  trigger(e, t, ...s) {
+    return this.run(this.chains.get(e.classIdentifier), t, s);
+  }
+  /** Runs the eager actions of every identifier, each group on its own. */
+  triggerEager(e, ...t) {
+    this.eagerChains.forEach((s) => this.run(s, e, t));
+  }
+  /** Runs the eager actions registered under `identifier` and nothing else. */
+  triggerEagerFor(e, t, ...s) {
+    return this.run(this.eagerChains.get(e), t, s);
+  }
+  /** the validators registered in this map, in registration order */
+  get validators() {
+    return this.registeredActions.filter((e) => e instanceof v);
+  }
+  clone() {
+    const e = new H();
+    return this.registeredActions.forEach((t) => e.register(t)), e;
+  }
+  /**
+   * 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(e) {
+    this.registeredActions.forEach((t) => t.boundToBinding(e));
   }
-  trigger(t, e, ...s) {
-    const r = t.classIdentifier;
-    r === lt && this.triggerEager(e, ...s);
-    const a = this.get(r);
+  /**
+   * Walks `chain` from the end backwards, handing each action a `supr` that continues at the one before it. The
+   * closures exist for the length of the run and only as deep as the run actually goes, so a chain nobody walks to
+   * the bottom costs nothing for the part left unreached.
+   */
+  step(e, t, s, i) {
+    if (t < 0) return null;
+    const r = (a, ...o) => this.step(e, t - 1, a, o);
+    return e[t].execute(s, r, ...i);
+  }
+  /** Walks a chain, answering null where there is none. An abort ends the run and is not an error to the caller. */
+  run(e, t, s) {
+    if (!e) return null;
     try {
-      if (a) return a(e, ...s);
-    } catch (l) {
-      if (!(l instanceof W)) throw l;
+      return this.step(e, e.length - 1, t, s);
+    } catch (i) {
+      if (!(i instanceof Ot)) throw i;
     }
     return null;
   }
-  triggerEager(t, ...e) {
-    for (const s of this.eagerActions) {
-      const r = this.get(s);
-      try {
-        r && r(t, ...e);
-      } catch (a) {
-        if (!(a instanceof W)) throw a;
-      }
-    }
+  insert(e, t, s, i) {
+    var o;
+    const r = (o = e.get(t)) != null ? o : [], a = i ? r.indexOf(i) : -1;
+    a < 0 ? r.push(s) : r.splice(a, 0, s), e.set(t, r);
   }
-  clone() {
-    const t = new L();
-    return this.registeredActions.forEach((e) => t.register(e)), t;
+  remove(e, t, s) {
+    const i = e.get(t);
+    if (!(i != null && i.includes(s))) return;
+    const r = i.filter((a) => a !== s);
+    r.length ? e.set(t, r) : e.delete(t);
   }
-  cloneWithoutValidators() {
-    const t = new L();
-    return this.registeredActions.forEach((e) => {
-      e instanceof f ? e.unregister() : t.register(e);
-    }), t;
+}
+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 lt(n, e) {
+  var s, i;
+  let t = e;
+  for (const r of fe(n))
+    if (t = (i = (s = t.field) == null ? void 0 : s.call(t, r)) != null ? i : void 0, !t) break;
+  return (t == null ? void 0 : t.declaration) === n ? t : T(n) === T(e.declaration) ? void 0 : n;
+}
+function Lt(n, e) {
+  const t = lt(n, e);
+  if (!t) return [];
+  if (t !== n) return [t];
+  const s = e.bindingsOf(n);
+  return s.length > 0 ? s : [n];
+}
+function 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 Ot = /* @__PURE__ */ Symbol("ConditionalStatementAction");
-class M extends y {
-  constructor(t, e) {
-    const s = (r, a, l, u) => {
-      const d = t.evaluate();
-      if (d !== this.lastResult) {
-        for (const x of this.boundFields)
-          e(x, d, this.lastResult);
-        this.lastResult = d;
-      }
-      return a(r, l, u);
-    };
-    super(s);
-    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());
-    t.collectFields().forEach((r) => r.registerAction(new y(s)));
+const me = /* @__PURE__ */ Symbol("ConditionalStatementAction");
+class Q extends O {
+  constructor(t, s) {
+    super((r, a, o, u) => (this.applyIn(T(r)) || r.markRecordIncomplete(), a(r, o, u)));
+    d(this, "statement");
+    d(this, "conditionalExecutor");
+    /**
+     * What the elements this action was registered on were declared as. It holds declarations rather than the
+     * elements themselves, so one entry stands for every row of a list, and the element a result is applied to is
+     * the one that declaration names within the record the change happened in.
+     */
+    d(this, "declarations", /* @__PURE__ */ new Set());
+    /**
+     * The elements this action was registered on. Registration reaches one element at a time - the rows of a list
+     * take the action on one by one, as they are built from the item template that carries it - so this is what
+     * says which of the elements a declaration stands for the action actually drives.
+     */
+    d(this, "registrations", /* @__PURE__ */ new WeakSet());
+    this.statement = t, this.conditionalExecutor = s;
+    const i = new O((r, a, ...o) => (this.applyFrom(r), a(r, ...o)));
+    t.collectFields().forEach((r) => r.registerAction(i));
   }
   static get classIdentifier() {
-    return Ot;
+    return me;
   }
   get eager() {
     return !0;
   }
-  boundToField(t) {
-    this.boundFields.add(t);
+  boundToBinding(t) {
+    this.declarations.add(t.declaration), this.registrations.add(t);
+  }
+  unregisterFrom(t) {
+    this.registrations.delete(t);
+  }
+  /**
+   * The elements of `scope` this action controls: what each declaration it serves names within that record, and of
+   * those the ones that took the action on. A row of a list that never took it on is not one this action drives.
+   */
+  targetsIn(t) {
+    const s = [];
+    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 Lt extends M {
-  constructor(i) {
-    super(i, (t, e) => {
-      t.visibility = e ? S.FULL : S.SUPPRESS;
+class be extends Q {
+  constructor(e) {
+    super(e, (t, s) => {
+      t.visibility = s ? N.FULL : N.SUPPRESS;
     });
   }
 }
-class Rt extends M {
-  constructor(i) {
-    super(i, (t, e) => {
-      t.enabled = e;
+class ve extends Q {
+  constructor(e) {
+    super(e, (t, s) => {
+      t.enabled = s;
     });
   }
 }
-class Bt extends M {
-  constructor(i, t) {
-    super(i, (e, s) => {
-      s && (e.value = t);
+class Ve extends Q {
+  constructor(e, t) {
+    super(e, (s, i) => {
+      i && (s.value = t);
     });
   }
 }
-var R = /* @__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))(R || {});
+var M = /* @__PURE__ */ ((n) => (n[n.NOT = 0] = "NOT", n[n.OR = 1] = "OR", n[n.AND = 2] = "AND", n[n.XOR = 3] = "XOR", n[n.NAND = 4] = "NAND", n[n.NOR = 5] = "NOR", n[n.EQUALS = -1] = "EQUALS", n[n.NOT_EQUALS = -2] = "NOT_EQUALS", n[n.GT = -3] = "GT", n[n.LT = -4] = "LT", n[n.GE = -5] = "GE", n[n.LE = -6] = "LE", n[n.IN = -7] = "IN", n[n.NOT_IN = -8] = "NOT_IN", n[n.INCLUDES = -9] = "INCLUDES", n[n.NOT_INCLUDES = -10] = "NOT_INCLUDES", n))(M || {});
 ((n) => {
-  function i(r) {
+  function e(r) {
     const a = r.toLowerCase();
     if (a === "not") return 0;
     if (a === "or") return 1;
@@ -401,185 +806,602 @@ var R = /* @__PURE__ */ ((n) => (n[n.NOT = 0] = "NOT", n[n.OR = 1] = "OR", n[n.A
     if (["not_includes", "not-includes", "not includes"].includes(a)) return -10;
     throw new Error(`Unrecognised operator ${a}`);
   }
-  n.fromString = i;
+  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}`);
   }
   n.fromAny = t;
-  function e(r) {
+  function s(r) {
     const a = typeof r == "number" ? r : n.fromString(r);
     return Object.values(n).includes(a);
   }
-  n.isDefined = e;
-  function s(r) {
+  n.isDefined = s;
+  function i(r) {
     return r >= 0;
   }
-  n.isLogicOperator = s;
-})(R || (R = {}));
-Object.freeze(R);
-const c = R, Ut = /* @__PURE__ */ Symbol("EnabledChangingAction");
-class ut extends m {
-  constructor(i) {
-    super(i);
+  n.isLogicOperator = i;
+})(M || (M = {}));
+Object.freeze(M);
+const m = M, we = /* @__PURE__ */ Symbol("EnabledChangingAction");
+class Bt extends y {
+  constructor(e) {
+    super(e);
   }
   static get classIdentifier() {
-    return Ut;
+    return we;
   }
-  execute(i, t, e, s) {
-    return super.execute(i, t, e, s);
+  execute(e, t, s, i) {
+    return super.execute(e, t, s, i);
   }
 }
-const kt = /* @__PURE__ */ Symbol("EnabledChangedAction");
-class ct extends m {
-  constructor(i) {
-    super(i);
+const ye = /* @__PURE__ */ Symbol("EnabledChangedAction");
+class Mt extends y {
+  constructor(e) {
+    super(e);
   }
   static get classIdentifier() {
-    return kt;
+    return ye;
   }
-  execute(i, t, e, s) {
-    return super.execute(i, t, e, s);
+  execute(e, t, s, i) {
+    return super.execute(e, t, s, i);
   }
 }
-const Dt = /* @__PURE__ */ Symbol("ValidChangedAction");
-class ht extends m {
-  constructor(i) {
-    super(i);
+const Ee = /* @__PURE__ */ Symbol("ValidChangedAction");
+class Ut extends y {
+  constructor(e) {
+    super(e);
   }
   static get classIdentifier() {
-    return Dt;
+    return Ee;
   }
-  execute(i, t, e, s) {
-    return super.execute(i, t, e, s);
+  execute(e, t, s, i) {
+    return super.execute(e, t, s, i);
   }
 }
-const Mt = /* @__PURE__ */ Symbol("VisibilityChangingAction");
-class dt extends m {
-  constructor(i) {
-    super(i);
+const Ce = /* @__PURE__ */ Symbol("VisibilityChangingAction");
+class Wt extends y {
+  constructor(e) {
+    super(e);
   }
   static get classIdentifier() {
-    return Mt;
+    return Ce;
   }
-  execute(i, t, e, s) {
-    return super.execute(i, t, e, s);
+  execute(e, t, s, i) {
+    return super.execute(e, t, s, i);
   }
 }
-const $t = /* @__PURE__ */ Symbol("VisibilityChangedAction");
-class gt extends m {
-  constructor(i) {
-    super(i);
+const xe = /* @__PURE__ */ Symbol("VisibilityChangedAction");
+class $t extends y {
+  constructor(e) {
+    super(e);
   }
   static get classIdentifier() {
-    return $t;
+    return xe;
   }
-  execute(i, t, e, s) {
-    return super.execute(i, t, e, s);
+  execute(e, t, s, i) {
+    return super.execute(e, t, s, i);
   }
 }
-class V {
-  /**
-   * 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.
-   */
-  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 L());
-    // default property handlers
-    o(this, "_visibility", S.FULL);
-    o(this, "_enabled", !0);
+const xt = /* @__PURE__ */ new WeakMap(), St = /* @__PURE__ */ new Set(["validators", "actions"]);
+let st = 0;
+var h, f;
+class A {
+  constructor(e) {
     /**
-     * While true, validate() on this field does nothing at all: it neither recomputes _valid nor emits
-     * ValidChangedAction, and nothing climbs to the parent. A container that walks its members one by one - assigning
-     * them a value, or revalidating them - sets it for the duration of the walk, so a member's upward climb cannot
-     * announce the verdict of a half-applied value or of a half-revalidated set, and clears it in a finally block
-     * followed by its own validate(). That call recomputes over the finished state and emits the net transition, so
-     * the deferral cannot swallow a real change.
+     * 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.
      */
-    o(this, "suppressValidation", !1);
-    /**
-     * While true, a validity change is still recomputed and still announced on this field, but it is not passed up to
-     * the parent: the climb is only remembered and carried out by flushParentValidityClimb(). A setter that notifies
-     * the parent of the new value itself holds it over the notifying region, so the parent forms its verdict once,
-     * over the finished value, instead of once over the value being replaced and once over the value replacing it.
-     */
-    o(this, "suppressParentValidityClimb", !1);
-    o(this, "parentValidityClimbPending", !1);
-    o(this, "_validationEpoch", 0);
-    return Et(this);
+    Z(this, h);
+    Z(this, f);
+    tt(this, f, e), tt(this, h, ee(e));
+  }
+  /**
+   * 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.
+   */
+  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]) => {
+      St.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) || St.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.
+   */
+  [$]() {
+    return C(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.
+   */
+  [jt](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;
+  }
+  /**
+   * 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 H()), 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 = xt.get(this);
+    return e || (e = Tt(() => this.composeValid()), xt.set(this, e)), e.value;
   }
-  set visibility(i) {
-    const t = this._visibility, e = this.actions.trigger(dt, this, i, t);
-    if (!S.isDefined(e != null ? e : i)) throw new Error("visibility must be a DisplayMode constant");
-    this._visibility = S.fromAny(e != null ? e : i), this.actions.trigger(gt, this, this._visibility, t);
+  /** 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(Mt, this, l(this, h).enabled, s);
+    });
   }
-  set enabled(i) {
-    const t = this._enabled, e = this.actions.trigger(ut, this, i, t);
-    if (!Vt(e != null ? e : i)) throw new Error("Enabled value must be boolean");
-    this._enabled = e != null ? e : i, this.actions.trigger(ct, this, this._enabled, t);
+  /**
+   * 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;
   }
-  /** Carries out the climb that a validity change made while suppressParentValidityClimb was held, if there was one. */
-  flushParentValidityClimb() {
-    var i;
-    this.parentValidityClimbPending && (this.parentValidityClimbPending = !1, (i = this.parent) == null || i.validate());
+  /**
+   * Announces what this element's value became over the transaction. The pair carried is (value now, value at the
+   * last announcement), so a value that went A -> B -> A within the transaction says nothing, and the events an
+   * operation states rather than an element's state - an item added, an item removed - are emitted first, in the
+   * order the operations happened.
+   */
+  [Pt](e, t, s, i) {
+    if (i == null || i.forEach((u) => {
+      var c;
+      return (c = this._actions) == null ? void 0 : c.trigger(u.actionClass, this, u.item, u.index);
+    }), !t) return;
+    const r = this._actions;
+    if (this.composesValue && !(r != null && r.willTrigger(Ft) || r != null && r.hasEager)) return;
+    const a = this.value, o = l(this, f).announcedValue;
+    !s && (this.composesValue ? nt(a, o) : a === o) || (e.touch(this), l(this, f).announcedValue = a, this.composesValue && (r == null || r.triggerEager(this, a, o)), r == null || r.trigger(O, this, a, o));
   }
-  validate(i = !1) {
-    var e;
-    if (this.suppressValidation) return;
-    i && this.actions.triggerEager(this, this.value, this.value);
-    const t = this._valid;
-    this._valid = this.valid, this._valid !== t && (this.actions.trigger(ht, this, this.valid, t), this.suppressParentValidityClimb ? this.parentValidityClimbPending = !0 : (e = this.parent) == null || e.validate());
+  /**
+   * 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(Ut, this, s, t);
+  }
+  validate(e = !1) {
+    g((t) => {
+      var s;
+      e && ((s = this._actions) == null || s.triggerEager(this, this.value, this.value)), t.markValidityDirty(this);
+    });
   }
   get valid() {
-    return this.errors.length === 0;
+    return l(this, h).errors.length === 0;
   }
   get fullValue() {
     return this.value;
   }
   get isChanged() {
-    return !D(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));
   }
   /**
    * 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(i) {
-    i.forEach((t) => {
-      this.actions.register(t), t.boundToField(this);
+  registerInitialActions(e) {
+    e.forEach((t) => {
+      this.actions.register(t), t.boundToBinding(this);
     });
   }
-  registerAction(i) {
-    return this.actions.register(i), i.boundToField(this), i.eager && this.actions.trigger(Object.getPrototypeOf(i).constructor, this, this.value, this.originalValue), this;
+  registerAction(e) {
+    return g((t) => {
+      t.willAnnounceValue(this) || this.refreshPreviousValue(), this.actions.register(e), this.registered(t, e), e.eager && this.actions.triggerEagerFor(e.classIdentifier, this, this.value, this.originalValue);
+    }), this;
+  }
+  /**
+   * Registers `action` so that `before` wraps it: `before` reaches it through the `supr` it is handed, instead of
+   * ending the run there. It is how an action is added to a chain someone else built and still sits inside a
+   * handler already registered, which registration order alone cannot arrange. `before` has to be registered on
+   * this element under the same identifier.
+   */
+  registerActionBefore(e, t) {
+    return g((s) => {
+      s.willAnnounceValue(this) || this.refreshPreviousValue(), this.actions.register(e, t), this.registered(s, e), e.eager && this.actions.triggerEagerFor(e.classIdentifier, this, this.value, this.originalValue);
+    }), this;
+  }
+  /**
+   * Drops `action` from this element and answers whether it held it. The instance goes on serving every other
+   * element it was registered on: what is dropped is this element's registration, not the action. A validator
+   * withdraws the errors it put on this element as it goes, so the verdict the element reports is the one the
+   * validators it still holds reach.
+   */
+  unregisterAction(e) {
+    let t = !1;
+    return g((s) => {
+      const i = this._actions;
+      i && (t = i.unregister(e), t && (s.touch(this), e instanceof v && l(this, h).validationEpoch++, s.whenRolledBack(() => {
+        i.register(e), e.boundToBinding(this);
+      }), e.unregisterFrom(this)));
+    }), t;
+  }
+  /**
+   * Records that `action` is now registered on this element, and that a rollback has to take that back. The
+   * registration is not one of the state slots the snapshot covers, so it hands its own undo in.
+   */
+  registered(e, t) {
+    t.boundToBinding(this), e.whenRolledBack(() => {
+      var s;
+      (s = this._actions) != null && s.unregister(t) && t.unregisterFrom(this);
+    });
   }
-  triggerAction(i, ...t) {
-    return this.actions.trigger(i, this, ...t);
+  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
@@ -587,70 +1409,97 @@ class V {
    * cannot push an error onto a field that no longer has the validator that produced it.
    */
   get validationEpoch() {
-    return this._validationEpoch;
+    return l(this, h).validationEpoch;
   }
   clearValidators() {
-    this._validationEpoch++, this.actions = this.actions.cloneWithoutValidators(), this.errors = [], this.validate();
+    g((e) => {
+      e.touch(this), l(this, h).validationEpoch++;
+      const t = this._actions;
+      t && t.validators.forEach((s) => {
+        t.unregister(s), e.whenRolledBack(() => {
+          t.register(s), s.boundToBinding(this);
+        }), s.unregisterFrom(this);
+      }), this.errors = [], this.validate();
+    });
   }
 }
-function qt(n, i) {
-  return n ? !i : i;
+h = new WeakMap(), f = new WeakMap();
+function Se(n, e) {
+  return n ? !e : e;
 }
-class N {
-  constructor(i, t, e) {
-    o(this, "operand1");
-    o(this, "operator");
-    o(this, "operand2");
-    this.operand1 = i, this.operator = t, this.operand2 = e;
+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 ? lt(e, t) : e;
+      return s ? b(s.value) : void 0;
+    }
+    return e;
   }
   get operand1Value() {
-    return this.operand1 instanceof N ? this.operand1.evaluate() : this.operand1 instanceof V ? h(this.operand1.value) : this.operand1;
+    return I.valueOf(this.operand1);
   }
   get operand2Value() {
-    return this.operand2 instanceof N ? this.operand2.evaluate() : this.operand2 instanceof V ? h(this.operand2.value) : this.operand2;
+    return I.valueOf(this.operand2);
   }
-  evaluate() {
-    var e, s;
-    const i = this.operand1Value, t = 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
       // `&&` 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 c.AND:
-        return !!(i && t);
-      case c.OR:
-        return !!(i || t);
-      case c.NAND:
-        return !(i && t);
-      case c.NOR:
-        return !(i || t);
-      case c.XOR:
-        return qt(!!i, !!t);
-      case c.NOT:
-        return !i;
+      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 c.EQUALS:
-        return i == t;
-      case c.NOT_EQUALS:
-        return i != t;
-      case c.LT:
-        return i < t;
-      case c.LE:
-        return i <= t;
-      case c.GE:
-        return i >= t;
-      case c.GT:
-        return i > t;
-      case c.IN:
-        return !!((e = t == null ? void 0 : t.includes) != null && e.call(t, i));
-      case c.NOT_IN:
-        return !((s = t == null ? void 0 : t.includes) != null && s.call(t, i));
-      case c.INCLUDES:
-        return A(i) && A(t) && i.indexOf(t) >= 0;
-      case c.NOT_INCLUDES:
-        return !(A(i) && A(t) && i.indexOf(t) >= 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 j(t) && j(s) && t.indexOf(s) >= 0;
+      case m.NOT_INCLUDES:
+        return !(j(t) && j(s) && t.indexOf(s) >= 0);
       default:
         throw new Error(`Operator not implemented ${this.operator}`);
     }
@@ -660,55 +1509,97 @@ class N {
    * @returns A set of all fields used in this statement
    */
   collectFields() {
-    const i = /* @__PURE__ */ new Set();
-    function t(e) {
-      e instanceof V ? i.add(e) : e instanceof N && e.collectFields().forEach((r) => i.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 t(this.operand1), t(this.operand2), i;
+    return t(this.operand1), t(this.operand2), e;
   }
 }
-const Ht = /* @__PURE__ */ Symbol("ExecuteAction");
-class ft extends m {
-  constructor(i) {
-    super(i);
+const Ie = /* @__PURE__ */ Symbol("ExecuteAction");
+class qt extends y {
+  constructor(e) {
+    super(e);
   }
   static get classIdentifier() {
-    return Ht;
+    return Ie;
   }
-  execute(i, t, e) {
-    return super.execute(i, t, e);
+  execute(e, t, s) {
+    return super.execute(e, t, s);
   }
 }
-const Qt = /* @__PURE__ */ Symbol("ListItemAddedAction");
-class z extends m {
-  constructor(i) {
-    super(i);
+const Ae = /* @__PURE__ */ Symbol("ListItemAddedAction");
+class rt extends y {
+  constructor(e) {
+    super(e);
   }
   static get classIdentifier() {
-    return Qt;
+    return Ae;
   }
-  execute(i, t, e, s) {
-    return super.execute(i, t, e, s);
+  execute(e, t, s, i) {
+    return super.execute(e, t, s, i);
   }
 }
-const Wt = /* @__PURE__ */ Symbol("ListItemRemovedAction");
-class pt extends m {
-  constructor(i) {
-    super(i);
+const _e = /* @__PURE__ */ Symbol("ListItemRemovedAction");
+class zt extends y {
+  constructor(e) {
+    super(e);
   }
   static get classIdentifier() {
-    return Wt;
+    return _e;
   }
-  execute(i, t, e, s) {
-    return super.execute(i, t, e, s);
+  execute(e, t, s, i) {
+    return super.execute(e, t, s, i);
   }
 }
-class $ extends V {
-  constructor(t) {
-    super();
-    o(this, "_value");
-    o(this, "_touched", !1);
-    this.init(t);
+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 C(p({}, Ht()), { value: void 0, touched: !1 });
+}
+function Qt() {
+  return C(p({}, Ht()), {
+    announcedValue: null,
+    cachedValue: null,
+    cachedValueVersion: -1
+  });
+}
+function Fe() {
+  return C(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(Oe()), this.init(e);
   }
   /**
    * Applies the constructor parameters. It is a hook so that a subclass needing different parameter handling
@@ -719,88 +1610,133 @@ class $ extends V {
    * subclass initializes read as undefined inside it, and anything it writes to such a member is overwritten
    * the moment the initializer runs.
    */
-  init(t) {
-    if (t) {
-      const e = t, { value: s, validators: r, actions: a } = e, l = F(e, ["value", "validators", "actions"]);
-      this.registerInitialActions([...r || [], ...a || []]), Object.assign(this, l), this._value = s !== void 0 ? s : this.originalValue, this.originalValue === void 0 && (this.originalValue = this._value);
-    }
-    this.actions.triggerEager(this, this.value, this.originalValue), this.validate();
+  init(e) {
+    g(() => {
+      var s;
+      if (e) {
+        const t = e, { value: i, validators: r, actions: a } = t, o = k(t, ["value", "validators", "actions"]);
+        this.registerInitialActions([...r || [], ...a || []]), this.assignParams(o), this._value = i !== void 0 ? i : this.originalValue, this.originalValue === void 0 && (this.originalValue = this._value);
+      }
+      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(t) {
-    const e = this._value;
-    if (!this.enabled || e === t) return;
-    this._value = t;
-    const s = this.suppressParentValidityClimb;
-    this.suppressParentValidityClimb = !0;
-    try {
-      this.actions.trigger(y, this, this._value, e), this.parent && this.parent.notifyValueChanged();
-    } finally {
-      this.suppressParentValidityClimb = s, this.validate(), this.flushParentValidityClimb();
-    }
+  set value(e) {
+    const t = this._value;
+    !this.enabled || t === e || g((s) => {
+      var i;
+      s.touch(this), this._value = e, this.bumpValueVersion(), (i = this._actions) == null || i.triggerEager(this, e, t), this.propagateValueChanged();
+    });
   }
   get touched() {
-    return this._touched;
+    return this.state.touched;
   }
-  set touched(t) {
-    this._touched = t;
+  set touched(e) {
+    this.touchState(), this.state.touched = e;
   }
-  clone(t) {
+  bind(e, t) {
     var r, a;
-    const e = this.constructor, s = new e(w(v({
-      // an override value is one the caller supplied, and undefined is not one; an explicit null is, and clears
-      value: (t == null ? void 0 : t.value) !== void 0 ? t.value : this.value
+    const s = this.constructor, i = new s(C(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 s.actions = this.actions.clone(), s.actions.triggerEager(s, s.value, s.originalValue), s;
+    return i.boundFrom(this, i.value, i.originalValue, t), i;
   }
 }
-const zt = new $({ value: "EmptyField" }).registerAction(
-  new y(() => {
+const je = new X({ value: "EmptyField" }).registerAction(
+  new O(() => {
     console.warn("Working with EmptyField! This should not happen");
   })
-);
-function H(n, i) {
-  return (n == null ? void 0 : n.label) == null && (n == null ? void 0 : n.icon) == null ? i : n;
-}
-class Xt extends $ {
-  init(i) {
-    if (this._value = { label: void 0, icon: void 0 }, i) {
-      const t = i, { value: e, originalValue: s, validators: r, actions: a } = t, l = F(t, ["value", "originalValue", "validators", "actions"]);
-      this.registerInitialActions([...r || [], ...a || []]), Object.assign(this, l);
-      const u = H(e, this._value), d = Object.freeze({ label: s == null ? void 0 : s.label, icon: s == null ? void 0 : s.icon });
-      this._value = H(u, v({}, d)), this.originalValue = H(d, u);
-    }
-    this.actions.triggerEager(this, this.value, this.originalValue), this.validate();
+), It = /* @__PURE__ */ new WeakMap();
+function it(n, e) {
+  return (n == null ? void 0 : n.label) == null && (n == null ? void 0 : n.icon) == null ? e : n;
+}
+class Pe extends X {
+  init(e) {
+    g(() => {
+      var s;
+      if (this._value = { label: void 0, icon: void 0 }, e) {
+        const t = e, { value: i, originalValue: r, validators: a, actions: o } = t, u = k(t, ["value", "originalValue", "validators", "actions"]);
+        this.registerInitialActions([...a || [], ...o || []]), this.assignParams(u);
+        const c = it(i, this._value), x = Object.freeze({ label: r == null ? void 0 : r.label, icon: r == null ? void 0 : r.icon });
+        this._value = it(c, p({}, x)), this.originalValue = it(x, c);
+      }
+      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(i) {
-    this.value.icon = i;
+  set icon(e) {
+    this.value.icon !== e && (this.value = this.valueWith("icon", e));
   }
   get label() {
     return this.value.label;
   }
-  set label(i) {
-    this.value.label = i;
+  /**
+   * 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));
+  }
+  /** the counter behind `busy`, allocated for this action the first time it is asked for */
+  get busyRuns() {
+    let e = It.get(this);
+    return e || (e = se(0), It.set(this, e)), e;
+  }
+  /** true from the moment execute() is called until the handler it ran has settled, however it settles */
+  get busy() {
+    return this.busyRuns.value > 0;
   }
-  execute(i) {
-    this.actions.trigger(ft, this, i);
+  /**
+   * 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 vt(this, null, function* () {
+      const t = this.busyRuns;
+      t.value++;
+      try {
+        return yield this.triggerAction(qt, e);
+      } finally {
+        t.value--;
+      }
+    });
   }
 }
-const Gt = /* @__PURE__ */ It({
+const Ne = /* @__PURE__ */ ie({
   __name: "messages-widget",
   props: {
     message: {},
     classes: {}
   },
   setup(n) {
-    const i = n, t = st("vue-markdown"), e = /* @__PURE__ */ new Set([
+    const e = n, t = Vt("vue-markdown"), s = /* @__PURE__ */ new Set([
       "div",
       "span",
       "p",
@@ -856,37 +1792,37 @@ const Gt = /* @__PURE__ */ It({
       "dl",
       "dt",
       "dd"
-    ]), s = () => {
-      if (typeof i.message == "string") return j("span", { class: i.classes }, i.message);
+    ]), i = () => {
+      if (typeof e.message == "string") return R("span", { class: e.classes }, e.message);
       const r = [];
-      return i.message.forEach((a) => {
+      return e.message.forEach((a) => {
         switch (a.componentName) {
           case "template":
-            r.push(j("div", { class: [i.classes, a.extraClasses] }, a.componentBody));
+            r.push(R("div", { class: [e.classes, a.extraClasses] }, a.componentBody));
             break;
           case "vue-markdown":
             if (typeof t == "string")
               console.warn(
                 "You are using markdown for messages-widget, but you haven't registered a vue-markdown component"
-              ), r.push(j("div", { class: [i.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(
-                j(t, {
-                  class: [i.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(
-              j(
-                e.has(a.componentName.toLowerCase()) ? a.componentName : st(a.componentName),
-                v(v({
-                  class: [i.classes, a.extraClasses]
+              R(
+                s.has(a.componentName.toLowerCase()) ? a.componentName : Vt(a.componentName),
+                p(p({
+                  class: [e.classes, a.extraClasses]
                 }, a.componentBindings), a.componentBody ? { innerHTML: a.componentBody } : {})
               )
             );
@@ -894,465 +1830,619 @@ const Gt = /* @__PURE__ */ It({
         }
       }), r;
     };
-    return (r, a) => (At(), St(s));
+    return (r, a) => (ne(), re(i));
   }
 });
-class C extends V {
-  constructor(t, e) {
-    super();
-    o(this, "_fields");
-    o(this, "_value", null);
-    o(this, "suppressNotifyValueChanged", !1);
-    if (!C.isValidFields(t)) throw new Error("Invalid fields object provided");
-    if (this._fields = /* @__PURE__ */ Object.create(null), Object.entries(t).forEach(([r, a]) => this.addField(r, a)), e) {
-      const s = e, { value: r, validators: a, actions: l } = s, u = F(s, ["value", "validators", "actions"]);
-      this.registerInitialActions([...a || [], ...l || []]), Object.assign(this, u), r !== void 0 ? this.assignMembers(r) : this.originalValue !== void 0 && this.assignMembers(this.originalValue);
-    }
-    this.originalValue === void 0 && (this.originalValue = this.value), this._value = 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, u]) => this.addField(o, u)), s) {
+        const r = s, { value: o, validators: u, actions: c } = r, x = k(r, ["value", "validators", "actions"]);
+        this.registerInitialActions([...u || [], ...c || []]), this.assignParams(x), o !== void 0 ? this.assignMembers(o) : this.originalValue !== void 0 && this.assignMembers(this.originalValue);
+      }
+      this.completeRecords();
+      const i = this.value;
+      this.originalValue === void 0 && (this.originalValue = w.baseline(i)), this.raw.announcedValue = i, (a = this._actions) == null || a.triggerEager(this, i, this.originalValue), this.validate();
+    });
+  }
+  get state() {
+    return super.state;
   }
-  addField(t, e) {
+  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(t, s) {
     if (Object.hasOwn(this._fields, t))
       throw new Error(`Field ${t} is already in this form`);
-    Object.defineProperty(e, "parent", { get: () => this, configurable: !1, enumerable: !1 }), Object.defineProperty(e, "fieldName", { get: () => t, configurable: !1, enumerable: !1 }), Object.defineProperty(this._fields, t, { get: () => e, configurable: !1, enumerable: !0 });
+    this.takeChild(s, t), Object.defineProperty(this._fields, t, { get: () => s, configurable: !1, enumerable: !0 });
   }
   static isValidFields(t) {
-    function e(s) {
-      return s instanceof V;
+    function s(i) {
+      return i instanceof A;
     }
-    return typeof t == "object" && t !== null && Object.entries(t).every(([, s]) => e(s));
+    return typeof t == "object" && t !== null && Object.entries(t).every(([, i]) => s(i));
   }
   static createFromFormData(t) {
-    if (t instanceof V)
+    if (t instanceof A)
       throw new Error("data is already a Form structure, should be a simple object");
-    return new C(
-      t == null ? {} : Object.fromEntries(Object.entries(t).map(([e, s]) => [e, new $({ value: s })]))
+    return new w(
+      t == null ? {} : Object.fromEntries(Object.entries(t).map(([s, i]) => [s, new X({ value: i })]))
     );
   }
   field(t) {
-    var e;
-    return (e = this._fields[t]) != null ? e : null;
+    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 t = /* @__PURE__ */ Object.create(null);
-    return Object.entries(this._fields).forEach(([e, s]) => {
-      const r = s.value;
-      (s.enabled || s instanceof C && !Q(r)) && (t[e] = r);
-    }), Q(t) ? null : v({}, t);
+    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;
   }
   /**
-   * Writes the members that the given value carries, without letting any single member announce the state in
-   * between: the group's own value notification and its own validation are both held back for the duration, so
-   * neither a ValueChangedAction nor a ValidChangedAction reports a verdict over a half-applied value. The
-   * caller decides what to announce once the whole value is in place. Both flags are restored to what they were,
-   * so a caller that is itself holding the group back stays in charge.
+   * 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) {
-    const e = this.suppressNotifyValueChanged, s = this.suppressValidation;
-    this.suppressNotifyValueChanged = !0, this.suppressValidation = !0;
-    try {
-      Object.entries(this._fields).forEach(([r, a]) => {
-        (t == null || Object.hasOwn(t, r)) && (a.value = t == null ? null : t[r]);
+    g(() => {
+      Object.entries(this._fields).forEach(([s, i]) => {
+        (t == null || Object.hasOwn(t, s)) && (i.value = t == null ? null : t[s]);
       });
-    } finally {
-      this.suppressNotifyValueChanged = e, this.suppressValidation = s;
-    }
+    });
   }
   set value(t) {
-    this.assignMembers(t), this.notifyValueChanged(), this.validate();
+    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, u]) => {
+        var x;
+        let c;
+        s === null ? c = null : s !== void 0 && Object.hasOwn(s, o) && (c = s[o]), this.resetChild(u, (x = i.field(o)) != null ? x : u, c);
+      });
+      const a = this.value;
+      this.raw.announcedValue = a, this.originalValue = w.baseline(a), super.validate(!0);
+    });
   }
   get touched() {
     return Object.values(this._fields).some((t) => t.touched);
   }
   set touched(t) {
-    Object.values(this._fields).forEach((e) => {
-      e.touched = t;
+    g(() => {
+      Object.values(this._fields).forEach((s) => {
+        s.touched = t;
+      });
     });
   }
   get fullValue() {
     const t = /* @__PURE__ */ Object.create(null);
-    return Object.entries(this._fields).forEach(([e, s]) => {
-      t[e] = s.fullValue;
-    }), v({}, t);
+    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 t = this.value;
-    if (!D(t, this._value)) {
-      const e = this._value;
-      this._value = t;
-      const s = this.suppressParentValidityClimb;
-      this.suppressParentValidityClimb = !0;
-      try {
-        this.actions.trigger(y, this, t, e), this.parent && this.parent.notifyValueChanged();
-      } finally {
-        this.suppressParentValidityClimb = s, this.validate(), this.flushParentValidityClimb();
-      }
-    }
+    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((t) => t.valid);
+    return this.validRead;
+  }
+  composeValid() {
+    return this.state.errors.length === 0 && Object.values(this._fields).every((t) => t.valid);
   }
   validate(t = !1) {
-    if (t) {
-      const e = this.suppressValidation;
-      this.suppressValidation = !0;
-      try {
-        Object.values(this._fields).forEach((s) => s.validate(!0));
-      } finally {
-        this.suppressValidation = e;
-      }
-    }
-    super.validate(t);
+    g(() => {
+      t && Object.values(this._fields).forEach((s) => s.validate(!0)), super.validate(t);
+    });
   }
-  clone(t) {
-    var r, a;
-    const e = /* @__PURE__ */ Object.create(null);
-    Object.entries(this._fields).forEach(([l, u]) => {
-      e[l] = u.clone();
+  bind(t, s) {
+    var a, o;
+    const i = /* @__PURE__ */ Object.create(null);
+    Object.entries(this._fields).forEach(([u, c]) => {
+      i[u] = c.bind();
     });
-    const s = new C(e, w(v({
-      // an override value is one the caller supplied, and undefined is not one; an explicit null is, and clears
-      value: (t == null ? void 0 : t.value) !== void 0 ? t.value : 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
+    const r = new w(i, C(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 s.actions = this.actions.clone(), s.actions.triggerEager(s, s.value, s.originalValue), s;
+    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 Y extends V {
-  constructor(t, e) {
-    super();
-    o(this, "_value", null);
-    o(this, "_itemTemplate");
-    o(this, "_previousValue");
-    if (this._itemTemplate = t, e) {
-      const s = e, { value: r, validators: a, actions: l } = s, u = F(s, ["value", "validators", "actions"]);
-      this.registerInitialActions([...a || [], ...l || []]), Object.assign(this, u), r != null && 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(Fe());
+    d(this, "_itemTemplate");
+    this._itemTemplate = t, g(() => {
+      var r;
+      if (s) {
+        const i = s, { value: a, validators: o, actions: u } = i, c = k(i, ["value", "validators", "actions"]);
+        this.registerInitialActions([...o || [], ...u || []]), this.assignParams(c), a != null && this.setValueInternal(a);
+      }
+      this.originalValue === void 0 && (this.originalValue = D.baseline(this.value)), this.raw.announcedValue = this.value, (r = this._actions) == null || r.triggerEager(this, this.value, this.originalValue), this.validate();
+    });
+  }
+  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. */
+  [$]() {
+    const t = super[$]();
+    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(t) {
-    let e;
-    return t instanceof C ? e = t : this._itemTemplate ? e = this._itemTemplate.clone({ value: t }) : e = C.createFromFormData(t), Object.defineProperty(e, "parent", { get: () => this, configurable: !1, enumerable: !1 }), e;
+    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;
   }
   /**
-   * Builds the item that fills a gap left by an insert beyond the end of the list: a copy of the item template with
-   * the template's own values, or an empty group when the list has no template.
+   * 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.clone() : null);
+    return this.processSetValueItem(this._itemTemplate ? this._itemTemplate.bind() : null);
   }
   setValueInternal(t) {
-    t == null ? this._value = null : Array.isArray(t) && (this._value = t.map((e) => this.processSetValueItem(e)));
+    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 u = t[o], c = r[o];
+          c && this._itemTemplate && !(u instanceof w) ? (this.resetChild(c, this._itemTemplate, u), a[o] = c) : (c && this.releaseChild(c), a[o] = this.processSetValueItem(u));
+        }
+        for (let o = t.length; o < r.length; o++) this.releaseChild(r[o]);
+        this.state.rows = a;
+      }
+      this.bumpValueVersion();
+    });
   }
   get value() {
-    var e;
-    const t = (e = this._value) == null ? void 0 : e.map((s) => s.value);
-    return Q(t) ? null : t;
+    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) {
-    const e = this._previousValue;
-    this.setValueInternal(t);
-    const s = this.value;
-    this._previousValue = s;
-    const r = this.suppressParentValidityClimb;
-    this.suppressParentValidityClimb = !0;
-    try {
-      this.actions.trigger(y, this, s, e), this.parent && this.parent.notifyValueChanged();
-    } finally {
-      this.suppressParentValidityClimb = r, this.validate(), this.flushParentValidityClimb();
-    }
+    g(() => {
+      this.setValueInternal(t), this.propagateValueChanged(!0);
+    });
+  }
+  /**
+   * 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 t;
-    return ((t = this._value) == null ? void 0 : t.some((e) => e.touched)) || !1;
+    return ((t = this.state.rows) == null ? void 0 : t.some((s) => s.touched)) || !1;
   }
   set touched(t) {
-    var e;
-    (e = this._value) == null || e.forEach((s) => {
-      s.touched = t;
+    g(() => {
+      var s;
+      (s = this.state.rows) == null || s.forEach((i) => {
+        i.touched = t;
+      });
     });
   }
-  clone(t) {
-    var s, r, a, l;
-    const e = new Y((s = this._itemTemplate) == null ? void 0 : s.clone(), w(v({
-      // an override value is one the caller supplied, and undefined is not one; an explicit null is, and clears
-      value: [...(r = (t == null ? void 0 : t.value) !== void 0 ? t.value : this.value) != null ? r : []]
-    }, t && "originalValue" in t ? { originalValue: t.originalValue } : {}), {
-      enabled: (a = t == null ? void 0 : t.enabled) != null ? a : this.enabled,
-      visibility: (l = t == null ? void 0 : t.visibility) != null ? l : this.visibility
+  bind(t, s) {
+    var r, a, o, u;
+    const i = new D((r = this._itemTemplate) == null ? void 0 : r.bind(), C(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: (u = s == null ? void 0 : s.visibility) != null ? u : this.visibility
     }));
-    return e.actions = this.actions.clone(), e.actions.triggerEager(e, e.value, e.originalValue), e;
+    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 t = this.value;
-    if (!D(t, this._previousValue)) {
-      const e = this._previousValue;
-      this._previousValue = t;
-      const s = this.suppressParentValidityClimb;
-      this.suppressParentValidityClimb = !0;
-      try {
-        this.actions.trigger(y, this, t, e), this.parent && this.parent.notifyValueChanged();
-      } finally {
-        this.suppressParentValidityClimb = s, this.validate(), this.flushParentValidityClimb();
-      }
-    }
+    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 t, e;
-    return super.valid && ((e = (t = this._value) == null ? void 0 : t.every((s) => s.valid)) != null ? e : !0);
+    return this.validRead;
+  }
+  composeValid() {
+    var t, s;
+    return this.state.errors.length === 0 && ((s = (t = this.state.rows) == null ? void 0 : t.every((i) => i.valid)) != null ? s : !0);
   }
   validate(t = !1) {
-    var e;
-    if (t) {
-      const s = this.suppressValidation;
-      this.suppressValidation = !0;
-      try {
-        (e = this._value) == null || e.forEach((r) => r.validate(!0));
-      } finally {
-        this.suppressValidation = s;
-      }
-    }
-    super.validate(t);
+    g(() => {
+      var s;
+      t && ((s = this.state.rows) == null || s.forEach((i) => i.validate(!0))), super.validate(t);
+    });
+  }
+  get members() {
+    var t;
+    return (t = this.raw.rows) != null ? t : [];
   }
   get(t) {
-    return this._value != null ? this._value[t] : void 0;
+    return this.state.rows != null ? this.state.rows[t] : void 0;
   }
   push(t) {
-    var e, s;
-    return this.insert(t, (s = (e = this._value) == null ? void 0 : e.length) != null ? s : 0) + 1;
+    var s, i;
+    return this.insert(t, (i = (s = this.state.rows) == null ? void 0 : s.length) != null ? i : 0) + 1;
   }
   pop() {
-    var t, e;
-    return this.remove(((e = (t = this._value) == null ? void 0 : t.length) != null ? e : 0) - 1);
+    var t, s;
+    return this.remove(((s = (t = this.state.rows) == null ? void 0 : t.length) != null ? s : 0) - 1);
   }
   remove(t) {
-    var s;
-    if (this._value == null || t < 0 || this._value.length <= t) return;
-    let e = (s = this._value.splice(t, 1)) == null ? void 0 : s[0];
-    return e && (e = e.clone(), this.actions.trigger(pt, this, e, t), this.notifyValueChanged()), e;
-  }
-  insert(t, e) {
-    this._value == null && (this._value = []);
-    const s = e < 0 ? Math.max(this._value.length + e, 0) : e;
-    for (; this._value.length < s; ) {
-      const a = this.createPaddingItem(), l = this._value.push(a) - 1;
-      this.actions.trigger(z, this, a, l);
-    }
-    const r = this.processSetValueItem(t);
-    return this._value.splice(s, 0, r), this.actions.trigger(z, this, r, s), this.notifyValueChanged(), s;
+    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(), u = this.state.rows.push(o) - 1;
+        this.bumpValueVersion(), r.recordStructural(this, { actionClass: rt, item: o, index: u });
+      }
+      const a = this.processSetValueItem(t);
+      this.state.rows.splice(i, 0, a), r.recordStructural(this, { actionClass: rt, item: a, index: i }), this.bumpValueVersion(), this.propagateValueChanged(!0);
+    }), i;
+  }
+  /** 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);
+    });
   }
 }
-class Yt extends f {
-  constructor(t, e, s) {
-    let r = !1, a, l;
-    super((d, x, _) => (a = d, l = x, r || (r = !0, this.otherField.registerAction(
-      new y((P, B, p, E) => {
-        B(P, p, E), this.unregistered || this.execute(_, () => null, a, l);
+class ke extends v {
+  constructor(t, s, i) {
+    super((a, o, u) => {
+      this.comparisonState(u).oldValue = o;
+      const c = this.resolve(u);
+      return c ? (this.listenOn(c), this.isValidComparison(b(a), b(c.value)) ? null : [
+        new V(
+          this.replacePlaceholders(i, { newValue: a, oldValue: o, field: u, otherField: c })
+        )
+      ]) : (u.markRecordIncomplete(), null);
+    });
+    d(this, "isValidComparison");
+    d(this, "otherField");
+    /**
+     * The fields this validator is registered on. Registration reaches one element at a time - the rows of a list
+     * take the validator on one by one, as they are built from the item template that carries it - so this is what
+     * says which of the fields a declaration stands for actually carry the rule, and a field that never took it on
+     * is left alone by a change of the compared field.
+     */
+    d(this, "registrations", /* @__PURE__ */ new WeakSet());
+    /**
+     * The fields this validator has installed its listener on. A binding of such a field carries the listener too -
+     * a binding takes on the actions of the field it was bound from - so the field it was bound from is what is
+     * asked about as well, and a list of a thousand rows installs one listener rather than a thousand.
+     */
+    d(this, "listening", /* @__PURE__ */ new WeakSet());
+    /**
+     * What the fields this validator was registered on were declared as. One entry stands for every binding of such a
+     * field, so a change of a compared field finds the fields of the record that change happened in without a list
+     * of a thousand rows being held here.
+     */
+    d(this, "declarations", /* @__PURE__ */ new Set());
+    this.isValidComparison = s, this.otherField = t;
+  }
+  /** The field `field` is compared against, within the record `field` belongs to. */
+  resolve(t) {
+    var i;
+    const s = this.otherField;
+    return typeof s == "function" ? (i = s(t)) != null ? i : void 0 : typeof s == "string" ? pe(s, t) : lt(s, T(t));
+  }
+  /**
+   * 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(
+          (u) => Lt(u, o).forEach((c) => {
+            this.registrations.has(c) && this.execute(c, () => null, c.value, this.comparisonState(c).oldValue);
+          })
+        );
       })
-    )), this.isValidComparison(h(d), h(this.otherField.value)) ? null : [
-      new g(
-        this.replacePlaceholders(s, { newValue: d, oldValue: x, field: _, otherField: this.otherField })
-      )
-    ]));
-    o(this, "otherField");
-    o(this, "isValidComparison");
-    o(this, "unregistered", !1);
-    this.otherField = t, this.isValidComparison = e;
+    ));
+  }
+  boundToBinding(t) {
+    this.declarations.add(t.declaration), this.registrations.add(t);
   }
-  unregister() {
-    this.unregistered = !0;
+  comparisonState(t) {
+    return this.bindingState(t);
+  }
+  newBindingState() {
+    return C(p({}, super.newBindingState()), { oldValue: void 0 });
+  }
+  unregisterFrom(t) {
+    this.registrations.delete(t);
   }
 }
-class Jt extends f {
-  constructor(i, t) {
-    const e = t || b("Must be one of [**{allowedAsText}**]");
-    let s = i.join(", ");
-    s.length > 60 && (s = Ct(s, {
+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: `... (${i.length} items total)`
+      omission: `... (${e.length} items total)`
     }));
-    const r = (a, l, u) => i.includes(h(a)) ? null : [
-      new g(
-        this.replacePlaceholders(e, { newValue: a, oldValue: l, field: u, allowedValues: i, allowedAsText: s })
+    const r = (a, o, u) => e.includes(b(a)) ? null : [
+      new V(
+        this.replacePlaceholders(s, { newValue: a, oldValue: o, field: u, allowedValues: e, allowedAsText: i })
       )
     ];
     super(r);
   }
 }
-function Kt(n) {
-  return n == null ? 0 : rt(n) || A(n) ? n.length : at(n) && Object.getPrototypeOf(n) === Object.prototype ? Object.keys(n).length : String(n).length;
+function De(n) {
+  return n == null ? 0 : At(n) || j(n) ? n.length : _t(n) && Object.getPrototypeOf(n) === Object.prototype ? Object.keys(n).length : String(n).length;
 }
-class Zt extends f {
-  constructor(i) {
-    const t = i || b("Please enter a value"), e = (s, r, a) => Kt(h(s)) === 0 ? [new g(this.replacePlaceholders(t, { newValue: s, oldValue: r, field: a }))] : null;
-    super(e);
+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 te extends f {
-  constructor(i, t) {
-    const e = t || b("Value must be larger or equal to **{minValue}**"), s = (r, a, l) => r < i || r === void 0 ? [
-      new g(this.replacePlaceholders(e, { newValue: r, oldValue: a, field: l, minValue: i }))
+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(s);
+    super(i);
   }
 }
-class ee extends f {
-  constructor(i, t) {
-    const e = t || b("Value must be less than or equal to **{maxValue}**"), s = (r, a, l) => r > i || r === void 0 ? [
-      new g(this.replacePlaceholders(e, { newValue: r, oldValue: a, field: l, maxValue: i }))
+class Me extends v {
+  constructor(e, t) {
+    const s = t || E("Value must be less than or equal to **{maxValue}**"), i = (r, a, o) => r > e || r === void 0 ? [
+      new V(this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, maxValue: e }))
     ] : null;
-    super(s);
+    super(i);
   }
 }
-class ie extends f {
-  constructor(i, t, e) {
-    const s = e || b("Value must be between **{minValue}** and **{maxValue}**"), r = (a, l, u) => a < i || a > t || a === void 0 ? [
-      new g(
-        this.replacePlaceholders(s, { newValue: a, oldValue: l, field: u, minValue: i, maxValue: t })
+class Ue extends v {
+  constructor(e, t, s) {
+    const i = s || E("Value must be between **{minValue}** and **{maxValue}**"), r = (a, o, u) => a < e || a > t || a === void 0 ? [
+      new V(
+        this.replacePlaceholders(i, { newValue: a, oldValue: o, field: u, minValue: e, maxValue: t })
       )
     ] : null;
     super(r);
   }
 }
-function J(n) {
-  return n == null ? 0 : rt(n) || A(n) ? n.length : at(n) && Object.getPrototypeOf(n) === Object.prototype ? Object.keys(n).length : String(n).length;
+function ut(n) {
+  return n == null ? 0 : At(n) || j(n) ? n.length : _t(n) && Object.getPrototypeOf(n) === Object.prototype ? Object.keys(n).length : String(n).length;
 }
-class se extends f {
-  constructor(i, t) {
-    const e = t || b("Length must be larger or equal to **{minLength}**"), s = (r, a, l) => J(r) < i ? [
-      new g(this.replacePlaceholders(e, { newValue: r, oldValue: a, field: l, minLength: i }))
+class We extends v {
+  constructor(e, t) {
+    const s = t || E("Length must be larger or equal to **{minLength}**"), i = (r, a, o) => ut(r) < e ? [
+      new V(this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, minLength: e }))
     ] : null;
-    super(s);
+    super(i);
   }
 }
-class ne extends f {
-  constructor(i, t) {
-    const e = t || b("Length must be less than or equal to **{maxLength}**"), s = (r, a, l) => J(r) > i ? [
-      new g(this.replacePlaceholders(e, { newValue: r, oldValue: a, field: l, maxLength: i }))
+class $e extends v {
+  constructor(e, t) {
+    const s = t || E("Length must be less than or equal to **{maxLength}**"), i = (r, a, o) => ut(r) > e ? [
+      new V(this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, maxLength: e }))
     ] : null;
-    super(s);
+    super(i);
   }
 }
-class re extends f {
-  constructor(i, t, e) {
-    const s = e || b("Length must be between **{minLength}** and **{maxLength}**"), r = (a, l, u) => {
-      const d = J(a);
-      return d < i || d > t ? [
-        new g(
-          this.replacePlaceholders(s, { newValue: a, oldValue: l, field: u, minLength: i, maxLength: t })
+class qe extends v {
+  constructor(e, t, s) {
+    const i = s || E("Length must be between **{minLength}** and **{maxLength}**"), r = (a, o, u) => {
+      const c = ut(a);
+      return c < e || c > t ? [
+        new V(
+          this.replacePlaceholders(i, { newValue: a, oldValue: o, field: u, minLength: e, maxLength: t })
         )
       ] : null;
     };
     super(r);
   }
 }
-class ae extends f {
-  constructor(i, t) {
-    const e = t || b('Value must match pattern "**{pattern}**"'), s = (r, a, l) => i.test(String(h(r))) ? null : [
-      new g(this.replacePlaceholders(e, { newValue: r, oldValue: a, field: l, pattern: i }))
+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(s);
+    super(i);
   }
 }
-const le = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const He = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  CompareTo: Yt,
-  InAllowedValues: Jt,
-  LengthInRange: re,
-  MaxLength: ne,
-  MaxValue: ee,
-  MinLength: se,
-  MinValue: te,
-  Pattern: ae,
-  Required: Zt,
-  Validator: f,
-  ValueInRange: ie
-}, Symbol.toStringTag, { value: "Module" })), de = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  CompareTo: ke,
+  InAllowedValues: Re,
+  LengthInRange: qe,
+  MaxLength: $e,
+  MaxValue: Me,
+  MinLength: We,
+  MinValue: Be,
+  Pattern: ze,
+  Required: Le,
+  Validator: v,
+  ValueInRange: Ue
+}, Symbol.toStringTag, { value: "Module" })), Je = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  AbortEventHandlingException: W,
-  Action: Xt,
-  ActionsMap: L,
-  ConditionalEnabledAction: Rt,
-  ConditionalStatementAction: M,
-  ConditionalValueAction: Bt,
-  ConditionalVisibilityAction: Lt,
-  DisplayMode: S,
-  EmptyField: zt,
-  EnabledChangedAction: ct,
-  EnabledChangingAction: ut,
-  ExecuteAction: ft,
-  Field: $,
-  FieldActionBase: m,
-  FieldBase: V,
-  Group: C,
-  List: Y,
-  ListItemAddedAction: z,
-  ListItemRemovedAction: pt,
-  MdString: O,
-  MessagesWidget: Gt,
-  Operator: c,
-  RenderableValue: jt,
-  Statement: N,
-  ValidChangedAction: ht,
-  ValidationError: G,
-  ValidationErrorRenderContent: g,
-  ValidationErrorText: Ft,
-  Validator: f,
-  Validators: le,
-  ValueChangedAction: y,
-  VisibilityChangedAction: gt,
-  VisibilityChangingAction: dt,
-  buildErrorMessage: b,
-  isCallableFunction: k,
-  isSimpleComponentDef: X
+  AbortEventHandlingException: Ot,
+  Action: Pe,
+  ActionsMap: H,
+  ConditionalEnabledAction: ve,
+  ConditionalStatementAction: Q,
+  ConditionalValueAction: Ve,
+  ConditionalVisibilityAction: be,
+  DisplayMode: N,
+  EmptyField: je,
+  EnabledChangedAction: Mt,
+  EnabledChangingAction: Bt,
+  ExecuteAction: qt,
+  Field: X,
+  FieldActionBase: y,
+  FieldBase: A,
+  Group: w,
+  List: D,
+  ListItemAddedAction: rt,
+  ListItemRemovedAction: zt,
+  MdString: B,
+  MessagesWidget: Ne,
+  Operator: m,
+  RenderableValue: he,
+  Statement: I,
+  ValidChangedAction: Ut,
+  ValidationError: ot,
+  ValidationErrorRenderContent: V,
+  ValidationErrorText: ce,
+  Validator: v,
+  Validators: He,
+  ValueChangedAction: O,
+  VisibilityChangedAction: $t,
+  VisibilityChangingAction: Wt,
+  buildErrorMessage: E,
+  isCallableFunction: z,
+  isSimpleComponentDef: at,
+  transaction: q
 }, Symbol.toStringTag, { value: "Module" }));
 export {
-  W as AbortEventHandlingException,
-  Xt as Action,
-  L as ActionsMap,
-  Rt as ConditionalEnabledAction,
-  M as ConditionalStatementAction,
-  Bt as ConditionalValueAction,
-  Lt as ConditionalVisibilityAction,
-  S as DisplayMode,
-  zt as EmptyField,
-  ct as EnabledChangedAction,
-  ut as EnabledChangingAction,
-  ft as ExecuteAction,
-  $ as Field,
-  m as FieldActionBase,
-  V as FieldBase,
-  C as Group,
-  Y as List,
-  z as ListItemAddedAction,
-  pt as ListItemRemovedAction,
-  O as MdString,
-  Gt as MessagesWidget,
-  c as Operator,
-  jt as RenderableValue,
-  N as Statement,
-  ht as ValidChangedAction,
-  G as ValidationError,
-  g as ValidationErrorRenderContent,
-  Ft as ValidationErrorText,
-  f as Validator,
-  le as Validators,
-  y as ValueChangedAction,
-  gt as VisibilityChangedAction,
-  dt as VisibilityChangingAction,
-  b as buildErrorMessage,
-  de as default,
-  he as forms,
-  k as isCallableFunction,
-  X as isSimpleComponentDef
+  Ot as AbortEventHandlingException,
+  Pe as Action,
+  H as ActionsMap,
+  ve as ConditionalEnabledAction,
+  Q as ConditionalStatementAction,
+  Ve as ConditionalValueAction,
+  be as ConditionalVisibilityAction,
+  N as DisplayMode,
+  je as EmptyField,
+  Mt as EnabledChangedAction,
+  Bt as EnabledChangingAction,
+  qt as ExecuteAction,
+  X as Field,
+  y as FieldActionBase,
+  A as FieldBase,
+  w as Group,
+  D as List,
+  rt as ListItemAddedAction,
+  zt as ListItemRemovedAction,
+  B as MdString,
+  Ne as MessagesWidget,
+  m as Operator,
+  he as RenderableValue,
+  I as Statement,
+  Ut as ValidChangedAction,
+  ot as ValidationError,
+  V as ValidationErrorRenderContent,
+  ce as ValidationErrorText,
+  v as Validator,
+  He as Validators,
+  O as ValueChangedAction,
+  $t as VisibilityChangedAction,
+  Wt as VisibilityChangingAction,
+  E as buildErrorMessage,
+  Je as default,
+  Ye as forms,
+  z as isCallableFunction,
+  at as isSimpleComponentDef,
+  q as transaction
 };
 //# sourceMappingURL=dynamicforms-vue-forms.js.map