@getodk/xforms-engine 0.14.0 → 0.16.0

package/dist/solid.js

@@ -7556,7 +7556,7 @@ const sn$1 = /*@__PURE__*/new WeakMap(),
     epochMilliseconds: I$1,
     epochNanoseconds: v$1
   },
-  [wn$1, In$1, vn$1] = createSlotClass$1(N$1, j$1, {
+  [wn$1, In$1] = createSlotClass$1(N$1, j$1, {
     ...gn$1,
     blank: y$1
   }, {
@@ -7641,7 +7641,7 @@ const sn$1 = /*@__PURE__*/new WeakMap(),
     from: (t, e) => En$1(toPlainDateTimeSlots$1(t, e)),
     compare: (t, e) => Yt$1(toPlainDateTimeSlots$1(t), toPlainDateTimeSlots$1(e))
   }),
-  [Ln$1, Vn$1, Jn$1] = createSlotClass$1(qt$1, Pt$1(kt$1, Mt$1), {
+  [Ln$1, Vn$1] = createSlotClass$1(qt$1, Pt$1(kt$1, Mt$1), {
     ...Pn$1,
     ...Dn$1
   }, {
@@ -7660,7 +7660,7 @@ const sn$1 = /*@__PURE__*/new WeakMap(),
   }, {
     from: (t, e) => Vn$1(toPlainMonthDaySlots$1(t, e))
   }),
-  [kn$1, qn$1, Rn$1] = createSlotClass$1(Ut$1, Pt$1(Qt$1, Mt$1), {
+  [kn$1, qn$1] = createSlotClass$1(Ut$1, Pt$1(Qt$1, Mt$1), {
     ...Pn$1,
     ...hn$1
   }, {
@@ -7684,7 +7684,7 @@ const sn$1 = /*@__PURE__*/new WeakMap(),
     from: (t, e) => qn$1(toPlainYearMonthSlots$1(t, e)),
     compare: (t, e) => te$1(toPlainYearMonthSlots$1(t), toPlainYearMonthSlots$1(e))
   }),
-  [xn$1, Wn$1, Gn$1] = createSlotClass$1(G$1, Pt$1(ue$1, Mt$1), {
+  [xn$1, Wn$1] = createSlotClass$1(G$1, Pt$1(ue$1, Mt$1), {
     ...Pn$1,
     ...Tn$1
   }, {
@@ -7767,7 +7767,7 @@ const sn$1 = /*@__PURE__*/new WeakMap(),
     from: (t, e) => $n$1(toZonedDateTimeSlots$1(t, e)),
     compare: (t, e) => Be$1(toZonedDateTimeSlots$1(t), toZonedDateTimeSlots$1(e))
   }),
-  [Hn$1, Kn$1, Qn$1] = createSlotClass$1(Re$1, qe$1, On$1, {
+  [Hn$1, Kn$1] = createSlotClass$1(Re$1, qe$1, On$1, {
     add: (t, e) => Kn$1(Ye$1(0, t, toDurationSlots$1(e))),
     subtract: (t, e) => Kn$1(Ye$1(1, t, toDurationSlots$1(e))),
     until: (t, e, n) => In$1(Ee$1(0, t, toInstantSlots$1(e), n)),
@@ -19301,6 +19301,12 @@ class XFormDOM {
         contextNode: model
       }
     );
+    const setValues = evaluator.evaluateNodes(
+      "./xf:setvalue[@event]",
+      {
+        contextNode: model
+      }
+    );
     const instances = evaluator.evaluateNodes("./xf:instance", {
       contextNode: model
     });
@@ -19336,6 +19342,7 @@ class XFormDOM {
     this.title = title;
     this.model = model;
     this.binds = binds;
+    this.setValues = setValues;
     this.primaryInstance = primaryInstance;
     this.primaryInstanceRoot = primaryInstanceRoot;
     this.itextTranslationElements = itextTranslationElements;
@@ -19353,6 +19360,7 @@ class XFormDOM {
   title;
   model;
   binds;
+  setValues;
   primaryInstance;
   primaryInstanceRoot;
   itextTranslationElements;
@@ -20193,6 +20201,27 @@ class ControlDefinition extends BodyElementDefinition {
   }
 }
 
+const parseToInteger = (value) => {
+  if (value === null) {
+    return null;
+  }
+  const parsed = Number(value);
+  if (typeof value !== "string" || value.trim() === "" || !Number.isInteger(parsed)) {
+    throw new Error(`Expected an integer, but got: ${value}`);
+  }
+  return parsed;
+};
+const parseToFloat = (value) => {
+  if (value === null) {
+    return null;
+  }
+  const parsed = Number(value);
+  if (typeof value !== "string" || value.trim() === "" || Number.isNaN(parsed)) {
+    throw new Error(`Expected a float, but got: ${value}`);
+  }
+  return parsed;
+};
+
 const inputAppearanceParser = new TokenListParser([
   "multiline",
   "numbers",
@@ -20226,27 +20255,6 @@ const inputAppearanceParser = new TokenListParser([
   "masked"
 ]);
 
-const parseToInteger = (value) => {
-  if (value === null) {
-    return null;
-  }
-  const parsed = Number(value);
-  if (typeof value !== "string" || value.trim() === "" || !Number.isInteger(parsed)) {
-    throw new Error(`Expected an integer, but got: ${value}`);
-  }
-  return parsed;
-};
-const parseToFloat = (value) => {
-  if (value === null) {
-    return null;
-  }
-  const parsed = Number(value);
-  if (typeof value !== "string" || value.trim() === "" || Number.isNaN(parsed)) {
-    throw new Error(`Expected a float, but got: ${value}`);
-  }
-  return parsed;
-};
-
 class InputControlDefinition extends ControlDefinition {
   static isCompatible(localName) {
     return localName === "input";
@@ -20623,8 +20631,8 @@ class GroupElementDefinition extends BodyElementDefinition {
       const childName = child.localName;
       return childName !== "label";
     });
-    this.children = this.body.getChildElementDefinitions(form, this, element, childElements);
     this.reference = parseNodesetReference(parent, element, "ref");
+    this.children = this.body.getChildElementDefinitions(form, this, element, childElements);
     this.appearances = structureElementAppearanceParser.parseFrom(element, "appearance");
     this.label = LabelDefinition.forGroup(form, this);
   }
@@ -21230,6 +21238,105 @@ class ItextTranslationsDefinition extends Map {
   }
 }
 
+class ActionComputationExpression extends DependentExpression {
+  constructor(resultType, expression) {
+    super(resultType, expression);
+  }
+}
+
+const XFORM_EVENT = {
+  odkInstanceLoad: "odk-instance-load",
+  odkInstanceFirstLoad: "odk-instance-first-load",
+  odkNewRepeat: "odk-new-repeat",
+  xformsRevalidate: "xforms-revalidate",
+  xformsValueChanged: "xforms-value-changed"
+};
+
+class ActionDefinition {
+  constructor(model, element, source) {
+    this.element = element;
+    const ref = ActionDefinition.getRef(model, element);
+    if (!ref) {
+      throw new Error(
+        'Invalid setvalue element - you must define either "ref" or "bind" attribute'
+      );
+    }
+    this.ref = ref;
+    this.events = ActionDefinition.getEvents(element);
+    const value = ActionDefinition.getValue(element);
+    this.computation = new ActionComputationExpression("string", value);
+    this.source = source;
+  }
+  static getRef(model, setValueElement) {
+    if (setValueElement.hasAttribute("ref")) {
+      return setValueElement.getAttribute("ref") ?? null;
+    }
+    if (setValueElement.hasAttribute("bind")) {
+      const bindId = setValueElement.getAttribute("bind");
+      const bindDefinition = Array.from(model.binds.values()).find((definition) => {
+        return definition.bindElement.getAttribute("id") === bindId;
+      });
+      return bindDefinition?.nodeset ?? null;
+    }
+    return null;
+  }
+  static getValue(element) {
+    if (element.hasAttribute("value")) {
+      return element.getAttribute("value") || "''";
+    }
+    if (element.firstChild && isTextNode(element.firstChild)) {
+      return `'${element.firstChild.nodeValue}'`;
+    }
+    return "''";
+  }
+  static isKnownEvent = (event) => {
+    return Object.values(XFORM_EVENT).includes(event);
+  };
+  static getEvents(element) {
+    const events = element.getAttribute("event")?.split(" ") ?? [];
+    const unknownEvents = events.filter((event) => !this.isKnownEvent(event));
+    if (unknownEvents.length) {
+      throw new Error(
+        `An action was registered for unsupported events: ${unknownEvents.join(", ")}`
+      );
+    }
+    return events;
+  }
+  ref;
+  events;
+  computation;
+  source;
+}
+
+const REPEAT_REGEX = /(\[[^\]]*\])/gm;
+class ModelActionMap extends Map {
+  static fromModel(model) {
+    return new this(model);
+  }
+  static getKey(ref) {
+    return ref.replace(REPEAT_REGEX, "");
+  }
+  constructor(model) {
+    super(
+      model.form.xformDOM.setValues.map((setValueElement) => {
+        const action = new ActionDefinition(model, setValueElement);
+        if (action.events.includes(XFORM_EVENT.odkNewRepeat)) {
+          throw new Error('Model contains "setvalue" element with "odk-new-repeat" event');
+        }
+        const key = ModelActionMap.getKey(action.ref);
+        return [key, action];
+      })
+    );
+  }
+  get(ref) {
+    return super.get(ModelActionMap.getKey(ref));
+  }
+  add(action) {
+    const key = ModelActionMap.getKey(action.ref);
+    this.set(key, action);
+  }
+}
+
 const defaultBindComputationExpressions = {
   calculate: null,
   constraint: "true()",
@@ -21295,6 +21402,7 @@ class MessageDefinition extends TextRangeDefinition {
   chunks;
 }
 
+const PRELOAD_UID_EXPRESSION = 'concat("uuid:", uuid())';
 const getPreloadInput = (bindElement) => {
   const type = bindElement.getAttributeNS(JAVAROSA_NAMESPACE_URI$1, "preload");
   if (type == null) {
@@ -21319,9 +21427,38 @@ class BindPreloadDefinition {
   }
   type;
   parameter;
+  event;
+  getValue(context) {
+    if (this.type === "uid") {
+      return context.evaluator.evaluateString(PRELOAD_UID_EXPRESSION);
+    }
+    if (this.type === "timestamp") {
+      return context.evaluator.evaluateString("now()");
+    }
+    if (this.type === "date") {
+      return context.evaluator.evaluateString("today()");
+    }
+    if (this.type === "property") {
+      const properties = context.instanceConfig.preloadProperties;
+      if (this.parameter === "deviceid") {
+        return properties.deviceID;
+      }
+      if (this.parameter === "email") {
+        return properties.email;
+      }
+      if (this.parameter === "phonenumber") {
+        return properties.phoneNumber;
+      }
+      if (this.parameter === "username") {
+        return properties.username;
+      }
+    }
+    return;
+  }
   constructor(input) {
     this.type = input.type;
     this.parameter = input.parameter;
+    this.event = this.type === "timestamp" && this.parameter === "end" ? XFORM_EVENT.xformsRevalidate : XFORM_EVENT.odkInstanceFirstLoad;
   }
 }
 
@@ -21468,10 +21605,7 @@ class BindDefinition extends DependencyContext {
   // TODO: it is unclear whether this will need to be supported.
   // https://github.com/getodk/collect/issues/3758 mentions deprecation.
   saveIncomplete;
-  // TODO: these are deferred until prioritized
-  // readonly preload: string | null;
-  // readonly preloadParams: string | null;
-  // readonly 'max-pixels': string | null;
+  // TODO: deferred until prioritized: readonly 'max-pixels': string | null;
   _parentBind;
   get parentBind() {
     let bind = this._parentBind;
@@ -21557,7 +21691,7 @@ const collectDefinitions = (result, definition) => {
     throw new ErrorProductionDesignPendingError();
   }
   result.set(nodeset, definition);
-  if (definition.type === "leaf-node") {
+  if (definition.type === "leaf-node" || definition.type === "attribute") {
     return result;
   }
   for (const child of definition.children) {
@@ -21612,33 +21746,39 @@ const serializeElementNamespaceDeclarationXML = (namespaceDeclarations) => {
     });
   }).join("");
 };
-const serializeElementAttributeXML = (attributes) => {
-  if (attributes == null) {
-    return "";
-  }
-  return attributes.map((attribute) => {
-    return attribute.serializeAttributeXML();
-  }).join("");
-};
-const serializeElementXML = (qualifiedName, children, options = {}) => {
+const serializeElementXML = (qualifiedName, children, attributes, namespaceDeclarations) => {
   const nodeName = qualifiedName.getPrefixedName(
     // options.namespaceDeclarations
   );
-  const namespaceDeclarations = serializeElementNamespaceDeclarationXML(
-    options.namespaceDeclarations
-  );
-  const attributes = serializeElementAttributeXML(options.attributes);
-  const prefix = `<${nodeName}${namespaceDeclarations}${attributes}`;
+  const serializedNamespaceDeclarations = serializeElementNamespaceDeclarationXML(namespaceDeclarations);
+  const prefix = `<${nodeName}${serializedNamespaceDeclarations}${attributes}`;
   if (children === "") {
     return `${prefix}/>`;
   }
   return `${prefix}>${children}</${nodeName}>`;
 };
-const serializeParentElementXML = (qualifiedName, serializedChildren, options) => {
-  return serializeElementXML(qualifiedName, serializedChildren.join(""), options);
+const serializeAttributeXML = (qualifiedName, xmlValue) => {
+  const nodeName = qualifiedName.getPrefixedName();
+  return ` ${nodeName}="${xmlValue.normalize()}"`;
+};
+const serializeParentElementXML = (qualifiedName, children, attributes, namespaceDeclarations) => {
+  const serializedChildren = children.map((child) => child.instanceState.instanceXML).join("");
+  const serializedAttributes = attributes.map((attribute) => attribute.instanceState.instanceXML).join("");
+  return serializeElementXML(
+    qualifiedName,
+    serializedChildren,
+    serializedAttributes,
+    namespaceDeclarations
+  );
 };
-const serializeLeafElementXML = (qualifiedName, xmlValue, options) => {
-  return serializeElementXML(qualifiedName, xmlValue.normalize(), options);
+const serializeLeafElementXML = (qualifiedName, xmlValue, attributes, namespaceDeclarations) => {
+  const serializedAttributes = attributes?.map((attribute) => attribute.instanceState.instanceXML).join("") ?? "";
+  return serializeElementXML(
+    qualifiedName,
+    xmlValue.normalize(),
+    serializedAttributes,
+    namespaceDeclarations
+  );
 };
 
 class NamespaceDeclaration {
@@ -21867,6 +22007,60 @@ class NodeDefinition {
   nodeset;
 }
 
+class AttributeDefinition extends NodeDefinition {
+  constructor(model, bind, template) {
+    super(bind);
+    this.model = model;
+    this.template = template;
+    const { value } = template;
+    this.root = model.root;
+    this.value = value;
+    this.qualifiedName = template.qualifiedName;
+    this.namespaceDeclarations = new NamespaceDeclarationMap(this);
+    if (this.qualifiedName.namespaceURI?.href === XMLNS_NAMESPACE_URI$1) {
+      this.serializedXML = "";
+    } else {
+      const xmlValue = escapeXMLText(this.value, true);
+      this.serializedXML = serializeAttributeXML(this.qualifiedName, xmlValue);
+    }
+  }
+  serializedXML;
+  value;
+  type = "attribute";
+  namespaceDeclarations;
+  bodyElement = null;
+  root;
+  isTranslated = false;
+  parent = null;
+  children = null;
+  attributes = null;
+  qualifiedName;
+  serializeAttributeXML() {
+    return this.serializedXML;
+  }
+}
+
+const isNonNamespaceAttribute = (attribute) => {
+  return attribute.qualifiedName.namespaceURI?.href !== XMLNS_NAMESPACE_URI$1;
+};
+class AttributeDefinitionMap extends Map {
+  static from(model, instanceNode) {
+    const nonNamespaceAttributes = instanceNode.attributes.filter(isNonNamespaceAttribute);
+    const definitions = nonNamespaceAttributes.map((attribute) => {
+      const bind = model.binds.getOrCreateBindDefinition(attribute.nodeset);
+      return new AttributeDefinition(model, bind, attribute);
+    });
+    return new this(definitions);
+  }
+  constructor(definitions) {
+    super(
+      definitions.map((attribute) => {
+        return [attribute.qualifiedName, attribute];
+      })
+    );
+  }
+}
+
 class DescendentNodeDefinition extends NodeDefinition {
   constructor(parent, bind, bodyElement) {
     super(bind);
@@ -21882,7 +22076,7 @@ class DescendentNodeDefinition extends NodeDefinition {
 }
 
 class GroupDefinition extends DescendentNodeDefinition {
-  constructor(parent, bind, bodyElement, template) {
+  constructor(model, parent, bind, bodyElement, template) {
     if (bodyElement != null && (bodyElement.category !== "structure" || bodyElement.type === "repeat")) {
       throw new Error(`Unexpected body element for nodeset ${bind.nodeset}`);
     }
@@ -21892,11 +22086,13 @@ class GroupDefinition extends DescendentNodeDefinition {
     this.qualifiedName = template.qualifiedName;
     this.namespaceDeclarations = new NamespaceDeclarationMap(this);
     this.children = root.buildSubtree(this, template);
+    this.attributes = AttributeDefinitionMap.from(model, template);
   }
   type = "group";
   namespaceDeclarations;
   qualifiedName;
   children;
+  attributes;
   toJSON() {
     const { parent, bodyElement, bind, root, ...rest } = this;
     return rest;
@@ -21904,21 +22100,24 @@ class GroupDefinition extends DescendentNodeDefinition {
 }
 
 class LeafNodeDefinition extends DescendentNodeDefinition {
-  constructor(parent, bind, bodyElement, template) {
+  constructor(model, parent, bind, bodyElement, template) {
     if (bodyElement != null && bodyElement.category !== "control") {
       throw new Error(`Unexpected body element for nodeset ${bind.nodeset}`);
     }
     super(parent, bind, bodyElement);
+    this.model = model;
     this.template = template;
     this.valueType = bind.type.resolved;
     this.qualifiedName = template.qualifiedName;
     this.namespaceDeclarations = new NamespaceDeclarationMap(this);
+    this.attributes = AttributeDefinitionMap.from(model, template);
   }
   type = "leaf-node";
   valueType;
   namespaceDeclarations;
   qualifiedName;
   children = null;
+  attributes;
   toJSON() {
     const { bind, bodyElement, parent, root, ...rest } = this;
     return rest;
@@ -21929,13 +22128,13 @@ const isNoteBindDefinition = (bind) => {
   return bind.readonly.isConstantTruthyExpression();
 };
 class NoteNodeDefinition extends LeafNodeDefinition {
-  constructor(parent, bind, bodyElement, noteTextDefinition, template) {
-    super(parent, bind, bodyElement, template);
+  constructor(model, parent, bind, bodyElement, noteTextDefinition, template) {
+    super(model, parent, bind, bodyElement, template);
     this.bind = bind;
     this.bodyElement = bodyElement;
     this.noteTextDefinition = noteTextDefinition;
   }
-  static from(parent, bind, bodyElement, node) {
+  static from(model, parent, bind, bodyElement, node) {
     if (!isNoteBindDefinition(bind) || bodyElement?.type !== "input") {
       return null;
     }
@@ -21944,7 +22143,7 @@ class NoteNodeDefinition extends LeafNodeDefinition {
     if (noteTextDefinition == null) {
       return null;
     }
-    return new this(parent, bind, bodyElement, noteTextDefinition, node);
+    return new this(model, parent, bind, bodyElement, noteTextDefinition, node);
   }
 }
 
@@ -25575,7 +25774,7 @@ const sn = /*@__PURE__*/ new WeakMap, cn = /*@__PURE__*/ sn.get.bind(sn), un = /
 }, gn = /*@__PURE__*/ g((t => e => e[t]), p.concat("sign")), pn = /*@__PURE__*/ g(((t, e) => t => t[w[e]]), O), On = {
   epochMilliseconds: I,
   epochNanoseconds: v
-}, [wn, In, vn] = createSlotClass(N, j, {
+}, [wn, In] = createSlotClass(N, j, {
   ...gn,
   blank: y
 }, {
@@ -25649,7 +25848,7 @@ const sn = /*@__PURE__*/ new WeakMap, cn = /*@__PURE__*/ sn.get.bind(sn), un = /
 }, {
   from: (t, e) => En(toPlainDateTimeSlots(t, e)),
   compare: (t, e) => Yt(toPlainDateTimeSlots(t), toPlainDateTimeSlots(e))
-}), [Ln, Vn, Jn] = createSlotClass(qt, Pt(kt, Mt), {
+}), [Ln, Vn] = createSlotClass(qt, Pt(kt, Mt), {
   ...Pn,
   ...Dn
 }, {
@@ -25667,7 +25866,7 @@ const sn = /*@__PURE__*/ new WeakMap, cn = /*@__PURE__*/ sn.get.bind(sn), un = /
   valueOf: neverValueOf
 }, {
   from: (t, e) => Vn(toPlainMonthDaySlots(t, e))
-}), [kn, qn, Rn] = createSlotClass(Ut, Pt(Qt, Mt), {
+}), [kn, qn] = createSlotClass(Ut, Pt(Qt, Mt), {
   ...Pn,
   ...hn
 }, {
@@ -25690,7 +25889,7 @@ const sn = /*@__PURE__*/ new WeakMap, cn = /*@__PURE__*/ sn.get.bind(sn), un = /
 }, {
   from: (t, e) => qn(toPlainYearMonthSlots(t, e)),
   compare: (t, e) => te(toPlainYearMonthSlots(t), toPlainYearMonthSlots(e))
-}), [xn, Wn, Gn] = createSlotClass(G, Pt(ue, Mt), {
+}), [xn, Wn] = createSlotClass(G, Pt(ue, Mt), {
   ...Pn,
   ...Tn
 }, {
@@ -25766,7 +25965,7 @@ const sn = /*@__PURE__*/ new WeakMap, cn = /*@__PURE__*/ sn.get.bind(sn), un = /
 }, {
   from: (t, e) => $n(toZonedDateTimeSlots(t, e)),
   compare: (t, e) => Be(toZonedDateTimeSlots(t), toZonedDateTimeSlots(e))
-}), [Hn, Kn, Qn] = createSlotClass(Re, qe, On, {
+}), [Hn, Kn] = createSlotClass(Re, qe, On, {
   add: (t, e) => Kn(Ye(0, t, toDurationSlots(e))),
   subtract: (t, e) => Kn(Ye(1, t, toDurationSlots(e))),
   until: (t, e, n) => In(Ee(0, t, toInstantSlots(e), n)),
@@ -26155,15 +26354,15 @@ class RangeNodeBoundsDefinition {
   }
 }
 class RangeNodeDefinition extends LeafNodeDefinition {
-  constructor(parent, bind, bodyElement, node) {
-    super(parent, bind, bodyElement, node);
+  constructor(model, parent, bind, bodyElement, node) {
+    super(model, parent, bind, bodyElement, node);
     this.bind = bind;
     this.bodyElement = bodyElement;
     this.bounds = RangeNodeBoundsDefinition.from(bodyElement.bounds, bind);
   }
-  static from(parent, bind, bodyElement, node) {
+  static from(model, parent, bind, bodyElement, node) {
     assertRangeBindDefinition(bind);
-    return new this(parent, bind, bodyElement, node);
+    return new this(model, parent, bind, bodyElement, node);
   }
   bounds;
 }
@@ -26228,8 +26427,8 @@ const parseRepeatTemplateElement = (firstRepeatInstanceNode) => {
   return cloneStaticElementStructure(firstRepeatInstanceNode);
 };
 class RepeatDefinition extends DescendentNodeDefinition {
-  static from(parent, bind, bodyElement, instanceNodes) {
-    return new this(parent, bind, bodyElement, instanceNodes);
+  static from(model, parent, bind, bodyElement, instanceNodes) {
+    return new this(model, parent, bind, bodyElement, instanceNodes);
   }
   type = "repeat";
   children;
@@ -26237,7 +26436,8 @@ class RepeatDefinition extends DescendentNodeDefinition {
   template;
   namespaceDeclarations;
   qualifiedName;
-  constructor(parent, bind, bodyElement, instanceNodes) {
+  attributes;
+  constructor(model, parent, bind, bodyElement, instanceNodes) {
     super(parent, bind, bodyElement);
     const { root } = parent;
     const [instanceNode] = instanceNodes;
@@ -26248,6 +26448,7 @@ class RepeatDefinition extends DescendentNodeDefinition {
     this.namespaceDeclarations = new NamespaceDeclarationMap(this);
     this.children = root.buildSubtree(self, template);
     const initialCount = this.omitTemplate(instanceNodes).length;
+    this.attributes = AttributeDefinitionMap.from(model, template);
     this.count = RepeatCountControlExpression.from(bodyElement, initialCount);
   }
   isControlled() {
@@ -26266,48 +26467,6 @@ class RepeatDefinition extends DescendentNodeDefinition {
   }
 }
 
-class RootAttributeDefinition {
-  serializedXML;
-  parent;
-  qualifiedName;
-  value;
-  constructor(root, source) {
-    const { qualifiedName, value } = source;
-    this.parent = root;
-    this.qualifiedName = qualifiedName;
-    this.value = value;
-    if (qualifiedName.namespaceURI?.href === XMLNS_NAMESPACE_URI$1) {
-      this.serializedXML = "";
-    } else {
-      const nodeName = qualifiedName.getPrefixedName();
-      this.serializedXML = ` ${nodeName}="${escapeXMLText(value, true)}"`;
-    }
-  }
-  serializeAttributeXML() {
-    return this.serializedXML;
-  }
-}
-
-const isNonNamespaceAttribute = (attribute) => {
-  return attribute.qualifiedName.namespaceURI?.href !== XMLNS_NAMESPACE_URI$1;
-};
-class RootAttributeMap extends Map {
-  static from(root, instanceNode) {
-    const nonNamespaceAttributes = instanceNode.attributes.filter(isNonNamespaceAttribute);
-    const definitions = nonNamespaceAttributes.map((attribute) => {
-      return new RootAttributeDefinition(root, attribute);
-    });
-    return new this(definitions);
-  }
-  constructor(definitions) {
-    super(
-      definitions.map((attribute) => {
-        return [attribute.qualifiedName, attribute];
-      })
-    );
-  }
-}
-
 class RootDefinition extends NodeDefinition {
   constructor(form, model, submission, classes) {
     const template = model.instance.root;
@@ -26325,7 +26484,7 @@ class RootDefinition extends NodeDefinition {
     this.classes = classes;
     this.qualifiedName = qualifiedName;
     this.template = template;
-    this.attributes = RootAttributeMap.from(this, template);
+    this.attributes = AttributeDefinitionMap.from(model, template);
     this.namespaceDeclarations = new NamespaceDeclarationMap(this);
     this.children = this.buildSubtree(this, template);
   }
@@ -26339,6 +26498,18 @@ class RootDefinition extends NodeDefinition {
   attributes;
   children;
   isTranslated = false;
+  mapActions(bodyElement) {
+    const source = bodyElement.reference;
+    if (!source) {
+      return;
+    }
+    for (const child of bodyElement.element.children) {
+      if (child.nodeName === "setvalue") {
+        const action = new ActionDefinition(this.model, child, source);
+        this.model.actions.add(action);
+      }
+    }
+  }
   buildSubtree(parent, node) {
     const { form, model } = this;
     const { body } = form;
@@ -26361,8 +26532,11 @@ class RootDefinition extends NodeDefinition {
       const bind = binds.getOrCreateBindDefinition(nodeset);
       const bodyElement = body.getBodyElement(nodeset);
       const [firstChild, ...restChildren] = children;
+      if (bodyElement) {
+        this.mapActions(bodyElement);
+      }
       if (bodyElement?.type === "repeat") {
-        return RepeatDefinition.from(parent, bind, bodyElement, children);
+        return RepeatDefinition.from(model, parent, bind, bodyElement, children);
       }
       if (restChildren.length) {
         throw new Error(`Unexpected: multiple elements for non-repeat nodeset: ${nodeset}`);
@@ -26370,11 +26544,11 @@ class RootDefinition extends NodeDefinition {
       const element = firstChild;
       if (element.isLeafElement()) {
         if (bodyElement?.type === "range") {
-          return RangeNodeDefinition.from(parent, bind, bodyElement, element);
+          return RangeNodeDefinition.from(model, parent, bind, bodyElement, element);
         }
-        return NoteNodeDefinition.from(parent, bind, bodyElement, element) ?? new LeafNodeDefinition(parent, bind, bodyElement, element);
+        return NoteNodeDefinition.from(model, parent, bind, bodyElement, element) ?? new LeafNodeDefinition(model, parent, bind, bodyElement, element);
       }
-      return new GroupDefinition(parent, bind, bodyElement, element);
+      return new GroupDefinition(model, parent, bind, bodyElement, element);
     });
   }
   toJSON() {
@@ -26420,6 +26594,7 @@ class ModelDefinition {
     this.form = form;
     const submission = new SubmissionDefinition(form.xformDOM);
     this.binds = ModelBindMap.fromModel(this);
+    this.actions = ModelActionMap.fromModel(this);
     this.instance = parseStaticDocumentFromDOMSubtree(form.xformDOM.primaryInstanceRoot, {
       nodesetPrefix: "/"
     });
@@ -26427,13 +26602,16 @@ class ModelDefinition {
     this.nodes = nodeDefinitionMap(this.root);
     this.itextTranslations = ItextTranslationsDefinition.from(form.xformDOM);
     this.itextChunks = generateItextChunks(form.xformDOM.itextTranslationElements);
+    this.xformsRevalidateListeners = /* @__PURE__ */ new Map();
   }
   binds;
+  actions;
   root;
   nodes;
   instance;
   itextTranslations;
   itextChunks;
+  xformsRevalidateListeners;
   getNodeDefinition(nodeset) {
     const definition = this.nodes.get(nodeset);
     if (definition == null) {
@@ -26448,14 +26626,20 @@ class ModelDefinition {
     }
     return definition;
   }
-  toJSON() {
-    const { form, ...rest } = this;
-    return rest;
+  registerXformsRevalidateListener(ref, listener) {
+    this.xformsRevalidateListeners.set(ref, listener);
+  }
+  triggerXformsRevalidateListeners() {
+    this.xformsRevalidateListeners.forEach((listener) => listener());
   }
   getTranslationChunks(itextId, activeLanguage) {
     const languageMap = this.itextChunks.get(activeLanguage.language);
     return languageMap?.get(itextId) ?? [];
   }
+  toJSON() {
+    const { form, ...rest } = this;
+    return rest;
+  }
 }
 
 class XFormDefinition {
@@ -28519,6 +28703,7 @@ const chunkedInstancePayload = (validation, submissionMeta, instanceFile, attach
   };
 };
 const prepareInstancePayload = (instanceRoot, options) => {
+  instanceRoot.root.parent.model.triggerXformsRevalidateListeners();
   const validation = validateInstance(instanceRoot);
   const submissionMeta = instanceRoot.definition.submission;
   const instanceFile = new InstanceFile(instanceRoot);
@@ -28544,6 +28729,30 @@ const prepareInstancePayload = (instanceRoot, options) => {
   }
 };
 
+const createAttributeState = (scope) => {
+  return scope.runTask(() => {
+    const baseState = createSignal([]);
+    const [getAttributes, baseSetAttributes] = baseState;
+    const setAttributes = (valueOrSetterCallback) => {
+      let setterCallback;
+      if (typeof valueOrSetterCallback === "function") {
+        setterCallback = valueOrSetterCallback;
+      } else {
+        setterCallback = (_) => valueOrSetterCallback;
+      }
+      return baseSetAttributes((prev) => {
+        return setterCallback(prev);
+      });
+    };
+    const attributes = [getAttributes, setAttributes];
+    return {
+      attributes,
+      getAttributes,
+      setAttributes
+    };
+  });
+};
+
 const createChildrenState = (parent) => {
   return parent.scope.runTask(() => {
     const baseState = createSignal([]);
@@ -28856,83 +29065,16 @@ class InstanceNode {
   }
 }
 
-class InstanceAttachmentsState extends Map {
-  constructor(sourceAttachments = null) {
-    super();
-    this.sourceAttachments = sourceAttachments;
-  }
-  getInitialFileValue(instanceNode) {
-    if (instanceNode == null) {
-      return null;
-    }
-    return this.sourceAttachments?.get(instanceNode.value) ?? null;
-  }
-}
-
-const createRootInstanceState = (node) => {
+const createAttributeNodeInstanceState = (node) => {
+  const { qualifiedName } = node.definition;
   return {
     get instanceXML() {
-      const { namespaceDeclarations, attributes } = node.definition;
-      const serializedChildren = node.currentState.children.map((child) => {
-        return child.instanceState.instanceXML;
-      });
-      return serializeParentElementXML(node.definition.qualifiedName, serializedChildren, {
-        namespaceDeclarations,
-        attributes: Array.from(attributes.values())
-      });
+      const xmlValue = escapeXMLText(node.currentState.instanceValue, true);
+      return serializeAttributeXML(qualifiedName, xmlValue);
     }
   };
 };
 
-const violationReference = (node) => {
-  const violation = node.getViolation();
-  if (violation == null) {
-    return null;
-  }
-  const { nodeId } = node;
-  return {
-    nodeId,
-    get reference() {
-      return node.currentState.reference;
-    },
-    violation
-  };
-};
-const collectViolationReferences = (context) => {
-  return context.getChildren().flatMap((child) => {
-    switch (child.nodeType) {
-      case "model-value":
-      case "input":
-      case "note":
-      case "select":
-      case "range":
-      case "rank":
-      case "trigger":
-      case "upload": {
-        const reference = violationReference(child);
-        if (reference == null) {
-          return [];
-        }
-        return [reference];
-      }
-      default:
-        return collectViolationReferences(child);
-    }
-  });
-};
-const createAggregatedViolations = (context, options) => {
-  const { scope } = context;
-  return scope.runTask(() => {
-    const violations = createMemo(() => {
-      return collectViolationReferences(context);
-    });
-    const spec = { violations };
-    return createSharedNodeState(scope, spec, options).currentState;
-  });
-};
-
-const XFORMS_XPATH_NODE_RANGE_KIND = "comment";
-
 const expressionEvaluator = (evaluator, type, expression, options) => {
   switch (type) {
     case "boolean":
@@ -28990,6 +29132,347 @@ const createComputedExpression = (context, dependentExpression, options = {}) =>
   });
 };
 
+const REPEAT_INDEX_REGEX = /([^[]*)(\[[0-9]+\])/g;
+const isInstanceFirstLoad = (context) => {
+  return context.rootDocument.initializationMode === "create";
+};
+const isAddingRepeatChild = (context) => {
+  return context.rootDocument.isAttached();
+};
+const isEditInitialLoad = (context) => {
+  return context.rootDocument.initializationMode === "edit";
+};
+const getInitialValue = (context) => {
+  const sourceNode = context.instanceNode ?? context.definition.template;
+  return context.decodeInstanceValue(sourceNode.value);
+};
+const createRelevantValueState = (context, baseValueState) => {
+  return context.scope.runTask(() => {
+    const [getRelevantValue, setValue] = baseValueState;
+    const getValue = createMemo(() => {
+      if (context.isRelevant()) {
+        return getRelevantValue();
+      }
+      return "";
+    });
+    return [getValue, setValue];
+  });
+};
+const guardDownstreamReadonlyWrites = (context, baseState) => {
+  const { readonly } = context.definition.bind;
+  if (readonly.isDefaultExpression) {
+    return baseState;
+  }
+  const [getValue, baseSetValue] = baseState;
+  const setValue = (value) => {
+    if (context.isReadonly()) {
+      const reference = untrack(() => context.contextReference());
+      throw new Error(`Cannot write to readonly field: ${reference}`);
+    }
+    return baseSetValue(value);
+  };
+  return [getValue, setValue];
+};
+const isLoading = (context) => {
+  return isInstanceFirstLoad(context) || isEditInitialLoad(context);
+};
+const setValueIfPreloadDefined = (context, setValue, preload) => {
+  const value = preload.getValue(context);
+  if (value) {
+    setValue(value);
+  }
+};
+const postloadValue = (context, setValue, preload) => {
+  const ref = context.contextReference();
+  context.definition.model.registerXformsRevalidateListener(ref, () => {
+    setValueIfPreloadDefined(context, setValue, preload);
+  });
+};
+const preloadValue = (context, setValue) => {
+  const { preload } = context.definition.bind;
+  if (!preload) {
+    return;
+  }
+  if (preload.event === XFORM_EVENT.xformsRevalidate) {
+    postloadValue(context, setValue, preload);
+    return;
+  }
+  if (isLoading(context)) {
+    setValueIfPreloadDefined(context, setValue, preload);
+  }
+};
+const referencesCurrentNode = (context, ref) => {
+  const nodes = context.evaluator.evaluateNodes(ref, {
+    contextNode: context.contextNode
+  });
+  if (nodes.length > 1) {
+    throw new Error(
+      "You are trying to target a repeated field. Currently you may only target a field in a specific repeat instance. XPath nodeset has more than one node."
+    );
+  }
+  return nodes.includes(context.contextNode);
+};
+const bindToRepeatInstance = (context, action) => {
+  let source = action.source;
+  let ref = action.ref;
+  if (source) {
+    const contextRef = context.contextReference();
+    for (const part of contextRef.matchAll(REPEAT_INDEX_REGEX)) {
+      const unbound = part[1] + "/";
+      if (source.includes(unbound)) {
+        const bound = part[0] + "/";
+        source = source.replace(unbound, bound);
+        ref = ref.replace(unbound, bound);
+      }
+    }
+  }
+  return { source, ref };
+};
+const createCalculation = (context, setRelevantValue, computation) => {
+  const calculate = createComputedExpression(context, computation);
+  createComputed(() => {
+    if (context.isAttached() && context.isRelevant()) {
+      const calculated = calculate();
+      const value = context.decodeInstanceValue(calculated);
+      setRelevantValue(value);
+    }
+  });
+};
+const createValueChangedCalculation = (context, setRelevantValue, action) => {
+  const { source, ref } = bindToRepeatInstance(context, action);
+  if (!source) {
+    return;
+  }
+  let previous = "";
+  const sourceElementExpression = new ActionComputationExpression("string", source);
+  const calculateValueSource = createComputedExpression(context, sourceElementExpression);
+  createComputed(() => {
+    if (context.isAttached() && context.isRelevant()) {
+      const valueSource = calculateValueSource();
+      if (previous !== valueSource) {
+        if (referencesCurrentNode(context, ref)) {
+          const calc = context.evaluator.evaluateString(action.computation.expression, context);
+          const value = context.decodeInstanceValue(calc);
+          setRelevantValue(value);
+        }
+      }
+      previous = valueSource;
+    }
+  });
+};
+const registerAction = (context, setValue, action) => {
+  if (action.events.includes(XFORM_EVENT.odkInstanceFirstLoad)) {
+    if (isInstanceFirstLoad(context)) {
+      createCalculation(context, setValue, action.computation);
+    }
+  }
+  if (action.events.includes(XFORM_EVENT.odkInstanceLoad)) {
+    if (!isAddingRepeatChild(context)) {
+      createCalculation(context, setValue, action.computation);
+    }
+  }
+  if (action.events.includes(XFORM_EVENT.odkNewRepeat)) {
+    if (isAddingRepeatChild(context)) {
+      createCalculation(context, setValue, action.computation);
+    }
+  }
+  if (action.events.includes(XFORM_EVENT.xformsValueChanged)) {
+    createValueChangedCalculation(context, setValue, action);
+  }
+};
+const createInstanceValueState = (context) => {
+  return context.scope.runTask(() => {
+    const initialValue = getInitialValue(context);
+    const baseValueState = createSignal(initialValue);
+    const relevantValueState = createRelevantValueState(context, baseValueState);
+    const [, setValue] = relevantValueState;
+    preloadValue(context, setValue);
+    const { calculate } = context.definition.bind;
+    if (calculate != null) {
+      createCalculation(context, setValue, calculate);
+    }
+    const action = context.definition.model.actions.get(context.contextReference());
+    if (action) {
+      registerAction(context, setValue, action);
+    }
+    return guardDownstreamReadonlyWrites(context, relevantValueState);
+  });
+};
+
+class Attribute {
+  constructor(owner, definition, instanceNode) {
+    this.owner = owner;
+    this.definition = definition;
+    this.instanceNode = instanceNode;
+    const codec = getSharedValueCodec("string");
+    this.contextNode = owner;
+    this.scope = owner.scope;
+    this.rootDocument = owner.rootDocument;
+    this.root = owner.root;
+    this.instanceConfig = owner.instanceConfig;
+    this.getActiveLanguage = owner.getActiveLanguage;
+    this.validationState = { violations: [] };
+    this.valueType = "string";
+    this.evaluator = owner.evaluator;
+    this.decodeInstanceValue = codec.decodeInstanceValue;
+    const instanceValueState = createInstanceValueState(this);
+    const valueState = codec.createRuntimeValueState(instanceValueState);
+    const [getInstanceValue] = instanceValueState;
+    const [, setValueState] = valueState;
+    this.getInstanceValue = getInstanceValue;
+    this.setValueState = setValueState;
+    this.valueState = valueState;
+    const state = createSharedNodeState(
+      owner.scope,
+      {
+        value: this.valueState,
+        instanceValue: this.getInstanceValue,
+        relevant: this.owner.isRelevant
+      },
+      this.instanceConfig
+    );
+    this.state = state;
+    this.engineState = state.engineState;
+    this.currentState = state.currentState;
+    this.instanceState = createAttributeNodeInstanceState(this);
+  }
+  [XPathNodeKindKey] = "attribute";
+  state;
+  engineState;
+  validationState;
+  nodeType = "attribute";
+  currentState;
+  instanceState;
+  appearances = null;
+  nodeOptions = null;
+  valueType;
+  decodeInstanceValue;
+  getInstanceValue;
+  valueState;
+  setValueState;
+  evaluator;
+  getActiveLanguage;
+  contextNode;
+  scope;
+  rootDocument;
+  instanceConfig;
+  root;
+  isRelevant = () => {
+    return this.owner.isRelevant();
+  };
+  isAttached = () => {
+    return this.owner.isAttached();
+  };
+  isReadonly = () => {
+    return true;
+  };
+  hasReadonlyAncestor = () => {
+    const { owner } = this;
+    return owner.hasReadonlyAncestor() || owner.isReadonly();
+  };
+  hasNonRelevantAncestor = () => {
+    const { owner } = this;
+    return owner.hasNonRelevantAncestor() || !owner.isRelevant();
+  };
+  contextReference = () => {
+    return this.owner.contextReference() + "/@" + this.definition.qualifiedName.getPrefixedName();
+  };
+  setValue(value) {
+    this.setValueState(value);
+    return this.root;
+  }
+  getChildren() {
+    return [];
+  }
+  getXPathChildNodes() {
+    return [];
+  }
+  getXPathValue() {
+    return "";
+  }
+}
+
+function buildAttributes(owner) {
+  return Array.from(owner.definition.attributes.values()).map((attributeDefinition) => {
+    return new Attribute(owner, attributeDefinition, attributeDefinition.template);
+  });
+}
+
+class InstanceAttachmentsState extends Map {
+  constructor(sourceAttachments = null) {
+    super();
+    this.sourceAttachments = sourceAttachments;
+  }
+  getInitialFileValue(instanceNode) {
+    if (instanceNode == null) {
+      return null;
+    }
+    return this.sourceAttachments?.get(instanceNode.value) ?? null;
+  }
+}
+
+const createRootInstanceState = (node) => {
+  return {
+    get instanceXML() {
+      return serializeParentElementXML(
+        node.definition.qualifiedName,
+        node.currentState.children,
+        node.currentState.attributes,
+        node.definition.namespaceDeclarations
+      );
+    }
+  };
+};
+
+const violationReference = (node) => {
+  const violation = node.getViolation();
+  if (violation == null) {
+    return null;
+  }
+  const { nodeId } = node;
+  return {
+    nodeId,
+    get reference() {
+      return node.currentState.reference;
+    },
+    violation
+  };
+};
+const collectViolationReferences = (context) => {
+  return context.getChildren().flatMap((child) => {
+    switch (child.nodeType) {
+      case "model-value":
+      case "input":
+      case "note":
+      case "select":
+      case "range":
+      case "rank":
+      case "trigger":
+      case "upload": {
+        const reference = violationReference(child);
+        if (reference == null) {
+          return [];
+        }
+        return [reference];
+      }
+      default:
+        return collectViolationReferences(child);
+    }
+  });
+};
+const createAggregatedViolations = (context, options) => {
+  const { scope } = context;
+  return scope.runTask(() => {
+    const violations = createMemo(() => {
+      return collectViolationReferences(context);
+    });
+    const spec = { violations };
+    return createSharedNodeState(scope, spec, options).currentState;
+  });
+};
+
+const XFORMS_XPATH_NODE_RANGE_KIND = "comment";
+
 class DescendantNode extends InstanceNode {
   constructor(parent, instanceNode, definition, options) {
     super(parent.instanceConfig, parent, instanceNode, definition, options);
@@ -29126,10 +29609,11 @@ const createParentNodeInstanceState = (node) => {
       if (!node.currentState.relevant) {
         return "";
       }
-      const serializedChildren = node.currentState.children.map((child) => {
-        return child.instanceState.instanceXML;
-      });
-      return serializeParentElementXML(node.definition.qualifiedName, serializedChildren);
+      return serializeParentElementXML(
+        node.definition.qualifiedName,
+        node.currentState.children,
+        node.currentState.attributes
+      );
     }
   };
 };
@@ -39418,6 +39902,7 @@ class Group extends DescendantNode {
     super(parent, instanceNode, definition);
     this.appearances = definition.bodyElement?.appearances ?? null;
     const childrenState = createChildrenState(this);
+    const attributeState = createAttributeState(this.scope);
     this.childrenState = childrenState;
     const state = createSharedNodeState(
       this.scope,
@@ -39429,6 +39914,7 @@ class Group extends DescendantNode {
         label: createNodeLabel(this, definition),
         hint: null,
         children: childrenState.childIds,
+        attributes: attributeState.getAttributes,
         valueOptions: null,
         value: null
       },
@@ -39442,6 +39928,7 @@ class Group extends DescendantNode {
       childrenState
     );
     childrenState.setChildren(buildChildren(this));
+    attributeState.setAttributes(buildAttributes(this));
     this.validationState = createAggregatedViolations(this, this.instanceConfig);
     this.instanceState = createParentNodeInstanceState(this);
   }
@@ -39466,92 +39953,12 @@ const createValueNodeInstanceState = (node) => {
         return "";
       }
       const xmlValue = escapeXMLText(node.currentState.instanceValue);
-      return serializeLeafElementXML(qualifiedName, xmlValue);
+      const attributes = node.currentState.attributes;
+      return serializeLeafElementXML(qualifiedName, xmlValue, attributes);
     }
   };
 };
 
-const isInstanceFirstLoad = (context) => {
-  return context.rootDocument.initializationMode === "create";
-};
-const isEditInitialLoad = (context) => {
-  return context.rootDocument.initializationMode === "edit";
-};
-const getInitialValue = (context) => {
-  const sourceNode = context.instanceNode ?? context.definition.template;
-  return context.decodeInstanceValue(sourceNode.value);
-};
-const createRelevantValueState = (context, baseValueState) => {
-  return context.scope.runTask(() => {
-    const [getRelevantValue, setValue] = baseValueState;
-    const getValue = createMemo(() => {
-      if (context.isRelevant()) {
-        return getRelevantValue();
-      }
-      return "";
-    });
-    return [getValue, setValue];
-  });
-};
-const guardDownstreamReadonlyWrites = (context, baseState) => {
-  const { readonly } = context.definition.bind;
-  if (readonly.isDefaultExpression) {
-    return baseState;
-  }
-  const [getValue, baseSetValue] = baseState;
-  const setValue = (value) => {
-    if (context.isReadonly()) {
-      const reference = untrack(() => context.contextReference());
-      throw new Error(`Cannot write to readonly field: ${reference}`);
-    }
-    return baseSetValue(value);
-  };
-  return [getValue, setValue];
-};
-const PRELOAD_UID_EXPRESSION = 'concat("uuid:", uuid())';
-const shouldPreloadUID = (context) => {
-  return isInstanceFirstLoad(context) || isEditInitialLoad(context);
-};
-const setPreloadUIDValue = (context, valueState) => {
-  const { preload } = context.definition.bind;
-  if (preload?.type !== "uid" || !shouldPreloadUID(context)) {
-    return;
-  }
-  const preloadUIDValue = context.evaluator.evaluateString(PRELOAD_UID_EXPRESSION, {
-    contextNode: context.contextNode
-  });
-  const [, setValue] = valueState;
-  setValue(preloadUIDValue);
-};
-const createCalculation = (context, setRelevantValue, calculateDefinition) => {
-  context.scope.runTask(() => {
-    const calculate = createComputedExpression(context, calculateDefinition, {
-      defaultValue: ""
-    });
-    createComputed(() => {
-      if (context.isAttached() && context.isRelevant()) {
-        const calculated = calculate();
-        const value = context.decodeInstanceValue(calculated);
-        setRelevantValue(value);
-      }
-    });
-  });
-};
-const createInstanceValueState = (context) => {
-  return context.scope.runTask(() => {
-    const initialValue = getInitialValue(context);
-    const baseValueState = createSignal(initialValue);
-    const relevantValueState = createRelevantValueState(context, baseValueState);
-    setPreloadUIDValue(context, relevantValueState);
-    const { calculate } = context.definition.bind;
-    if (calculate != null) {
-      const [, setValue] = relevantValueState;
-      createCalculation(context, setValue, calculate);
-    }
-    return guardDownstreamReadonlyWrites(context, relevantValueState);
-  });
-};
-
 const engineViolationMessage = (context, role) => {
   const messageText = VALIDATION_TEXT[role];
   const chunk = new TextChunk(context, "literal", messageText);
@@ -39741,6 +40148,7 @@ class InputControl extends ValueNode {
     super(parent, instanceNode, definition, codec);
     this.appearances = definition.bodyElement.appearances;
     this.nodeOptions = nodeOptionsFactoryByType[definition.valueType](definition.bodyElement);
+    const attributeState = createAttributeState(this.scope);
     const state = createSharedNodeState(
       this.scope,
       {
@@ -39751,12 +40159,14 @@ class InputControl extends ValueNode {
         label: createNodeLabel(this, definition),
         hint: createFieldHint(this, definition),
         children: null,
+        attributes: attributeState.getAttributes,
         valueOptions: null,
         value: this.valueState,
         instanceValue: this.getInstanceValue
       },
       this.instanceConfig
     );
+    attributeState.setAttributes(buildAttributes(this));
     this.state = state;
     this.engineState = state.engineState;
     this.currentState = state.currentState;
@@ -39784,6 +40194,7 @@ class ModelValue extends ValueNode {
   constructor(parent, instanceNode, definition) {
     const codec = getSharedValueCodec(definition.valueType);
     super(parent, instanceNode, definition, codec);
+    const attributeState = createAttributeState(this.scope);
     const state = createSharedNodeState(
       this.scope,
       {
@@ -39794,12 +40205,14 @@ class ModelValue extends ValueNode {
         label: null,
         hint: null,
         children: null,
+        attributes: attributeState.getAttributes,
         valueOptions: null,
         value: this.valueState,
         instanceValue: this.getInstanceValue
       },
       this.instanceConfig
     );
+    attributeState.setAttributes(buildAttributes(this));
     this.state = state;
     this.engineState = state.engineState;
     this.currentState = state.currentState;
@@ -39891,6 +40304,7 @@ class Note extends ValueNode {
     this.appearances = definition.bodyElement.appearances;
     const isReadonly = createNoteReadonlyThunk(this, definition);
     const noteTextComputation = createNoteText(this, definition.noteTextDefinition);
+    const attributeState = createAttributeState(this.scope);
     let noteText;
     let label;
     let hint;
@@ -39921,12 +40335,14 @@ class Note extends ValueNode {
         hint,
         noteText,
         children: null,
+        attributes: attributeState.getAttributes,
         valueOptions: null,
         value: this.valueState,
         instanceValue: this.getInstanceValue
       },
       this.instanceConfig
     );
+    attributeState.setAttributes(buildAttributes(this));
     this.state = state;
     this.engineState = state.engineState;
     this.currentState = state.currentState;
@@ -39990,6 +40406,7 @@ class RangeControl extends ValueNode {
     const codec = new RangeCodec(baseCodec, definition);
     super(parent, instanceNode, definition, codec);
     this.appearances = definition.bodyElement.appearances;
+    const attributeState = createAttributeState(this.scope);
     const state = createSharedNodeState(
       this.scope,
       {
@@ -40000,12 +40417,14 @@ class RangeControl extends ValueNode {
         label: createNodeLabel(this, definition),
         hint: createFieldHint(this, definition),
         children: null,
+        attributes: attributeState.getAttributes,
         valueOptions: null,
         value: this.valueState,
         instanceValue: this.getInstanceValue
       },
       this.instanceConfig
     );
+    attributeState.setAttributes(buildAttributes(this));
     this.state = state;
     this.engineState = state.engineState;
     this.currentState = state.currentState;
@@ -40223,6 +40642,7 @@ class RankControl extends ValueNode {
     this.mapOptionsByValue = mapOptionsByValue;
     const baseValueState = this.valueState;
     const [baseGetValue, setValue] = baseValueState;
+    const attributeState = createAttributeState(this.scope);
     const getValue = this.scope.runTask(() => {
       return createMemo(() => {
         const options = valueOptions();
@@ -40257,12 +40677,14 @@ class RankControl extends ValueNode {
         label: createNodeLabel(this, definition),
         hint: createFieldHint(this, definition),
         children: null,
+        attributes: attributeState.getAttributes,
         valueOptions,
         value: valueState,
         instanceValue: this.getInstanceValue
       },
       this.instanceConfig
     );
+    attributeState.setAttributes(buildAttributes(this));
     this.state = state;
     this.engineState = state.engineState;
     this.currentState = state.currentState;
@@ -40318,26 +40740,17 @@ const createNodeRangeInstanceState = (node) => {
   };
 };
 
-class TemplatedNodeAttributeSerializationError extends Error {
-  constructor() {
-    super("Template attribute omission not implemented");
-  }
-}
-
 const createTemplatedNodeInstanceState = (node) => {
   return {
     get instanceXML() {
       if (!node.currentState.relevant) {
         return "";
       }
-      const serializedChildren = node.currentState.children.map((child) => {
-        return child.instanceState.instanceXML;
-      });
-      const { attributes } = node.currentState;
-      if (attributes != null) {
-        throw new TemplatedNodeAttributeSerializationError();
-      }
-      return serializeParentElementXML(node.definition.qualifiedName, serializedChildren);
+      return serializeParentElementXML(
+        node.definition.qualifiedName,
+        node.currentState.children,
+        node.currentState.attributes
+      );
     }
   };
 };
@@ -40358,6 +40771,7 @@ class RepeatInstance extends DescendantNode {
     this.parent = parent;
     this.appearances = definition.bodyElement.appearances;
     const childrenState = createChildrenState(this);
+    const attributeState = createAttributeState(this.scope);
     this.childrenState = childrenState;
     this.currentIndex = currentIndex;
     const state = createSharedNodeState(
@@ -40370,7 +40784,7 @@ class RepeatInstance extends DescendantNode {
         // TODO: only-child <group><label>
         label: createNodeLabel(this, definition),
         hint: null,
-        attributes: null,
+        attributes: attributeState.getAttributes,
         children: childrenState.childIds,
         valueOptions: null,
         value: null
@@ -40431,6 +40845,7 @@ class RepeatInstance extends DescendantNode {
 
 class BaseRepeatRange extends DescendantNode {
   childrenState;
+  attributeState;
   /**
    * A repeat range doesn't have a corresponding primary instance element of its
    * own. It is represented in the following ways:
@@ -40470,7 +40885,9 @@ class BaseRepeatRange extends DescendantNode {
     super(parent, definition.template, definition);
     const repeatRange = this;
     const childrenState = createChildrenState(repeatRange);
+    const attributeState = createAttributeState(this.scope);
     this.childrenState = childrenState;
+    this.attributeState = attributeState;
     const state = createSharedNodeState(
       this.scope,
       {
@@ -40481,6 +40898,7 @@ class BaseRepeatRange extends DescendantNode {
         label: createNodeLabel(this, definition),
         hint: null,
         children: childrenState.childIds,
+        attributes: attributeState.getAttributes,
         valueOptions: null,
         value: null
       },
@@ -40548,6 +40966,9 @@ class BaseRepeatRange extends DescendantNode {
   getChildren() {
     return this.childrenState.getChildren();
   }
+  getAttributes() {
+    return this.attributeState.getAttributes();
+  }
 }
 
 class RepeatRangeControlled extends BaseRepeatRange {
@@ -40755,6 +41176,7 @@ class SelectControl extends ValueNode {
     super(parent, instanceNode, definition, codec);
     this.appearances = definition.bodyElement.appearances;
     this.selectType = definition.bodyElement.type;
+    const attributeState = createAttributeState(this.scope);
     const valueOptions = createItemCollection(this);
     const isSelectWithImages = this.scope.runTask(() => {
       return createMemo(() => valueOptions().some((item) => !!item.label.imageSource));
@@ -40791,6 +41213,7 @@ class SelectControl extends ValueNode {
         label: createNodeLabel(this, definition),
         hint: createFieldHint(this, definition),
         children: null,
+        attributes: attributeState.getAttributes,
         valueOptions,
         value: valueState,
         instanceValue: this.getInstanceValue,
@@ -40798,6 +41221,7 @@ class SelectControl extends ValueNode {
       },
       this.instanceConfig
     );
+    attributeState.setAttributes(buildAttributes(this));
     this.state = state;
     this.engineState = state.engineState;
     this.currentState = state.currentState;
@@ -40916,6 +41340,7 @@ class TriggerControl extends ValueNode {
   constructor(parent, instanceNode, definition) {
     super(parent, instanceNode, definition, codec);
     this.appearances = definition.bodyElement.appearances;
+    const attributeState = createAttributeState(this.scope);
     const state = createSharedNodeState(
       this.scope,
       {
@@ -40926,12 +41351,14 @@ class TriggerControl extends ValueNode {
         label: createNodeLabel(this, definition),
         hint: createFieldHint(this, definition),
         children: null,
+        attributes: attributeState.getAttributes,
         valueOptions: null,
         value: this.valueState,
         instanceValue: this.getInstanceValue
       },
       this.instanceConfig
     );
+    attributeState.setAttributes(buildAttributes(this));
     this.state = state;
     this.engineState = state.engineState;
     this.currentState = state.currentState;
@@ -41124,6 +41551,7 @@ class UploadControl extends DescendantNode {
     this.nodeOptions = definition.bodyElement.options;
     const instanceAttachment = createInstanceAttachment(this);
     this.instanceAttachment = instanceAttachment;
+    const attributeState = createAttributeState(this.scope);
     this.decodeInstanceValue = instanceAttachment.decodeInstanceValue;
     this.getXPathValue = instanceAttachment.getInstanceValue;
     const state = createSharedNodeState(
@@ -41138,6 +41566,7 @@ class UploadControl extends DescendantNode {
         children: null,
         valueOptions: null,
         value: instanceAttachment.valueState,
+        attributes: attributeState.getAttributes,
         instanceValue: instanceAttachment.getInstanceValue
       },
       this.instanceConfig
@@ -41273,7 +41702,7 @@ const buildMetaValueElement = (group, localName, value) => {
 const buildDeprecatedIDDefinition = (group, instanceNode) => {
   const nodeset = instanceNode.nodeset;
   const bind = group.model.binds.getOrCreateBindDefinition(nodeset);
-  return new LeafNodeDefinition(group.parent.definition, bind, null, instanceNode);
+  return new LeafNodeDefinition(group.model, group.parent.definition, bind, null, instanceNode);
 };
 const buildDeprecatedID = (group, value) => {
   const instanceNode = buildMetaValueElement(group, DEPRECATED_ID_LOCAL_NAME, value);
@@ -41500,6 +41929,7 @@ class Root extends DescendantNode {
     });
     this.classes = parent.classes;
     const childrenState = createChildrenState(this);
+    const attributeState = createAttributeState(this.scope);
     this.childrenState = childrenState;
     this.languages = parent.languages;
     const state = createSharedNodeState(
@@ -41514,7 +41944,8 @@ class Root extends DescendantNode {
         required: () => false,
         valueOptions: null,
         value: null,
-        children: childrenState.childIds
+        children: childrenState.childIds,
+        attributes: attributeState.getAttributes
       },
       this.instanceConfig
     );
@@ -41526,6 +41957,7 @@ class Root extends DescendantNode {
       childrenState
     );
     childrenState.setChildren(buildChildren(this));
+    attributeState.setAttributes(buildAttributes(this));
     this.validationState = createAggregatedViolations(this, this.instanceConfig);
     this.instanceState = createRootInstanceState(this);
   }
@@ -41606,6 +42038,7 @@ class PrimaryInstance extends InstanceNode {
     this.evaluator = evaluator;
     this.classes = definition.classes;
     const childrenState = createChildrenState(this);
+    const attributeState = createAttributeState(this.scope);
     this.getChildren = childrenState.getChildren;
     const stateSpec = {
       activeLanguage: getActiveLanguage,
@@ -41617,7 +42050,8 @@ class PrimaryInstance extends InstanceNode {
       required: false,
       valueOptions: null,
       value: null,
-      children: childrenState.childIds
+      children: childrenState.childIds,
+      attributes: attributeState.getAttributes
     };
     const state = createSharedNodeState(scope, stateSpec, config);
     this.state = state;
@@ -41632,6 +42066,7 @@ class PrimaryInstance extends InstanceNode {
     };
     this.instanceState = createPrimaryInstanceState(this);
     childrenState.setChildren([root]);
+    attributeState.setAttributes(buildAttributes(this));
     setIsAttached(true);
   }
   // PrimaryInstanceDocument
@@ -41682,7 +42117,8 @@ class FormInstance {
     const { mode, initialState, instanceConfig } = options;
     const config = {
       clientStateFactory: instanceConfig.stateFactory ?? identity,
-      computeAttachmentName: instanceConfig.instanceAttachments?.fileNameFactory ?? (() => null)
+      computeAttachmentName: instanceConfig.instanceAttachments?.fileNameFactory ?? (() => null),
+      preloadProperties: instanceConfig.preloadProperties ?? {}
     };
     const primaryInstanceOptions = {
       ...options.instanceOptions,