@getodk/xforms-engine 0.14.0 → 0.15.0

package/dist/index.js

@@ -7899,7 +7899,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
   }, {
@@ -7984,7 +7984,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
   }, {
@@ -8003,7 +8003,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
   }, {
@@ -8027,7 +8027,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
   }, {
@@ -8110,7 +8110,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)),
@@ -21900,7 +21900,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) {
@@ -21955,33 +21955,33 @@ 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, namespaceDeclarations) => {
+  return serializeElementXML(qualifiedName, xmlValue.normalize(), "", namespaceDeclarations);
 };
 
 class NamespaceDeclaration {
@@ -22210,6 +22210,59 @@ class NodeDefinition {
   nodeset;
 }
 
+class AttributeDefinition extends NodeDefinition {
+  constructor(root, bind, template) {
+    super(bind);
+    this.template = template;
+    const { value } = template;
+    this.root = 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.root, 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);
@@ -22225,7 +22278,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}`);
     }
@@ -22235,11 +22288,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;
@@ -22262,6 +22317,7 @@ class LeafNodeDefinition extends DescendentNodeDefinition {
   namespaceDeclarations;
   qualifiedName;
   children = null;
+  attributes = null;
   toJSON() {
     const { bind, bodyElement, parent, root, ...rest } = this;
     return rest;
@@ -25918,7 +25974,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
 }, {
@@ -25992,7 +26048,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
 }, {
@@ -26010,7 +26066,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
 }, {
@@ -26033,7 +26089,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
 }, {
@@ -26109,7 +26165,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)),
@@ -26571,8 +26627,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;
@@ -26580,7 +26636,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;
@@ -26591,6 +26648,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() {
@@ -26609,48 +26667,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;
@@ -26668,7 +26684,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);
   }
@@ -26705,7 +26721,7 @@ class RootDefinition extends NodeDefinition {
       const bodyElement = body.getBodyElement(nodeset);
       const [firstChild, ...restChildren] = children;
       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}`);
@@ -26717,7 +26733,7 @@ class RootDefinition extends NodeDefinition {
         }
         return NoteNodeDefinition.from(parent, bind, bodyElement, element) ?? new LeafNodeDefinition(parent, bind, bodyElement, element);
       }
-      return new GroupDefinition(parent, bind, bodyElement, element);
+      return new GroupDefinition(model, parent, bind, bodyElement, element);
     });
   }
   toJSON() {
@@ -28887,6 +28903,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([]);
@@ -29199,6 +29239,249 @@ class InstanceNode {
   }
 }
 
