@getodk/xforms-engine 0.15.0 → 0.16.1

package/dist/solid.js

@@ -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);
   }
@@ -20901,6 +20909,7 @@ class StaticAttribute extends StaticNode {
   nodeset;
   attributes = [];
   children = null;
+  childElements = [];
   value;
   // XFormsXPathAttribute
   getXPathValue() {
@@ -21230,6 +21239,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 +21403,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 +21428,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 +21606,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;
@@ -21637,8 +21772,14 @@ const serializeParentElementXML = (qualifiedName, children, attributes, namespac
     namespaceDeclarations
   );
 };
-const serializeLeafElementXML = (qualifiedName, xmlValue, namespaceDeclarations) => {
-  return serializeElementXML(qualifiedName, xmlValue.normalize(), "", namespaceDeclarations);
+const serializeLeafElementXML = (qualifiedName, xmlValue, attributes, namespaceDeclarations) => {
+  const serializedAttributes = attributes?.map((attribute) => attribute.instanceState.instanceXML).join("") ?? "";
+  return serializeElementXML(
+    qualifiedName,
+    xmlValue.normalize(),
+    serializedAttributes,
+    namespaceDeclarations
+  );
 };
 
 class NamespaceDeclaration {
@@ -21868,11 +22009,12 @@ class NodeDefinition {
 }
 
 class AttributeDefinition extends NodeDefinition {
-  constructor(root, bind, template) {
+  constructor(model, bind, template) {
     super(bind);
+    this.model = model;
     this.template = template;
     const { value } = template;
-    this.root = root;
+    this.root = model.root;
     this.value = value;
     this.qualifiedName = template.qualifiedName;
     this.namespaceDeclarations = new NamespaceDeclarationMap(this);
@@ -21886,6 +22028,7 @@ class AttributeDefinition extends NodeDefinition {
   serializedXML;
   value;
   type = "attribute";
+  valueType = "string";
   namespaceDeclarations;
   bodyElement = null;
   root;
@@ -21897,6 +22040,10 @@ class AttributeDefinition extends NodeDefinition {
   serializeAttributeXML() {
     return this.serializedXML;
   }
+  toJSON() {
+    const { bind, bodyElement, parent, root, ...rest } = this;
+    return rest;
+  }
 }
 
 const isNonNamespaceAttribute = (attribute) => {
@@ -21907,7 +22054,7 @@ class AttributeDefinitionMap extends Map {
     const nonNamespaceAttributes = instanceNode.attributes.filter(isNonNamespaceAttribute);
     const definitions = nonNamespaceAttributes.map((attribute) => {
       const bind = model.binds.getOrCreateBindDefinition(attribute.nodeset);
-      return new AttributeDefinition(model.root, bind, attribute);
+      return new AttributeDefinition(model, bind, attribute);
     });
     return new this(definitions);
   }
@@ -21959,22 +22106,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 = null;
+  attributes;
   toJSON() {
     const { bind, bodyElement, parent, root, ...rest } = this;
     return rest;
@@ -21985,13 +22134,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;
     }
@@ -22000,7 +22149,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);
   }
 }
 
@@ -26211,15 +26360,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;
 }
@@ -26355,6 +26504,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;
@@ -26377,6 +26538,9 @@ 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(model, parent, bind, bodyElement, children);
       }
@@ -26386,9 +26550,9 @@ 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(model, parent, bind, bodyElement, element);
     });
@@ -26436,6 +26600,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: "/"
     });
