@getodk/xforms-engine 0.1.1 → 0.2.0

package/dist/solid.js

@@ -1,7 +1,8 @@
-import { createUniqueId as createUniqueId$1, createSignal, createMemo, createComputed, untrack, createRoot, getOwner, runWithOwner, on } from 'solid-js';
+import { createUniqueId as createUniqueId$1, createSignal, createComputed, untrack, createRoot, getOwner, runWithOwner, createMemo, on } from 'solid-js';
 
 const identity$1 = (value) => value;
 
+const XMLNS_NAMESPACE_URI$1 = "http://www.w3.org/2000/xmlns/";
 const JAVAROSA_NAMESPACE_URI$1 = "http://openrosa.org/javarosa";
 const XFORMS_NAMESPACE_URI$1 = "http://www.w3.org/2002/xforms";
 
@@ -34053,7 +34054,50 @@ const normalizeBodyRefNodesetAttributes = (body) => {
     }
   }
 };
-const normalizeRepeatGroups = (xformDocument, body) => {
+const normalizeRepeatGroupAttributes = (group, repeat) => {
+  for (const groupAttribute of group.attributes) {
+    const { localName, namespaceURI, nodeName, value } = groupAttribute;
+    if (
+      // Don't propagate namespace declarations (which appear as attributes in
+      // the browser/XML DOM, either named `xmlns` or with an `xmlns` prefix,
+      // always in the XMLNS namespace).
+      namespaceURI === XMLNS_NAMESPACE_URI$1 || // Don't propagate `ref`, it has been normalized as `nodeset` on the
+      // repeat element.
+      localName === "ref" || // TODO: this accommodates tests of this normalization process, where
+      // certain nodes of interest are given an `id` attribute, and looked up
+      // for the purpose of asserting what was normalized about them. It's
+      // unclear if there's a generally expected behavior around the attribute.
+      localName === "id"
+    ) {
+      continue;
+    }
+    if (localName === "appearance" && namespaceURI === XFORMS_NAMESPACE_URI$1 && repeat.hasAttribute(localName)) {
+      const ref = group.getAttribute("ref");
+      throw new Error(
+        `Failed to normalize conflicting "appearances" attribute of group/repeat "${ref}"`
+      );
+    }
+    repeat.setAttributeNS(namespaceURI, nodeName, value);
+  }
+};
+const normalizeRepeatGroupLabel = (group, repeat) => {
+  const groupLabel = Array.from(group.children).find((child) => {
+    return child.localName === "label";
+  });
+  if (groupLabel == null) {
+    return;
+  }
+  const repeatLabel = groupLabel.cloneNode(true);
+  repeatLabel.setAttribute("form-definition-source", "repeat-group");
+  repeat.prepend(repeatLabel);
+  groupLabel.remove();
+};
+const unwrapRepeatGroup = (group, repeat) => {
+  normalizeRepeatGroupAttributes(group, repeat);
+  normalizeRepeatGroupLabel(group, repeat);
+  group.replaceWith(repeat);
+};
+const normalizeRepeatGroups = (body) => {
   const repeats = body.querySelectorAll("repeat");
   for (const repeat of repeats) {
     const parent = repeat.parentElement;
@@ -34068,11 +34112,8 @@ const normalizeRepeatGroups = (xformDocument, body) => {
         group = parent;
       }
     }
-    if (group == null) {
-      group = xformDocument.createElementNS(XFORMS_NAMESPACE_URI$1, "group");
-      group.setAttribute("ref", repeatNodeset);
-      repeat.before(group);
-      group.append(repeat);
+    if (group != null) {
+      unwrapRepeatGroup(group, repeat);
     }
   }
 };
@@ -34090,7 +34131,7 @@ const parseNormalizedXForm = (sourceXML, options) => {
     normalizedXML = sourceXML;
   } else {
     normalizeBodyRefNodesetAttributes(body);
-    normalizeRepeatGroups(xformDocument, body);
+    normalizeRepeatGroups(body);
     normalizedXML = html.outerHTML;
   }
   return {
@@ -34222,6 +34263,70 @@ class DependencyContext {
   }
 }
 
+const XML_XPATH_WHITESPACE_SUBPATTERN = "[\\x20\\x09\\x0D\\x0A]";
+const XML_XPATH_WHITESPACE_PATTERN = new RegExp(XML_XPATH_WHITESPACE_SUBPATTERN, "g");
+const XML_XPATH_LEADING_TRAILING_WHITESPACE_PATTERN = new RegExp(
+  `^${XML_XPATH_WHITESPACE_SUBPATTERN}+|${XML_XPATH_WHITESPACE_SUBPATTERN}+$`,
+  "g"
+);
+const XPATH_REPEATING_WHITESPACE_PATTERN = new RegExp(
+  `${XML_XPATH_WHITESPACE_SUBPATTERN}{2,}`,
+  "g"
+);
+const trimXMLXPathWhitespace = (value) => value.replaceAll(XML_XPATH_LEADING_TRAILING_WHITESPACE_PATTERN, "");
+const normalizeXMLXPathWhitespace = (value) => trimXMLXPathWhitespace(value).replaceAll(XPATH_REPEATING_WHITESPACE_PATTERN, " ");
+const xmlXPathWhitespaceSeparatedList = (value, options) => {
+  if (options?.ignoreEmpty && value === "") {
+    return [];
+  }
+  return normalizeXMLXPathWhitespace(value).split(XML_XPATH_WHITESPACE_PATTERN);
+};
+
+class TokenListParser {
+  constructor(canonicalTokens, options) {
+    this.canonicalTokens = canonicalTokens;
+    this.aliases = new Map(
+      (options?.aliases ?? []).map(({ fromAlias, toCanonical }) => {
+        return [fromAlias, toCanonical];
+      })
+    );
+  }
+  aliases;
+  parseFrom(element, attributeName) {
+    const serialized = element.getAttribute(attributeName) ?? "";
+    const specified = xmlXPathWhitespaceSeparatedList(serialized, {
+      ignoreEmpty: true
+    });
+    const { aliases } = this;
+    const resolved = specified.flatMap((token) => {
+      const alias = aliases.get(token);
+      if (alias == null) {
+        return token;
+      }
+      return [alias, token];
+    });
+    const tokens = new Set(resolved);
+    return new Proxy(
+      {
+        [Symbol.iterator]() {
+          return resolved.values();
+        }
+      },
+      {
+        get(target, property, receiver) {
+          if (typeof property === "symbol") {
+            return Reflect.get(target, property, receiver);
+          }
+          return tokens.has(property);
+        },
+        set() {
+          return false;
+        }
+      }
+    );
+  }
+}
+
 class BodyElementDefinition extends DependencyContext {
   constructor(form, parent, element) {
     super();
@@ -34246,17 +34351,7 @@ class BodyElementDefinition extends DependencyContext {
   }
 }
 
-class UnsupportedBodyElementDefinition extends BodyElementDefinition {
-  static isCompatible() {
-    return true;
-  }
-  category = "UNSUPPORTED";
-  type = "UNSUPPORTED";
-  reference = null;
-  constructor(form, parent, element) {
-    super(form, parent, element);
-  }
-}
+const structureElementAppearanceParser = new TokenListParser(["field-list", "table-list"]);
 
 const SUPPORTS_SCOPE_CHILD_SELECTOR = (() => {
   const parent = document.createElement("parent");
@@ -34318,7 +34413,10 @@ const hintLookup = new ScopedElementLookup(":scope > hint", "hint");
 const itemLookup = new ScopedElementLookup(":scope > item", "item");
 const itemsetLookup = new ScopedElementLookup(":scope > itemset[nodeset]", "itemset[nodeset]");
 const labelLookup = new ScopedElementLookup(":scope > label", "label");
-const repeatLookup = new ScopedElementLookup(":scope > repeat[nodeset]", "repeat[nodeset]");
+const repeatGroupLabelLookup = new ScopedElementLookup(
+  ':scope > label[form-definition-source="repeat-group"]',
+  'label[form-definition-source="repeat-group"]'
+);
 const valueLookup = new ScopedElementLookup(":scope > value", "value");
 const getHintElement = (parent) => {
   return hintLookup.getElement(parent);
@@ -34332,8 +34430,8 @@ const getItemsetElement = (parent) => {
 const getLabelElement = (parent) => {
   return labelLookup.getElement(parent);
 };
-const getRepeatElement = (parent) => {
-  return repeatLookup.getElement(parent);
+const getRepeatGroupLabelElement = (parent) => {
+  return repeatGroupLabelLookup.getElement(parent);
 };
 const getValueElement = (parent) => {
   return valueLookup.getElement(parent);
@@ -34641,17 +34739,6 @@ class TextElementDefinition extends BodyElementDefinition {
   }
 }
 
-class HintDefinition extends TextElementDefinition {
-  static forElement(form, definition) {
-    const hintElement = getHintElement(definition.element);
-    if (hintElement == null) {
-      return null;
-    }
-    return new this(form, definition, hintElement);
-  }
-  type = "hint";
-}
-
 class LabelDefinition extends TextElementDefinition {
   static staticDefinition(form, definition) {
     const labelElement = getLabelElement(definition.element);
@@ -34663,6 +34750,13 @@ class LabelDefinition extends TextElementDefinition {
   static forControl(form, control) {
     return this.staticDefinition(form, control);
   }
+  static forRepeatGroup(form, repeat) {
+    const repeatGroupLabel = getRepeatGroupLabelElement(repeat.element);
+    if (repeatGroupLabel == null) {
+      return null;
+    }
+    return new this(form, repeat, repeatGroupLabel);
+  }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   static forGroup(form, group) {
     return this.staticDefinition(form, group);
@@ -34680,6 +34774,68 @@ class LabelDefinition extends TextElementDefinition {
   type = "label";
 }
 
+class RepeatElementDefinition extends BodyElementDefinition {
+  static isCompatible(localName) {
+    return localName === "repeat";
+  }
+  category = "structure";
+  type = "repeat";
+  reference;
+  appearances;
+  label;
+  // TODO: this will fall into the growing category of non-`BindExpression`
+  // cases which have roughly the same design story.
+  countExpression;
+  isFixedCount;
+  children;
+  constructor(form, parent, element) {
+    super(form, parent, element);
+    this.label = LabelDefinition.forRepeatGroup(form, this);
+    const reference = element.getAttribute("nodeset");
+    if (reference == null) {
+      throw new Error("Invalid repeat: missing `nodeset` reference");
+    }
+    this.reference = reference;
+    this.appearances = structureElementAppearanceParser.parseFrom(element, "appearance");
+    this.countExpression = element.getAttributeNS(JAVAROSA_NAMESPACE_URI$1, "count");
+    const childElements = Array.from(element.children).filter((childElement) => {
+      const { localName } = childElement;
+      return localName !== "label" && localName !== "group-label";
+    });
+    const children = BodyDefinition.getChildElementDefinitions(form, this, element, childElements);
+    this.children = children;
+    const noAddRemove = element.getAttributeNS(JAVAROSA_NAMESPACE_URI$1, "noAddRemove")?.trim().replaceAll(/\s+/g, "") ?? "false()";
+    this.isFixedCount = noAddRemove === "true()";
+  }
+  toJSON() {
+    const { form, parent, ...rest } = this;
+    return rest;
+  }
+}
+
+class UnsupportedBodyElementDefinition extends BodyElementDefinition {
+  static isCompatible() {
+    return true;
+  }
+  category = "UNSUPPORTED";
+  type = "UNSUPPORTED";
+  reference = null;
+  constructor(form, parent, element) {
+    super(form, parent, element);
+  }
+}
+
+class HintDefinition extends TextElementDefinition {
+  static forElement(form, definition) {
+    const hintElement = getHintElement(definition.element);
+    if (hintElement == null) {
+      return null;
+    }
+    return new this(form, definition, hintElement);
+  }
+  type = "hint";
+}
+
 class ControlDefinition extends BodyElementDefinition {
   category = "control";
   reference;
@@ -34697,13 +34853,84 @@ class ControlDefinition extends BodyElementDefinition {
   }
 }
 
+const inputAppearanceParser = new TokenListParser([
+  "multiline",
+  "numbers",
+  "url",
+  "thousand-sep",
+  // date (TODO: data types)
+  "no-calendar",
+  "month-year",
+  "year",
+  // date > calendars
+  "ethiopian",
+  "coptic",
+  "islamic",
+  "bikram-sambat",
+  "myanmar",
+  "persian",
+  // geo (TODO: data types)
+  "placement-map",
+  "maps",
+  // image/media (TODO: move to eventual `<upload>`?)
+  "hidden-answer",
+  "annotate",
+  "draw",
+  "signature",
+  "new-front",
+  "new",
+  "front",
+  // *?
+  "printer",
+  // Note: actual usage uses `printer:...` (like `ex:...`).
+  "masked"
+]);
+
 class InputDefinition extends ControlDefinition {
   static isCompatible(localName) {
     return localName === "input";
   }
   type = "input";
+  appearances;
+  constructor(form, parent, element) {
+    super(form, parent, element);
+    this.appearances = inputAppearanceParser.parseFrom(element, "appearance");
+  }
 }
 
+const selectAppearanceParser = new TokenListParser(
+  [
+    // From XLSForm Docs:
+    "compact",
+    "horizontal",
+    "horizontal-compact",
+    "label",
+    "list-nolabel",
+    "minimal",
+    // From Collect `Appearances.kt`:
+    "columns",
+    "columns-1",
+    "columns-2",
+    "columns-3",
+    "columns-4",
+    "columns-5",
+    // Note: Collect supports arbitrary columns-n. Technically we do too (we parse
+    // out any appearance, not just those we know about). But we'll only include
+    // types/defaults up to 5.
+    "columns-pack",
+    "autocomplete",
+    // TODO: these are `<select1>` only
+    "likert",
+    "quick",
+    "quickcompact",
+    "map"
+    // "quick map"
+  ],
+  {
+    aliases: [{ fromAlias: "search", toCanonical: "autocomplete" }]
+  }
+);
+
 class ItemDefinition extends BodyElementDefinition {
   constructor(form, parent, element) {
     const valueElement = getValueElement(element);
@@ -34757,7 +34984,11 @@ class ItemsetDefinition extends BodyElementDefinition {
   }
 }
 
-const selectLocalNames = /* @__PURE__ */ new Set(["rank", "select", "select1"]);
+const selectLocalNames = /* @__PURE__ */ new Set([
+  /* 'rank', */
+  "select",
+  "select1"
+]);
 const isSelectElement = (element, localName = element.localName) => {
   return selectLocalNames.has(localName);
 };
@@ -34770,6 +35001,7 @@ class SelectDefinition extends ControlDefinition {
   }
   type;
   element;
+  appearances;
   itemset;
   items;
   constructor(form, parent, element) {
@@ -34777,8 +35009,9 @@ class SelectDefinition extends ControlDefinition {
       throw new Error(`Invalid select element: <${element.nodeName}>`);
     }
     super(form, parent, element);
-    this.element = element;
     this.type = element.localName;
+    this.element = element;
+    this.appearances = selectAppearanceParser.parseFrom(element, "appearance");
     const itemsetElement = getItemsetElement(element);
     const itemElements = getItemElements(element);
     if (itemsetElement == null) {
@@ -34811,22 +35044,16 @@ class UpsertableMap extends Map {
 }
 
 class BaseGroupDefinition extends BodyElementDefinition {
+  // TODO: does this really accomplish anything? It seems highly unlikely it
+  // has enough performance benefit to outweigh its memory and lookup costs.
   static groupTypes = new UpsertableMap();
   static getGroupType(localName, element) {
     return this.groupTypes.upsert(element, () => {
       if (localName !== "group") {
         return null;
       }
-      const ref = element.getAttribute("ref");
-      if (ref != null) {
-        const repeat = getRepeatElement(element);
-        if (repeat == null) {
-          return "logical-group";
-        }
-        if (repeat.getAttribute("nodeset") === ref) {
-          return "repeat-group";
-        }
-        throw new Error("Unexpected <repeat> child of unrelated <group>");
+      if (element.hasAttribute("ref")) {
+        return "logical-group";
       }
       const label = getLabelElement(element);
       if (label == null) {
@@ -34838,18 +35065,20 @@ class BaseGroupDefinition extends BodyElementDefinition {
   category = "structure";
   children;
   reference;
+  appearances;
   label;
   constructor(form, parent, element, children) {
     super(form, parent, element);
     this.children = children ?? this.getChildren(element);
     this.reference = element.getAttribute("ref");
+    this.appearances = structureElementAppearanceParser.parseFrom(element, "appearance");
     this.label = LabelDefinition.forGroup(form, this);
   }
   getChildren(element) {
     const { form } = this;
     const children = Array.from(element.children).filter((child) => {
       const childName = child.localName;
-      return childName !== "label" && childName !== "repeat";
+      return childName !== "label";
     });
     return BodyDefinition.getChildElementDefinitions(form, this, element, children);
   }
@@ -34878,54 +35107,6 @@ class PresentationGroupDefinition extends BaseGroupDefinition {
   }
 }
 
-class RepeatDefinition extends BodyElementDefinition {
-  constructor(form, groupDefinition, element) {
-    super(form, groupDefinition, element);
-    this.groupDefinition = groupDefinition;
-    const reference = element.getAttribute("nodeset");
-    if (reference == null) {
-      throw new Error("Invalid repeat: missing `nodeset` reference");
-    }
-    this.reference = reference;
-    this.countExpression = element.getAttributeNS(JAVAROSA_NAMESPACE_URI$1, "count");
-    this.children = groupDefinition.getChildren(element);
-    const noAddRemove = element.getAttributeNS(JAVAROSA_NAMESPACE_URI$1, "noAddRemove")?.trim().replaceAll(/\s+/g, "") ?? "false()";
-    this.isFixedCount = noAddRemove === "true()";
-  }
-  category = "structure";
-  type = "repeat";
-  reference;
-  // TODO: this will fall into the growing category of non-`BindExpression`
-  // cases which have roughly the same design story.
-  countExpression;
-  isFixedCount;
-  children;
-  toJSON() {
-    const { form, groupDefinition, parent, ...rest } = this;
-    return rest;
-  }
-}
-
-class RepeatGroupDefinition extends BaseGroupDefinition {
-  static isCompatible(localName, element) {
-    return this.getGroupType(localName, element) === "repeat-group";
-  }
-  type = "repeat-group";
-  repeat;
-  get repeatChildren() {
-    return this.repeat.children;
-  }
-  constructor(form, parent, element) {
-    const repeat = getRepeatElement(element);
-    if (repeat == null) {
-      throw new Error("Invalid repeat-group");
-    }
-    super(form, parent, element);
-    const repeatDefinition = new RepeatDefinition(form, this, repeat);
-    this.repeat = repeatDefinition;
-  }
-}
-
 class StructuralGroupDefinition extends BaseGroupDefinition {
   static isCompatible(localName, element) {
     return this.getGroupType(localName, element) === "structural-group";
@@ -34934,7 +35115,7 @@ class StructuralGroupDefinition extends BaseGroupDefinition {
 }
 
 const BodyElementDefinitionConstructors = [
-  RepeatGroupDefinition,
+  RepeatElementDefinition,
   LogicalGroupDefinition,
   PresentationGroupDefinition,
   StructuralGroupDefinition,
@@ -34949,12 +35130,12 @@ class BodyElementMap extends Map {
   mapElementsByReference(elements) {
     for (const element of elements) {
       const { reference } = element;
-      if (element instanceof RepeatGroupDefinition) {
+      if (element instanceof RepeatElementDefinition) {
         if (reference == null) {
-          throw new Error("Missing reference for repeat/repeat group");
+          throw new Error("Missing reference for repeat");
         }
         this.set(reference, element);
-        this.mapElementsByReference(element.repeatChildren);
+        this.mapElementsByReference(element.children);
       }
       if (element instanceof LogicalGroupDefinition || element instanceof PresentationGroupDefinition || element instanceof StructuralGroupDefinition) {
         if (reference != null) {
@@ -34980,6 +35161,10 @@ class BodyElementMap extends Map {
     return Object.fromEntries(this.entries());
   }
 }
+const bodyClassParser = new TokenListParser([
+  "pages"
+  /*, 'theme-grid' */
+]);
 class BodyDefinition extends DependencyContext {
   constructor(form) {
     super();
@@ -34987,6 +35172,7 @@ class BodyDefinition extends DependencyContext {
     const { body: element } = form.xformDOM;
     this.reference = form.rootReference;
     this.element = element;
+    this.classes = bodyClassParser.parseFrom(element, "class");
     this.elements = BodyDefinition.getChildElementDefinitions(form, this, element);
     this.elementsByReference = new BodyElementMap(this.elements);
   }
@@ -35002,6 +35188,23 @@ class BodyDefinition extends DependencyContext {
     });
   }
   element;
+  /**
+   * @todo this class is already an oddity in that it's **like** an element
+   * definition, but it isn't one itself. Adding this property here emphasizes
+   * that awkwardness. It also extends the applicable scope where instances of
+   * this class are accessed. While it's still ephemeral, it's anticipated that
+   * this extension might cause some disomfort. If so, the most plausible
+   * alternative is an additional refactor to:
+   *
+   * 1. Introduce a `BodyElementDefinition` sublass for `<h:body>`.
+   * 2. Disambiguate the respective names of those, in some reasonable way.
+   * 3. Add a layer of indirection between this class and that new body element
+   *    definition's class.
+   * 4. At that point, we may as well prioritize the little bit of grunt work to
+   *    pass the `BodyDefinition` instance by reference rather than assigning it
+   *    to anything.
+   */
+  classes;
   elements;
   elementsByReference;
   // DependencyContext
@@ -35010,13 +35213,6 @@ class BodyDefinition extends DependencyContext {
   getBodyElement(reference) {
     return this.elementsByReference.get(reference) ?? null;
   }
-  getRepeatGroup(reference) {
-    const element = this.getBodyElement(reference);
-    if (element?.type === "repeat-group") {
-      return element;
-    }
-    return null;
-  }
   toJSON() {
     const { form, ...rest } = this;
     return rest;
@@ -35249,17 +35445,11 @@ class DescendentNodeDefinition {
 }
 
 class RepeatInstanceDefinition extends DescendentNodeDefinition {
-  constructor(sequence, node) {
-    const {
-      bind,
-      bodyElement: repeatGroupBodyElement,
-      parent: repeatSequenceParent,
-      root
-    } = sequence;
-    super(repeatSequenceParent, bind, repeatGroupBodyElement.repeat);
-    this.sequence = sequence;
+  constructor(range, node) {
+    const { bind, bodyElement, parent, root } = range;
+    super(parent, bind, bodyElement);
     this.node = node;
-    this.nodeName = sequence.nodeName;
+    this.nodeName = range.nodeName;
     this.children = root.buildSubtree(this);
   }
   type = "repeat-instance";
@@ -35268,7 +35458,7 @@ class RepeatInstanceDefinition extends DescendentNodeDefinition {
   instances = null;
   defaultValue = null;
   toJSON() {
-    const { bind, bodyElement, parent, root, sequence, ...rest } = this;
+    const { bind, bodyElement, parent, root, ...rest } = this;
     return rest;
   }
 }
@@ -35307,15 +35497,9 @@ const splitInstanceNodes = (modelNodes) => {
   return [template, ...modelNodes];
 };
 class RepeatTemplateDefinition extends DescendentNodeDefinition {
-  constructor(sequence, templateNode) {
-    const {
-      bind,
-      bodyElement: repeatGroupBodyElement,
-      parent: repeatSequenceParent,
-      root
-    } = sequence;
-    super(repeatSequenceParent, bind, repeatGroupBodyElement.repeat);
-    this.sequence = sequence;
+  constructor(range, templateNode) {
+    const { bind, bodyElement, parent, root } = range;
+    super(parent, bind, bodyElement);
     this.templateNode = templateNode;
     const node = templateNode.cloneNode(true);
     node.removeAttributeNS(JAVAROSA_NAMESPACE_URI$1, "template");
@@ -35323,14 +35507,14 @@ class RepeatTemplateDefinition extends DescendentNodeDefinition {
     this.nodeName = node.localName;
     this.children = root.buildSubtree(this);
   }
-  static parseModelNodes(sequence, modelNodes) {
-    const { bind } = sequence;
+  static parseModelNodes(range, modelNodes) {
+    const { bind } = range;
     let template = repeatTemplates.get(bind);
     let instanceNodes;
     if (template == null) {
       const [templateNode, ...rest] = splitInstanceNodes(modelNodes);
       instanceNodes = rest;
-      template = new this(sequence, templateNode);
+      template = new this(range, templateNode);
     } else {
       const duplicateTemplate = modelNodes.find(
         (node) => node.hasAttributeNS(JAVAROSA_NAMESPACE_URI$1, "template")
@@ -35352,12 +35536,12 @@ class RepeatTemplateDefinition extends DescendentNodeDefinition {
   instances = null;
   defaultValue = null;
   toJSON() {
-    const { bind, bodyElement, parent, root, sequence, ...rest } = this;
+    const { bind, bodyElement, parent, root, ...rest } = this;
     return rest;
   }
 }
 
-class RepeatSequenceDefinition extends DescendentNodeDefinition {
+class RepeatRangeDefinition extends DescendentNodeDefinition {
   // TODO: if an implicit template is derived from an instance in a form
   // definition, should its default values (if any) be cleared? Probably!
   static createTemplateElement(instanceElement) {
@@ -35366,7 +35550,7 @@ class RepeatSequenceDefinition extends DescendentNodeDefinition {
   static createInstanceElement(templateElement) {
     return templateElement.cloneNode(true);
   }
-  type = "repeat-sequence";
+  type = "repeat-range";
   template;
   children = null;
   instances;
@@ -35390,7 +35574,7 @@ class RepeatSequenceDefinition extends DescendentNodeDefinition {
 
 class SubtreeDefinition extends DescendentNodeDefinition {
   constructor(parent, bind, bodyElement, node) {
-    if (bodyElement != null && (bodyElement.category !== "structure" || bodyElement.type === "repeat-group")) {
+    if (bodyElement != null && (bodyElement.category !== "structure" || bodyElement.type === "repeat")) {
       throw new Error(`Unexpected body element for nodeset ${bind.nodeset}`);
     }
     super(parent, bind, bodyElement);
@@ -35432,9 +35616,10 @@ class ValueNodeDefinition extends DescendentNodeDefinition {
 }
 
 class RootDefinition {
-  constructor(form, model) {
+  constructor(form, model, classes) {
     this.form = form;
     this.model = model;
+    this.classes = classes;
     const { primaryInstanceRoot } = form.xformDOM;
     const { localName: rootNodeName } = primaryInstanceRoot;
     this.nodeName = rootNodeName;
@@ -35483,13 +35668,8 @@ class RootDefinition {
       const bind = binds.getOrCreateBindDefinition(nodeset);
       const bodyElement = body.getBodyElement(nodeset);
       const [firstChild, ...restChildren] = children;
-      const repeatGroup = body.getRepeatGroup(nodeset);
-      if (repeatGroup != null) {
-        const repeatDefinition = bodyElement.repeat;
-        if (repeatDefinition == null) {
-          throw 'TODO: this is why I have hesitated to pick an "is repeat" predicate direction';
-        }
-        return new RepeatSequenceDefinition(parent, bind, repeatGroup, children);
+      if (bodyElement?.type === "repeat") {
+        return new RepeatRangeDefinition(parent, bind, bodyElement, children);
       }
       if (restChildren.length) {
         throw new Error(`Unexpected: multiple elements for non-repeat nodeset: ${nodeset}`);
@@ -35512,7 +35692,7 @@ class ModelDefinition {
   constructor(form) {
     this.form = form;
     this.binds = ModelBindMap.fromModel(this);
-    this.root = new RootDefinition(form, this);
+    this.root = new RootDefinition(form, this, form.body.classes);
   }
   binds;
   root;
@@ -35642,11 +35822,26 @@ const createUniqueId = (() => {
 
 const createChildrenState = (parent) => {
   return parent.scope.runTask(() => {
-    const children = createSignal([]);
-    const [getChildren, setChildren] = children;
-    const childIds = createMemo(() => {
-      return getChildren().map((child) => child.nodeId);
-    });
+    const baseState = createSignal([]);
+    const [getChildren, baseSetChildren] = baseState;
+    const ids = createSignal([]);
+    const [childIds, setChildIds] = ids;
+    const setChildren = (valueOrSetterCallback) => {
+      let setterCallback;
+      if (typeof valueOrSetterCallback === "function") {
+        setterCallback = valueOrSetterCallback;
+      } else {
+        setterCallback = (_) => valueOrSetterCallback;
+      }
+      return baseSetChildren((prev) => {
+        const result = setterCallback(prev);
+        setChildIds(() => {
+          return result.map((child) => child.nodeId);
+        });
+        return result;
+      });
+    };
+    const children = [getChildren, setChildren];
     return {
       children,
       getChildren,
@@ -35656,13 +35851,13 @@ const createChildrenState = (parent) => {
   });
 };
 
-const materializeCurrentStateChildren = (currentState, childrenState) => {
+const materializeCurrentStateChildren = (scope, currentState, childrenState) => {
   const baseState = currentState;
   const proxyTarget = baseState;
   return new Proxy(proxyTarget, {
     get(_, key) {
       if (key === "children") {
-        currentState.children;
+        scope.runTask(() => currentState.children);
         const children = childrenState.getChildren();
         return children;
       }
@@ -35865,104 +36060,59 @@ const declareNodeID = (id) => {
 };
 
 class InstanceNode {
-  constructor(engineConfig, parent, definition) {
+  constructor(engineConfig, parent, definition, options) {
     this.engineConfig = engineConfig;
     this.parent = parent;
     this.definition = definition;
+    this.computeReference = options?.computeReference ?? this.computeChildStepReference;
     this.scope = createReactiveScope();
     this.engineConfig = engineConfig;
     this.nodeId = declareNodeID(engineConfig.createUniqueId());
     this.definition = definition;
-    const checkStateInitialized = () => this.engineState != null;
-    const [isStateInitialized, setStateInitialized] = createSignal(checkStateInitialized());
-    this.isStateInitialized = isStateInitialized;
-    queueMicrotask(() => {
-      if (checkStateInitialized()) {
-        setStateInitialized(true);
-      } else {
-        throw new Error("Node state was never initialized");
-      }
-    });
-  }
-  isStateInitialized;
-  /**
-   * Provides a generalized mechanism for accessing a reactive state value
-   * during a node's construction, while {@link engineState} is still being
-   * defined and thus isn't assigned.
-   *
-   * The fallback value specified in {@link options} will be returned on access
-   * until {@link isStateInitialized} returns true. This ensures:
-   *
-   * - a value of the expected type will be available
-   * - any read access will become reactive to the actual state, once it has
-   *   been initialized and {@link engineState} is assigned
-   *
-   * @todo This is one among several chicken/egg problems encountered trying to
-   * support state initialization in which some aspects of the state derive from
-   * other aspects of it. It would be nice to dispense with this entirely. But
-   * if it must persist, we should also consider replacing the method with a
-   * direct accessor once state initialization completes, so the initialized
-   * check is only called until it becomes impertinent.
-   */
-  getInitializedState(key, options) {
-    if (this.isStateInitialized()) {
-      return this.engineState[key];
-    }
-    return options.uninitializedFallback;
-  }
-  /**
-   * @package Exposed on every node type to facilitate inheritance, as well as
-   * conditional behavior for value nodes.
-   */
-  get isReadonly() {
-    return this.getInitializedState("readonly", {
-      uninitializedFallback: false
-    });
-  }
-  /**
-   * @package Exposed on every node type to facilitate inheritance, as well as
-   * conditional behavior for value nodes.
-   */
-  get isRelevant() {
-    return this.getInitializedState("relevant", {
-      uninitializedFallback: true
-    });
   }
   // BaseNode: identity
   nodeId;
   // EvaluationContext *and* Subscribable: node-specific
   scope;
+  computeReference;
+  computeChildStepReference = (parent, definition) => {
+    if (parent == null) {
+      throw new Error(
+        "Cannot compute child step reference of node without parent (was this called from `Root`?)"
+      );
+    }
+    return `${parent.contextReference()}/${definition.nodeName}`;
+  };
   // EvaluationContext: node-specific
-  get contextReference() {
+  contextReference = () => {
     return this.computeReference(this.parent, this.definition);
-  }
-  getNodeByReference(visited, dependencyReference) {
+  };
+  getNodesByReference(visited, dependencyReference) {
     if (visited.has(this)) {
-      return null;
+      return [];
     }
     visited.add(this);
     const { nodeset } = this.definition;
     if (dependencyReference === nodeset) {
-      return this;
+      if (this.nodeType === "repeat-instance") {
+        return [this.parent];
+      }
+      return [this];
     }
     if (dependencyReference.startsWith(`${nodeset}/`) || dependencyReference.startsWith(`${nodeset}[`)) {
-      const children = this.getChildren();
-      if (children == null) {
-        return null;
-      }
-      for (const child of children) {
-        const dependency = child.getNodeByReference(visited, dependencyReference);
-        if (dependency != null) {
-          return dependency;
-        }
-      }
+      return this.getChildren().flatMap((child) => {
+        return child.getNodesByReference(visited, dependencyReference);
+      });
     }
-    return this.parent?.getNodeByReference(visited, dependencyReference) ?? null;
+    return this.parent?.getNodesByReference(visited, dependencyReference) ?? [];
   }
   // EvaluationContext: node-relative
-  getSubscribableDependencyByReference(reference) {
-    const visited = /* @__PURE__ */ new WeakSet();
-    return this.getNodeByReference(visited, reference);
+  getSubscribableDependenciesByReference(reference) {
+    if (this.nodeType === "root") {
+      const visited = /* @__PURE__ */ new WeakSet();
+      return this.getNodesByReference(visited, reference);
+    }
+    return this.root.getSubscribableDependenciesByReference(reference);
   }
   // SubscribableDependency
   /**
@@ -36054,7 +36204,7 @@ const createComputedExpression = (context, dependentExpression) => {
     }
     const getReferencedDependencies = createMemo(() => {
       return dependencyReferences.flatMap((reference) => {
-        return context.getSubscribableDependencyByReference(reference) ?? [];
+        return context.getSubscribableDependenciesByReference(reference) ?? [];
       });
     });
     let getDependencies;
@@ -36145,42 +36295,45 @@ const createNodeLabel = (context, definition) => {
 };
 
 class DescendantNode extends InstanceNode {
-  constructor(parent, definition) {
-    super(parent.engineConfig, parent, definition);
+  constructor(parent, definition, options) {
+    super(parent.engineConfig, parent, definition, options);
     this.parent = parent;
     this.definition = definition;
     const { evaluator, root } = parent;
     this.root = root;
     this.evaluator = evaluator;
     this.contextNode = this.initializeContextNode(parent.contextNode, definition.nodeName);
-  }
+    const { readonly, relevant, required } = definition.bind;
+    this.isSelfReadonly = createComputedExpression(this, readonly);
+    this.isSelfRelevant = createComputedExpression(this, relevant);
+    this.isRequired = createComputedExpression(this, required);
+  }
+  hasReadonlyAncestor = () => {
+    const { parent } = this;
+    return parent.hasReadonlyAncestor() || parent.isReadonly();
+  };
+  isSelfReadonly;
+  isReadonly = () => {
+    if (this.hasReadonlyAncestor()) {
+      return true;
+    }
+    return this.isSelfReadonly();
+  };
+  hasNonRelevantAncestor = () => {
+    const { parent } = this;
+    return parent.hasNonRelevantAncestor() || !parent.isRelevant();
+  };
+  isSelfRelevant;
+  isRelevant = () => {
+    if (this.hasNonRelevantAncestor()) {
+      return false;
+    }
+    return this.isSelfRelevant();
+  };
+  isRequired;
   root;
   evaluator;
   contextNode;
-  computeChildStepReference(parent) {
-    return `${parent.contextReference}/${this.definition.nodeName}`;
-  }
-  buildSharedStateSpec(parent, definition) {
-    return this.scope.runTask(() => {
-      const reference = createMemo(() => this.contextReference);
-      const { bind } = definition;
-      const selfReadonly = createComputedExpression(this, bind.readonly);
-      const readonly = createMemo(() => {
-        return parent.isReadonly || selfReadonly();
-      });
-      const selfRelevant = createComputedExpression(this, bind.relevant);
-      const relevant = createMemo(() => {
-        return parent.isRelevant && selfRelevant();
-      });
-      const required = createComputedExpression(this, bind.required);
-      return {
-        reference,
-        readonly,
-        relevant,
-        required
-      };
-    });
-  }
   createContextNode(parentContextNode, nodeName) {
     return parentContextNode.ownerDocument.createElement(nodeName);
   }
@@ -36243,16 +36396,21 @@ class Group extends DescendantNode {
   state;
   engineState;
   // GroupNode
-  currentState;
   nodeType = "group";
+  appearances;
+  currentState;
   constructor(parent, definition) {
     super(parent, definition);
+    this.appearances = definition.bodyElement.appearances;
     const childrenState = createChildrenState(this);
     this.childrenState = childrenState;
     const state = createSharedNodeState(
       this.scope,
       {
-        ...this.buildSharedStateSpec(parent, definition),
+        reference: this.contextReference,
+        readonly: this.isReadonly,
+        relevant: this.isRelevant,
+        required: this.isRequired,
         label: createNodeLabel(this, definition),
         hint: null,
         children: childrenState.childIds,
@@ -36265,12 +36423,13 @@ class Group extends DescendantNode {
     );
     this.state = state;
     this.engineState = state.engineState;
-    this.currentState = materializeCurrentStateChildren(state.currentState, childrenState);
+    this.currentState = materializeCurrentStateChildren(
+      this.scope,
+      state.currentState,
+      childrenState
+    );
     childrenState.setChildren(buildChildren(this));
   }
-  computeReference(parent) {
-    return this.computeChildStepReference(parent);
-  }
   getChildren() {
     return this.childrenState.getChildren();
   }
@@ -36295,20 +36454,30 @@ const insertAtIndex = (currentValues, insertionIndex, newValue) => {
 
 class RepeatInstance extends DescendantNode {
   constructor(parent, definition, options) {
-    super(parent, definition);
-    this.parent = parent;
-    const childrenState = createChildrenState(this);
-    this.childrenState = childrenState;
-    options.precedingPrimaryInstanceNode.after(this.contextNode);
     const { precedingInstance } = options;
     const precedingIndex = precedingInstance?.currentIndex ?? (() => -1);
     const initialIndex = precedingIndex() + 1;
     const [currentIndex, setCurrentIndex] = createSignal(initialIndex);
+    super(parent, definition, {
+      computeReference: () => {
+        const currentPosition = currentIndex() + 1;
+        return `${parent.contextReference()}[${currentPosition}]`;
+      }
+    });
+    this.parent = parent;
+    this.appearances = definition.bodyElement.appearances;
+    const childrenState = createChildrenState(this);
+    this.childrenState = childrenState;
+    options.precedingPrimaryInstanceNode.after(this.contextNode);
     this.currentIndex = currentIndex;
     const state = createSharedNodeState(
       this.scope,
       {
-        ...this.buildSharedStateSpec(parent, definition),
+        reference: this.contextReference,
+        readonly: this.isReadonly,
+        relevant: this.isRelevant,
+        required: this.isRequired,
+        // TODO: only-child <group><label>
         label: createNodeLabel(this, definition),
         hint: null,
         children: childrenState.childIds,
@@ -36321,7 +36490,11 @@ class RepeatInstance extends DescendantNode {
     );
     this.state = state;
     this.engineState = state.engineState;
-    this.currentState = materializeCurrentStateChildren(state.currentState, childrenState);
+    this.currentState = materializeCurrentStateChildren(
+      this.scope,
+      state.currentState,
+      childrenState
+    );
     this.scope.runTask(() => {
       const computeCurrentIndex = parent.getInstanceIndex.bind(parent, this);
       createComputed(on(computeCurrentIndex, setCurrentIndex, { defer: true }));
@@ -36333,13 +36506,29 @@ class RepeatInstance extends DescendantNode {
   // InstanceNode
   state;
   engineState;
+  /**
+   * A repeat instance can inherit non-relevance, just like any other node. That
+   * inheritance is derived from the repeat instance's parent node in the
+   * primary instance XML/DOM tree (and would be semantically expected to do so
+   * even if we move away from that implementation detail).
+   *
+   * Since {@link RepeatInstance.parent} is a {@link RepeatRange}, which is a
+   * runtime data model fiction that does not exist in that hierarchy, we pass
+   * this call through, allowing the {@link RepeatRange} to check the actual
+   * primary instance parent node's relevance state.
+   *
+   * @todo Should we apply similar reasoning in {@link hasReadonlyAncestor}?
+   */
+  hasNonRelevantAncestor = () => {
+    return this.parent.hasNonRelevantAncestor();
+  };
   // RepeatInstanceNode
   nodeType = "repeat-instance";
+  /**
+   * @see {@link RepeatRange.appearances}
+   */
+  appearances;
   currentState;
-  computeReference(parent) {
-    const currentPosition = this.currentIndex() + 1;
-    return `${parent.contextReference}[${currentPosition}]`;
-  }
   initializeContextNode(parentContextNode, nodeName) {
     return this.createContextNode(parentContextNode, nodeName);
   }
@@ -36403,17 +36592,118 @@ class RepeatRange extends DescendantNode {
   // InstanceNode
   state;
   engineState;
+  emptyRangeEvaluationContext;
+  /**
+   * @see {@link isSelfRelevant}
+   */
+  isEmptyRangeSelfRelevant;
+  /**
+   * A repeat range does not exist in the primary instance tree. A `relevant`
+   * expression applies to each {@link RepeatInstance} child of the repeat
+   * range. Determining whether a repeat range itself "is relevant" isn't a
+   * concept the spec addresses, but it may be used by clients to determine
+   * whether to allow interaction with the range (e.g. by adding a repeat
+   * instance, or presenting the range's label when empty).
+   *
+   * As a naive first pass, it seems like the heuristic for this should be:
+   *
+   * 1. Does the repeat range have any repeat instance children?
+   *
+   *     - If yes, go to 2.
+   *     - If no, go to 3.
+   *
+   * 2. Does one or more of those children return `true` for the node's
+   *    `relevant` expression (i.e. is the repeat instance "self relevant")?
+   *
+   * 3. Does the relevant expression return `true` for the repeat range itself
+   *    (where, at least for now, the context of that evaluation would be the
+   *    repeat range's {@link anchorNode} to ensure correct relative expressions
+   *    resolve correctly)?
+   *
+   * @todo While (3) is proactively implemented, there isn't presently a test
+   * exercising it. It felt best for now to surface this for discussion in
+   * review to validate that it's going in the right direction.
+   *
+   * @todo While (2) **is actually tested**, the tests currently in place behave
+   * the same way with only the logic for (3), regardless of whether the repeat
+   * range actually has any repeat instance children. It's unclear (a) if that's
+   * a preferable simplification and (b) how that might affect performance (in
+   * theory it could vary depending on form structure and runtime state).
+   */
+  isSelfRelevant = () => {
+    const instances = this.childrenState.getChildren();
+    if (instances.length > 0) {
+      return instances.some((instance) => instance.isSelfRelevant());
+    }
+    return this.isEmptyRangeSelfRelevant();
+  };
   // RepeatRangeNode
   nodeType = "repeat-range";
+  /**
+   * @todo RepeatRange*, RepeatInstance* (and RepeatTemplate*) all share the
+   * same body element, and thus all share the same definition `bodyElement`. As
+   * such, they also all share the same `appearances`. At time of writing,
+   * `web-forms` (Vue UI package) treats a `RepeatRangeNode`...
+   *
+   * - ... as a group, if the node has a label (i.e.
+   *   `<group><label/><repeat/></group>`)
+   * - ... effectively as a fragment containing only its instances, otherwise
+   *
+   * We now collapse `<group><repeat>` into `<repeat>`, and no longer treat
+   * "repeat group" as a concept (after parsing). According to the spec, these
+   * appearances **are supposed to** come from that "repeat group" in the form
+   * definition. In practice, many forms do define appearances directly on a
+   * repeat element. The engine currently produces an error if both are defined
+   * simultaneously, but otherwise makes no distinction between appearances in
+   * these form definition shapes:
+   *
+   * ```xml
+   * <group ref="/data/rep1" appearance="...">
+   *   <repeat nodeset="/data/rep1"/>
+   * </group>
+   *
+   * <group ref="/data/rep1">
+   *   <repeat nodeset="/data/rep1"/ appearance="...">
+   * </group>
+   *
+   * <repeat nodeset="/data/rep1"/ appearance="...">
+   * ```
+   *
+   * All of the above creates considerable ambiguity about where "repeat
+   * appearances" should apply, under which circumstances.
+   */
+  appearances;
   currentState;
   constructor(parent, definition) {
     super(parent, definition);
+    this.appearances = definition.bodyElement.appearances;
     const childrenState = createChildrenState(this);
     this.childrenState = childrenState;
+    this.anchorNode = this.contextNode.ownerDocument.createComment(
+      `Begin repeat range: ${definition.nodeset}`
+    );
+    this.contextNode.append(this.anchorNode);
+    this.emptyRangeEvaluationContext = {
+      scope: this.scope,
+      evaluator: this.evaluator,
+      root: this.root,
+      contextReference: this.contextReference,
+      contextNode: this.anchorNode,
+      getSubscribableDependenciesByReference: (reference) => {
+        return this.getSubscribableDependenciesByReference(reference);
+      }
+    };
+    this.isEmptyRangeSelfRelevant = createComputedExpression(
+      this.emptyRangeEvaluationContext,
+      definition.bind.relevant
+    );
     const state = createSharedNodeState(
       this.scope,
       {
-        ...this.buildSharedStateSpec(parent, definition),
+        reference: this.contextReference,
+        readonly: this.isReadonly,
+        relevant: this.isRelevant,
+        required: this.isRequired,
         label: createNodeLabel(this, definition),
         hint: null,
         children: childrenState.childIds,
@@ -36424,13 +36714,13 @@ class RepeatRange extends DescendantNode {
         clientStateFactory: this.engineConfig.stateFactory
       }
     );
-    this.anchorNode = this.contextNode.ownerDocument.createComment(
-      `Begin repeat range: ${definition.nodeset}`
-    );
-    this.contextNode.append(this.anchorNode);
     this.state = state;
     this.engineState = state.engineState;
-    this.currentState = materializeCurrentStateChildren(state.currentState, childrenState);
+    this.currentState = materializeCurrentStateChildren(
+      this.scope,
+      state.currentState,
+      childrenState
+    );
     definition.instances.forEach((instanceDefinition, index) => {
       const afterIndex = index - 1;
       this.addInstances(afterIndex, 1, instanceDefinition);
@@ -36442,9 +36732,6 @@ class RepeatRange extends DescendantNode {
   initializeContextNode(parentContextNode) {
     return parentContextNode;
   }
-  computeReference(parent) {
-    return this.computeChildStepReference(parent);
-  }
   getInstanceIndex(instance) {
     return this.engineState.children.indexOf(instance.nodeId);
   }
@@ -36516,25 +36803,6 @@ class RepeatRange extends DescendantNode {
   }
 }
 
-const XML_XPATH_WHITESPACE_SUBPATTERN = "[\\x20\\x09\\x0D\\x0A]";
-const XML_XPATH_WHITESPACE_PATTERN = new RegExp(XML_XPATH_WHITESPACE_SUBPATTERN, "g");
-const XML_XPATH_LEADING_TRAILING_WHITESPACE_PATTERN = new RegExp(
-  `^${XML_XPATH_WHITESPACE_SUBPATTERN}+|${XML_XPATH_WHITESPACE_SUBPATTERN}+$`,
-  "g"
-);
-const XPATH_REPEATING_WHITESPACE_PATTERN = new RegExp(
-  `${XML_XPATH_WHITESPACE_SUBPATTERN}{2,}`,
-  "g"
-);
-const trimXMLXPathWhitespace = (value) => value.replaceAll(XML_XPATH_LEADING_TRAILING_WHITESPACE_PATTERN, "");
-const normalizeXMLXPathWhitespace = (value) => trimXMLXPathWhitespace(value).replaceAll(XPATH_REPEATING_WHITESPACE_PATTERN, " ");
-const xmlXPathWhitespaceSeparatedList = (value, options) => {
-  if (value === "") {
-    return [];
-  }
-  return normalizeXMLXPathWhitespace(value).split(XML_XPATH_WHITESPACE_PATTERN);
-};
-
 const createSelectItemLabel = (context, definition) => {
   const { label, value } = definition;
   return createTextRange(context, "label", label, {
@@ -36563,15 +36831,14 @@ class ItemsetItemEvaluationContext {
     this.scope = selectField.scope;
     this.evaluator = selectField.evaluator;
     this.root = selectField.root;
+    this.contextReference = selectField.contextReference;
   }
   scope;
   evaluator;
   root;
-  get contextReference() {
-    return this.selectField.contextReference;
-  }
-  getSubscribableDependencyByReference(reference) {
-    return this.selectField.getSubscribableDependencyByReference(reference);
+  contextReference;
+  getSubscribableDependenciesByReference(reference) {
+    return this.selectField.getSubscribableDependenciesByReference(reference);
   }
 }
 const createSelectItemsetItemLabel = (context, definition, itemValue) => {
@@ -36635,7 +36902,7 @@ const createPrimaryInstanceValueState = (context, options) => {
     const initialValue = initialValueSource === "PRIMARY_INSTANCE" ? contextNode.textContent ?? defaultValue : defaultValue;
     const persistedValueState = createSignal(
       {
-        isRelevant: context.isRelevant,
+        isRelevant: context.isRelevant(),
         value: initialValue
       },
       {
@@ -36652,7 +36919,7 @@ const createPrimaryInstanceValueState = (context, options) => {
     );
     const [persistedValue, setValueForPersistence] = persistedValueState;
     createComputed(() => {
-      const isRelevant = context.isRelevant;
+      const isRelevant = context.isRelevant();
       setValueForPersistence((persisted) => {
         return {
           isRelevant,
@@ -36675,7 +36942,7 @@ const createPrimaryInstanceValueState = (context, options) => {
     });
     const setPrimaryInstanceValue = (value) => {
       const persisted = setValueForPersistence({
-        isRelevant: context.isRelevant,
+        isRelevant: context.isRelevant(),
         value
       });
       return persisted.value;
@@ -36704,8 +36971,8 @@ const guardDownstreamReadonlyWrites = (context, baseState) => {
   }
   const [getValue, baseSetValue] = baseState;
   const setValue = (value) => {
-    if (context.isReadonly) {
-      const reference = untrack(() => context.contextReference);
+    if (context.isReadonly()) {
+      const reference = untrack(() => context.contextReference());
       throw new Error(`Cannot write to readonly field: ${reference}`);
     }
     return baseSetValue(value);
@@ -36716,7 +36983,7 @@ const createCalculation = (context, setValue, calculateDefinition) => {
   context.scope.runTask(() => {
     const calculate = createComputedExpression(context, calculateDefinition);
     createComputed(() => {
-      if (context.isRelevant) {
+      if (context.isRelevant()) {
         const calculated = calculate();
         const value = context.decodeValue(calculated);
         setValue(value);
@@ -36749,6 +37016,7 @@ class SelectField extends DescendantNode {
   engineState;
   // SelectNode
   nodeType = "select";
+  appearances;
   currentState;
   // ValueContext
   encodeValue = (runtimeValue) => {
@@ -36757,7 +37025,9 @@ class SelectField extends DescendantNode {
   };
   decodeValue = (instanceValue) => {
     return this.scope.runTask(() => {
-      const values = xmlXPathWhitespaceSeparatedList(instanceValue);
+      const values = xmlXPathWhitespaceSeparatedList(instanceValue, {
+        ignoreEmpty: true
+      });
       const items = this.getSelectItemsByValue();
       return values.map((value) => {
         return items.get(value);
@@ -36769,13 +37039,17 @@ class SelectField extends DescendantNode {
   getValueOptions;
   constructor(parent, definition) {
     super(parent, definition);
+    this.appearances = definition.bodyElement.appearances;
     this.selectExclusive = definition.bodyElement.type === "select1";
     const valueOptions = createSelectItems(this);
     this.getValueOptions = valueOptions;
     const state = createSharedNodeState(
       this.scope,
       {
-        ...this.buildSharedStateSpec(parent, definition),
+        reference: this.contextReference,
+        readonly: this.isReadonly,
+        relevant: this.isRelevant,
+        required: this.isRequired,
         label: createNodeLabel(this, definition),
         hint: createFieldHint(this, definition),
         children: null,
@@ -36797,9 +37071,6 @@ class SelectField extends DescendantNode {
       })
     );
   }
-  computeReference(parent) {
-    return this.computeChildStepReference(parent);
-  }
   updateSelectedItemValues(values) {
     const itemsByValue = untrack(() => this.getSelectItemsByValue());
     const items = values.flatMap((value) => {
@@ -36862,16 +37133,21 @@ class StringField extends DescendantNode {
   engineState;
   // StringNode
   nodeType = "string";
+  appearances;
   currentState;
   // ValueContext
   encodeValue = identity$1;
   decodeValue = identity$1;
   constructor(parent, definition) {
     super(parent, definition);
+    this.appearances = definition.bodyElement?.appearances ?? null;
     const state = createSharedNodeState(
       this.scope,
       {
-        ...this.buildSharedStateSpec(parent, definition),
+        reference: this.contextReference,
+        readonly: this.isReadonly,
+        relevant: this.isRelevant,
+        required: this.isRequired,
         label: createNodeLabel(this, definition),
         hint: createFieldHint(this, definition),
         children: null,
@@ -36886,9 +37162,6 @@ class StringField extends DescendantNode {
     this.engineState = state.engineState;
     this.currentState = state.currentState;
   }
-  computeReference(parent) {
-    return this.computeChildStepReference(parent);
-  }
   // InstanceNode
   getChildren() {
     return [];
@@ -36907,6 +37180,7 @@ class Subtree extends DescendantNode {
   engineState;
   // SubtreeNode
   nodeType = "subtree";
+  appearances = null;
   currentState;
   constructor(parent, definition) {
     super(parent, definition);
@@ -36915,7 +37189,10 @@ class Subtree extends DescendantNode {
     const state = createSharedNodeState(
       this.scope,
       {
-        ...this.buildSharedStateSpec(parent, definition),
+        reference: this.contextReference,
+        readonly: this.isReadonly,
+        relevant: this.isRelevant,
+        required: this.isRequired,
         label: null,
         hint: null,
         children: childrenState.childIds,
@@ -36928,12 +37205,13 @@ class Subtree extends DescendantNode {
     );
     this.state = state;
     this.engineState = state.engineState;
-    this.currentState = materializeCurrentStateChildren(state.currentState, childrenState);
+    this.currentState = materializeCurrentStateChildren(
+      this.scope,
+      state.currentState,
+      childrenState
+    );
     childrenState.setChildren(buildChildren(this));
   }
-  computeReference(parent) {
-    return this.computeChildStepReference(parent);
-  }
   getChildren() {
     return this.childrenState.getChildren();
   }
@@ -36952,14 +37230,20 @@ const buildChildren = (parent) => {
         }
         return new Group(parent, child);
       }
-      case "repeat-sequence": {
+      case "repeat-range": {
         return new RepeatRange(parent, child);
       }
       case "value-node": {
-        if (child.bodyElement instanceof SelectDefinition) {
-          return new SelectField(parent, child);
+        switch (child.bodyElement?.type) {
+          case "select":
+          case "select1":
+            return new SelectField(parent, child);
+          case "input":
+          case void 0:
+            return new StringField(parent, child);
+          default:
+            throw new UnreachableError(child.bodyElement);
         }
-        return new StringField(parent, child);
       }
       default: {
         throw new UnreachableError(child);
@@ -36998,27 +37282,24 @@ const getInitialLanguageState = (translations) => {
   };
 };
 class Root extends InstanceNode {
-  static async initialize(xformDOM, definition, engineConfig) {
-    const instance = new Root(xformDOM, definition, engineConfig);
-    await instance.formStateInitialized();
-    return instance;
-  }
   childrenState;
   // InstanceNode
+  hasReadonlyAncestor = () => false;
+  isReadonly = () => false;
+  hasNonRelevantAncestor = () => false;
+  isRelevant = () => true;
   state;
   engineState;
   // RootNode
   nodeType = "root";
+  appearances = null;
+  classes;
   currentState;
   instanceDOM;
   // BaseNode
   root = this;
   // EvaluationContext
   evaluator;
-  rootReference;
-  get contextReference() {
-    return this.rootReference;
-  }
   contextNode;
   // RootNode
   parent = null;
@@ -37028,11 +37309,13 @@ class Root extends InstanceNode {
     return this.engineState.activeLanguage;
   }
   constructor(xformDOM, definition, engineConfig) {
-    super(engineConfig, null, definition);
+    const reference = definition.nodeset;
+    super(engineConfig, null, definition, {
+      computeReference: () => reference
+    });
+    this.classes = definition.classes;
     const childrenState = createChildrenState(this);
     this.childrenState = childrenState;
-    const reference = definition.nodeset;
-    this.rootReference = reference;
     const instanceDOM = xformDOM.createInstance();
     const evaluator = instanceDOM.primaryInstanceEvaluator;
     const { translations } = evaluator;
@@ -37057,7 +37340,11 @@ class Root extends InstanceNode {
     );
     this.state = state;
     this.engineState = state.engineState;
-    this.currentState = materializeCurrentStateChildren(state.currentState, childrenState);
+    this.currentState = materializeCurrentStateChildren(
+      this.scope,
+      state.currentState,
+      childrenState
+    );
     const contextNode = instanceDOM.xformDocument.createElement(definition.nodeName);
     instanceDOM.primaryInstanceRoot.replaceWith(contextNode);
     this.evaluator = evaluator;
@@ -37066,37 +37353,6 @@ class Root extends InstanceNode {
     this.languages = languages;
     childrenState.setChildren(buildChildren(this));
   }
-  /**
-   * Waits until form state is fully initialized.
-   *
-   * As much as possible, all instance state computations are implemented so
-   * that they complete synchronously.
-   *
-   * There is currently one exception: because instance nodes may form
-   * computation dependencies into their descendants as well as their ancestors,
-   * there is an allowance **during form initialization only** to account for
-   * this chicken/egg scenario. Note that this allowance is intentionally,
-   * strictly limited: if form state initialization is not resolved within a
-   * single microtask tick we throw/reject.
-   *
-   * All subsequent computations are always performed synchronously (and we will
-   * use tests to validate this, by utilizing the synchronously returned `Root`
-   * state from client-facing write interfaces).
-   */
-  async formStateInitialized() {
-    await new Promise((resolve) => {
-      queueMicrotask(resolve);
-    });
-    if (!this.isStateInitialized()) {
-      throw new Error(
-        "Form state initialization failed to complete in a single frame. Has some aspect of reactive computation been made asynchronous by mistake?"
-      );
-    }
-  }
-  // InstanceNode
-  computeReference(_parent, definition) {
-    return definition.nodeset;
-  }
   getChildren() {
     return this.childrenState.getChildren();
   }
@@ -37130,7 +37386,7 @@ const initializeForm$1 = async (input, options = {}) => {
   const engineConfig = buildInstanceConfig(options.config);
   const sourceXML = await retrieveSourceXMLResource(input, engineConfig);
   const form = new XFormDefinition(sourceXML);
-  return Root.initialize(form.xformDOM, form.model.root, engineConfig);
+  return new Root(form.xformDOM, form.model.root, engineConfig);
 };
 
 const initializeForm = initializeForm$1;