+const createAttributeNodeInstanceState = (node) => {
+  const { qualifiedName } = node.definition;
+  return {
+    get instanceXML() {
+      const xmlValue = escapeXMLText(node.currentState.instanceValue, true);
+      return serializeAttributeXML(qualifiedName, xmlValue);
+    }
+  };
+};
+
+const expressionEvaluator = (evaluator, type, expression, options) => {
+  switch (type) {
+    case "boolean":
+      return () => {
+        return evaluator.evaluateBoolean(expression, options);
+      };
+    case "nodes":
+      return () => {
+        return evaluator.evaluateNodes(expression, options);
+      };
+    case "number":
+      return () => {
+        return evaluator.evaluateNumber(expression, options);
+      };
+    case "string":
+      return () => {
+        return evaluator.evaluateString(expression, options);
+      };
+    default:
+      throw new UnreachableError$1(type);
+  }
+};
+const DEFAULT_BOOLEAN_EVALUATION = false;
+const DEFAULT_NODES_EVALUATION = [];
+const DEFAULT_NUMBER_EVALUATION = NaN;
+const DEFAULT_STRING_EVALUATION = "";
+const defaultEvaluationsByType = {
+  boolean: DEFAULT_BOOLEAN_EVALUATION,
+  nodes: DEFAULT_NODES_EVALUATION,
+  number: DEFAULT_NUMBER_EVALUATION,
+  string: DEFAULT_STRING_EVALUATION
+};
+const createComputedExpression = (context, dependentExpression, options = {}) => {
+  return context.scope.runTask(() => {
+    const { contextNode, evaluator } = context;
+    const { expression, isTranslated, resultType } = dependentExpression;
+    const evaluatePreInitializationDefaultValue = () => {
+      return options?.defaultValue ?? defaultEvaluationsByType[resultType];
+    };
+    const evaluateExpression = expressionEvaluator(evaluator, resultType, expression, {
+      contextNode
+    });
+    if (isConstantExpression(expression)) {
+      return createMemo(evaluateExpression);
+    }
+    return createMemo(() => {
+      if (!context.isAttached()) {
+        return evaluatePreInitializationDefaultValue();
+      }
+      if (isTranslated) {
+        context.getActiveLanguage();
+      }
+      return evaluateExpression();
+    });
+  });
+};
+
+const isInstanceFirstLoad$1 = (context) => {
+  return context.rootDocument.initializationMode === "create";
+};
+const isEditInitialLoad$1 = (context) => {
+  return context.rootDocument.initializationMode === "edit";
+};
+const getInitialValue$1 = (context) => {
+  const sourceNode = context.instanceNode ?? context.definition.template;
+  return context.decodeInstanceValue(sourceNode.value);
+};
+const createRelevantValueState$1 = (context, baseValueState) => {
+  return context.scope.runTask(() => {
+    const [getRelevantValue, setValue] = baseValueState;
+    const getValue = createMemo(() => {
+      if (context.isRelevant()) {
+        return getRelevantValue();
+      }
+      return "";
+    });
+    return [getValue, setValue];
+  });
+};
+const guardDownstreamReadonlyWrites$1 = (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$1 = 'concat("uuid:", uuid())';
+const shouldPreloadUID$1 = (context) => {
+  return isInstanceFirstLoad$1(context) || isEditInitialLoad$1(context);
+};
+const setPreloadUIDValue$1 = (context, valueState) => {
+  const { preload } = context.definition.bind;
+  if (preload?.type !== "uid" || !shouldPreloadUID$1(context)) {
+    return;
+  }
+  const preloadUIDValue = context.evaluator.evaluateString(PRELOAD_UID_EXPRESSION$1, {
+    contextNode: context.contextNode
+  });
+  const [, setValue] = valueState;
+  setValue(preloadUIDValue);
+};
+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 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);
+    }
+    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 [];
+  }
+}
+
+function buildAttributes(parent) {
+  return Array.from(parent.definition.attributes.values()).map((attributeDefinition) => {
+    return new Attribute(parent, attributeDefinition, attributeDefinition.template);
+  });
+}
+
 class InstanceAttachmentsState extends Map {
   constructor(sourceAttachments = null) {
     super();
@@ -29215,14 +29498,12 @@ class InstanceAttachmentsState extends Map {
 const createRootInstanceState = (node) => {
   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())
-      });
+      return serializeParentElementXML(
+        node.definition.qualifiedName,
+        node.currentState.children,
+        node.currentState.attributes,
+        node.definition.namespaceDeclarations
+      );
     }
   };
 };
@@ -29276,63 +29557,6 @@ const createAggregatedViolations = (context, options) => {
 
 const XFORMS_XPATH_NODE_RANGE_KIND = "comment";
 
-const expressionEvaluator = (evaluator, type, expression, options) => {
-  switch (type) {
-    case "boolean":
-      return () => {
-        return evaluator.evaluateBoolean(expression, options);
-      };
-    case "nodes":
-      return () => {
-        return evaluator.evaluateNodes(expression, options);
-      };
-    case "number":
-      return () => {
-        return evaluator.evaluateNumber(expression, options);
-      };
-    case "string":
-      return () => {
-        return evaluator.evaluateString(expression, options);
-      };
-    default:
-      throw new UnreachableError$1(type);
-  }
-};
-const DEFAULT_BOOLEAN_EVALUATION = false;
-const DEFAULT_NODES_EVALUATION = [];
-const DEFAULT_NUMBER_EVALUATION = NaN;
-const DEFAULT_STRING_EVALUATION = "";
-const defaultEvaluationsByType = {
-  boolean: DEFAULT_BOOLEAN_EVALUATION,
-  nodes: DEFAULT_NODES_EVALUATION,
-  number: DEFAULT_NUMBER_EVALUATION,
-  string: DEFAULT_STRING_EVALUATION
-};
-const createComputedExpression = (context, dependentExpression, options = {}) => {
-  return context.scope.runTask(() => {
-    const { contextNode, evaluator } = context;
-    const { expression, isTranslated, resultType } = dependentExpression;
-    const evaluatePreInitializationDefaultValue = () => {
-      return options?.defaultValue ?? defaultEvaluationsByType[resultType];
-    };
-    const evaluateExpression = expressionEvaluator(evaluator, resultType, expression, {
-      contextNode
-    });
-    if (isConstantExpression(expression)) {
-      return createMemo(evaluateExpression);
-    }
-    return createMemo(() => {
-      if (!context.isAttached()) {
-        return evaluatePreInitializationDefaultValue();
-      }
-      if (isTranslated) {
-        context.getActiveLanguage();
-      }
-      return evaluateExpression();
-    });
-  });
-};
-
 class DescendantNode extends InstanceNode {
   constructor(parent, instanceNode, definition, options) {
     super(parent.instanceConfig, parent, instanceNode, definition, options);
@@ -29358,6 +29582,11 @@ class DescendantNode extends InstanceNode {
             return true;
           }
         }
+        for (const attr of parent.getAttributes()) {
+          if (attr === self) {
+            return true;
+          }
+        }
         return false;
       });
     });