@@ -26443,13 +26608,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) {
@@ -26464,14 +26632,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 {
@@ -27442,6 +27616,7 @@ const resolveEngineXPathNodeNamespaceURI = (node, prefix) => {
     case "static-element":
     case "static-text":
       return resolveNamespaceURIFromStaticNodeContext(node, prefix);
+    case "attribute":
     case "group":
     case "input":
     case "model-value":
@@ -27474,10 +27649,13 @@ class XPathFunctionalityPendingError extends XPathFunctionalityError {
 const getContainingEngineXPathDocument = (node) => {
   return node.rootDocument;
 };
-const getEngineXPathAttributes = (node) => {
+const getAttributes = (node) => {
   if (node.nodeType === "static-element") {
     return node.attributes;
   }
+  if (isEngineXPathElement(node)) {
+    return node.getAttributes();
+  }
   return [];
 };
 const getNamespaceDeclarations = () => [];
@@ -27634,7 +27812,7 @@ const engineDOMAdapter = {
   getNodeValue: getEngineXPathNodeValue,
   // XPathTraversalAdapter
   compareDocumentOrder,
-  getAttributes: getEngineXPathAttributes,
+  getAttributes,
   getChildElements,
   getChildNodes,
   getContainingDocument: getContainingEngineXPathDocument,
@@ -28535,6 +28713,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);
@@ -28963,17 +29142,21 @@ const createComputedExpression = (context, dependentExpression, options = {}) =>
   });
 };
 
-const isInstanceFirstLoad$1 = (context) => {
+const REPEAT_INDEX_REGEX = /([^[]*)(\[[0-9]+\])/g;
+const isInstanceFirstLoad = (context) => {
   return context.rootDocument.initializationMode === "create";
 };
-const isEditInitialLoad$1 = (context) => {
+const isAddingRepeatChild = (context) => {
+  return context.rootDocument.isAttached();
+};
+const isEditInitialLoad = (context) => {
   return context.rootDocument.initializationMode === "edit";
 };
-const getInitialValue$1 = (context) => {
+const getInitialValue = (context) => {
   const sourceNode = context.instanceNode ?? context.definition.template;
   return context.decodeInstanceValue(sourceNode.value);
 };
-const createRelevantValueState$1 = (context, baseValueState) => {
+const createRelevantValueState = (context, baseValueState) => {
   return context.scope.runTask(() => {
     const [getRelevantValue, setValue] = baseValueState;
     const getValue = createMemo(() => {
@@ -28985,7 +29168,7 @@ const createRelevantValueState$1 = (context, baseValueState) => {
     return [getValue, setValue];
   });
 };
-const guardDownstreamReadonlyWrites$1 = (context, baseState) => {
+const guardDownstreamReadonlyWrites = (context, baseState) => {
   const { readonly } = context.definition.bind;
   if (readonly.isDefaultExpression) {
     return baseState;
@@ -29000,215 +29183,144 @@ const guardDownstreamReadonlyWrites$1 = (context, baseState) => {
   };
   return [getValue, setValue];
 };
-const PRELOAD_UID_EXPRESSION$1 = 'concat("uuid:", uuid())';
-const shouldPreloadUID$1 = (context) => {
-  return isInstanceFirstLoad$1(context) || isEditInitialLoad$1(context);
+const isLoading = (context) => {
+  return isInstanceFirstLoad(context) || isEditInitialLoad(context);
 };
-const setPreloadUIDValue$1 = (context, valueState) => {
+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?.type !== "uid" || !shouldPreloadUID$1(context)) {
+  if (!preload) {
     return;
   }
-  const preloadUIDValue = context.evaluator.evaluateString(PRELOAD_UID_EXPRESSION$1, {
+  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
   });
-  const [, setValue] = valueState;
-  setValue(preloadUIDValue);
+  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 createCalculation$1 = (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 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 createAttributeValueState = (context) => {
-  return context.scope.runTask(() => {
-    const initialValue = getInitialValue$1(context);
-    const baseValueState = createSignal(initialValue);
-    const relevantValueState = createRelevantValueState$1(context, baseValueState);
-    setPreloadUIDValue$1(context, relevantValueState);
-    const { calculate } = context.definition.bind;
-    if (calculate != null) {
-      const [, setValue] = relevantValueState;
-      createCalculation$1(context, setValue, calculate);
+const createActionCalculation = (context, setRelevantValue, computation) => {
+  createComputed(() => {
+    if (context.isAttached()) {
+      const relevant = untrack(() => context.isRelevant());
+      if (!relevant) {
+        return;
+      }
+      const calculated = untrack(() => {
+        return context.evaluator.evaluateString(computation.expression, context);
+      });
+      const value = context.decodeInstanceValue(calculated);
+      setRelevantValue(value);
     }
-    return guardDownstreamReadonlyWrites$1(context, relevantValueState);
   });
 };
-
-class Attribute extends InstanceNode {
-  constructor(parent, definition, instanceNode) {
-    const codec = getSharedValueCodec("string");
-    super(parent.instanceConfig, parent, instanceNode, definition, {
-      scope: parent.scope,
-      computeReference: () => "@" + this.definition.qualifiedName.getPrefixedName()
-    });
-    this.instanceNode = instanceNode;
-    this.root = parent.root;
-    this.getActiveLanguage = parent.getActiveLanguage;
-    this.validationState = { violations: [] };
-    this.valueType = "string";
-    this.evaluator = parent.evaluator;
-    this.decodeInstanceValue = codec.decodeInstanceValue;
-    const instanceValueState = createAttributeValueState(this);
-    const valueState = codec.createRuntimeValueState(instanceValueState);
-    const [getInstanceValue] = instanceValueState;
-    const [, setValueState] = valueState;
-    this.getInstanceValue = getInstanceValue;
-    this.setValueState = setValueState;
-    this.getXPathValue = () => {
-      return this.getInstanceValue();
-    };
-    this.valueState = valueState;
-    const state = createSharedNodeState(
-      this.scope,
-      {
-        reference: this.contextReference,
-        readonly: this.isReadonly,
-        relevant: this.isRelevant,
-        required: () => false,
-        label: null,
-        hint: null,
-        children: null,
-        valueOptions: null,
-        value: this.valueState,
-        instanceValue: this.getInstanceValue,
-        attributes: null
-      },
-      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;
-  root;
-  isRelevant = () => {
-    return this.parent.isRelevant();
-  };
-  isAttached = () => {
-    return this.parent.isAttached();
-  };
-  isReadonly = () => {
-    return true;
-  };
-  hasReadonlyAncestor = () => {
-    const { parent } = this;
-    return parent.hasReadonlyAncestor() || parent.isReadonly();
-  };
-  hasNonRelevantAncestor = () => {
-    const { parent } = this;
-    return parent.hasNonRelevantAncestor() || !parent.isRelevant();
-  };
-  setValue(value) {
-    this.setValueState(value);
-    return this.root;
-  }
-  getChildren() {
-    return [];
+const createValueChangedCalculation = (context, setRelevantValue, action) => {
+  const { source, ref } = bindToRepeatInstance(context, action);
+  if (!source) {
+    return;
   }
-}
-
-function buildAttributes(parent) {
-  return Array.from(parent.definition.attributes.values()).map((attributeDefinition) => {
-    return new Attribute(parent, attributeDefinition, attributeDefinition.template);
+  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;
+    }
   });
-}
-
-class InstanceAttachmentsState extends Map {
-  constructor(sourceAttachments = null) {
-    super();
-    this.sourceAttachments = sourceAttachments;
+};
+const registerAction = (context, setValue, action) => {
+  if (action.events.includes(XFORM_EVENT.odkInstanceFirstLoad)) {
+    if (isInstanceFirstLoad(context)) {
+      createActionCalculation(context, setValue, action.computation);
+    }
   }
-  getInitialFileValue(instanceNode) {
-    if (instanceNode == null) {
-      return null;
+  if (action.events.includes(XFORM_EVENT.odkInstanceLoad)) {
+    if (!isAddingRepeatChild(context)) {
+      createActionCalculation(context, setValue, action.computation);
     }
-    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
-      );
+  if (action.events.includes(XFORM_EVENT.odkNewRepeat)) {
+    if (isAddingRepeatChild(context)) {
+      createActionCalculation(context, setValue, action.computation);
     }
-  };
-};
-
-const violationReference = (node) => {
-  const violation = node.getViolation();
-  if (violation == null) {
-    return null;
   }
-  const { nodeId } = node;
-  return {
-    nodeId,
-    get reference() {
-      return node.currentState.reference;
-    },
-    violation
-  };
+  if (action.events.includes(XFORM_EVENT.xformsValueChanged)) {
+    createValueChangedCalculation(context, setValue, action);
+  }
 };
-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 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 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 action = context.definition.model.actions.get(context.contextReference());
+    if (action) {
+      registerAction(context, setValue, action);
+    }
+    return guardDownstreamReadonlyWrites(context, relevantValueState);
   });
 };
 
@@ -29239,11 +29351,6 @@ class DescendantNode extends InstanceNode {
             return true;
           }
         }
-        for (const attr of parent.getAttributes()) {
-          if (attr === self) {
-            return true;
-          }
-        }
         return false;
       });
     });
@@ -29279,75 +29386,234 @@ class DescendantNode extends InstanceNode {
     if (this.hasReadonlyAncestor()) {
       return true;
     }
-    return this.isSelfReadonly();
+    return this.isSelfReadonly();
+  };
+  hasNonRelevantAncestor = () => {
+    const { parent } = this;
+    return parent.hasNonRelevantAncestor() || !parent.isRelevant();
+  };
+  isSelfRelevant;
+  isRelevant = () => {
+    if (this.hasNonRelevantAncestor()) {
+      return false;
+    }
+    return this.isSelfRelevant();
+  };
+  isRequired;
+  // XFormsXPathPrimaryInstanceDescendantNode
+  /**
+   * WARNING! Ideally, this would be an abstract property, defined by each
+   * concrete subclass (or other intermediate abstract classes, where
+   * appropriate). Unfortunately it must be assigned here, so it will be present
+   * for certain XPath DOM adapter functionality **during** each concrete node's
+   * construction.
+   *
+   * Those subclasses nevertheless override this same property, assigning the
+   * same value, for the purposes of narrowing the XPath node kind semantics
+   * appropriate for each node type.
+   */
+  [XPathNodeKindKey];
+  root;
+  // EvaluationContext
+  isAttached;
+  evaluator;
+  contextNode = this;
+  getActiveLanguage;
+  /**
+   * @package
+   *
+   * Performs recursive removal, first of the node's descendants, then of the
+   * node itself. For all {@link DescendantNode}s, removal involves **at least**
+   * disposal of its {@link scope} ({@link ReactiveScope}).
+   *
+   * It is expected that the outermost node targeted for removal will always be
+   * a {@link RepeatInstance}. @see {@link RepeatInstance.remove} for additional
+   * details.
+   *
+   * It is also expected that upon that outermost node's removal, its parent
+   * {@link RepeatRange} will perform a reactive update to its children state so
+   * that:
+   *
+   * 1. Any downstream computations affected by the removal are updated.
+   * 2. The client invoking removal is also reactively updated (where
+   *    applicable).
+   *
+   * @see {@link RepeatInstance.remove} and {@link RepeatRange.removeInstances}
+   * for additional details about their respective node-specific removal
+   * behaviors and ordering.
+   *
+   * @todo Possibly retain removed repeat instances in memory. This came up as a
+   * behavior of Collect/JavaRosa, and we should investigate the details and
+   * ramifications of that, and whether it's the desired behavior.
+   */
+  remove() {
+    this.scope.runTask(() => {
+      this.getChildren().forEach((child) => {
+        child.remove();
+      });
+    });
+    this.scope.dispose();
+  }
+}
+
+class Attribute extends DescendantNode {
+  constructor(owner, definition, instanceNode) {
+    const computeReference = () => {
+      return `${this.owner.contextReference()}/@${this.definition.qualifiedName.getPrefixedName()}`;
+    };
+    super(owner, instanceNode, definition, { computeReference });
+    this.owner = owner;
+    this.instanceNode = instanceNode;
+    const codec = getSharedValueCodec("string");
+    this.validationState = { violations: [] };
+    this.valueType = "string";
+    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,
+        readonly: () => true,
+        reference: this.contextReference,
+        required: () => false,
+        children: null,
+        label: () => null,
+        hint: () => null,
+        attributes: () => [],
+        valueOptions: () => []
+      },
+      this.instanceConfig
+    );
+    this.state = state;
+    this.engineState = state.engineState;
+    this.currentState = state.currentState;
+    this.instanceState = createAttributeNodeInstanceState(this);
+    this.attributeState = createAttributeState(this.scope);
+    this.getXPathValue = () => {
+      return this.getInstanceValue();
+    };
+  }
+  [XPathNodeKindKey] = "attribute";
+  state;
+  engineState;
+  validationState;
+  nodeType = "attribute";
+  currentState;
+  instanceState;
+  appearances = null;
+  nodeOptions = null;
+  valueType;
+  decodeInstanceValue;
+  getInstanceValue;
+  valueState;
+  setValueState;
+  attributeState;
+  isAttached = () => {
+    return this.owner.isAttached();
+  };
+  getXPathValue;
+  setValue(value) {
+    this.setValueState(value);
+    return this.root;
+  }
+  getAttributes() {
+    return [];
+  }
+  getChildren() {
+    return [];
+  }
+}
+
+function buildAttributes(owner) {
+  const attributes = owner.definition.attributes;
+  if (!attributes) {
+    return [];
+  }
+  return Array.from(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
+      );
+    }
   };
-  hasNonRelevantAncestor = () => {
-    const { parent } = this;
-    return parent.hasNonRelevantAncestor() || !parent.isRelevant();
+};
+
+const violationReference = (node) => {
+  const violation = node.getViolation();
+  if (violation == null) {
+    return null;
+  }
+  const { nodeId } = node;
+  return {
+    nodeId,
+    get reference() {
+      return node.currentState.reference;
+    },
+    violation
   };
-  isSelfRelevant;
-  isRelevant = () => {
-    if (this.hasNonRelevantAncestor()) {
-      return false;
+};
+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);
     }
-    return this.isSelfRelevant();
-  };
-  isRequired;
-  // XFormsXPathPrimaryInstanceDescendantNode
-  /**
-   * WARNING! Ideally, this would be an abstract property, defined by each
-   * concrete subclass (or other intermediate abstract classes, where
-   * appropriate). Unfortunately it must be assigned here, so it will be present
-   * for certain XPath DOM adapter functionality **during** each concrete node's
-   * construction.
-   *
-   * Those subclasses nevertheless override this same property, assigning the
-   * same value, for the purposes of narrowing the XPath node kind semantics
-   * appropriate for each node type.
-   */
-  [XPathNodeKindKey];
-  root;
-  // EvaluationContext
-  isAttached;
-  evaluator;
-  contextNode = this;
-  getActiveLanguage;
-  /**
-   * @package
-   *
-   * Performs recursive removal, first of the node's descendants, then of the
-   * node itself. For all {@link DescendantNode}s, removal involves **at least**
-   * disposal of its {@link scope} ({@link ReactiveScope}).
-   *
-   * It is expected that the outermost node targeted for removal will always be
-   * a {@link RepeatInstance}. @see {@link RepeatInstance.remove} for additional
-   * details.
-   *
-   * It is also expected that upon that outermost node's removal, its parent
-   * {@link RepeatRange} will perform a reactive update to its children state so
-   * that:
-   *
-   * 1. Any downstream computations affected by the removal are updated.
-   * 2. The client invoking removal is also reactively updated (where
-   *    applicable).
-   *
-   * @see {@link RepeatInstance.remove} and {@link RepeatRange.removeInstances}
-   * for additional details about their respective node-specific removal
-   * behaviors and ordering.
-   *
-   * @todo Possibly retain removed repeat instances in memory. This came up as a
-   * behavior of Collect/JavaRosa, and we should investigate the details and
-   * ramifications of that, and whether it's the desired behavior.
-   */
-  remove() {
-    this.scope.runTask(() => {
-      this.getChildren().forEach((child) => {
-        child.remove();
-      });
+  });
+};
+const createAggregatedViolations = (context, options) => {
+  const { scope } = context;
+  return scope.runTask(() => {
+    const violations = createMemo(() => {
+      return collectViolationReferences(context);
     });
-    this.scope.dispose();
-  }
-}
+    const spec = { violations };
+    return createSharedNodeState(scope, spec, options).currentState;
+  });
+};
 
 const createParentNodeInstanceState = (node) => {
   return {
@@ -39633,11 +39899,11 @@ const createNodeLabel = (context, definition) => {
 
 class Group extends DescendantNode {
   childrenState;
-  attributeState;
   [XPathNodeKindKey] = "element";
   // InstanceNode
   state;
   engineState;
+  attributeState;
   // GroupNode
   nodeType = "group";
   appearances;
@@ -39649,9 +39915,8 @@ class Group extends DescendantNode {
     super(parent, instanceNode, definition);
     this.appearances = definition.bodyElement?.appearances ?? null;
     const childrenState = createChildrenState(this);
-    const attributeState = createAttributeState(this.scope);
+    this.attributeState = createAttributeState(this.scope);
     this.childrenState = childrenState;
-    this.attributeState = attributeState;
     const state = createSharedNodeState(
       this.scope,
       {
@@ -39662,7 +39927,7 @@ class Group extends DescendantNode {
         label: createNodeLabel(this, definition),
         hint: null,
         children: childrenState.childIds,
-        attributes: attributeState.getAttributes,
+        attributes: this.attributeState.getAttributes,
         valueOptions: null,
         value: null
       },
@@ -39676,7 +39941,7 @@ class Group extends DescendantNode {
       childrenState
     );
     childrenState.setChildren(buildChildren(this));
-    attributeState.setAttributes(buildAttributes(this));
+    this.attributeState.setAttributes(buildAttributes(this));
     this.validationState = createAggregatedViolations(this, this.instanceConfig);
     this.instanceState = createParentNodeInstanceState(this);
   }
@@ -39704,90 +39969,10 @@ const createValueNodeInstanceState = (node) => {
         return "";
       }
       const xmlValue = escapeXMLText(node.currentState.instanceValue);
-      return serializeLeafElementXML(qualifiedName, xmlValue);
-    }
-  };
-};
-
-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}`);
+      const attributes = node.currentState.attributes;
+      return serializeLeafElementXML(qualifiedName, xmlValue, attributes);
     }
-    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) => {
@@ -39969,6 +40154,7 @@ class InputControl extends ValueNode {
   // InstanceNode
   state;
   engineState;
+  attributeState;
   // InputNode
   nodeType = "input";
   appearances;
@@ -39979,6 +40165,7 @@ class InputControl extends ValueNode {
     super(parent, instanceNode, definition, codec);
     this.appearances = definition.bodyElement.appearances;
     this.nodeOptions = nodeOptionsFactoryByType[definition.valueType](definition.bodyElement);
+    this.attributeState = createAttributeState(this.scope);
     const state = createSharedNodeState(
       this.scope,
       {
@@ -39989,13 +40176,14 @@ class InputControl extends ValueNode {
         label: createNodeLabel(this, definition),
         hint: createFieldHint(this, definition),
         children: null,
-        attributes: null,
+        attributes: this.attributeState.getAttributes,
         valueOptions: null,
         value: this.valueState,
         instanceValue: this.getInstanceValue
       },
       this.instanceConfig
     );
+    this.attributeState.setAttributes(buildAttributes(this));
     this.state = state;
     this.engineState = state.engineState;
     this.currentState = state.currentState;
@@ -40004,6 +40192,9 @@ class InputControl extends ValueNode {
     this.setValueState(value);
     return this.root;
   }
+  getAttributes() {
+    return this.attributeState.getAttributes();
+  }
 }
 
 class ModelValue extends ValueNode {
@@ -40015,6 +40206,7 @@ class ModelValue extends ValueNode {
   // InstanceNode
   state;
   engineState;
+  attributeState;
   // ModelValueNode
   nodeType = "model-value";
   appearances = null;
@@ -40023,6 +40215,7 @@ class ModelValue extends ValueNode {
   constructor(parent, instanceNode, definition) {
     const codec = getSharedValueCodec(definition.valueType);
     super(parent, instanceNode, definition, codec);
+    this.attributeState = createAttributeState(this.scope);
     const state = createSharedNodeState(
       this.scope,
       {
@@ -40033,17 +40226,21 @@ class ModelValue extends ValueNode {
         label: null,
         hint: null,
         children: null,
-        attributes: null,
+        attributes: this.attributeState.getAttributes,
         valueOptions: null,
         value: this.valueState,
         instanceValue: this.getInstanceValue
       },
       this.instanceConfig
     );
+    this.attributeState.setAttributes(buildAttributes(this));
     this.state = state;
     this.engineState = state.engineState;
     this.currentState = state.currentState;
   }
+  getAttributes() {
+    return this.attributeState.getAttributes();
+  }
 }
 
 class NoteCodec extends ValueCodec {
@@ -40120,6 +40317,7 @@ class Note extends ValueNode {
   // InstanceNode
   state;
   engineState;
+  attributeState;
   // NoteNode
   nodeType = "note";
   appearances;
@@ -40131,6 +40329,7 @@ class Note extends ValueNode {
     this.appearances = definition.bodyElement.appearances;
     const isReadonly = createNoteReadonlyThunk(this, definition);
     const noteTextComputation = createNoteText(this, definition.noteTextDefinition);
+    this.attributeState = createAttributeState(this.scope);
     let noteText;
     let label;
     let hint;
@@ -40161,17 +40360,21 @@ class Note extends ValueNode {
         hint,
         noteText,
         children: null,
-        attributes: null,
+        attributes: this.attributeState.getAttributes,
         valueOptions: null,
         value: this.valueState,
         instanceValue: this.getInstanceValue
       },
       this.instanceConfig
     );
+    this.attributeState.setAttributes(buildAttributes(this));
     this.state = state;
     this.engineState = state.engineState;
     this.currentState = state.currentState;
   }
+  getAttributes() {
+    return this.attributeState.getAttributes();
+  }
 }
 
 class RangeCodec extends ValueCodec {
@@ -40221,6 +40424,7 @@ class RangeControl extends ValueNode {
   // InstanceNode
   state;
   engineState;
+  attributeState;
   // RangeNode
   nodeType = "range";
   appearances;
@@ -40231,6 +40435,7 @@ class RangeControl extends ValueNode {
     const codec = new RangeCodec(baseCodec, definition);
     super(parent, instanceNode, definition, codec);
     this.appearances = definition.bodyElement.appearances;
+    this.attributeState = createAttributeState(this.scope);
     const state = createSharedNodeState(
       this.scope,
       {
@@ -40241,13 +40446,14 @@ class RangeControl extends ValueNode {
         label: createNodeLabel(this, definition),
         hint: createFieldHint(this, definition),
         children: null,
-        attributes: null,
+        attributes: this.attributeState.getAttributes,
         valueOptions: null,
         value: this.valueState,
         instanceValue: this.getInstanceValue
       },
       this.instanceConfig
     );
+    this.attributeState.setAttributes(buildAttributes(this));
     this.state = state;
     this.engineState = state.engineState;
     this.currentState = state.currentState;
@@ -40256,6 +40462,9 @@ class RangeControl extends ValueNode {
     this.setValueState(value);
     return this.root;
   }
+  getAttributes() {
+    return this.attributeState.getAttributes();
+  }
 }
 
 class RankMissingValueError extends Error {
@@ -40447,6 +40656,7 @@ class RankControl extends ValueNode {
   // InstanceNode
   state;
   engineState;
+  attributeState;
   // RankNode
   nodeType = "rank";
   appearances;
@@ -40465,6 +40675,7 @@ class RankControl extends ValueNode {
     this.mapOptionsByValue = mapOptionsByValue;
     const baseValueState = this.valueState;
     const [baseGetValue, setValue] = baseValueState;
+    this.attributeState = createAttributeState(this.scope);
     const getValue = this.scope.runTask(() => {
       return createMemo(() => {
         const options = valueOptions();
@@ -40499,17 +40710,21 @@ class RankControl extends ValueNode {
         label: createNodeLabel(this, definition),
         hint: createFieldHint(this, definition),
         children: null,
-        attributes: null,
+        attributes: this.attributeState.getAttributes,
         valueOptions,
         value: valueState,
         instanceValue: this.getInstanceValue
       },
       this.instanceConfig
     );
+    this.attributeState.setAttributes(buildAttributes(this));
     this.state = state;
     this.engineState = state.engineState;
     this.currentState = state.currentState;
   }
+  getAttributes() {
+    return this.attributeState.getAttributes();
+  }
   getValueLabel(value) {
     const valueOption = this.currentState.valueOptions.find((item) => item.value === value);
     return valueOption?.label ?? null;
@@ -40592,9 +40807,8 @@ class RepeatInstance extends DescendantNode {
     this.parent = parent;
     this.appearances = definition.bodyElement.appearances;
     const childrenState = createChildrenState(this);
-    const attributeState = createAttributeState(this.scope);
+    this.attributeState = createAttributeState(this.scope);
     this.childrenState = childrenState;
-    this.attributeState = attributeState;
     this.currentIndex = currentIndex;
     const state = createSharedNodeState(
       this.scope,
@@ -40606,7 +40820,7 @@ class RepeatInstance extends DescendantNode {
         // TODO: only-child <group><label>
         label: createNodeLabel(this, definition),
         hint: null,
-        attributes: attributeState.getAttributes,
+        attributes: this.attributeState.getAttributes,
         children: childrenState.childIds,
         valueOptions: null,
         value: null
@@ -40991,6 +41205,7 @@ class SelectControl extends ValueNode {
   // InstanceNode
   state;
   engineState;
+  attributeState;
   // SelectNode
   nodeType = "select";
   selectType;
@@ -41002,6 +41217,7 @@ class SelectControl extends ValueNode {
     super(parent, instanceNode, definition, codec);
     this.appearances = definition.bodyElement.appearances;
     this.selectType = definition.bodyElement.type;
+    this.attributeState = createAttributeState(this.scope);
     const valueOptions = createItemCollection(this);
     const isSelectWithImages = this.scope.runTask(() => {
       return createMemo(() => valueOptions().some((item) => !!item.label.imageSource));
@@ -41038,7 +41254,7 @@ class SelectControl extends ValueNode {
         label: createNodeLabel(this, definition),
         hint: createFieldHint(this, definition),
         children: null,
-        attributes: null,
+        attributes: this.attributeState.getAttributes,
         valueOptions,
         value: valueState,
         instanceValue: this.getInstanceValue,
@@ -41046,6 +41262,7 @@ class SelectControl extends ValueNode {
       },
       this.instanceConfig
     );
+    this.attributeState.setAttributes(buildAttributes(this));
     this.state = state;
     this.engineState = state.engineState;
     this.currentState = state.currentState;
@@ -41104,6 +41321,9 @@ class SelectControl extends ValueNode {
     const option = this.mapOptionsByValue().get(value);
     return option?.label?.asString ?? null;
   }
+  getAttributes() {
+    return this.attributeState.getAttributes();
+  }
 }
 
 const TRIGGER_INSTANCE_VALUES = {
@@ -41156,6 +41376,7 @@ class TriggerControl extends ValueNode {
   // InstanceNode
   state;
   engineState;
+  attributeState;
   // TriggerNode
   nodeType = "trigger";
   appearances;
@@ -41164,6 +41385,7 @@ class TriggerControl extends ValueNode {
   constructor(parent, instanceNode, definition) {
     super(parent, instanceNode, definition, codec);
     this.appearances = definition.bodyElement.appearances;
+    this.attributeState = createAttributeState(this.scope);
     const state = createSharedNodeState(
       this.scope,
       {
@@ -41174,17 +41396,21 @@ class TriggerControl extends ValueNode {
         label: createNodeLabel(this, definition),
         hint: createFieldHint(this, definition),
         children: null,
-        attributes: null,
+        attributes: this.attributeState.getAttributes,
         valueOptions: null,
         value: this.valueState,
         instanceValue: this.getInstanceValue
       },
       this.instanceConfig
     );
+    this.attributeState.setAttributes(buildAttributes(this));
     this.state = state;
     this.engineState = state.engineState;
     this.currentState = state.currentState;
   }
+  getAttributes() {
+    return this.attributeState.getAttributes();
+  }
   // TriggerNode
   setValue(value) {
     this.setValueState(value);
@@ -41373,8 +41599,7 @@ class UploadControl extends DescendantNode {
     this.nodeOptions = definition.bodyElement.options;
     const instanceAttachment = createInstanceAttachment(this);
     this.instanceAttachment = instanceAttachment;
-    const attributeState = createAttributeState(this.scope);
-    this.attributeState = attributeState;
+    this.attributeState = createAttributeState(this.scope);
     this.decodeInstanceValue = instanceAttachment.decodeInstanceValue;
     this.getXPathValue = instanceAttachment.getInstanceValue;
     const state = createSharedNodeState(
@@ -41389,7 +41614,7 @@ class UploadControl extends DescendantNode {
         children: null,
         valueOptions: null,
         value: instanceAttachment.valueState,
-        attributes: attributeState.getAttributes,
+        attributes: this.attributeState.getAttributes,
         instanceValue: instanceAttachment.getInstanceValue
       },
       this.instanceConfig
@@ -41398,6 +41623,7 @@ class UploadControl extends DescendantNode {
     this.engineState = state.engineState;
     this.currentState = state.currentState;
     this.validation = createValidationState(this, this.instanceConfig);
+    this.attributeState.setAttributes(buildAttributes(this));
     this.instanceState = createValueNodeInstanceState(this);
   }
   static from(parent, instanceNode, definition) {
@@ -41406,13 +41632,13 @@ class UploadControl extends DescendantNode {
   }
   validation;
   instanceAttachment;
-  attributeState;
   // XFormsXPathElement
   [XPathNodeKindKey] = "element";
   getXPathValue;
   // InstanceNode
   state;
   engineState;
+  attributeState;
   // InstanceValueContext
   decodeInstanceValue;
   // UploadNode
@@ -41436,14 +41662,14 @@ class UploadControl extends DescendantNode {
   getChildren() {
     return [];
   }
+  getAttributes() {
+    return this.attributeState.getAttributes();
+  }
   // UploadNode
   setValue(value) {
     this.instanceAttachment.setValue(value);
     return this.root;
   }
-  getAttributes() {
-    return this.attributeState.getAttributes();
-  }
 }
 
 const META_LOCAL_NAME = "meta";
@@ -41529,7 +41755,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);
@@ -41725,12 +41951,12 @@ const buildChildren = (parent) => {
 
 class Root extends DescendantNode {
   childrenState;
-  attributeState;
   // XFormsXPathElement
   [XPathNodeKindKey] = "element";
   // DescendantNode
   state;
   engineState;
+  attributeState;
   hasReadonlyAncestor = () => false;
   isSelfReadonly = () => false;
   isReadonly = () => false;
@@ -41757,9 +41983,8 @@ class Root extends DescendantNode {
     });
     this.classes = parent.classes;
     const childrenState = createChildrenState(this);
-    const attributeState = createAttributeState(this.scope);
+    this.attributeState = createAttributeState(this.scope);
     this.childrenState = childrenState;
-    this.attributeState = attributeState;
     this.languages = parent.languages;
     const state = createSharedNodeState(
       this.scope,
@@ -41774,7 +41999,7 @@ class Root extends DescendantNode {
         valueOptions: null,
         value: null,
         children: childrenState.childIds,
-        attributes: attributeState.getAttributes
+        attributes: this.attributeState.getAttributes
       },
       this.instanceConfig
     );
@@ -41786,7 +42011,7 @@ class Root extends DescendantNode {
       childrenState
     );
     childrenState.setChildren(buildChildren(this));
-    attributeState.setAttributes(buildAttributes(this));
+    this.attributeState.setAttributes(buildAttributes(this));
     this.validationState = createAggregatedViolations(this, this.instanceConfig);
     this.instanceState = createRootInstanceState(this);
   }
@@ -41814,6 +42039,7 @@ class PrimaryInstance extends InstanceNode {
   // InstanceNode
   state;
   engineState;
+  attributeState;
   instanceNode;
   getChildren;
   hasReadonlyAncestor = () => false;
@@ -41840,7 +42066,6 @@ class PrimaryInstance extends InstanceNode {
   isAttached;
   evaluator;
   contextNode = this;
-  attributeState;
   constructor(options) {
     const { mode, initialState, scope, model, secondaryInstances, config } = options;
     const { instance: modelInstance } = model;
@@ -41871,9 +42096,8 @@ class PrimaryInstance extends InstanceNode {
     this.evaluator = evaluator;
     this.classes = definition.classes;
     const childrenState = createChildrenState(this);
-    const attributeState = createAttributeState(this.scope);
+    this.attributeState = createAttributeState(this.scope);
     this.getChildren = childrenState.getChildren;
-    this.attributeState = attributeState;
     const stateSpec = {
       activeLanguage: getActiveLanguage,
       reference: PRIMARY_INSTANCE_REFERENCE,
@@ -41885,7 +42109,7 @@ class PrimaryInstance extends InstanceNode {
       valueOptions: null,
       value: null,
       children: childrenState.childIds,
-      attributes: attributeState.getAttributes
+      attributes: this.attributeState.getAttributes
     };
     const state = createSharedNodeState(scope, stateSpec, config);
     this.state = state;
@@ -41900,9 +42124,12 @@ class PrimaryInstance extends InstanceNode {
     };
     this.instanceState = createPrimaryInstanceState(this);
     childrenState.setChildren([root]);
-    attributeState.setAttributes(buildAttributes(this));
+    this.attributeState.setAttributes(buildAttributes(this));
     setIsAttached(true);
   }
+  getAttributes() {
+    return this.attributeState.getAttributes();
+  }
   // PrimaryInstanceDocument
   /**
    * @todo Note that this method's signature is intentionally derived from
@@ -41943,9 +42170,6 @@ class PrimaryInstance extends InstanceNode {
     });
     return Promise.resolve(result);
   }
-  getAttributes() {
-    return this.attributeState.getAttributes();
-  }
 }
 
 class FormInstance {
@@ -41954,7 +42178,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,