@@ -29469,10 +29698,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
+      );
     }
   };
 };
@@ -39746,6 +39976,7 @@ const createNodeLabel = (context, definition) => {
 
 class Group extends DescendantNode {
   childrenState;
+  attributeState;
   [XPathNodeKindKey] = "element";
   // InstanceNode
   state;
@@ -39761,7 +39992,9 @@ 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;
+    this.attributeState = attributeState;
     const state = createSharedNodeState(
       this.scope,
       {
@@ -39772,6 +40005,7 @@ class Group extends DescendantNode {
         label: createNodeLabel(this, definition),
         hint: null,
         children: childrenState.childIds,
+        attributes: attributeState.getAttributes,
         valueOptions: null,
         value: null
       },
@@ -39785,12 +40019,16 @@ class Group extends DescendantNode {
       childrenState
     );
     childrenState.setChildren(buildChildren(this));
+    attributeState.setAttributes(buildAttributes(this));
     this.validationState = createAggregatedViolations(this, this.instanceConfig);
     this.instanceState = createParentNodeInstanceState(this);
   }
   getChildren() {
     return this.childrenState.getChildren();
   }
+  getAttributes() {
+    return this.attributeState.getAttributes();
+  }
 }
 
 const createFieldHint = (context, definition) => {
@@ -40094,6 +40332,7 @@ class InputControl extends ValueNode {
         label: createNodeLabel(this, definition),
         hint: createFieldHint(this, definition),
         children: null,
+        attributes: null,
         valueOptions: null,
         value: this.valueState,
         instanceValue: this.getInstanceValue
@@ -40137,6 +40376,7 @@ class ModelValue extends ValueNode {
         label: null,
         hint: null,
         children: null,
+        attributes: null,
         valueOptions: null,
         value: this.valueState,
         instanceValue: this.getInstanceValue
@@ -40264,6 +40504,7 @@ class Note extends ValueNode {
         hint,
         noteText,
         children: null,
+        attributes: null,
         valueOptions: null,
         value: this.valueState,
         instanceValue: this.getInstanceValue
@@ -40343,6 +40584,7 @@ class RangeControl extends ValueNode {
         label: createNodeLabel(this, definition),
         hint: createFieldHint(this, definition),
         children: null,
+        attributes: null,
         valueOptions: null,
         value: this.valueState,
         instanceValue: this.getInstanceValue
@@ -40600,6 +40842,7 @@ class RankControl extends ValueNode {
         label: createNodeLabel(this, definition),
         hint: createFieldHint(this, definition),
         children: null,
+        attributes: null,
         valueOptions,
         value: valueState,
         instanceValue: this.getInstanceValue
@@ -40661,26 +40904,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
+      );
     }
   };
 };
@@ -40701,7 +40935,9 @@ 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.attributeState = attributeState;
     this.currentIndex = currentIndex;
     const state = createSharedNodeState(
       this.scope,
@@ -40713,7 +40949,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
@@ -40736,6 +40972,7 @@ class RepeatInstance extends DescendantNode {
     this.instanceState = createTemplatedNodeInstanceState(this);
   }
   childrenState;
+  attributeState;
   currentIndex;
   [XPathNodeKindKey] = "element";
   // InstanceNode
@@ -40770,10 +41007,14 @@ class RepeatInstance extends DescendantNode {
   getChildren() {
     return this.childrenState.getChildren();
   }
+  getAttributes() {
+    return this.attributeState.getAttributes();
+  }
 }
 
 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:
@@ -40813,7 +41054,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,
       {
@@ -40824,6 +41067,7 @@ class BaseRepeatRange extends DescendantNode {
         label: createNodeLabel(this, definition),
         hint: null,
         children: childrenState.childIds,
+        attributes: attributeState.getAttributes,
         valueOptions: null,
         value: null
       },
@@ -40891,6 +41135,9 @@ class BaseRepeatRange extends DescendantNode {
   getChildren() {
     return this.childrenState.getChildren();
   }
+  getAttributes() {
+    return this.attributeState.getAttributes();
+  }
 }
 
 class RepeatRangeControlled extends BaseRepeatRange {
@@ -41134,6 +41381,7 @@ class SelectControl extends ValueNode {
         label: createNodeLabel(this, definition),
         hint: createFieldHint(this, definition),
         children: null,
+        attributes: null,
         valueOptions,
         value: valueState,
         instanceValue: this.getInstanceValue,
@@ -41269,6 +41517,7 @@ class TriggerControl extends ValueNode {
         label: createNodeLabel(this, definition),
         hint: createFieldHint(this, definition),
         children: null,
+        attributes: null,
         valueOptions: null,
         value: this.valueState,
         instanceValue: this.getInstanceValue
@@ -41467,6 +41716,8 @@ 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.decodeInstanceValue = instanceAttachment.decodeInstanceValue;
     this.getXPathValue = instanceAttachment.getInstanceValue;
     const state = createSharedNodeState(
@@ -41481,6 +41732,7 @@ class UploadControl extends DescendantNode {
         children: null,
         valueOptions: null,
         value: instanceAttachment.valueState,
+        attributes: attributeState.getAttributes,
         instanceValue: instanceAttachment.getInstanceValue
       },
       this.instanceConfig
@@ -41497,6 +41749,7 @@ class UploadControl extends DescendantNode {
   }
   validation;
   instanceAttachment;
+  attributeState;
   // XFormsXPathElement
   [XPathNodeKindKey] = "element";
   getXPathValue;
@@ -41531,6 +41784,9 @@ class UploadControl extends DescendantNode {
     this.instanceAttachment.setValue(value);
     return this.root;
   }
+  getAttributes() {
+    return this.attributeState.getAttributes();
+  }
 }
 
 const META_LOCAL_NAME = "meta";
@@ -41812,6 +42068,7 @@ const buildChildren = (parent) => {
 
 class Root extends DescendantNode {
   childrenState;
+  attributeState;
   // XFormsXPathElement
   [XPathNodeKindKey] = "element";
   // DescendantNode
@@ -41843,7 +42100,9 @@ class Root extends DescendantNode {
     });
     this.classes = parent.classes;
     const childrenState = createChildrenState(this);
+    const attributeState = createAttributeState(this.scope);
     this.childrenState = childrenState;
+    this.attributeState = attributeState;
     this.languages = parent.languages;
     const state = createSharedNodeState(
       this.scope,
@@ -41857,7 +42116,8 @@ class Root extends DescendantNode {
         required: () => false,
         valueOptions: null,
         value: null,
-        children: childrenState.childIds
+        children: childrenState.childIds,
+        attributes: attributeState.getAttributes
       },
       this.instanceConfig
     );
@@ -41869,12 +42129,16 @@ class Root extends DescendantNode {
       childrenState
     );
     childrenState.setChildren(buildChildren(this));
+    attributeState.setAttributes(buildAttributes(this));
     this.validationState = createAggregatedViolations(this, this.instanceConfig);
     this.instanceState = createRootInstanceState(this);
   }
   getChildren() {
     return this.childrenState.getChildren();
   }
+  getAttributes() {
+    return this.attributeState.getAttributes();
+  }
   // RootNode
   setLanguage(language) {
     this.rootDocument.setLanguage(language);
@@ -41919,6 +42183,7 @@ class PrimaryInstance extends InstanceNode {
   isAttached;
   evaluator;
   contextNode = this;
+  attributeState;
   constructor(options) {
     const { mode, initialState, scope, model, secondaryInstances, config } = options;
     const { instance: modelInstance } = model;
@@ -41949,7 +42214,9 @@ class PrimaryInstance extends InstanceNode {
     this.evaluator = evaluator;
     this.classes = definition.classes;
     const childrenState = createChildrenState(this);
+    const attributeState = createAttributeState(this.scope);
     this.getChildren = childrenState.getChildren;
+    this.attributeState = attributeState;
     const stateSpec = {
       activeLanguage: getActiveLanguage,
       reference: PRIMARY_INSTANCE_REFERENCE,
@@ -41960,7 +42227,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;
@@ -41975,6 +42243,7 @@ class PrimaryInstance extends InstanceNode {
     };
     this.instanceState = createPrimaryInstanceState(this);
     childrenState.setChildren([root]);
+    attributeState.setAttributes(buildAttributes(this));
     setIsAttached(true);
   }
   // PrimaryInstanceDocument
@@ -42017,6 +42286,9 @@ class PrimaryInstance extends InstanceNode {
     });
     return Promise.resolve(result);
   }
+  getAttributes() {
+    return this.attributeState.getAttributes();
+  }
 }
 
 class FormInstance {