@getodk/xforms-engine 0.6.0 → 0.7.0

package/dist/solid.js

@@ -1,20 +1,17 @@
-import { createRoot, getOwner, runWithOwner, createUniqueId as createUniqueId$1, createSignal, createComputed, untrack, createMemo, on } from 'solid-js';
-
-const identity$1 = (value) => value;
+import { createRoot, getOwner, runWithOwner, createSignal, createComputed, untrack, createUniqueId as createUniqueId$1, createMemo, on } from 'solid-js';
 
 const MISSING_RESOURCE_BEHAVIOR = {
   /**
-   * When this behavior is configured, {@link InitializeForm | initializing} a
-   * {@link PrimaryInstance} for a form which references any **missing**
-   * resources will fail, producing an error to the calling client.
+   * When this behavior is configured, {@link LoadForm | loading a form} which
+   * references any **missing** resources will fail, producing an error to the
+   * calling client.
    *
    * @see {@link MissingResourceBehavior}
    */
   ERROR: "ERROR",
   /**
-   * When this behavior is configured, {@link InitializeForm | initializing} a
-   * {@link PrimaryInstance} for a form which references any **missing**
-   * resources will succeed (producing a warning).
+   * When this behavior is configured, {@link LoadForm | loading a form} which
+   * references any **missing** resources will succeed (producing a warning).
    *
    * Such missing resources will be parsed as if they are blank, as appropriate
    * for the resource's XForm semantic usage and/or format.
@@ -33,17 +30,77 @@ const VALIDATION_TEXT = {
   constraintMsg: "Condition not satisfied: constraint",
   requiredMsg: "Condition not satisfied: required"
 };
-const SUBMISSION_INSTANCE_FILE_NAME = "xml_submission_file";
-const SUBMISSION_INSTANCE_FILE_TYPE = "text/xml";
+const INSTANCE_FILE_NAME = "xml_submission_file";
+const INSTANCE_FILE_TYPE = "text/xml";
 
 const constants = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
 	__proto__: null,
+	INSTANCE_FILE_NAME,
+	INSTANCE_FILE_TYPE,
 	MISSING_RESOURCE_BEHAVIOR,
-	SUBMISSION_INSTANCE_FILE_NAME,
-	SUBMISSION_INSTANCE_FILE_TYPE,
 	VALIDATION_TEXT
 }, Symbol.toStringTag, { value: 'Module' }));
 
+const blobDescription = (resource) => {
+  const { name } = resource;
+  if (typeof name === "string") {
+    return name;
+  }
+  let commonConstructorName;
+  if (resource instanceof File) {
+    commonConstructorName = "File";
+  } else {
+    commonConstructorName = "Blob";
+  }
+  return `Unknown ${commonConstructorName} data`;
+};
+const formResourceMetadata = (resource) => {
+  if (resource instanceof Blob) {
+    return {
+      description: blobDescription(resource),
+      rawData: null
+    };
+  }
+  if (resource instanceof URL) {
+    return {
+      description: resource.href,
+      rawData: null
+    };
+  }
+  return {
+    description: "Raw string data",
+    rawData: resource
+  };
+};
+class LoadFormFailureError extends AggregateError {
+  constructor(resource, errors) {
+    const { description, rawData } = formResourceMetadata(resource);
+    const messageLines = [
+      `Failed to load form resource: ${description}`,
+      "\n",
+      ...errors.map((error) => {
+        const aggregatedMessage = error.message;
+        if (aggregatedMessage == null) {
+          return "- Unknown error";
+        }
+        return `- ${aggregatedMessage}`;
+      })
+    ];
+    if (rawData != null) {
+      messageLines.push("\n- - -\n", "Raw resource data:", rawData);
+    }
+    const message = messageLines.join("\n");
+    super(errors, message);
+    const [head, ...tail] = errors;
+    if (head != null && tail.length === 0) {
+      const { stack } = head;
+      if (typeof stack === "string") {
+        this.stack = stack;
+      }
+    }
+  }
+}
+
 let UnreachableError$1 = class UnreachableError extends Error {
   constructor(unrechable, additionalDetail) {
     let message = `Unreachable value: ${JSON.stringify(unrechable)}`;
@@ -141,6 +198,11 @@ const retrieveSourceXMLResource = async (resource, options) => {
   assertResourceTextIsXML(text);
   return text;
 };
+const retrieveFormDefinition = async (resource, options) => {
+  return retrieveSourceXMLResource(resource, {
+    fetchResource: options.fetchFormDefinition
+  });
+};
 
 const validateReactiveScopeAPI = (api) => {
   if (api.owner == null) {
@@ -182,11 +244,6 @@ const createReactiveScope = (options = {}) => {
   }, options.owner ?? getOwner());
 };
 
-const createUniqueId = (() => {
-  const { crypto } = globalThis;
-  return crypto?.randomUUID?.bind(crypto) ?? createUniqueId$1;
-})();
-
 const XHTML_NAMESPACE_URI$1 = "http://www.w3.org/1999/xhtml";
 const XMLNS_NAMESPACE_URI$1 = "http://www.w3.org/2000/xmlns/";
 const XSD_NAMESPACE_URI = "http://www.w3.org/2001/XMLSchema";
@@ -25104,7 +25161,7 @@ class UnreachableError extends Error {
   }
 }
 
-const identity = (value) => value;
+const identity$1 = (value) => value;
 
 class Reiterable {
   constructor(source) {
@@ -25384,7 +25441,7 @@ const getNodeTypeFilter = (domProvider, step) => {
     case "comment":
       return domProvider.filterComments;
     case "node":
-      return identity;
+      return identity$1;
     case "text":
       return domProvider.filterTextNodes;
     default:
@@ -28865,9 +28922,6 @@ class DefaultEvaluator extends Evaluator {
   }
 }
 
-const XFORMS_LOCAL_NAME = Symbol("XFORMS_LOCAL_NAME");
-const XFORMS_KNOWN_ATTRIBUTE = Symbol("XFORMS_KNOWN_ATTRIBUTE");
-
 const DAY_MILLISECONDS = 1e3 * 60 * 60 * 24;
 const MILLISECOND_NANOSECONDS = BigInt(1e6);
 const ISO_DATE_LIKE_SUBPATTERN = "\\d{4}-\\d{2}-\\d{2}";
@@ -38658,38 +38712,6 @@ class BodyDefinition extends DependencyContext {
   }
 }
 
-class FormSubmissionDefinition {
-  submissionAction;
-  submissionMethod = "post";
-  encryptionKey;
-  constructor(xformDOM) {
-    const submissionElement = getSubmissionElement(xformDOM.model);
-    let submissionAction = null;
-    let submissionMethod;
-    let encryptionKey = null;
-    if (submissionElement == null) {
-      submissionAction = null;
-      submissionMethod = "post";
-      encryptionKey = null;
-    } else {
-      const method = submissionElement.getAttribute("method")?.trim();
-      if (method == null || method === "post" || method === "form-data-post") {
-        submissionMethod = "post";
-      } else {
-        throw new Error(`Unexpected <submission method>: ${method}`);
-      }
-      const action = submissionElement.getAttribute("action");
-      if (action != null) {
-        submissionAction = new URL(action.trim());
-      }
-      encryptionKey = submissionElement.getAttribute("base64RsaPublicKey");
-    }
-    this.submissionAction = submissionAction;
-    this.submissionMethod = submissionMethod;
-    this.encryptionKey = encryptionKey;
-  }
-}
-
 class NamespaceURL extends URL {
   static from(namespaceURI) {
     if (namespaceURI == null || namespaceURI === "") {
@@ -38763,13 +38785,34 @@ class StaticNode {
   }
 }
 
+class UnprefixedXFormsName extends QualifiedName {
+  constructor(localName) {
+    super({
+      namespaceURI: XFORMS_NAMESPACE_URI$1,
+      prefix: null,
+      localName
+    });
+  }
+}
+
+const staticNodeName = (source) => {
+  if (source instanceof QualifiedName) {
+    return source;
+  }
+  if (typeof source === "string") {
+    return new UnprefixedXFormsName(source);
+  }
+  return new QualifiedName(source);
+};
+
 class StaticAttribute extends StaticNode {
   constructor(parent, options) {
     super();
     this.parent = parent;
     this.rootDocument = parent.rootDocument;
     this.root = parent.root;
-    this.qualifiedName = new QualifiedName(options);
+    this.qualifiedName = staticNodeName(options.name);
+    this.nodeset = `${parent.nodeset}/@${this.qualifiedName.getPrefixedName()}`;
     this.value = options.value;
   }
   [XPathNodeKindKey] = "attribute";
@@ -38777,6 +38820,7 @@ class StaticAttribute extends StaticNode {
   rootDocument;
   root;
   qualifiedName;
+  nodeset;
   attributes = [];
   children = null;
   value;
@@ -38786,36 +38830,140 @@ class StaticAttribute extends StaticNode {
   }
 }
 
-const assertStaticElementKnownAttributeValue = (element, localName, value) => {
-  if (localName === element[XFORMS_KNOWN_ATTRIBUTE] && value == null) {
-    throw new Error(`Expected attribute: ${element[XFORMS_KNOWN_ATTRIBUTE]}`);
+class StaticParentNode extends StaticNode {
+  [XPathNodeKindKey];
+  nodeType;
+  constructor(kind) {
+    super();
+    this[XPathNodeKindKey] = kind;
+    this.nodeType = `static-${kind}`;
   }
-};
-class StaticElement extends StaticNode {
-  constructor(parent, attributesFactory, childNodesFactory, options) {
+}
+
+class StaticText extends StaticNode {
+  constructor(parent, value) {
     super();
     this.parent = parent;
+    this.value = value;
+    this.rootDocument = parent.rootDocument;
+    this.root = parent.root;
+  }
+  [XPathNodeKindKey] = "text";
+  nodeType = "static-text";
+  rootDocument;
+  root;
+  children = null;
+  // XFormsXPathText
+  getXPathValue() {
+    return this.value;
+  }
+}
+
+const leafElementChildrenResult = (parent, leafValue) => {
+  const child = new StaticText(parent, leafValue);
+  return {
+    children: [child],
+    childElements: [],
+    leafValue
+  };
+};
+const blankLeafElementChildrenResult = (parent) => {
+  return leafElementChildrenResult(parent, "");
+};
+const buildStaticElementChildren = (parent, options) => {
+  const children = Array();
+  const childElements = Array();
+  const childOptions = options.children ?? [""];
+  if (childOptions.length === 0) {
+    return {
+      children,
+      childElements,
+      leafValue: ""
+    };
+  }
+  const [head, ...tail] = childOptions;
+  if (tail.length === 0) {
+    if (head == null) {
+      return blankLeafElementChildrenResult(parent);
+    }
+    if (typeof head === "string") {
+      return leafElementChildrenResult(parent, head);
+    }
+  }
+  if (typeof head === "string" && tail.length === 0) {
+    const child = new StaticText(parent, head);
+    children.push(child);
+    return {
+      children,
+      childElements,
+      leafValue: child.value
+    };
+  }
+  for (const item of childOptions) {
+    switch (typeof item) {
+      case "string":
+        children.push(new StaticText(parent, item));
+        break;
+      case "object": {
+        const childElement = new StaticElement(parent, item);
+        children.push(childElement);
+        childElements.push(childElement);
+        break;
+      }
+      default:
+        throw new UnreachableError$1(item);
+    }
+  }
+  return {
+    children,
+    childElements,
+    leafValue: null
+  };
+};
+class StaticElement extends StaticParentNode {
+  constructor(parent, options) {
+    super("element");
+    this.parent = parent;
     const { rootDocument } = parent;
+    let nodesetPrefix = parent.nodeset;
     this.rootDocument = rootDocument;
     if (parent === rootDocument) {
       this.root = this;
+      if (nodesetPrefix === "/") {
+        nodesetPrefix = "";
+      }
     } else {
       this.root = parent.root;
     }
-    this.qualifiedName = new QualifiedName(options);
-    this.attributes = attributesFactory(this);
-    this.children = childNodesFactory(this);
+    const { name, attributes = [] } = options;
+    this.qualifiedName = staticNodeName(name);
+    this.nodeset = `${nodesetPrefix}/${this.qualifiedName.getPrefixedName()}`;
+    this.attributes = attributes.map((attrOptions) => {
+      return new StaticAttribute(this, attrOptions);
+    });
+    const { children, childElements, leafValue } = buildStaticElementChildren(this, options);
+    this.children = children;
+    this.childElements = childElements;
+    this.computedValue = leafValue;
+    this.value = leafValue;
   }
-  [XFORMS_LOCAL_NAME];
-  [XFORMS_KNOWN_ATTRIBUTE];
-  [XPathNodeKindKey] = "element";
-  nodeType = "static-element";
+  computedValue;
   rootDocument;
   root;
   qualifiedName;
+  nodeset;
   attributes;
   children;
-  value = null;
+  childElements;
+  value;
+  isLeafElement() {
+    return this.value != null;
+  }
+  assertLeafElement() {
+    if (!this.isLeafElement()) {
+      throw new ErrorProductionDesignPendingError();
+    }
+  }
   /**
    * @todo Generalize this, incorporate into {@link EngineDOMAdapter}
    * @todo Namespaced lookup
@@ -38838,109 +38986,36 @@ class StaticElement extends StaticNode {
   getAttributeValue(localName) {
     const attribute = this.getAttributeNode(localName);
     const value = attribute?.value ?? null;
-    assertStaticElementKnownAttributeValue(this, localName, value);
     return value;
   }
   // XFormsXPathElement
   getXPathValue() {
-    return this.children.map((child) => child.getXPathValue()).join("");
-  }
-}
-
-class StaticText extends StaticNode {
-  constructor(parent, value) {
-    super();
-    this.parent = parent;
-    this.value = value;
-    this.rootDocument = parent.rootDocument;
-    this.root = parent.root;
-  }
-  [XPathNodeKindKey] = "text";
-  nodeType = "static-text";
-  rootDocument;
-  root;
-  children = null;
-  // XFormsXPathText
-  getXPathValue() {
-    return this.value;
+    const { computedValue } = this;
+    if (computedValue != null) {
+      return computedValue;
+    }
+    const result = this.children.map((child) => child.getXPathValue()).join("");
+    this.computedValue = result;
+    return result;
   }
 }
 
-const domElementAttributesFactory = (domElement) => {
-  const attributes = Array.from(domElement.attributes);
-  return (element) => {
-    return attributes.map((attr) => {
-      return new StaticAttribute(element, attr);
-    });
-  };
-};
-const { ELEMENT_NODE, CDATA_SECTION_NODE, TEXT_NODE } = Node;
-const toStaticChildNodeSource = (childNode) => {
-  const domType = childNode.nodeType;
-  switch (domType) {
-    case ELEMENT_NODE:
-      return {
-        domType,
-        domNode: childNode
-      };
-    case TEXT_NODE:
-      return {
-        domType,
-        domNode: childNode
-      };
-    case CDATA_SECTION_NODE:
-      return {
-        domType,
-        domNode: childNode
-      };
-    default:
-      return null;
-  }
-};
-const toStaticChildNodeSources = (childNode) => {
-  return toStaticChildNodeSource(childNode) ?? [];
-};
-const domElementChildNodesFactory = (domElement) => {
-  const childNodeSources = Array.from(domElement.childNodes).flatMap(toStaticChildNodeSources);
-  return (parent) => {
-    return childNodeSources.map((domSource) => {
-      switch (domSource.domType) {
-        case ELEMENT_NODE:
-          return parseStaticElementFromDOMElement(parent, StaticElement, domSource.domNode);
-        case TEXT_NODE:
-        case CDATA_SECTION_NODE:
-          return new StaticText(parent, domSource.domNode.data);
-        default:
-          throw new UnreachableError$1(domSource);
-      }
-    });
-  };
-};
-const parseStaticElementFromDOMElement = (parent, ElementConstructor, domElement) => {
-  const attributesFactory = domElementAttributesFactory(domElement);
-  const childNodesFactory = domElementChildNodesFactory(domElement);
-  return new ElementConstructor(parent, attributesFactory, childNodesFactory, domElement);
-};
-const parseStaticDocumentFromDOMSubtree = (DocumentConstructor, DocumentRootConstructor, subtreeRootElement) => {
-  const rootFactory = (parent) => {
-    return parseStaticElementFromDOMElement(parent, DocumentRootConstructor, subtreeRootElement);
-  };
-  return new DocumentConstructor(rootFactory);
-};
-
-class StaticDocument extends StaticNode {
-  [XPathNodeKindKey] = "document";
-  nodeType = "static-document";
+class StaticDocument extends StaticParentNode {
   rootDocument;
   root;
   parent = null;
+  nodeset;
   children;
-  constructor(rootFactory) {
-    super();
+  childElements;
+  constructor(options) {
+    super("document");
+    this.nodeset = options.nodesetPrefix ?? "/";
     this.rootDocument = this;
-    const root = rootFactory(this);
+    const { documentRoot } = options;
+    const root = new StaticElement(this, documentRoot);
     this.root = root;
     this.children = [root];
+    this.childElements = this.children;
   }
   // XFormsXPathDocument
   getXPathValue() {
@@ -38948,41 +39023,74 @@ class StaticDocument extends StaticNode {
   }
 }
 
-const assertItextTranslationRootKnownAttributeValue = (localName, value) => {
-  if (localName === "lang" && value == null) {
-    throw new Error("Invalid itext <translation> element: missing `lang` attribute");
-  }
+const parseNodeName = (domNode) => {
+  return {
+    namespaceURI: domNode.namespaceURI,
+    prefix: domNode.prefix,
+    localName: domNode.localName
+  };
+};
+const parseStaticElementAttributes = (domElement) => {
+  return Array.from(domElement.attributes).map((attr) => ({
+    name: attr,
+    value: attr.value
+  }));
+};
+const { ELEMENT_NODE, CDATA_SECTION_NODE, TEXT_NODE } = Node;
+const parseStaticElementChildren = (domElement) => {
+  return Array.from(domElement.childNodes).flatMap((child) => {
+    switch (child.nodeType) {
+      case ELEMENT_NODE:
+        return parseStaticElementOptions(child);
+      case TEXT_NODE:
+      case CDATA_SECTION_NODE:
+        return child.data;
+      default:
+        return [];
+    }
+  });
+};
+const parseStaticElementOptions = (domElement) => {
+  return {
+    name: parseNodeName(domElement),
+    attributes: parseStaticElementAttributes(domElement),
+    children: parseStaticElementChildren(domElement)
+  };
+};
+const parseStaticDocumentFromDOMSubtree = (subtreeRootElement, options = {}) => {
+  const documentRoot = parseStaticElementOptions(subtreeRootElement);
+  return new StaticDocument({
+    ...options,
+    documentRoot
+  });
 };
-class ItextTranslationRootDefinition extends StaticElement {
-  [XFORMS_LOCAL_NAME] = "translation";
-  [XFORMS_KNOWN_ATTRIBUTE] = "lang";
-  getAttributeValue(localName) {
-    const value = super.getAttributeValue(localName);
-    assertItextTranslationRootKnownAttributeValue(localName, value);
-    return value;
-  }
-}
-
-class ItextTranslationDefinition extends StaticDocument {
-}
 
+const assertItextTranslationsDefinitionEntry = ([
+  key,
+  root
+]) => {
+  if (key == null || root.qualifiedName.localName !== "translation") {
+    throw new Error();
+  }
+};
+const itextTranslationNodesetPrefix = (lang) => {
+  return `wf:translation('${lang}')`;
+};
 class ItextTranslationsDefinition extends Map {
   static from(xformDOM) {
-    const translationDefinitions = xformDOM.itextTranslationElements.map((element) => {
-      return parseStaticDocumentFromDOMSubtree(
-        ItextTranslationDefinition,
-        ItextTranslationRootDefinition,
-        element
-      );
+    const entries = xformDOM.itextTranslationElements.map((element) => {
+      const lang = element.getAttribute("lang");
+      const { root } = parseStaticDocumentFromDOMSubtree(element, {
+        nodesetPrefix: itextTranslationNodesetPrefix(lang)
+      });
+      const entry = [lang, root];
+      assertItextTranslationsDefinitionEntry(entry);
+      return entry;
     });
-    return new this(translationDefinitions);
+    return new this(entries);
   }
-  constructor(translations) {
-    super(
-      translations.map(({ root }) => {
-        return [root.getAttributeValue("lang"), root];
-      })
-    );
+  constructor(entries) {
+    super(entries);
   }
 }
 
@@ -39288,6 +39396,24 @@ class ModelBindMap extends Map {
   }
 }
 
+const collectDefinitions = (result, definition) => {
+  const { nodeset } = definition;
+  if (result.has(nodeset)) {
+    throw new ErrorProductionDesignPendingError();
+  }
+  result.set(nodeset, definition);
+  if (definition.type === "leaf-node") {
+    return result;
+  }
+  for (const child of definition.children) {
+    collectDefinitions(result, child);
+  }
+  return result;
+};
+const nodeDefinitionMap = (root) => {
+  return collectDefinitions(/* @__PURE__ */ new Map(), root);
+};
+
 const ATTR_REGEX = /[&<>"]/;
 const CONTENT_REGEX = /[&<>]/;
 const escapeXMLText = (text, attr) => {
@@ -39597,24 +39723,21 @@ class DescendentNodeDefinition extends NodeDefinition {
 }
 
 class LeafNodeDefinition extends DescendentNodeDefinition {
-  constructor(parent, bind, bodyElement, node) {
+  constructor(parent, bind, bodyElement, template) {
     if (bodyElement != null && bodyElement.category !== "control") {
       throw new Error(`Unexpected body element for nodeset ${bind.nodeset}`);
     }
     super(parent, bind, bodyElement);
-    this.node = node;
+    this.template = template;
     this.valueType = bind.type.resolved;
-    this.qualifiedName = new QualifiedName(node);
+    this.qualifiedName = template.qualifiedName;
     this.namespaceDeclarations = new NamespaceDeclarationMap(this);
-    this.defaultValue = node.textContent ?? "";
   }
   type = "leaf-node";
   valueType;
   namespaceDeclarations;
   qualifiedName;
   children = null;
-  instances = null;
-  defaultValue;
   toJSON() {
     const { bind, bodyElement, parent, root, ...rest } = this;
     return rest;
@@ -39625,8 +39748,8 @@ const isNoteBindDefinition = (bind) => {
   return bind.readonly.isConstantTruthyExpression();
 };
 class NoteNodeDefinition extends LeafNodeDefinition {
-  constructor(parent, bind, bodyElement, noteTextDefinition, node) {
-    super(parent, bind, bodyElement, node);
+  constructor(parent, bind, bodyElement, noteTextDefinition, template) {
+    super(parent, bind, bodyElement, template);
     this.bind = bind;
     this.bodyElement = bodyElement;
     this.noteTextDefinition = noteTextDefinition;
@@ -39867,20 +39990,22 @@ class IntValueCodec extends ValueCodec {
   }
 }
 
+const identity = (value) => value;
+
 class StringValueCodec extends ValueCodec {
   constructor() {
-    super("string", identity$1, identity$1, {
-      decodeInstanceValueFactory: () => identity$1,
-      runtimeValueStateFactory: () => identity$1
+    super("string", identity, identity, {
+      decodeInstanceValueFactory: () => identity,
+      runtimeValueStateFactory: () => identity
     });
   }
 }
 
 class ValueTypePlaceholderCodec extends ValueCodec {
   constructor(valueType) {
-    super(valueType, identity$1, identity$1, {
-      decodeInstanceValueFactory: () => identity$1,
-      runtimeValueStateFactory: () => identity$1
+    super(valueType, identity, identity, {
+      decodeInstanceValueFactory: () => identity,
+      runtimeValueStateFactory: () => identity
     });
   }
 }
@@ -39967,131 +40092,70 @@ class RepeatCountControlExpression extends DependentExpression {
   }
 }
 
-class RepeatInstanceDefinition extends DescendentNodeDefinition {
-  constructor(range, node) {
-    const { bind, bodyElement, parent, root } = range;
-    super(parent, bind, bodyElement);
-    this.node = node;
-    this.qualifiedName = new QualifiedName(node);
-    this.namespaceDeclarations = new NamespaceDeclarationMap(this);
-    this.children = root.buildSubtree(this);
-  }
-  type = "repeat-instance";
-  namespaceDeclarations;
-  qualifiedName;
-  children;
-  instances = null;
-  defaultValue = null;
-  toJSON() {
-    const { bind, bodyElement, parent, root, ...rest } = this;
-    return rest;
+const isJRTemplateAttributeName = (name) => {
+  if (name.localName !== "template") {
+    return false;
   }
-}
-
-const repeatTemplates = /* @__PURE__ */ new WeakMap();
-const isExplicitRepeatTemplateElement = (element) => {
-  return element.hasAttributeNS(JAVAROSA_NAMESPACE_URI$1, "template");
+  const namespaceURI = name.namespaceURI?.href ?? name.namespaceURI;
+  return namespaceURI === JAVAROSA_NAMESPACE_URI$1;
 };
-const isLeafNode = (element) => {
-  return element.childElementCount === 0;
+const isJRTemplateAttribute = (attribute) => {
+  return isJRTemplateAttributeName(attribute.qualifiedName);
 };
-const clearLeafNodes = (element) => {
-  if (isLeafNode(element)) {
-    element.textContent = "";
-  } else {
-    for (const child of element.children) {
-      clearLeafNodes(child);
-    }
-  }
-  return element;
+const isExplicitRepeatTemplateElement = (sourceElement) => {
+  return sourceElement.attributes.some(isJRTemplateAttribute);
 };
-const getOrCreateTemplateElement = (element) => {
-  if (isExplicitRepeatTemplateElement(element)) {
-    return element;
-  }
-  const clone = element.cloneNode(true);
-  clone.setAttributeNS(JAVAROSA_NAMESPACE_URI$1, "template", "");
-  return clearLeafNodes(clone);
+const cloneStaticAttributeOptions = (attribute) => {
+  return {
+    name: attribute.qualifiedName,
+    value: attribute.value
+  };
+};
+const cloneStaticSubtreeStructure = (sourceElement) => {
+  const name = sourceElement.qualifiedName;
+  const attributes = sourceElement.attributes.map(cloneStaticAttributeOptions);
+  const children = sourceElement.childElements.map(cloneStaticSubtreeStructure);
+  return {
+    name,
+    attributes,
+    children
+  };
 };
-const splitInstanceNodes = (modelNodes) => {
-  const [first, ...rest] = modelNodes;
-  const template = getOrCreateTemplateElement(first);
-  if (template === first) {
-    return [template, ...rest];
+const cloneStaticElementStructure = (sourceElement) => {
+  const { root: clone } = new StaticDocument({
+    documentRoot: cloneStaticSubtreeStructure(sourceElement),
+    nodesetPrefix: sourceElement.parent.nodeset
+  });
+  return clone;
+};
+const parseRepeatTemplateElement = (firstRepeatInstanceNode) => {
+  if (isExplicitRepeatTemplateElement(firstRepeatInstanceNode)) {
+    return firstRepeatInstanceNode;
   }
-  return [template, ...modelNodes];
+  return cloneStaticElementStructure(firstRepeatInstanceNode);
 };
-class RepeatTemplateDefinition extends DescendentNodeDefinition {
-  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");
-    this.node = node;
-    this.qualifiedName = new QualifiedName(node);
-    this.namespaceDeclarations = new NamespaceDeclarationMap(this);
-    this.children = root.buildSubtree(this);
-  }
-  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(range, templateNode);
-    } else {
-      const duplicateTemplate = modelNodes.find(
-        (node) => node.hasAttributeNS(JAVAROSA_NAMESPACE_URI$1, "template")
-      );
-      if (duplicateTemplate != null) {
-        throw new Error(`Multiple explicit templates defined for ${bind.nodeset}`);
-      }
-      instanceNodes = modelNodes;
-    }
-    return {
-      template,
-      instanceNodes
-    };
+class RepeatDefinition extends DescendentNodeDefinition {
+  static from(parent, bind, bodyElement, instanceNodes) {
+    return new this(parent, bind, bodyElement, instanceNodes);
   }
-  type = "repeat-template";
-  node;
-  namespaceDeclarations;
-  qualifiedName;
+  type = "repeat";
   children;
-  instances = null;
-  defaultValue = null;
-  toJSON() {
-    const { bind, bodyElement, parent, root, ...rest } = this;
-    return rest;
-  }
-}
-
-class RepeatRangeDefinition extends DescendentNodeDefinition {
-  static from(parent, bind, bodyElement, modelNodes) {
-    const definition = new this(parent, bind, bodyElement, modelNodes);
-    return definition;
-  }
-  type = "repeat-range";
-  template;
-  children = null;
-  instances;
   count;
-  node = null;
+  template;
   namespaceDeclarations;
   qualifiedName;
-  defaultValue = null;
-  constructor(parent, bind, bodyElement, modelNodes) {
+  constructor(parent, bind, bodyElement, instanceNodes) {
     super(parent, bind, bodyElement);
-    const { template, instanceNodes } = RepeatTemplateDefinition.parseModelNodes(this, modelNodes);
+    const { root } = parent;
+    const [instanceNode] = instanceNodes;
+    const template = parseRepeatTemplateElement(instanceNode);
+    const self = this;
     this.template = template;
     this.qualifiedName = template.qualifiedName;
     this.namespaceDeclarations = new NamespaceDeclarationMap(this);
-    this.count = RepeatCountControlExpression.from(bodyElement, instanceNodes.length);
-    this.instances = instanceNodes.map((element) => {
-      return new RepeatInstanceDefinition(this, element);
-    });
+    this.children = root.buildSubtree(self, template);
+    const initialCount = this.omitTemplate(instanceNodes).length;
+    this.count = RepeatCountControlExpression.from(bodyElement, initialCount);
   }
   isControlled() {
     return this.count != null;
@@ -40099,9 +40163,13 @@ class RepeatRangeDefinition extends DescendentNodeDefinition {
   isUncontrolled() {
     return this.count == null;
   }
+  omitTemplate(instanceNodes) {
+    return instanceNodes.filter((instanceNode) => {
+      return instanceNode !== this.template;
+    });
+  }
   toJSON() {
-    const { bind, bodyElement: groupDefinition, parent, root, ...rest } = this;
-    return rest;
+    return {};
   }
 }
 
@@ -40111,13 +40179,14 @@ class RootAttributeDefinition {
   qualifiedName;
   value;
   constructor(root, source) {
-    const { namespaceURI, nodeName, value } = source;
+    const { qualifiedName, value } = source;
     this.parent = root;
-    this.qualifiedName = new QualifiedName(source);
+    this.qualifiedName = qualifiedName;
     this.value = value;
-    if (namespaceURI === XMLNS_NAMESPACE_URI$1) {
+    if (qualifiedName.namespaceURI?.href === XMLNS_NAMESPACE_URI$1) {
       this.serializedXML = "";
     } else {
+      const nodeName = qualifiedName.getPrefixedName();
       this.serializedXML = ` ${nodeName}="${escapeXMLText(value, true)}"`;
     }
   }
@@ -40126,21 +40195,20 @@ class RootAttributeDefinition {
   }
 }
 
-const isNonNamespaceDeclarationDOMAttr = (domAttr) => {
-  return domAttr.namespaceURI !== XMLNS_NAMESPACE_URI$1;
+const isNonNamespaceAttribute = (attribute) => {
+  return attribute.qualifiedName.namespaceURI?.href !== XMLNS_NAMESPACE_URI$1;
 };
 class RootAttributeMap extends Map {
-  static from(root, domRootSourceElement) {
-    const domAttrs = Array.from(domRootSourceElement.attributes);
-    const nonNamespaceDeclarationDOMAttrs = domAttrs.filter(isNonNamespaceDeclarationDOMAttr);
-    const attributes = nonNamespaceDeclarationDOMAttrs.map((source) => {
-      return new RootAttributeDefinition(root, source);
+  static from(root, instanceNode) {
+    const nonNamespaceAttributes = instanceNode.attributes.filter(isNonNamespaceAttribute);
+    const definitions = nonNamespaceAttributes.map((attribute) => {
+      return new RootAttributeDefinition(root, attribute);
     });
-    return new this(attributes);
+    return new this(definitions);
   }
-  constructor(attributes) {
+  constructor(definitions) {
     super(
-      attributes.map((attribute) => {
+      definitions.map((attribute) => {
         return [attribute.qualifiedName, attribute];
       })
     );
@@ -40148,23 +40216,21 @@ class RootAttributeMap extends Map {
 }
 
 class SubtreeDefinition extends DescendentNodeDefinition {
-  constructor(parent, bind, bodyElement, node) {
+  constructor(parent, bind, bodyElement, template) {
     if (bodyElement != null && (bodyElement.category !== "structure" || bodyElement.type === "repeat")) {
       throw new Error(`Unexpected body element for nodeset ${bind.nodeset}`);
     }
     super(parent, bind, bodyElement);
-    this.node = node;
+    this.template = template;
     const { root } = parent;
-    this.qualifiedName = new QualifiedName(node);
+    this.qualifiedName = template.qualifiedName;
     this.namespaceDeclarations = new NamespaceDeclarationMap(this);
-    this.children = root.buildSubtree(this);
+    this.children = root.buildSubtree(this, template);
   }
   type = "subtree";
   namespaceDeclarations;
   qualifiedName;
   children;
-  instances = null;
-  defaultValue = null;
   toJSON() {
     const { parent, bodyElement, bind, root, ...rest } = this;
     return rest;
@@ -40173,8 +40239,8 @@ class SubtreeDefinition extends DescendentNodeDefinition {
 
 class RootDefinition extends NodeDefinition {
   constructor(form, model, submission, classes) {
-    const { primaryInstanceRoot } = form.xformDOM;
-    const qualifiedName = new QualifiedName(primaryInstanceRoot);
+    const template = model.instance.root;
+    const qualifiedName = template.qualifiedName;
     const nodeName = qualifiedName.getPrefixedName();
     const nodeset = `/${nodeName}`;
     const bind = model.binds.get(nodeset);
@@ -40187,32 +40253,30 @@ class RootDefinition extends NodeDefinition {
     this.submission = submission;
     this.classes = classes;
     this.qualifiedName = qualifiedName;
-    this.node = primaryInstanceRoot;
-    this.attributes = RootAttributeMap.from(this, primaryInstanceRoot);
+    this.template = template;
+    this.attributes = RootAttributeMap.from(this, template);
     this.namespaceDeclarations = new NamespaceDeclarationMap(this);
-    this.children = this.buildSubtree(this);
+    this.children = this.buildSubtree(this, template);
   }
   type = "root";
   qualifiedName;
   bodyElement = null;
   root = this;
   parent = null;
+  template;
   namespaceDeclarations;
   attributes;
   children;
-  instances = null;
-  node;
-  defaultValue = null;
   isTranslated = false;
-  buildSubtree(parent) {
+  buildSubtree(parent, node) {
     const { form, model } = this;
     const { body } = form;
     const { binds } = model;
-    const { bind: parentBind, node } = parent;
+    const { bind: parentBind } = parent;
     const { nodeset: parentNodeset } = parentBind;
     const childrenByName = /* @__PURE__ */ new Map();
-    for (const child of node.children) {
-      const { nodeName } = child;
+    for (const child of node.childElements) {
+      const nodeName = child.qualifiedName.getPrefixedName();
       let elements = childrenByName.get(nodeName);
       if (elements == null) {
         elements = [child];
@@ -40227,14 +40291,13 @@ class RootDefinition extends NodeDefinition {
       const bodyElement = body.getBodyElement(nodeset);
       const [firstChild, ...restChildren] = children;
       if (bodyElement?.type === "repeat") {
-        return RepeatRangeDefinition.from(parent, bind, bodyElement, children);
+        return RepeatDefinition.from(parent, bind, bodyElement, children);
       }
       if (restChildren.length) {
         throw new Error(`Unexpected: multiple elements for non-repeat nodeset: ${nodeset}`);
       }
       const element = firstChild;
-      const isLeafNode = element.childElementCount === 0;
-      if (isLeafNode) {
+      if (element.isLeafElement()) {
         if (bodyElement?.type === "range") {
           return RangeNodeDefinition.from(parent, bind, bodyElement, element);
         }
@@ -40249,17 +40312,69 @@ class RootDefinition extends NodeDefinition {
   }
 }
 
+class SubmissionDefinition {
+  submissionAction;
+  submissionMethod = "post";
+  encryptionKey;
+  constructor(xformDOM) {
+    const submissionElement = getSubmissionElement(xformDOM.model);
+    let submissionAction = null;
+    let submissionMethod;
+    let encryptionKey = null;
+    if (submissionElement == null) {
+      submissionAction = null;
+      submissionMethod = "post";
+      encryptionKey = null;
+    } else {
+      const method = submissionElement.getAttribute("method")?.trim();
+      if (method == null || method === "post" || method === "form-data-post") {
+        submissionMethod = "post";
+      } else {
+        throw new Error(`Unexpected <submission method>: ${method}`);
+      }
+      const action = submissionElement.getAttribute("action");
+      if (action != null) {
+        submissionAction = new URL(action.trim());
+      }
+      encryptionKey = submissionElement.getAttribute("base64RsaPublicKey");
+    }
+    this.submissionAction = submissionAction;
+    this.submissionMethod = submissionMethod;
+    this.encryptionKey = encryptionKey;
+  }
+}
+
 class ModelDefinition {
   constructor(form) {
     this.form = form;
-    const submission = new FormSubmissionDefinition(form.xformDOM);
+    const submission = new SubmissionDefinition(form.xformDOM);
     this.binds = ModelBindMap.fromModel(this);
+    this.instance = parseStaticDocumentFromDOMSubtree(form.xformDOM.primaryInstanceRoot, {
+      nodesetPrefix: "/"
+    });
     this.root = new RootDefinition(form, this, submission, form.body.classes);
+    this.nodes = nodeDefinitionMap(this.root);
     this.itextTranslations = ItextTranslationsDefinition.from(form.xformDOM);
   }
   binds;
   root;
+  nodes;
+  instance;
   itextTranslations;
+  getNodeDefinition(nodeset) {
+    const definition = this.nodes.get(nodeset);
+    if (definition == null) {
+      throw new ErrorProductionDesignPendingError(`No definition for nodeset: ${nodeset}`);
+    }
+    return definition;
+  }
+  getRootDefinition(instance) {
+    const definition = this.getNodeDefinition(instance.root.nodeset);
+    if (definition !== this.root) {
+      throw new ErrorProductionDesignPendingError();
+    }
+    return definition;
+  }
   toJSON() {
     const { form, ...rest } = this;
     return rest;
@@ -40305,13 +40420,30 @@ class JRResourceURL extends URL {
   }
 }
 
-class SecondaryInstanceRootDefinition extends StaticElement {
-  [XFORMS_LOCAL_NAME] = "instance";
-  [XFORMS_KNOWN_ATTRIBUTE] = "id";
-}
+const assertSecondaryInstanceDefinition = ({ root }) => {
+  const id = root.getAttributeValue("id");
+  if (id == null) {
+    throw new Error();
+  }
+};
 
-class SecondaryInstanceDefinition extends StaticDocument {
-}
+const defineSecondaryInstance = (instanceId, secondaryInstanceRoot) => {
+  const doc = new StaticDocument({
+    documentRoot: {
+      name: "instance",
+      attributes: [
+        {
+          name: "id",
+          value: instanceId
+        }
+      ],
+      children: [secondaryInstanceRoot]
+    },
+    nodesetPrefix: `instance('${instanceId}')`
+  });
+  assertSecondaryInstanceDefinition(doc);
+  return doc;
+};
 
 class SecondaryInstanceSource {
   constructor(format, instanceId, resourceURL, domElement) {
@@ -40326,24 +40458,8 @@ class BlankSecondaryInstanceSource extends SecondaryInstanceSource {
   constructor(instanceId, resourceURL, domElement) {
     super("blank", instanceId, resourceURL, domElement);
   }
-  /**
-   * @todo there is really no sense in using the DOM for this, other than it was
-   * quicker/more ergonomic than constructing the requisite {@link StaticNode}
-   * structures directly. Pretty good sign those constructor signatures could
-   * use some TLC!
-   */
   parseDefinition() {
-    const xmlDocument = this.domElement.ownerDocument.implementation.createDocument(
-      XFORMS_NAMESPACE_URI$1,
-      "instance"
-    );
-    const instanceElement = xmlDocument.documentElement;
-    instanceElement.setAttribute("id", this.instanceId);
-    return parseStaticDocumentFromDOMSubtree(
-      SecondaryInstanceDefinition,
-      SecondaryInstanceRootDefinition,
-      instanceElement
-    );
+    return defineSecondaryInstance(this.instanceId, "");
   }
 }
 
@@ -40406,80 +40522,28 @@ const stripTrailingEmptyCells = (columns, row) => {
   }
   return result;
 };
-class CSVExternalSecondaryInstanceColumnElement extends StaticElement {
-  constructor(parent, column) {
-    const { columnName, cellValue } = column;
-    super(
-      parent,
-      () => [],
-      (self) => [new StaticText(self, cellValue)],
-      {
-        namespaceURI: XFORMS_NAMESPACE_URI$1,
-        localName: columnName
-      }
-    );
-  }
-}
-class CSVExternalSecondaryInstanceItemElement extends StaticElement {
-  constructor(parent, item) {
-    super(
-      parent,
-      () => [],
-      (self) => {
-        return item.map((column) => {
-          return new CSVExternalSecondaryInstanceColumnElement(self, column);
-        });
-      },
-      {
-        namespaceURI: XFORMS_NAMESPACE_URI$1,
-        localName: "item"
-      }
-    );
-  }
-}
-class CSVExternalSecondaryInstanceRootElement extends StaticElement {
-  constructor(parent, items) {
-    super(
-      parent,
-      () => [],
-      (self) => {
-        return items.map((item) => {
-          return new CSVExternalSecondaryInstanceItemElement(self, item);
-        });
-      },
-      {
-        namespaceURI: XFORMS_NAMESPACE_URI$1,
-        localName: "root"
-      }
-    );
-  }
-}
-class CSVExternalSecondaryInstanceDocumentElement extends SecondaryInstanceRootDefinition {
-  constructor(instanceId, parent, items) {
-    super(
-      parent,
-      (self) => [
-        new StaticAttribute(self, {
-          namespaceURI: XFORMS_NAMESPACE_URI$1,
-          localName: "id",
-          value: instanceId
-        })
-      ],
-      (self) => [new CSVExternalSecondaryInstanceRootElement(self, items)],
-      {
-        namespaceURI: XFORMS_NAMESPACE_URI$1,
-        localName: "instance"
-      }
-    );
-  }
-}
-class CSVExternalSecondaryInstanceDefinition extends SecondaryInstanceDefinition {
-  constructor(instanceId, items) {
-    super((self) => {
-      return new CSVExternalSecondaryInstanceDocumentElement(instanceId, self, items);
-    });
-  }
-}
+const columnChildOption = (column) => {
+  const { columnName, cellValue } = column;
+  return {
+    name: columnName,
+    children: [cellValue]
+  };
+};
+const itemChildOption$1 = (item) => {
+  return {
+    name: "item",
+    children: item.map(columnChildOption)
+  };
+};
+const rootChildOption$1 = (items) => {
+  return {
+    name: "root",
+    children: items.map(itemChildOption$1)
+  };
+};
+const csvExternalSecondaryInstanceDefinition = (instanceId, items) => {
+  return defineSecondaryInstance(instanceId, rootChildOption$1(items));
+};
 class CSVExternalSecondaryInstanceSource extends ExternalSecondaryInstanceSource {
   /**
    * Based on
@@ -40567,7 +40631,7 @@ class CSVExternalSecondaryInstanceSource extends ExternalSecondaryInstanceSource
       delimiter: meta.delimiter
     });
     const items = this.toItems(columns, rows);
-    return new CSVExternalSecondaryInstanceDefinition(this.instanceId, items);
+    return csvExternalSecondaryInstanceDefinition(this.instanceId, items);
   }
 }
 
@@ -40816,134 +40880,72 @@ const serializeCoordinates = (coordinates) => {
   const [longitude, latitude] = coordinates;
   return `${latitude} ${longitude} 0 0`;
 };
-class GeoJSONSecondaryInstanceFeatureGeometryElement extends StaticElement {
-  static from(parent, feature) {
-    const { geometry } = feature;
-    switch (geometry.type) {
-      case "LineString":
-        return new this(parent, geometry.coordinates);
-      case "Point":
-        return new this(parent, [geometry.coordinates]);
-      case "Polygon":
-        return new this(parent, geometry.coordinates[0] ?? []);
-      default:
-        throw new UnreachableError$1(geometry);
-    }
-  }
-  constructor(parent, points) {
-    const values = points.map(serializeCoordinates);
-    const value = values.join("; ");
-    super(
-      parent,
-      () => [],
-      (self) => [new StaticText(self, value)],
-      {
-        namespaceURI: XFORMS_NAMESPACE_URI$1,
-        localName: "geometry"
-      }
-    );
-  }
-}
-class GeoJSONSecondaryInstanceFeaturePropertyElement extends StaticElement {
-  static *buildPropertyElements(parent, feature) {
-    const { properties } = feature;
-    if (properties == null) {
-      return [];
-    }
-    const { id: propertiesId, ...nonIdProperties } = properties;
-    const { id = propertiesId } = feature;
-    if (id !== undefined) {
-      yield new this(parent, "id", String(id));
+const geometryValues = (geometry) => {
+  switch (geometry.type) {
+    case "LineString":
+      return geometry.coordinates.map(serializeCoordinates);
+    case "Point":
+      return [serializeCoordinates(geometry.coordinates)];
+    case "Polygon": {
+      const [coordinates = []] = geometry.coordinates;
+      return coordinates.map(serializeCoordinates);
     }
-    for (const [propertyName, propertyValue] of Object.entries(nonIdProperties)) {
-      yield new this(parent, propertyName, String(propertyValue));
-    }
-  }
-  constructor(parent, propertyName, propertyValue) {
-    super(
-      parent,
-      () => [],
-      (self) => [new StaticText(self, propertyValue)],
-      {
-        namespaceURI: XFORMS_NAMESPACE_URI$1,
-        localName: propertyName
-      }
-    );
-  }
-}
-class GeoJSONSecondaryInstanceFeatureItemElement extends StaticElement {
-  constructor(parent, feature) {
-    super(
-      parent,
-      () => [],
-      (self) => {
-        const geometry = GeoJSONSecondaryInstanceFeatureGeometryElement.from(self, feature);
-        const properties = GeoJSONSecondaryInstanceFeaturePropertyElement.buildPropertyElements(
-          self,
-          feature
-        );
-        return [geometry, ...properties];
-      },
-      {
-        namespaceURI: XFORMS_NAMESPACE_URI$1,
-        localName: "item"
-      }
-    );
+    default:
+      throw new UnreachableError$1(geometry);
   }
-}
-class GeoJSONSecondaryInstanceRootElement extends StaticElement {
-  constructor(parent, featureCollection) {
-    super(
-      parent,
-      () => [],
-      (self) => {
-        return featureCollection.features.map((feature) => {
-          return new GeoJSONSecondaryInstanceFeatureItemElement(self, feature);
-        });
-      },
-      {
-        namespaceURI: XFORMS_NAMESPACE_URI$1,
-        localName: "root"
-      }
-    );
+};
+const geometryChildElementOption = (feature) => {
+  const { geometry } = feature;
+  const values = geometryValues(geometry);
+  const value = values.join("; ");
+  return {
+    name: "geometry",
+    children: [value]
+  };
+};
+const propertyChildOption = (propertyName, propertyValue) => {
+  return {
+    name: propertyName,
+    children: [propertyValue]
+  };
+};
+function* propertyChildOptions(feature) {
+  const { properties } = feature;
+  if (properties == null) {
+    return [];
   }
-}
-class GeoJSONExternalSecondaryInstanceDocumentElement extends SecondaryInstanceRootDefinition {
-  constructor(instanceId, parent, featureCollection) {
-    super(
-      parent,
-      (self) => [
-        new StaticAttribute(self, {
-          namespaceURI: XFORMS_NAMESPACE_URI$1,
-          localName: "id",
-          value: instanceId
-        })
-      ],
-      (self) => [new GeoJSONSecondaryInstanceRootElement(self, featureCollection)],
-      {
-        namespaceURI: XFORMS_NAMESPACE_URI$1,
-        localName: "instance"
-      }
-    );
+  const { id: propertiesId, ...nonIdProperties } = properties;
+  const { id = propertiesId } = feature;
+  if (id !== undefined) {
+    yield propertyChildOption("id", String(id));
   }
-}
-class GeoJSONExternalSecondaryInstanceDefinition extends SecondaryInstanceDefinition {
-  constructor(instanceId, featureCollection) {
-    super((self) => {
-      return new GeoJSONExternalSecondaryInstanceDocumentElement(
-        instanceId,
-        self,
-        featureCollection
-      );
-    });
+  for (const [propertyName, propertyValue] of Object.entries(nonIdProperties)) {
+    yield propertyChildOption(propertyName, String(propertyValue));
   }
 }
+const itemChildOption = (feature) => {
+  const geometry = geometryChildElementOption(feature);
+  const properties = propertyChildOptions(feature);
+  return {
+    name: "item",
+    children: [geometry, ...properties]
+  };
+};
+const rootChildOption = (featureCollection) => {
+  return {
+    name: "root",
+    children: featureCollection.features.map(itemChildOption)
+  };
+};
+const geoJSONExternalSecondaryInstanceDefinition = (instanceId, featureCollection) => {
+  return defineSecondaryInstance(instanceId, rootChildOption(featureCollection));
+};
 class GeoJSONExternalSecondaryInstanceSource extends ExternalSecondaryInstanceSource {
   parseDefinition() {
     const { data } = this.resource;
     const value = JSON.parse(data);
     assertFeatureCollection(value);
-    return new GeoJSONExternalSecondaryInstanceDefinition(this.instanceId, value);
+    return geoJSONExternalSecondaryInstanceDefinition(this.instanceId, value);
   }
 }
 
@@ -40952,11 +40954,11 @@ class InternalSecondaryInstanceSource extends SecondaryInstanceSource {
     super("internal", instanceId, resourceURL, domElement);
   }
   parseDefinition() {
-    return parseStaticDocumentFromDOMSubtree(
-      SecondaryInstanceDefinition,
-      SecondaryInstanceRootDefinition,
-      this.domElement
-    );
+    const doc = parseStaticDocumentFromDOMSubtree(this.domElement, {
+      nodesetPrefix: `instance('${this.instanceId}')`
+    });
+    assertSecondaryInstanceDefinition(doc);
+    return doc;
   }
 }
 
@@ -40976,11 +40978,9 @@ class XMLExternalSecondaryInstanceSource extends ExternalSecondaryInstanceSource
     const instanceElement = xmlDocument.documentElement;
     instanceElement.setAttribute("id", this.instanceId);
     instanceElement.innerHTML = this.resource.data;
-    return parseStaticDocumentFromDOMSubtree(
-      SecondaryInstanceDefinition,
-      SecondaryInstanceRootDefinition,
-      instanceElement
-    );
+    const doc = parseStaticDocumentFromDOMSubtree(instanceElement);
+    assertSecondaryInstanceDefinition(doc);
+    return doc;
   }
 }
 
@@ -41049,6 +41049,208 @@ class SecondaryInstancesDefinition extends Map {
   }
 }
 
+class BaseFormResult {
+  status;
+  warnings;
+  error;
+  constructor(options) {
+    this.status = options.status;
+    this.warnings = options.warnings;
+    this.error = options.error;
+  }
+}
+
+const failedFormResultMethodFactory = (cause) => {
+  return () => {
+    throw new Error(cause.message, { cause });
+  };
+};
+class FormFailureResult extends BaseFormResult {
+  createInstance;
+  editInstance;
+  restoreInstance;
+  constructor(options) {
+    const { error, warnings } = options;
+    super({
+      status: "failure",
+      warnings,
+      error
+    });
+    this.createInstance = failedFormResultMethodFactory(error);
+    this.editInstance = failedFormResultMethodFactory(error);
+    this.restoreInstance = failedFormResultMethodFactory(error);
+  }
+}
+
+const wrapInstanceXML = (model, instanceXML) => {
+  const defaultNamespace = model.root.namespaceDeclarations.get(null);
+  const defaultNamespaceURI = defaultNamespace?.declaredURI?.href;
+  if (defaultNamespaceURI == null) {
+    return `<wrapped>${instanceXML}</wrapped>`;
+  }
+  return (
+    /* xml */
+    `<wrapped xmlns="${escapeXMLText(defaultNamespaceURI, true)}">
+		${instanceXML}
+	</wrapped>`
+  );
+};
+const assertSoleChildElement = (element) => {
+  if (element == null) {
+    throw new ErrorProductionDesignPendingError("Expected a child element");
+  }
+  const { parentNode } = element;
+  if (parentNode == null) {
+    throw new ErrorProductionDesignPendingError("Expected element to be a child of a parent node");
+  }
+  if (element !== parentNode.firstElementChild || element !== parentNode.lastElementChild) {
+    throw new ErrorProductionDesignPendingError(
+      "Expected child element to be parent node's only element child."
+    );
+  }
+};
+const getWrappedInstanceRootElement = (xml) => {
+  const domParser = new DOMParser();
+  const doc = domParser.parseFromString(xml, "text/xml");
+  const { documentElement } = doc;
+  const [root] = documentElement.children;
+  assertSoleChildElement(root);
+  return root;
+};
+const parseInstanceXML = (model, instanceXML) => {
+  const wrappedXML = wrapInstanceXML(model, instanceXML);
+  const root = getWrappedInstanceRootElement(wrappedXML);
+  return parseStaticDocumentFromDOMSubtree(root);
+};
+
+class MalformedInstanceDataError extends ErrorProductionDesignPendingError {
+}
+
+const resolveInstanceAttachmentMapSource = async (input) => {
+  const inputEntries = Array.from(input.entries());
+  if (inputEntries.length > 0) {
+    const fileNames = Array.from(input.keys());
+    const errors = fileNames.map((fileName) => {
+      return new Error(`Failed to resolve instance attachment with file name "${fileName}"`);
+    });
+    throw new AggregateError(errors, "Not implemented: instance attachment resource resolution");
+  }
+  const entries = await Promise.all(
+    inputEntries.map(async ([fileName, resolveAttachment]) => {
+      const response = await resolveAttachment();
+      const blob = await response.blob();
+      const value = new File([blob], fileName);
+      return [fileName, value];
+    })
+  );
+  return { entries: () => entries };
+};
+const assertKeyedInstanceDataFile = (key, file) => {
+  if (file.name !== key) {
+    throw new MalformedInstanceDataError(
+      `Unexpected InstanceData file. Expected file name to match key, got key: ${JSON.stringify(key)} and file name: ${JSON.stringify(file.name)}`
+    );
+  }
+};
+const assertInstanceDataEntry = (entry) => {
+  const [key, value] = entry;
+  if (!(value instanceof File)) {
+    throw new MalformedInstanceDataError(
+      `Unexpected non-file attachment in InstanceData for key: ${key}`
+    );
+  }
+  assertKeyedInstanceDataFile(key, value);
+};
+class InstanceAttachmentMap extends Map {
+  static from(sources) {
+    return new this(sources);
+  }
+  /**
+   * @todo
+   * @see {@link resolveInstanceAttachmentMapSource}
+   */
+  static async resolve(input) {
+    const source = await resolveInstanceAttachmentMapSource(input);
+    return new this([source]);
+  }
+  constructor(sources) {
+    super();
+    for (const source of sources) {
+      for (const entry of source.entries()) {
+        const [key] = entry;
+        if (key === INSTANCE_FILE_NAME) {
+          continue;
+        }
+        if (this.has(key)) {
+          throw new MalformedInstanceDataError(
+            `Unexpected InstanceData entry. Duplicate instance attachment for key: ${JSON.stringify(key)}`
+          );
+        }
+        assertInstanceDataEntry(entry);
+        const [, value] = entry;
+        this.set(key, value);
+      }
+    }
+  }
+}
+
+const resolveInstanceXML = async (input) => {
+  const instanceResult = await input.resolveInstance();
+  if (typeof instanceResult === "string") {
+    return instanceResult;
+  }
+  if (instanceResult instanceof Blob) {
+    return getBlobText(instanceResult);
+  }
+  return instanceResult.text();
+};
+const parseInstanceDocument = (model, instanceXML) => {
+  const doc = parseInstanceXML(model, instanceXML);
+  const expectedId = model.instance.root.getAttributeValue("id");
+  const actualId = doc.root.getAttributeValue("id");
+  if (expectedId !== actualId) {
+    throw new ErrorProductionDesignPendingError(
+      `Invalid instance input. Expected instance id to be "${expectedId}", got: "${actualId}"`
+    );
+  }
+  return doc;
+};
+class InitialInstanceState {
+  static async from(model, data) {
+    return this.resolve(model, {
+      inputType: "FORM_INSTANCE_INPUT_RESOLVED",
+      data
+    });
+  }
+  static async resolve(model, input) {
+    if (input.inputType === "FORM_INSTANCE_INPUT_RESOLVED") {
+      const { data } = input;
+      const [instanceData] = data;
+      const instanceFile = instanceData.get(INSTANCE_FILE_NAME);
+      const instanceXML2 = await getBlobText(instanceFile);
+      const attachments2 = InstanceAttachmentMap.from(data);
+      return new this(model, {
+        instanceXML: instanceXML2,
+        attachments: attachments2
+      });
+    }
+    const [instanceXML, attachments] = await Promise.all([
+      resolveInstanceXML(input),
+      InstanceAttachmentMap.resolve(input.attachments)
+    ]);
+    return new this(model, {
+      instanceXML,
+      attachments
+    });
+  }
+  document;
+  attachments;
+  constructor(model, options) {
+    this.document = parseInstanceDocument(model, options.instanceXML);
+    this.attachments = options.attachments;
+  }
+}
+
 const isEngineXPathNode = (value) => {
   return typeof value === "object" && value != null && XPathNodeKindKey in value;
 };
@@ -41360,53 +41562,51 @@ class EngineXPathEvaluator extends XFormsXPathEvaluator {
   }
 }
 
-const createInstanceSubmissionState = (node) => {
+const createPrimaryInstanceState = (node) => {
   return {
-    get submissionXML() {
-      return node.root.submissionState.submissionXML;
+    get instanceXML() {
+      return node.root.instanceState.instanceXML;
     }
   };
 };
 
 class InstanceFile extends File {
-  name = SUBMISSION_INSTANCE_FILE_NAME;
-  type = SUBMISSION_INSTANCE_FILE_TYPE;
+  name = INSTANCE_FILE_NAME;
+  type = INSTANCE_FILE_TYPE;
   constructor(instanceRoot) {
-    const { submissionXML } = instanceRoot.submissionState;
-    super([submissionXML], SUBMISSION_INSTANCE_FILE_NAME, {
-      type: SUBMISSION_INSTANCE_FILE_TYPE
+    const { instanceXML } = instanceRoot.instanceState;
+    super([instanceXML], INSTANCE_FILE_NAME, {
+      type: INSTANCE_FILE_TYPE
     });
   }
 }
-const assertSubmissionData = (data) => {
-  const instanceFile = data.get(SUBMISSION_INSTANCE_FILE_NAME);
+const assertInstanceData = (data) => {
+  const instanceFile = data.get(INSTANCE_FILE_NAME);
   if (!(instanceFile instanceof InstanceFile)) {
-    throw new Error(`Invalid SubmissionData`);
+    throw new Error(`Invalid InstanceData`);
   }
 };
-class InstanceSubmissionData extends FormData {
+class InstanceData extends FormData {
   constructor(instanceFile, attachments) {
     super();
     this.instanceFile = instanceFile;
     this.attachments = attachments;
-    this.set(SUBMISSION_INSTANCE_FILE_NAME, instanceFile);
+    this.set(INSTANCE_FILE_NAME, instanceFile);
     attachments.forEach((attachment) => {
       const { name } = attachment;
-      if (name === SUBMISSION_INSTANCE_FILE_NAME && attachment !== instanceFile) {
-        throw new Error(
-          `Failed to add conflicting attachment with name ${SUBMISSION_INSTANCE_FILE_NAME}`
-        );
+      if (name === INSTANCE_FILE_NAME && attachment !== instanceFile) {
+        throw new Error(`Failed to add conflicting attachment with name ${INSTANCE_FILE_NAME}`);
       }
       this.set(name, attachment);
     });
   }
   static from(instanceFile, attachments) {
     const data = new this(instanceFile, attachments);
-    assertSubmissionData(data);
+    assertInstanceData(data);
     return data;
   }
 }
-const validateSubmission = (instanceRoot) => {
+const validateInstance = (instanceRoot) => {
   const { violations } = instanceRoot.validationState;
   if (violations.length === 0) {
     return {
@@ -41419,48 +41619,50 @@ const validateSubmission = (instanceRoot) => {
     violations
   };
 };
-const monolithicSubmissionResult = (validation, definition, instanceFile, attachments) => {
-  const data = InstanceSubmissionData.from(instanceFile, attachments);
+const monolithicInstancePayload = (validation, submissionMeta, instanceFile, attachments) => {
+  const data = InstanceData.from(instanceFile, attachments);
   return {
+    payloadType: "monolithic",
     ...validation,
-    definition,
-    data
+    submissionMeta,
+    data: [data]
   };
 };
-const chunkedSubmissionResult = (validation, definition, instanceFile, attachments, options) => {
+const chunkedInstancePayload = (validation, submissionMeta, instanceFile, attachments, options) => {
   if (attachments.length > 0 || options.maxSize !== Infinity) {
-    throw new Error("Submission chunking pending implementation");
+    throw new Error("InstancePayload chunking pending implementation");
   }
-  const data = InstanceSubmissionData.from(instanceFile, attachments);
+  const data = InstanceData.from(instanceFile, attachments);
   return {
+    payloadType: "chunked",
     ...validation,
-    definition,
+    submissionMeta,
     data: [data]
   };
 };
-const prepareSubmission = (instanceRoot, options) => {
-  const validation = validateSubmission(instanceRoot);
-  const definition = instanceRoot.definition.submission;
+const prepareInstancePayload = (instanceRoot, options) => {
+  const validation = validateInstance(instanceRoot);
+  const submissionMeta = instanceRoot.definition.submission;
   const instanceFile = new InstanceFile(instanceRoot);
   const attachments = [];
-  switch (options.chunked) {
+  switch (options.payloadType) {
     case "chunked":
-      return chunkedSubmissionResult(
+      return chunkedInstancePayload(
         validation,
-        definition,
+        submissionMeta,
         instanceFile,
         attachments,
         options
       );
     case "monolithic":
-      return monolithicSubmissionResult(
+      return monolithicInstancePayload(
         validation,
-        definition,
+        submissionMeta,
         instanceFile,
         attachments
       );
     default:
-      throw new UnreachableError$1(options.chunked);
+      throw new UnreachableError$1(options.payloadType);
   }
 };
 
@@ -41688,14 +41890,20 @@ const createSharedNodeState = (scope, spec, options) => {
   };
 };
 
+const createUniqueId = (() => {
+  const { crypto } = globalThis;
+  return crypto?.randomUUID?.bind(crypto) ?? createUniqueId$1;
+})();
+
 const nodeID = (id) => {
   return `node:${id}`;
 };
 
 class InstanceNode {
-  constructor(engineConfig, parent, definition, options) {
-    this.engineConfig = engineConfig;
+  constructor(instanceConfig, parent, instanceNode, definition, options) {
+    this.instanceConfig = instanceConfig;
     this.parent = parent;
+    this.instanceNode = instanceNode;
     this.definition = definition;
     const self = this;
     if (parent == null) {
@@ -41710,8 +41918,8 @@ class InstanceNode {
     }
     this.computeReference = options?.computeReference ?? this.computeChildStepReference;
     this.scope = options?.scope ?? createReactiveScope();
-    this.engineConfig = engineConfig;
-    this.nodeId = nodeID(engineConfig.createUniqueId());
+    this.instanceConfig = instanceConfig;
+    this.nodeId = nodeID(createUniqueId());
     this.definition = definition;
   }
   rootDocument;
@@ -41770,12 +41978,12 @@ class InstanceNode {
   }
 }
 
-const createRootSubmissionState = (node) => {
+const createRootInstanceState = (node) => {
   return {
-    get submissionXML() {
+    get instanceXML() {
       const { namespaceDeclarations, attributes } = node.definition;
       const serializedChildren = node.currentState.children.map((child) => {
-        return child.submissionState.submissionXML;
+        return child.instanceState.instanceXML;
       });
       return serializeParentElementXML(node.definition.qualifiedName, serializedChildren, {
         namespaceDeclarations,
@@ -41892,9 +42100,10 @@ const createComputedExpression = (context, dependentExpression, options = {}) =>
 };
 
 class DescendantNode extends InstanceNode {
-  constructor(parent, definition, options) {
-    super(parent.engineConfig, parent, definition, options);
+  constructor(parent, instanceNode, definition, options) {
+    super(parent.instanceConfig, parent, instanceNode, definition, options);
     this.parent = parent;
+    this.instanceNode = instanceNode;
     this.definition = definition;
     if (this.isRoot()) {
       this.root = this;
@@ -41902,7 +42111,7 @@ class DescendantNode extends InstanceNode {
       this.root = parent.root;
     }
     const { evaluator } = parent;
-    if (definition.type === "repeat-range") {
+    if (definition.type === "repeat") {
       this[XPathNodeKindKey] = XFORMS_XPATH_NODE_RANGE_KIND;
     } else {
       this[XPathNodeKindKey] = "element";
@@ -42020,14 +42229,14 @@ class DescendantNode extends InstanceNode {
   }
 }
 
-const createParentNodeSubmissionState = (node) => {
+const createParentNodeInstanceState = (node) => {
   return {
-    get submissionXML() {
+    get instanceXML() {
       if (!node.currentState.relevant) {
         return "";
       }
       const serializedChildren = node.currentState.children.map((child) => {
-        return child.submissionState.submissionXML;
+        return child.instanceState.instanceXML;
       });
       return serializeParentElementXML(node.definition.qualifiedName, serializedChildren);
     }
@@ -42134,15 +42343,12 @@ class Group extends DescendantNode {
   nodeOptions = null;
   currentState;
   validationState;
-  submissionState;
-  constructor(parent, definition) {
-    super(parent, definition);
+  instanceState;
+  constructor(parent, instanceNode, definition) {
+    super(parent, instanceNode, definition);
     this.appearances = definition.bodyElement.appearances;
     const childrenState = createChildrenState(this);
     this.childrenState = childrenState;
-    const sharedStateOptions = {
-      clientStateFactory: this.engineConfig.stateFactory
-    };
     const state = createSharedNodeState(
       this.scope,
       {
@@ -42156,7 +42362,7 @@ class Group extends DescendantNode {
         valueOptions: null,
         value: null
       },
-      sharedStateOptions
+      this.instanceConfig
     );
     this.state = state;
     this.engineState = state.engineState;
@@ -42166,8 +42372,8 @@ class Group extends DescendantNode {
       childrenState
     );
     childrenState.setChildren(buildChildren(this));
-    this.validationState = createAggregatedViolations(this, sharedStateOptions);
-    this.submissionState = createParentNodeSubmissionState(this);
+    this.validationState = createAggregatedViolations(this, this.instanceConfig);
+    this.instanceState = createParentNodeInstanceState(this);
   }
   getChildren() {
     return this.childrenState.getChildren();
@@ -42182,10 +42388,10 @@ const createFieldHint = (context, definition) => {
   return createTextRange(context, "hint", hintDefinition);
 };
 
-const createValueNodeSubmissionState = (node) => {
+const createValueNodeInstanceState = (node) => {
   const { qualifiedName } = node.definition;
   return {
-    get submissionXML() {
+    get instanceXML() {
       if (!node.currentState.relevant) {
         return "";
       }
@@ -42195,18 +42401,17 @@ const createValueNodeSubmissionState = (node) => {
   };
 };
 
-const isInstanceFirstLoad = (valueSource) => {
-  return valueSource === "FORM_DEFAULT";
+const isInstanceFirstLoad = (context) => {
+  return context.rootDocument.initializationMode === "create";
 };
-const getInitialValue$1 = (context, options) => {
-  const { initialValueSource = "FORM_DEFAULT" } = options;
-  if (initialValueSource === "FORM_DEFAULT") {
-    const { defaultValue } = context.definition;
-    return context.decodeInstanceValue(defaultValue);
-  }
-  throw new ErrorProductionDesignPendingError("Edit implementation pending");
+const isEditInitialLoad = (context) => {
+  return context.rootDocument.initializationMode === "edit";
 };
-const createRelevantValueState$1 = (context, baseValueState) => {
+const getInitialValue = (context) => {
+  const sourceNode = context.instanceNode ?? context.definition.template;
+  return context.decodeInstanceValue(sourceNode.value);
+};
+const createRelevantValueState = (context, baseValueState) => {
   return context.scope.runTask(() => {
     const [getRelevantValue, setValue] = baseValueState;
     const getValue = createMemo(() => {
@@ -42218,7 +42423,7 @@ const createRelevantValueState$1 = (context, baseValueState) => {
     return [getValue, setValue];
   });
 };
-const guardDownstreamReadonlyWrites$1 = (context, baseState) => {
+const guardDownstreamReadonlyWrites = (context, baseState) => {
   const { readonly } = context.definition.bind;
   if (readonly.isDefaultExpression) {
     return baseState;
@@ -42234,9 +42439,12 @@ const guardDownstreamReadonlyWrites$1 = (context, baseState) => {
   return [getValue, setValue];
 };
 const PRELOAD_UID_EXPRESSION = 'concat("uuid:", uuid())';
-const setPreloadUIDValue = (context, valueState, options) => {
+const shouldPreloadUID = (context) => {
+  return isInstanceFirstLoad(context) || isEditInitialLoad(context);
+};
+const setPreloadUIDValue = (context, valueState) => {
   const { preload } = context.definition.bind;
-  if (preload?.type !== "uid" || !isInstanceFirstLoad(options?.initialValueSource)) {
+  if (preload?.type !== "uid" || !shouldPreloadUID(context)) {
     return;
   }
   const preloadUIDValue = context.evaluator.evaluateString(PRELOAD_UID_EXPRESSION, {
@@ -42245,7 +42453,7 @@ const setPreloadUIDValue = (context, valueState, options) => {
   const [, setValue] = valueState;
   setValue(preloadUIDValue);
 };
-const createCalculation$1 = (context, setRelevantValue, calculateDefinition) => {
+const createCalculation = (context, setRelevantValue, calculateDefinition) => {
   context.scope.runTask(() => {
     const calculate = createComputedExpression(context, calculateDefinition, {
       defaultValue: ""
@@ -42259,18 +42467,18 @@ const createCalculation$1 = (context, setRelevantValue, calculateDefinition) =>
     });
   });
 };
-const createInstanceValueState = (context, options = {}) => {
+const createInstanceValueState = (context) => {
   return context.scope.runTask(() => {
-    const initialValue = getInitialValue$1(context, options);
+    const initialValue = getInitialValue(context);
     const baseValueState = createSignal(initialValue);
-    const relevantValueState = createRelevantValueState$1(context, baseValueState);
-    setPreloadUIDValue(context, relevantValueState, options);
+    const relevantValueState = createRelevantValueState(context, baseValueState);
+    setPreloadUIDValue(context, relevantValueState);
     const { calculate } = context.definition.bind;
     if (calculate != null) {
       const [, setValue] = relevantValueState;
-      createCalculation$1(context, setValue, calculate);
+      createCalculation(context, setValue, calculate);
     }
-    return guardDownstreamReadonlyWrites$1(context, relevantValueState);
+    return guardDownstreamReadonlyWrites(context, relevantValueState);
   });
 };
 
@@ -42378,6 +42586,24 @@ const createValidationState = (context, options) => {
 };
 
 class ValueNode extends DescendantNode {
+  constructor(parent, instanceNode, definition, codec) {
+    super(parent, instanceNode, definition);
+    this.instanceNode = instanceNode;
+    this.valueType = definition.valueType;
+    this.decodeInstanceValue = codec.decodeInstanceValue;
+    const instanceValueState = createInstanceValueState(this);
+    const valueState = codec.createRuntimeValueState(instanceValueState);
+    const [getInstanceValue] = instanceValueState;
+    const [, setValueState] = valueState;
+    this.getInstanceValue = getInstanceValue;
+    this.setValueState = setValueState;
+    this.getXPathValue = () => {
+      return this.getInstanceValue();
+    };
+    this.valueState = valueState;
+    this.validation = createValidationState(this, this.instanceConfig);
+    this.instanceState = createValueNodeInstanceState(this);
+  }
   validation;
   getInstanceValue;
   valueState;
@@ -42391,28 +42617,7 @@ class ValueNode extends DescendantNode {
   get validationState() {
     return this.validation.currentState;
   }
-  submissionState;
-  constructor(parent, definition, codec) {
-    super(parent, definition);
-    this.valueType = definition.valueType;
-    this.decodeInstanceValue = codec.decodeInstanceValue;
-    const instanceValueState = createInstanceValueState(this, {
-      initialValueSource: "FORM_DEFAULT"
-    });
-    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;
-    this.validation = createValidationState(this, {
-      clientStateFactory: this.engineConfig.stateFactory
-    });
-    this.submissionState = createValueNodeSubmissionState(this);
-  }
+  instanceState;
   // ValidationContext
   getViolation() {
     return this.validation.engineState.violation;
@@ -42449,8 +42654,8 @@ const nodeOptionsFactoryByType = {
   intent: () => null
 };
 class InputControl extends ValueNode {
-  static from(parent, definition) {
-    return new this(parent, definition);
+  static from(parent, instanceNode, definition) {
+    return new this(parent, instanceNode, definition);
   }
   // XFormsXPathElement
   [XPathNodeKindKey] = "element";
@@ -42462,14 +42667,11 @@ class InputControl extends ValueNode {
   appearances;
   nodeOptions;
   currentState;
-  constructor(parent, definition) {
+  constructor(parent, instanceNode, definition) {
     const codec = getSharedValueCodec(definition.valueType);
-    super(parent, definition, codec);
+    super(parent, instanceNode, definition, codec);
     this.appearances = definition.bodyElement.appearances;
     this.nodeOptions = nodeOptionsFactoryByType[definition.valueType](definition.bodyElement);
-    const sharedStateOptions = {
-      clientStateFactory: this.engineConfig.stateFactory
-    };
     const state = createSharedNodeState(
       this.scope,
       {
@@ -42484,7 +42686,7 @@ class InputControl extends ValueNode {
         value: this.valueState,
         instanceValue: this.getInstanceValue
       },
-      sharedStateOptions
+      this.instanceConfig
     );
     this.state = state;
     this.engineState = state.engineState;
@@ -42497,8 +42699,8 @@ class InputControl extends ValueNode {
 }
 
 class ModelValue extends ValueNode {
-  static from(parent, definition) {
-    return new this(parent, definition);
+  static from(parent, instanceNode, definition) {
+    return new this(parent, instanceNode, definition);
   }
   // XFormsXPathElement
   [XPathNodeKindKey] = "element";
@@ -42510,12 +42712,9 @@ class ModelValue extends ValueNode {
   appearances = null;
   nodeOptions = null;
   currentState;
-  constructor(parent, definition) {
+  constructor(parent, instanceNode, definition) {
     const codec = getSharedValueCodec(definition.valueType);
-    super(parent, definition, codec);
-    const sharedStateOptions = {
-      clientStateFactory: this.engineConfig.stateFactory
-    };
+    super(parent, instanceNode, definition, codec);
     const state = createSharedNodeState(
       this.scope,
       {
@@ -42530,7 +42729,7 @@ class ModelValue extends ValueNode {
         value: this.valueState,
         instanceValue: this.getInstanceValue
       },
-      sharedStateOptions
+      this.instanceConfig
     );
     this.state = state;
     this.engineState = state.engineState;
@@ -42617,13 +42816,10 @@ class Note extends ValueNode {
   appearances;
   nodeOptions = null;
   currentState;
-  constructor(parent, definition) {
+  constructor(parent, instanceNode, definition) {
     const codec = getNoteCodec(definition.valueType);
-    super(parent, definition, codec);
+    super(parent, instanceNode, definition, codec);
     this.appearances = definition.bodyElement.appearances;
-    const sharedStateOptions = {
-      clientStateFactory: this.engineConfig.stateFactory
-    };
     const isReadonly = createNoteReadonlyThunk(this, definition);
     const noteTextComputation = createNoteText(this, definition.noteTextDefinition);
     let noteText;
@@ -42660,7 +42856,7 @@ class Note extends ValueNode {
         value: this.valueState,
         instanceValue: this.getInstanceValue
       },
-      sharedStateOptions
+      this.instanceConfig
     );
     this.state = state;
     this.engineState = state.engineState;
@@ -42707,8 +42903,8 @@ class RangeCodec extends ValueCodec {
 }
 
 class RangeControl extends ValueNode {
-  static from(parent, definition) {
-    return new this(parent, definition);
+  static from(parent, instanceNode, definition) {
+    return new this(parent, instanceNode, definition);
   }
   // XFormsXPathElement
   [XPathNodeKindKey] = "element";
@@ -42720,14 +42916,11 @@ class RangeControl extends ValueNode {
   appearances;
   nodeOptions = null;
   currentState;
-  constructor(parent, definition) {
+  constructor(parent, instanceNode, definition) {
     const baseCodec = getSharedValueCodec(definition.valueType);
     const codec = new RangeCodec(baseCodec, definition);
-    super(parent, definition, codec);
+    super(parent, instanceNode, definition, codec);
     this.appearances = definition.bodyElement.appearances;
-    const sharedStateOptions = {
-      clientStateFactory: this.engineConfig.stateFactory
-    };
     const state = createSharedNodeState(
       this.scope,
       {
@@ -42742,7 +42935,7 @@ class RangeControl extends ValueNode {
         value: this.valueState,
         instanceValue: this.getInstanceValue
       },
-      sharedStateOptions
+      this.instanceConfig
     );
     this.state = state;
     this.engineState = state.engineState;
@@ -42754,6 +42947,256 @@ class RangeControl extends ValueNode {
   }
 }
 
+class RankMissingValueError extends Error {
+  constructor(message) {
+    super(message);
+  }
+}
+
+class XFormsSpecViolationError extends Error {
+}
+
+class RankValueTypeError extends XFormsSpecViolationError {
+  constructor(definition) {
+    const { valueType } = definition;
+    super(
+      `Ranks of type ${valueType} are not currently supported. If this functionality would be useful for your form, your feedback is welcome!`
+    );
+  }
+}
+
+class ValueArrayCodec extends ValueCodec {
+  decodeItemValue;
+  constructor(baseCodec, encodeValue, decodeValue) {
+    const decodeItemValue = (value) => {
+      const decoded = baseCodec.decodeValue(value);
+      if (decoded == null) {
+        throw new ErrorProductionDesignPendingError(
+          `Failed to decode item value: ${JSON.stringify(value)}`
+        );
+      }
+      return decoded;
+    };
+    super(baseCodec.valueType, encodeValue, decodeValue);
+    this.decodeItemValue = decodeItemValue;
+  }
+}
+
+class BaseItemCodec extends ValueArrayCodec {
+  constructor(baseCodec, encodeValue, decodeValue) {
+    super(baseCodec, encodeValue, decodeValue);
+  }
+}
+
+class MultipleValueItemCodec extends BaseItemCodec {
+  constructor(baseCodec) {
+    const encodeValue = (value) => {
+      return value.join(" ");
+    };
+    const decodeValue = (value) => {
+      return xmlXPathWhitespaceSeparatedList(value, {
+        ignoreEmpty: true
+      });
+    };
+    super(baseCodec, encodeValue, decodeValue);
+  }
+}
+
+const derivedItemLabel = (context, value) => {
+  const chunk = new TextChunk(context, "literal", value);
+  return new TextRange("form-derived", "item-label", [chunk]);
+};
+const createItemLabel = (context, definition) => {
+  const { label, value } = definition;
+  if (label == null) {
+    return () => derivedItemLabel(context, value);
+  }
+  return createTextRange(context, "item-label", label);
+};
+const createTranslatedStaticItems = (control, items) => {
+  return control.scope.runTask(() => {
+    const labeledItems = items.map((item) => {
+      const { value } = item;
+      const label = createItemLabel(control, item);
+      return () => ({
+        value,
+        label: label()
+      });
+    });
+    return createMemo(() => {
+      return labeledItems.map((item) => item());
+    });
+  });
+};
+class ItemsetItemEvaluationContext {
+  constructor(control, contextNode) {
+    this.contextNode = contextNode;
+    this.isAttached = control.isAttached;
+    this.scope = control.scope;
+    this.evaluator = control.evaluator;
+    this.contextReference = control.contextReference;
+    this.getActiveLanguage = control.getActiveLanguage;
+  }
+  isAttached;
+  scope;
+  evaluator;
+  contextReference;
+  getActiveLanguage;
+}
+const createItemsetItemLabel = (context, definition, itemValue) => {
+  const { label } = definition;
+  if (label == null) {
+    return createMemo(() => {
+      return derivedItemLabel(context, itemValue());
+    });
+  }
+  return createTextRange(context, "item-label", label);
+};
+const createItemsetItems = (control, itemset) => {
+  return control.scope.runTask(() => {
+    const itemNodes = createComputedExpression(control, itemset.nodes, {
+      defaultValue: []
+    });
+    const itemsCache = new UpsertableMap();
+    return createMemo(() => {
+      return itemNodes().map((itemNode) => {
+        return itemsCache.upsert(itemNode, () => {
+          const context = new ItemsetItemEvaluationContext(control, itemNode);
+          const value = createComputedExpression(context, itemset.value, {
+            defaultValue: ""
+          });
+          const label = createItemsetItemLabel(context, itemset, value);
+          return {
+            label,
+            value
+          };
+        });
+      });
+    });
+  });
+};
+const createItemset = (control, itemset) => {
+  return control.scope.runTask(() => {
+    const itemsetItems = createItemsetItems(control, itemset);
+    return createMemo(() => {
+      return itemsetItems().map((item) => {
+        return {
+          label: item.label(),
+          value: item.value()
+        };
+      });
+    });
+  });
+};
+const createItemCollection = (control) => {
+  const { items, itemset } = control.definition.bodyElement;
+  if (itemset != null) {
+    return createItemset(control, itemset);
+  }
+  return createTranslatedStaticItems(control, items);
+};
+
+const assertRankNodeDefinition = (definition) => {
+  if (definition.valueType !== "string") {
+    throw new RankValueTypeError(definition);
+  }
+};
+const isBlankValueState = (values) => {
+  return values.length === 0;
+};
+class RankControl extends ValueNode {
+  static from(parent, instanceNode, definition) {
+    assertRankNodeDefinition(definition);
+    return new this(parent, instanceNode, definition);
+  }
+  mapOptionsByValue;
+  getInstanceValue;
+  // XFormsXPathElement
+  [XPathNodeKindKey] = "element";
+  // InstanceNode
+  state;
+  engineState;
+  // RankNode
+  nodeType = "rank";
+  appearances;
+  nodeOptions = null;
+  currentState;
+  constructor(parent, instanceNode, definition) {
+    const codec = new MultipleValueItemCodec(sharedValueCodecs.string);
+    super(parent, instanceNode, definition, codec);
+    this.appearances = definition.bodyElement.appearances;
+    const valueOptions = createItemCollection(this);
+    const mapOptionsByValue = this.scope.runTask(() => {
+      return createMemo(() => {
+        return new Map(valueOptions().map((item) => [item.value, item]));
+      });
+    });
+    this.mapOptionsByValue = mapOptionsByValue;
+    const baseValueState = this.valueState;
+    const [baseGetValue, setValue] = baseValueState;
+    const getValue = this.scope.runTask(() => {
+      return createMemo(() => {
+        const options = valueOptions();
+        const values = baseGetValue();
+        if (isBlankValueState(values)) {
+          return values;
+        }
+        const optionValues = new Set(options.map((option) => option.value));
+        const currentValues = values.filter((value) => optionValues.has(value));
+        return Array.from(
+          /* @__PURE__ */ new Set([
+            ...currentValues,
+            /**
+             * @see {@link getValue} ToDo paragraph 1.
+             */
+            ...optionValues
+          ])
+        );
+      });
+    });
+    const valueState = [getValue, setValue];
+    this.getInstanceValue = this.scope.runTask(() => {
+      return createMemo(() => codec.encodeValue(getValue()));
+    });
+    const state = createSharedNodeState(
+      this.scope,
+      {
+        reference: this.contextReference,
+        readonly: this.isReadonly,
+        relevant: this.isRelevant,
+        required: this.isRequired,
+        label: createNodeLabel(this, definition),
+        hint: createFieldHint(this, definition),
+        children: null,
+        valueOptions,
+        value: valueState,
+        instanceValue: this.getInstanceValue
+      },
+      this.instanceConfig
+    );
+    this.state = state;
+    this.engineState = state.engineState;
+    this.currentState = state.currentState;
+  }
+  getValueLabel(value) {
+    const valueOption = this.currentState.valueOptions.find((item) => item.value === value);
+    return valueOption?.label ?? null;
+  }
+  setValues(valuesInOrder) {
+    if (isBlankValueState(valuesInOrder)) {
+      this.setValueState(valuesInOrder);
+      return this.root;
+    }
+    const sourceValues = Array.from(this.mapOptionsByValue().keys());
+    const hasAllValues = sourceValues.every((sourceValue) => valuesInOrder.includes(sourceValue));
+    if (!hasAllValues) {
+      throw new RankMissingValueError("There are missing options. Rank should have all options.");
+    }
+    this.setValueState(valuesInOrder);
+    return this.root;
+  }
+}
+
 const insertAtIndex = (currentValues, insertionIndex, newValues) => {
   const { length } = currentValues;
   if (insertionIndex > length) {
@@ -42771,24 +43214,49 @@ const insertAtIndex = (currentValues, insertionIndex, newValues) => {
   ];
 };
 
-const createNodeRangeSubmissionState = (node) => {
+const createNodeRangeInstanceState = (node) => {
   return {
-    get submissionXML() {
+    get instanceXML() {
       const serializedChildren = node.currentState.children.map((child) => {
-        return child.submissionState.submissionXML;
+        return child.instanceState.instanceXML;
       });
       return serializedChildren.join("");
     }
   };
 };
 
+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);
+    }
+  };
+};
+
 class RepeatInstance extends DescendantNode {
-  constructor(parent, definition, options) {
+  constructor(parent, instanceNode, options) {
+    const { definition } = parent;
     const { precedingInstance } = options;
     const precedingIndex = precedingInstance?.currentIndex ?? (() => -1);
     const initialIndex = precedingIndex() + 1;
     const [currentIndex, setCurrentIndex] = createSignal(initialIndex);
-    super(parent, definition, {
+    super(parent, instanceNode, definition, {
       computeReference: () => {
         const currentPosition = currentIndex() + 1;
         return `${parent.contextReference()}[${currentPosition}]`;
@@ -42799,9 +43267,6 @@ class RepeatInstance extends DescendantNode {
     const childrenState = createChildrenState(this);
     this.childrenState = childrenState;
     this.currentIndex = currentIndex;
-    const sharedStateOptions = {
-      clientStateFactory: this.engineConfig.stateFactory
-    };
     const state = createSharedNodeState(
       this.scope,
       {
@@ -42812,11 +43277,12 @@ class RepeatInstance extends DescendantNode {
         // TODO: only-child <group><label>
         label: createNodeLabel(this, definition),
         hint: null,
+        attributes: null,
         children: childrenState.childIds,
         valueOptions: null,
         value: null
       },
-      sharedStateOptions
+      this.instanceConfig
     );
     this.state = state;
     this.engineState = state.engineState;
@@ -42830,8 +43296,8 @@ class RepeatInstance extends DescendantNode {
       createComputed(on(computeCurrentIndex, setCurrentIndex, { defer: true }));
     });
     childrenState.setChildren(buildChildren(this));
-    this.validationState = createAggregatedViolations(this, sharedStateOptions);
-    this.submissionState = createParentNodeSubmissionState(this);
+    this.validationState = createAggregatedViolations(this, this.instanceConfig);
+    this.instanceState = createTemplatedNodeInstanceState(this);
   }
   childrenState;
   currentIndex;
@@ -42864,7 +43330,7 @@ class RepeatInstance extends DescendantNode {
   nodeOptions = null;
   currentState;
   validationState;
-  submissionState;
+  instanceState;
   getChildren() {
     return this.childrenState.getChildren();
   }
@@ -42906,15 +43372,12 @@ class BaseRepeatRange extends DescendantNode {
   engineState;
   nodeOptions = null;
   currentState;
-  submissionState;
+  instanceState;
   constructor(parent, definition) {
-    super(parent, definition);
+    super(parent, definition.template, definition);
     const repeatRange = this;
     const childrenState = createChildrenState(repeatRange);
     this.childrenState = childrenState;
-    const sharedStateOptions = {
-      clientStateFactory: this.engineConfig.stateFactory
-    };
     const state = createSharedNodeState(
       this.scope,
       {
@@ -42928,7 +43391,7 @@ class BaseRepeatRange extends DescendantNode {
         valueOptions: null,
         value: null
       },
-      sharedStateOptions
+      this.instanceConfig
     );
     this.state = state;
     this.engineState = state.engineState;
@@ -42937,7 +43400,7 @@ class BaseRepeatRange extends DescendantNode {
       state.currentState,
       childrenState
     );
-    this.submissionState = createNodeRangeSubmissionState(this);
+    this.instanceState = createNodeRangeInstanceState(this);
   }
   getLastIndex() {
     return this.engineState.children.length - 1;
@@ -42945,7 +43408,7 @@ class BaseRepeatRange extends DescendantNode {
   getInstanceIndex(instance) {
     return this.engineState.children.indexOf(instance.nodeId);
   }
-  createChildren(afterIndex, definitions) {
+  createChildren(afterIndex, instanceNodes) {
     return this.scope.runTask(() => {
       let initialPrecedingInstance;
       if (afterIndex === -1) {
@@ -42958,7 +43421,7 @@ class BaseRepeatRange extends DescendantNode {
         initialPrecedingInstance = instance;
       }
       const repeatRange = this;
-      return definitions.reduce((acc, definition) => {
+      return instanceNodes.reduce((acc, definition) => {
         const precedingInstance = acc[acc.length - 1] ?? initialPrecedingInstance;
         const newInstance = new RepeatInstance(repeatRange, definition, {
           precedingInstance
@@ -42968,10 +43431,10 @@ class BaseRepeatRange extends DescendantNode {
       }, []);
     });
   }
-  addChildren(afterIndex, definitions) {
+  addChildren(afterIndex, instanceNodes) {
     return this.scope.runTask(() => {
       const initialIndex = afterIndex + 1;
-      const newInstances = this.createChildren(afterIndex, definitions);
+      const newInstances = this.createChildren(afterIndex, instanceNodes);
       return this.childrenState.setChildren((currentInstances) => {
         return insertAtIndex(currentInstances, initialIndex, newInstances);
       });
@@ -42995,25 +43458,33 @@ class BaseRepeatRange extends DescendantNode {
 }
 
 class RepeatRangeControlled extends BaseRepeatRange {
+  isInstanceCreation;
+  countControlType;
   // RepeatRangeControlledNode
   nodeType = "repeat-range:controlled";
   appearances;
   validationState;
-  constructor(parent, definition) {
+  constructor(parent, instanceNodes, definition) {
     super(parent, definition);
+    this.isInstanceCreation = parent.rootDocument.initializationMode === "create";
     this.appearances = definition.bodyElement.appearances;
-    this.initializeControlledChildrenState(definition);
-    this.validationState = createAggregatedViolations(this, {
-      clientStateFactory: this.engineConfig.stateFactory
-    });
+    if (definition.count.isConstantExpression()) {
+      this.countControlType = "REPEAT_COUNT_CONTROL_FIXED";
+    } else {
+      this.countControlType = "REPEAT_COUNT_CONTROL_DYNAMIC";
+    }
+    this.initializeControlledChildrenState(definition, instanceNodes);
+    this.validationState = createAggregatedViolations(this, this.instanceConfig);
   }
-  initializeControlledChildrenState(definition) {
+  initializeControlledChildrenState(definition, instanceNodes) {
     this.scope.runTask(() => {
-      const { count, instances, template } = definition;
+      const { count, template } = definition;
+      const repeatInstanceNodes = definition.omitTemplate(instanceNodes);
       const computeCount = createComputedExpression(this, count, {
         defaultValue: 0
       });
-      createComputed((previousCount) => {
+      createComputed((previousCountComputation = null) => {
+        const previousCount = previousCountComputation ?? 0;
         let currentCount = computeCount();
         if (Number.isFinite(currentCount) && currentCount < 0) {
           currentCount = 0;
@@ -43026,21 +43497,57 @@ class RepeatRangeControlled extends BaseRepeatRange {
         Number.isNaN(currentCount)) {
           return previousCount;
         }
+        this.warnDroppedInstanceNodes(repeatInstanceNodes, previousCountComputation, currentCount);
         if (currentCount > previousCount) {
           const delta = currentCount - previousCount;
-          const definitions = Array(delta).fill(template).map((baseDefinition, index) => {
+          const inputNodes = Array(delta).fill(null).map((_, index) => {
             const instanceIndex = previousCount + index;
-            return instances[instanceIndex] ?? baseDefinition;
+            return repeatInstanceNodes[instanceIndex] ?? template;
           });
-          this.addChildren(previousCount - 1, definitions);
+          this.addChildren(previousCount - 1, inputNodes);
         } else {
           const delta = previousCount - currentCount;
           this.removeChildren(currentCount, delta);
         }
         return currentCount;
-      }, 0);
+      });
     });
   }
+  /**
+   * Note: we do not warn about dropping "excess" repeat instances...
+   *
+   * - ... after the instance is fully loaded: dropping repeat instances after
+   *   that point is an expected behavior of _dynamically-controlled repeats_
+   *   (i.e. those defined with `jr:count`), and it does not occur for
+   *   _fixed-controlled repeats_ (i.e. defined with `jr:noAddRemove`);
+   *
+   * - ... for dynamic (`jr:count`) repeats _in newly created form instances_, i.e. instances whose input instance
+   *   nodes are derived from the _form definition_: those form-defined repeat
+   *   instances are not "dropped", instead they're retained in memory to be
+   *   added as count is recomputed to a larger value.
+   *
+   * @todo ^ it is pretty likely that retain-in-memory behavior also applies to
+   * instance state which has been serialized and restored as well! In this way,
+   * it's possible we're not really "dropping" those nodes, only deferring their
+   * restoration. Is this what we want?
+   *
+   * @todo Design and produce {@link LoadFormWarnings | warnings} as values!
+   */
+  warnDroppedInstanceNodes(repeatInstanceNodes, previousCountComputation, initialCount) {
+    if (this.isInstanceCreation) {
+      return;
+    }
+    const isInstanceLoad = previousCountComputation == null;
+    if (isInstanceLoad && this.countControlType === "REPEAT_COUNT_CONTROL_DYNAMIC") {
+      return;
+    }
+    const droppedCount = repeatInstanceNodes.length - initialCount;
+    if (droppedCount > 0) {
+      console.warn(
+        `Dropped ${droppedCount} repeat instances for repeat range ${this.contextReference()}`
+      );
+    }
+  }
 }
 
 class RepeatRangeUncontrolled extends BaseRepeatRange {
@@ -43048,13 +43555,11 @@ class RepeatRangeUncontrolled extends BaseRepeatRange {
   nodeType = "repeat-range:uncontrolled";
   appearances;
   validationState;
-  constructor(parent, definition) {
+  constructor(parent, instanceNodes, definition) {
     super(parent, definition);
     this.appearances = definition.bodyElement.appearances;
-    this.addChildren(-1, definition.instances);
-    this.validationState = createAggregatedViolations(this, {
-      clientStateFactory: this.engineConfig.stateFactory
-    });
+    this.addChildren(-1, definition.omitTemplate(instanceNodes));
+    this.validationState = createAggregatedViolations(this, this.instanceConfig);
   }
   // RepeatRangeUncontrolledNode
   addInstances(afterIndex = this.getLastIndex(), count = 1) {
@@ -43085,9 +43590,6 @@ class RepeatRangeUncontrolled extends BaseRepeatRange {
   }
 }
 
-class XFormsSpecViolationError extends Error {
-}
-
 class SelectValueTypeError extends XFormsSpecViolationError {
   constructor(definition) {
     const { valueType } = definition;
@@ -43097,43 +43599,6 @@ class SelectValueTypeError extends XFormsSpecViolationError {
   }
 }
 
-class ValueArrayCodec extends ValueCodec {
-  decodeItemValue;
-  constructor(baseCodec, encodeValue, decodeValue) {
-    const decodeItemValue = (value) => {
-      const decoded = baseCodec.decodeValue(value);
-      if (decoded == null) {
-        throw new ErrorProductionDesignPendingError(
-          `Failed to decode item value: ${JSON.stringify(value)}`
-        );
-      }
-      return decoded;
-    };
-    super(baseCodec.valueType, encodeValue, decodeValue);
-    this.decodeItemValue = decodeItemValue;
-  }
-}
-
-class BaseItemCodec extends ValueArrayCodec {
-  constructor(baseCodec, encodeValue, decodeValue) {
-    super(baseCodec, encodeValue, decodeValue);
-  }
-}
-
-class MultipleValueItemCodec extends BaseItemCodec {
-  constructor(baseCodec) {
-    const encodeValue = (value) => {
-      return value.join(" ");
-    };
-    const decodeValue = (value) => {
-      return xmlXPathWhitespaceSeparatedList(value, {
-        ignoreEmpty: true
-      });
-    };
-    super(baseCodec, encodeValue, decodeValue);
-  }
-}
-
 const encodeValueFactory = (baseCodec) => {
   return (values) => {
     const [value] = values;
@@ -43169,109 +43634,15 @@ const getSelectCodec = (definition) => {
   }
 };
 
-const derivedItemLabel = (context, value) => {
-  const chunk = new TextChunk(context, "literal", value);
-  return new TextRange("form-derived", "item-label", [chunk]);
-};
-const createItemLabel = (context, definition) => {
-  const { label, value } = definition;
-  if (label == null) {
-    return () => derivedItemLabel(context, value);
-  }
-  return createTextRange(context, "item-label", label);
-};
-const createTranslatedStaticItems = (control, items) => {
-  return control.scope.runTask(() => {
-    const labeledItems = items.map((item) => {
-      const { value } = item;
-      const label = createItemLabel(control, item);
-      return () => ({
-        value,
-        label: label()
-      });
-    });
-    return createMemo(() => {
-      return labeledItems.map((item) => item());
-    });
-  });
-};
-class ItemsetItemEvaluationContext {
-  constructor(control, contextNode) {
-    this.contextNode = contextNode;
-    this.isAttached = control.isAttached;
-    this.scope = control.scope;
-    this.evaluator = control.evaluator;
-    this.contextReference = control.contextReference;
-    this.getActiveLanguage = control.getActiveLanguage;
-  }
-  isAttached;
-  scope;
-  evaluator;
-  contextReference;
-  getActiveLanguage;
-}
-const createItemsetItemLabel = (context, definition, itemValue) => {
-  const { label } = definition;
-  if (label == null) {
-    return createMemo(() => {
-      return derivedItemLabel(context, itemValue());
-    });
-  }
-  return createTextRange(context, "item-label", label);
-};
-const createItemsetItems = (control, itemset) => {
-  return control.scope.runTask(() => {
-    const itemNodes = createComputedExpression(control, itemset.nodes, {
-      defaultValue: []
-    });
-    const itemsCache = new UpsertableMap();
-    return createMemo(() => {
-      return itemNodes().map((itemNode) => {
-        return itemsCache.upsert(itemNode, () => {
-          const context = new ItemsetItemEvaluationContext(control, itemNode);
-          const value = createComputedExpression(context, itemset.value, {
-            defaultValue: ""
-          });
-          const label = createItemsetItemLabel(context, itemset, value);
-          return {
-            label,
-            value
-          };
-        });
-      });
-    });
-  });
-};
-const createItemset = (control, itemset) => {
-  return control.scope.runTask(() => {
-    const itemsetItems = createItemsetItems(control, itemset);
-    return createMemo(() => {
-      return itemsetItems().map((item) => {
-        return {
-          label: item.label(),
-          value: item.value()
-        };
-      });
-    });
-  });
-};
-const createItemCollection = (control) => {
-  const { items, itemset } = control.definition.bodyElement;
-  if (itemset != null) {
-    return createItemset(control, itemset);
-  }
-  return createTranslatedStaticItems(control, items);
-};
-
 const assertSupportedSelectValueType = (definition) => {
   if (definition.valueType !== "string") {
     throw new SelectValueTypeError(definition);
   }
 };
 class SelectControl extends ValueNode {
-  static from(parent, definition) {
+  static from(parent, instanceNode, definition) {
     assertSupportedSelectValueType(definition);
-    return new this(parent, definition);
+    return new this(parent, instanceNode, definition);
   }
   mapOptionsByValue;
   getInstanceValue;
@@ -43286,9 +43657,9 @@ class SelectControl extends ValueNode {
   appearances;
   nodeOptions = null;
   currentState;
-  constructor(parent, definition) {
+  constructor(parent, instanceNode, definition) {
     const codec = getSelectCodec(definition);
-    super(parent, definition, codec);
+    super(parent, instanceNode, definition, codec);
     this.appearances = definition.bodyElement.appearances;
     this.selectType = definition.bodyElement.type;
     const valueOptions = createItemCollection(this);
@@ -43314,9 +43685,6 @@ class SelectControl extends ValueNode {
         return codec.encodeValue(getValue());
       });
     });
-    const sharedStateOptions = {
-      clientStateFactory: this.engineConfig.stateFactory
-    };
     const state = createSharedNodeState(
       this.scope,
       {
@@ -43331,7 +43699,7 @@ class SelectControl extends ValueNode {
         value: valueState,
         instanceValue: this.getInstanceValue
       },
-      sharedStateOptions
+      this.instanceConfig
     );
     this.state = state;
     this.engineState = state.engineState;
@@ -43401,14 +43769,11 @@ class Subtree extends DescendantNode {
   nodeOptions = null;
   currentState;
   validationState;
-  submissionState;
-  constructor(parent, definition) {
-    super(parent, definition);
+  instanceState;
+  constructor(parent, instanceNode, definition) {
+    super(parent, instanceNode, definition);
     const childrenState = createChildrenState(this);
     this.childrenState = childrenState;
-    const sharedStateOptions = {
-      clientStateFactory: this.engineConfig.stateFactory
-    };
     const state = createSharedNodeState(
       this.scope,
       {
@@ -43422,7 +43787,7 @@ class Subtree extends DescendantNode {
         valueOptions: null,
         value: null
       },
-      sharedStateOptions
+      this.instanceConfig
     );
     this.state = state;
     this.engineState = state.engineState;
@@ -43432,8 +43797,8 @@ class Subtree extends DescendantNode {
       childrenState
     );
     childrenState.setChildren(buildChildren(this));
-    this.validationState = createAggregatedViolations(this, sharedStateOptions);
-    this.submissionState = createParentNodeSubmissionState(this);
+    this.validationState = createAggregatedViolations(this, this.instanceConfig);
+    this.instanceState = createParentNodeInstanceState(this);
   }
   getChildren() {
     return this.childrenState.getChildren();
@@ -43477,13 +43842,13 @@ class TriggerCodec extends ValueCodec {
 
 const codec = new TriggerCodec();
 class TriggerControl extends ValueNode {
-  static from(parent, definition) {
+  static from(parent, instanceNode, definition) {
     if (definition.valueType !== "string") {
       throw new ErrorProductionDesignPendingError(
         `Unsupported trigger value type: ${definition.valueType}`
       );
     }
-    return new this(parent, definition);
+    return new this(parent, instanceNode, definition);
   }
   // XFormsXPathElement
   [XPathNodeKindKey] = "element";
@@ -43495,12 +43860,9 @@ class TriggerControl extends ValueNode {
   appearances;
   nodeOptions = null;
   currentState;
-  constructor(parent, definition) {
-    super(parent, definition, codec);
+  constructor(parent, instanceNode, definition) {
+    super(parent, instanceNode, definition, codec);
     this.appearances = definition.bodyElement.appearances;
-    const sharedStateOptions = {
-      clientStateFactory: this.engineConfig.stateFactory
-    };
     const state = createSharedNodeState(
       this.scope,
       {
@@ -43515,7 +43877,7 @@ class TriggerControl extends ValueNode {
         value: this.valueState,
         instanceValue: this.getInstanceValue
       },
-      sharedStateOptions
+      this.instanceConfig
     );
     this.state = state;
     this.engineState = state.engineState;
@@ -43528,86 +43890,59 @@ class TriggerControl extends ValueNode {
   }
 }
 
-class RankMissingValueError extends Error {
-  constructor(message) {
-    super(message);
+class TempUnsupportedControlEncodeError extends Error {
+  constructor() {
+    super(`Cannot encode state: not implemented`);
   }
 }
-
-class RankValueTypeError extends XFormsSpecViolationError {
-  constructor(definition) {
-    const { valueType } = definition;
-    super(
-      `Ranks of type ${valueType} are not currently supported. If this functionality would be useful for your form, your feedback is welcome!`
-    );
+class TempUnsupportedControlCodec extends ValueCodec {
+  constructor(valueType) {
+    const encodeValue = (input) => {
+      if (typeof input === "string") {
+        return input;
+      }
+      throw new TempUnsupportedControlEncodeError();
+    };
+    const decodeValue = identity;
+    super(valueType, encodeValue, decodeValue);
   }
 }
 
-const assertRankNodeDefinition = (definition) => {
-  if (definition.valueType !== "string") {
-    throw new RankValueTypeError(definition);
-  }
-};
-const isBlankValueState = (values) => {
-  return values.length === 0;
+const codecs = {
+  string: new TempUnsupportedControlCodec("string"),
+  int: new TempUnsupportedControlCodec("int"),
+  decimal: new TempUnsupportedControlCodec("decimal"),
+  boolean: new TempUnsupportedControlCodec("boolean"),
+  date: new TempUnsupportedControlCodec("date"),
+  time: new TempUnsupportedControlCodec("time"),
+  dateTime: new TempUnsupportedControlCodec("dateTime"),
+  geopoint: new TempUnsupportedControlCodec("geopoint"),
+  geotrace: new TempUnsupportedControlCodec("geotrace"),
+  geoshape: new TempUnsupportedControlCodec("geoshape"),
+  binary: new TempUnsupportedControlCodec("binary"),
+  barcode: new TempUnsupportedControlCodec("barcode"),
+  intent: new TempUnsupportedControlCodec("intent")
 };
-class RankControl extends ValueNode {
-  static from(parent, definition) {
-    assertRankNodeDefinition(definition);
-    return new this(parent, definition);
+class UnsupportedControlWriteError extends Error {
+  constructor(type) {
+    super(`Cannot write state for node (type: ${type}) - not implemented`);
   }
-  mapOptionsByValue;
-  getInstanceValue;
+}
+class UploadControl extends ValueNode {
   // XFormsXPathElement
   [XPathNodeKindKey] = "element";
   // InstanceNode
   state;
   engineState;
-  // RankNode
-  nodeType = "rank";
+  // UploadNode
+  nodeType = "upload";
   appearances;
   nodeOptions = null;
   currentState;
-  constructor(parent, definition) {
-    const codec = new MultipleValueItemCodec(sharedValueCodecs.string);
-    super(parent, definition, codec);
+  constructor(parent, instanceNode, definition) {
+    const codec = codecs[definition.valueType];
+    super(parent, instanceNode, definition, codec);
     this.appearances = definition.bodyElement.appearances;
-    const valueOptions = createItemCollection(this);
-    const mapOptionsByValue = this.scope.runTask(() => {
-      return createMemo(() => {
-        return new Map(valueOptions().map((item) => [item.value, item]));
-      });
-    });
-    this.mapOptionsByValue = mapOptionsByValue;
-    const baseValueState = this.valueState;
-    const [baseGetValue, setValue] = baseValueState;
-    const getValue = this.scope.runTask(() => {
-      return createMemo(() => {
-        const options = valueOptions();
-        const values = baseGetValue();
-        if (isBlankValueState(values)) {
-          return values;
-        }
-        const optionValues = new Set(options.map((option) => option.value));
-        const currentValues = values.filter((value) => optionValues.has(value));
-        return Array.from(
-          /* @__PURE__ */ new Set([
-            ...currentValues,
-            /**
-             * @see {@link getValue} ToDo paragraph 1.
-             */
-            ...optionValues
-          ])
-        );
-      });
-    });
-    const valueState = [getValue, setValue];
-    this.getInstanceValue = this.scope.runTask(() => {
-      return createMemo(() => codec.encodeValue(getValue()));
-    });
-    const sharedStateOptions = {
-      clientStateFactory: this.engineConfig.stateFactory
-    };
     const state = createSharedNodeState(
       this.scope,
       {
@@ -43618,209 +43953,218 @@ class RankControl extends ValueNode {
         label: createNodeLabel(this, definition),
         hint: createFieldHint(this, definition),
         children: null,
-        valueOptions,
-        value: valueState,
+        valueOptions: null,
+        value: this.valueState,
         instanceValue: this.getInstanceValue
       },
-      sharedStateOptions
+      this.instanceConfig
     );
     this.state = state;
     this.engineState = state.engineState;
     this.currentState = state.currentState;
   }
-  getValueLabel(value) {
-    const valueOption = this.currentState.valueOptions.find((item) => item.value === value);
-    return valueOption?.label ?? null;
-  }
-  setValues(valuesInOrder) {
-    if (isBlankValueState(valuesInOrder)) {
-      this.setValueState(valuesInOrder);
-      return this.root;
-    }
-    const sourceValues = Array.from(this.mapOptionsByValue().keys());
-    const hasAllValues = sourceValues.every((sourceValue) => valuesInOrder.includes(sourceValue));
-    if (!hasAllValues) {
-      throw new RankMissingValueError("There are missing options. Rank should have all options.");
-    }
-    this.setValueState(valuesInOrder);
-    return this.root;
+  // UnsupportedControlNode
+  setValue(_) {
+    throw new UnsupportedControlWriteError(this.nodeType);
   }
 }
 
-const createLeafNodeSubmissionState = (node) => {
-  return {
-    get submissionXML() {
-      if (!node.currentState.relevant) {
-        return "";
+const META_LOCAL_NAME = "meta";
+const INSTANCE_ID_LOCAL_NAME = "instanceID";
+const DEPRECATED_ID_LOCAL_NAME = "deprecatedID";
+const META_NAMESPACE_URIS = [OPENROSA_XFORMS_NAMESPACE_URI$1, XFORMS_NAMESPACE_URI$1];
+const isMetaNamespacedName = (qualifiedName) => {
+  const namespaceURI = qualifiedName.namespaceURI?.href;
+  return namespaceURI != null && META_NAMESPACE_URIS.includes(namespaceURI);
+};
+const isMetaName = (qualifiedName) => {
+  return isMetaNamespacedName(qualifiedName) && qualifiedName.localName === META_LOCAL_NAME;
+};
+const isDirectRootDescendant = (parent) => {
+  return parent.parent === parent.root;
+};
+const isBaseMetaDefinition = (definition) => {
+  return isMetaName(definition.qualifiedName);
+};
+const isMetaSubroot = (options) => {
+  const { nodeType } = options.parent;
+  return (nodeType === "subtree" || nodeType === "group") && isDirectRootDescendant(options.parent) && isBaseMetaDefinition(options.parent.definition);
+};
+const isEditModeInstance = (primaryInstance) => {
+  return primaryInstance.initializationMode === "edit";
+};
+const isEditModeMetaSubroot = (subroot) => {
+  return isEditModeInstance(subroot.parent.rootDocument);
+};
+const isLeafNodeInitOptions = (options) => {
+  const { instanceNodes } = options;
+  const [instanceNode, ...rest] = instanceNodes;
+  return instanceNode != null && rest.length === 0 && instanceNode.isLeafElement();
+};
+const findMetaLeafChild = (subroot, localName) => {
+  const metaName = subroot.parent.definition.qualifiedName;
+  const namespaceURI = metaName.namespaceURI.href;
+  const result = Array.from(subroot.children.entries()).find(
+    (entry) => {
+      const [, child] = entry;
+      if (!isLeafNodeInitOptions(child)) {
+        return false;
       }
-      const value = node.encodeValue(node.currentState.value);
-      const xmlValue = escapeXMLText(value);
-      return serializeLeafElementXML(node.definition.qualifiedName, xmlValue);
+      const [instanceNode] = child.instanceNodes;
+      const { qualifiedName } = instanceNode;
+      return qualifiedName.localName === localName && qualifiedName.namespaceURI?.href === namespaceURI;
     }
-  };
+  );
+  return result ?? null;
 };
-
-const getInitialValue = (context, options) => {
-  const { initialValueSource = "FORM_DEFAULT" } = options;
-  if (initialValueSource === "FORM_DEFAULT") {
-    return context.definition.defaultValue;
+const getInstanceIDValue = (subroot) => {
+  const [, child = null] = findMetaLeafChild(subroot, INSTANCE_ID_LOCAL_NAME) ?? [];
+  if (child == null) {
+    return null;
   }
-  throw new ErrorProductionDesignPendingError("Edit implementation pending");
+  const [instanceIDNode] = child.instanceNodes;
+  return instanceIDNode.value;
 };
-const createRelevantValueState = (context, baseValueState) => {
-  return context.scope.runTask(() => {
-    const [getRelevantValue, setValue] = baseValueState;
-    const getValue = createMemo(() => {
-      if (context.isRelevant()) {
-        return getRelevantValue();
-      }
-      return "";
-    });
-    return [getValue, setValue];
-  });
+const assertStaticLeafElement = (element) => {
+  if (!element.isLeafElement()) {
+    throw new ErrorProductionDesignPendingError(
+      `Expected a leaf element, got a non-leaf element at nodeset: ${element.nodeset}`
+    );
+  }
 };
-const createRuntimeValueState = (context, relevantValueState) => {
-  const { decodeValue, encodeValue } = context;
-  return context.scope.runTask(() => {
-    const [primaryInstanceValue, setPrimaryInstanceValue] = relevantValueState;
-    const getRuntimeValue = createMemo(() => {
-      return decodeValue(primaryInstanceValue());
-    });
-    const setRuntimeValue = (value) => {
-      const encodedValue = encodeValue(value);
-      return decodeValue(setPrimaryInstanceValue(encodedValue));
-    };
-    return [getRuntimeValue, setRuntimeValue];
+const buildMetaValueElement = (subroot, localName, value) => {
+  const { qualifiedName, nodeset } = subroot.parent.definition;
+  const { namespaceURI, prefix } = qualifiedName;
+  const { root } = new StaticDocument({
+    documentRoot: {
+      name: {
+        namespaceURI,
+        prefix,
+        localName
+      },
+      children: [value]
+    },
+    nodesetPrefix: nodeset
   });
+  assertStaticLeafElement(root);
+  return root;
 };
-const guardDownstreamReadonlyWrites = (context, baseState) => {
-  const { readonly } = context.definition.bind;
-  if (readonly.isDefaultExpression) {
-    return baseState;
-  }
-  const [getValue, baseSetValue] = baseState;
-  const setValue = (value) => {
-    if (context.isReadonly()) {
-      const reference = untrack(() => context.contextReference());
-      throw new Error(`Cannot write to readonly field: ${reference}`);
-    }
-    return baseSetValue(value);
+const buildDeprecatedIDDefinition = (subroot, instanceNode) => {
+  const nodeset = instanceNode.nodeset;
+  const bind = subroot.model.binds.getOrCreateBindDefinition(nodeset);
+  return new LeafNodeDefinition(subroot.parent.definition, bind, null, instanceNode);
+};
+const buildDeprecatedID = (subroot, value) => {
+  const instanceNode = buildMetaValueElement(subroot, DEPRECATED_ID_LOCAL_NAME, value);
+  const definition = buildDeprecatedIDDefinition(subroot, instanceNode);
+  return {
+    childNodeset: instanceNode.nodeset,
+    definition,
+    instanceNodes: [instanceNode]
   };
-  return [getValue, setValue];
 };
-const createCalculation = (context, setValue, calculateDefinition) => {
-  context.scope.runTask(() => {
-    const calculate = createComputedExpression(context, calculateDefinition, {
-      defaultValue: ""
-    });
-    createComputed(() => {
-      if (context.isAttached() && context.isRelevant()) {
-        const calculated = calculate();
-        const value = context.decodeValue(calculated);
-        setValue(value);
-      }
-    });
-  });
+const updateDeprecatedID = (subroot, child, value) => {
+  const instanceNode = buildMetaValueElement(subroot, DEPRECATED_ID_LOCAL_NAME, value);
+  return {
+    childNodeset: child.childNodeset,
+    definition: child.definition,
+    instanceNodes: [instanceNode]
+  };
 };
-const createValueState = (context, options = {}) => {
-  return context.scope.runTask(() => {
-    const initialValue = getInitialValue(context, options);
-    const baseValueState = createSignal(initialValue);
-    const valueState = createRelevantValueState(context, baseValueState);
-    const runtimeState = createRuntimeValueState(context, valueState);
-    const { calculate } = context.definition.bind;
-    if (calculate != null) {
-      const [, setValue] = runtimeState;
-      createCalculation(context, setValue, calculate);
-    }
-    return guardDownstreamReadonlyWrites(context, runtimeState);
-  });
+const replace = (values, index, value) => {
+  const results = values.slice();
+  results.splice(index, 1, value);
+  return results;
 };
-
-class UnsupportedControlValueEncodeError extends Error {
-  constructor(type) {
-    super(`Cannot encode state for node (type: ${type}) - not implemented`);
+const replaceOrConcat = (values, index, value) => {
+  if (index == null) {
+    return values.concat(value);
   }
-}
-class UnsupportedControlWriteError extends Error {
-  constructor(type) {
-    super(`Cannot write state for node (type: ${type}) - not implemented`);
+  return replace(values, index, value);
+};
+const populateDeprecatedID = (subroot) => {
+  const value = getInstanceIDValue(subroot);
+  if (value == null) {
+    return subroot;
   }
-}
-class UnsupportedControl extends DescendantNode {
-  validation;
-  state;
-  // XFormsXPathElement
-  [XPathNodeKindKey] = "element";
-  // InstanceNode
-  engineState;
-  appearances;
-  nodeOptions = null;
-  currentState;
-  get validationState() {
-    return this.validation.currentState;
+  const [index, currentDeprecatedID] = findMetaLeafChild(subroot, DEPRECATED_ID_LOCAL_NAME) ?? [
+    null
+  ];
+  let deprecatedID;
+  if (currentDeprecatedID == null) {
+    deprecatedID = buildDeprecatedID(subroot, value);
+  } else {
+    deprecatedID = updateDeprecatedID(subroot, currentDeprecatedID, value);
   }
-  submissionState;
-  encodeValue = (instanceValue) => {
-    const encoded = instanceValue;
-    if (typeof encoded === "string") {
-      return encoded;
-    }
-    throw new UnsupportedControlValueEncodeError(this.nodeType);
-  };
-  decodeValue = (instanceValue) => {
-    return identity$1(instanceValue);
+  return {
+    model: subroot.model,
+    parent: subroot.parent,
+    children: replaceOrConcat(subroot.children, index, deprecatedID)
   };
-  constructor(parent, definition) {
-    super(parent, definition);
-    this.appearances = definition.bodyElement.appearances;
-    const sharedStateOptions = {
-      clientStateFactory: this.engineConfig.stateFactory
-    };
-    const stateSpec = {
-      reference: this.contextReference,
-      readonly: this.isReadonly,
-      relevant: this.isRelevant,
-      required: this.isRequired,
-      label: createNodeLabel(this, definition),
-      hint: createFieldHint(this, definition),
-      children: null,
-      valueOptions: null,
-      value: createValueState(this)
-    };
-    const state = createSharedNodeState(this.scope, stateSpec, sharedStateOptions);
-    this.state = state;
-    this.engineState = state.engineState;
-    this.currentState = state.currentState;
-    this.validation = createValidationState(this, sharedStateOptions);
-    this.submissionState = createLeafNodeSubmissionState(this);
-  }
-  // XFormsXPathElement
-  getXPathValue() {
-    return this.encodeValue(this.engineState.value);
+};
+const normalizeMetaSubroot = (subroot) => {
+  if (isEditModeMetaSubroot(subroot)) {
+    return populateDeprecatedID(subroot);
   }
-  // ValidationContext
-  getViolation() {
-    return this.validation.engineState.violation;
+  return subroot;
+};
+const normalizeChildInitOptions = (options) => {
+  if (isMetaSubroot(options)) {
+    return normalizeMetaSubroot(options);
   }
-  isBlank() {
-    return this.engineState.value === "";
+  return options;
+};
+
+const collectModelChildNodesets = (parentTemplate) => {
+  const nodesets = parentTemplate.childElements.map(({ nodeset }) => {
+    return nodeset;
+  });
+  return Array.from(new Set(nodesets));
+};
+const groupChildElementsByNodeset = (parent) => {
+  const result = /* @__PURE__ */ new Map();
+  for (const child of parent.childElements) {
+    const { nodeset } = child;
+    const group = result.get(nodeset);
+    if (group == null) {
+      result.set(nodeset, [child]);
+    } else {
+      group.push(child);
+    }
   }
-  // InstanceNode
-  getChildren() {
-    return [];
+  return result;
+};
+const assertChildNodeDefinition = (definition, childNodeset) => {
+  if (definition.type === "root") {
+    throw new Error(`Unexpected root definition for child nodeset: ${childNodeset}`);
   }
-  // UnsupportedControlNode
-  setValue(_) {
-    throw new UnsupportedControlWriteError(this.nodeType);
+};
+const childrenInitOptions = (parent) => {
+  const { model } = parent.rootDocument;
+  const childNodesets = collectModelChildNodesets(parent.definition.template);
+  let instanceChildren;
+  if (parent.instanceNode == null) {
+    instanceChildren = null;
+  } else {
+    instanceChildren = groupChildElementsByNodeset(parent.instanceNode);
   }
-}
-
-class UploadControl extends UnsupportedControl {
-  nodeType = "upload";
-  // ValueContext
-  contextNode = this;
-}
+  const children = childNodesets.map((childNodeset) => {
+    const definition = model.getNodeDefinition(childNodeset);
+    assertChildNodeDefinition(definition, childNodeset);
+    const instanceNodes = instanceChildren?.get(childNodeset) ?? [];
+    return {
+      childNodeset,
+      definition,
+      instanceNodes
+    };
+  });
+  const baseResult = {
+    parent,
+    model,
+    children
+  };
+  return normalizeChildInitOptions(baseResult);
+};
 
 const isSubtreeDefinition = (definition) => {
   return definition.bodyElement == null;
@@ -43855,52 +44199,56 @@ const isUploadNodeDefinition = (definition) => {
   return definition.bodyElement.type === "upload";
 };
 const buildChildren = (parent) => {
-  const { children } = parent.definition;
-  return children.map((child) => {
-    switch (child.type) {
+  const { children } = childrenInitOptions(parent);
+  return children.map(({ instanceNodes, definition }) => {
+    const [instanceNode = null] = instanceNodes;
+    switch (definition.type) {
       case "subtree": {
-        if (isSubtreeDefinition(child)) {
-          return new Subtree(parent, child);
+        if (isSubtreeDefinition(definition)) {
+          return new Subtree(parent, instanceNode, definition);
         }
-        return new Group(parent, child);
+        return new Group(parent, instanceNode, definition);
       }
-      case "repeat-range": {
-        if (child.isControlled()) {
-          return new RepeatRangeControlled(parent, child);
+      case "repeat": {
+        if (definition.isControlled()) {
+          return new RepeatRangeControlled(parent, instanceNodes, definition);
         }
-        return new RepeatRangeUncontrolled(parent, child);
+        return new RepeatRangeUncontrolled(parent, instanceNodes, definition);
       }
       case "leaf-node": {
-        if (child instanceof NoteNodeDefinition) {
-          return new Note(parent, child);
+        if (instanceNode != null && !instanceNode.isLeafElement()) {
+          throw new ErrorProductionDesignPendingError();
         }
-        const leafChild = child;
+        if (definition instanceof NoteNodeDefinition) {
+          return new Note(parent, instanceNode, definition);
+        }
+        const leafChild = definition;
         if (isModelValueDefinition(leafChild)) {
-          return ModelValue.from(parent, leafChild);
+          return ModelValue.from(parent, instanceNode, leafChild);
         }
         if (isInputDefinition(leafChild)) {
-          return InputControl.from(parent, leafChild);
+          return InputControl.from(parent, instanceNode, leafChild);
         }
         if (isSelectDefinition(leafChild)) {
-          return SelectControl.from(parent, leafChild);
+          return SelectControl.from(parent, instanceNode, leafChild);
         }
         if (isRankDefinition(leafChild)) {
-          return RankControl.from(parent, leafChild);
+          return RankControl.from(parent, instanceNode, leafChild);
         }
         if (isTriggerNodeDefinition(leafChild)) {
-          return TriggerControl.from(parent, leafChild);
+          return TriggerControl.from(parent, instanceNode, leafChild);
         }
         if (isRangeLeafNodeDefinition(leafChild)) {
           assertRangeNodeDefinition(leafChild);
-          return RangeControl.from(parent, leafChild);
+          return RangeControl.from(parent, instanceNode, leafChild);
         }
         if (isUploadNodeDefinition(leafChild)) {
-          return new UploadControl(parent, leafChild);
+          return new UploadControl(parent, instanceNode, leafChild);
         }
         throw new UnreachableError$1(leafChild);
       }
       default: {
-        throw new UnreachableError$1(child);
+        throw new UnreachableError$1(definition);
       }
     }
   });
@@ -43927,27 +44275,20 @@ class Root extends DescendantNode {
   classes;
   currentState;
   validationState;
-  submissionState;
-  // ClientReactiveSubmittableInstance
-  get submissionDefinition() {
-    return this.definition.submission;
-  }
-  // RootNode
+  instanceState;
   languages;
   constructor(parent) {
-    const { definition } = parent;
+    const { definition, instanceNode: instance } = parent;
+    const instanceNode = instance.root;
     const { nodeset: reference } = definition;
     const computeReference = () => reference;
-    super(parent, definition, {
+    super(parent, instanceNode, definition, {
       computeReference
     });
     this.classes = parent.classes;
     const childrenState = createChildrenState(this);
     this.childrenState = childrenState;
     this.languages = parent.languages;
-    const sharedStateOptions = {
-      clientStateFactory: this.engineConfig.stateFactory
-    };
     const state = createSharedNodeState(
       this.scope,
       {
@@ -43962,7 +44303,7 @@ class Root extends DescendantNode {
         value: null,
         children: childrenState.childIds
       },
-      sharedStateOptions
+      this.instanceConfig
     );
     this.state = state;
     this.engineState = state.engineState;
@@ -43972,8 +44313,8 @@ class Root extends DescendantNode {
       childrenState
     );
     childrenState.setChildren(buildChildren(this));
-    this.validationState = createAggregatedViolations(this, sharedStateOptions);
-    this.submissionState = createRootSubmissionState(this);
+    this.validationState = createAggregatedViolations(this, this.instanceConfig);
+    this.instanceState = createRootInstanceState(this);
   }
   getChildren() {
     return this.childrenState.getChildren();
@@ -43983,16 +44324,22 @@ class Root extends DescendantNode {
     this.rootDocument.setLanguage(language);
     return this;
   }
-  prepareSubmission(options) {
-    return this.rootDocument.prepareSubmission(options);
+  prepareInstancePayload(options) {
+    return this.rootDocument.prepareInstancePayload(options);
   }
 }
 
 const PRIMARY_INSTANCE_REFERENCE = "/";
 class PrimaryInstance extends InstanceNode {
+  /**
+   * @todo this will be populated as we introduce other initialization modes!
+   */
+  initializationMode = "create";
+  model;
   // InstanceNode
   state;
   engineState;
+  instanceNode;
   getChildren;
   hasReadonlyAncestor = () => false;
   isReadonly = () => false;
@@ -44002,7 +44349,7 @@ class PrimaryInstance extends InstanceNode {
   setActiveLanguage;
   // XFormsXPathDocument
   [XPathNodeKindKey] = "document";
-  // PrimaryInstanceDocument, ClientReactiveSubmittableInstance
+  // PrimaryInstanceDocument, ClientReactiveSerializableInstance
   nodeType = "primary-instance";
   appearances = null;
   nodeOptions = null;
@@ -44010,7 +44357,7 @@ class PrimaryInstance extends InstanceNode {
   root;
   currentState;
   validationState;
-  submissionState;
+  instanceState;
   languages;
   // TranslationContext (+ EvaluationContext)
   getActiveLanguage;
@@ -44018,12 +44365,18 @@ class PrimaryInstance extends InstanceNode {
   isAttached;
   evaluator;
   contextNode = this;
-  constructor(scope, model, secondaryInstances, engineConfig) {
-    const { root: definition } = model;
-    super(engineConfig, null, definition, {
+  constructor(options) {
+    const { mode, initialState, scope, model, secondaryInstances, config } = options;
+    const { instance: modelInstance } = model;
+    const activeInstance = initialState?.document ?? modelInstance;
+    const definition = model.getRootDefinition(activeInstance);
+    super(config, null, activeInstance, definition, {
       scope,
       computeReference: () => PRIMARY_INSTANCE_REFERENCE
     });
+    this.initializationMode = mode;
+    this.model = model;
+    this.instanceNode = activeInstance;
     const [isAttached, setIsAttached] = createSignal(false);
     this.isAttached = isAttached;
     const evaluator = new EngineXPathEvaluator({
@@ -44054,9 +44407,7 @@ class PrimaryInstance extends InstanceNode {
       value: null,
       children: childrenState.childIds
     };
-    const state = createSharedNodeState(scope, stateSpec, {
-      clientStateFactory: engineConfig.stateFactory
-    });
+    const state = createSharedNodeState(scope, stateSpec, config);
     this.state = state;
     this.engineState = state.engineState;
     this.currentState = materializeCurrentStateChildren(scope, state.currentState, childrenState);
@@ -44067,7 +44418,7 @@ class PrimaryInstance extends InstanceNode {
         return root.validationState.violations;
       }
     };
-    this.submissionState = createInstanceSubmissionState(this);
+    this.instanceState = createPrimaryInstanceState(this);
     childrenState.setChildren([root]);
     setIsAttached(true);
   }
@@ -44103,43 +44454,188 @@ class PrimaryInstance extends InstanceNode {
     this.evaluator.setActiveLanguage(availableFormLanguage.language);
     return this.setActiveLanguage(availableFormLanguage);
   }
-  // PrimaryInstanceDocument, ClientReactiveSubmittableInstance
-  prepareSubmission(options) {
-    const result = prepareSubmission(this, {
-      chunked: options?.chunked ?? "monolithic",
+  // PrimaryInstanceDocument
+  prepareInstancePayload(options) {
+    const result = prepareInstancePayload(this, {
+      payloadType: options?.payloadType ?? "monolithic",
       maxSize: options?.maxSize ?? Infinity
     });
     return Promise.resolve(result);
   }
 }
 
-const buildInstanceConfig = (options = {}) => {
+class FormInstance {
+  constructor(formResult, options) {
+    this.formResult = formResult;
+    const { mode, initialState } = options;
+    const config = {
+      clientStateFactory: options.instanceConfig.stateFactory ?? identity
+    };
+    const primaryInstanceOptions = {
+      ...options.instanceOptions,
+      mode,
+      initialState,
+      config
+    };
+    const { root } = new PrimaryInstance(primaryInstanceOptions);
+    this.mode = mode;
+    this.root = root;
+  }
+  mode;
+  root;
+}
+
+class BaseInstantiableFormResult extends BaseFormResult {
+  createInstance;
+  editInstance;
+  restoreInstance;
+  constructor(options) {
+    const { status, warnings, error, instanceOptions } = options;
+    super({
+      status,
+      warnings,
+      error
+    });
+    this.createInstance = (instanceConfig = {}) => {
+      this.assertInstantiable();
+      return new FormInstance(this, {
+        mode: "create",
+        instanceOptions,
+        initialState: null,
+        instanceConfig
+      });
+    };
+    this.editInstance = async (input, instanceConfig = {}) => {
+      this.assertInstantiable();
+      const initialState = await InitialInstanceState.resolve(instanceOptions.model, input);
+      return new FormInstance(this, {
+        mode: "edit",
+        instanceOptions,
+        initialState,
+        instanceConfig
+      });
+    };
+    this.restoreInstance = async (input, instanceConfig = {}) => {
+      this.assertInstantiable();
+      const initialState = await InitialInstanceState.from(instanceOptions.model, input.data);
+      return new FormInstance(this, {
+        mode: "restore",
+        instanceOptions,
+        initialState,
+        instanceConfig
+      });
+    };
+  }
+  isInstantiable() {
+    const self = this;
+    return self.status !== "failure";
+  }
+  assertInstantiable() {
+    if (!this.isInstantiable()) {
+      throw new ErrorProductionDesignPendingError(
+        'Failed to instantiate from result with status: "failure"'
+      );
+    }
+  }
+}
+
+class FormSuccessResult extends BaseInstantiableFormResult {
+  constructor(options) {
+    super({
+      status: "success",
+      ...options
+    });
+  }
+}
+
+const createPotentiallyClientOwnedReactiveScope = () => {
+  const clientOwner = getOwner();
+  return createReactiveScope({ owner: clientOwner });
+};
+let unboundGlobalFetch;
+if (typeof globalThis.fetch === "function") {
+  unboundGlobalFetch = (...args) => {
+    return globalThis.fetch(...args);
+  };
+} else {
+  unboundGlobalFetch = () => {
+    throw new Error("fetch is not supported in this environment");
+  };
+}
+const resolveOptions = (options) => {
   return {
-    createUniqueId,
-    fetchFormDefinition: options.fetchFormDefinition ?? fetch,
-    fetchFormAttachment: options.fetchFormAttachment ?? fetch,
-    missingResourceBehavior: options.missingResourceBehavior ?? MISSING_RESOURCE_BEHAVIOR.DEFAULT,
-    stateFactory: options.stateFactory ?? identity$1
+    fetchFormDefinition: options?.fetchFormDefinition ?? unboundGlobalFetch,
+    fetchFormAttachment: options?.fetchFormAttachment ?? unboundGlobalFetch,
+    missingResourceBehavior: options?.missingResourceBehavior ?? MISSING_RESOURCE_BEHAVIOR.DEFAULT
   };
 };
-const initializeForm$1 = async (input, options = {}) => {
-  const owner = getOwner();
-  const scope = createReactiveScope({ owner });
-  const engineConfig = buildInstanceConfig(options.config);
-  const sourceXML = await retrieveSourceXMLResource(input, {
-    fetchResource: engineConfig.fetchFormDefinition
-  });
-  const xformDOM = XFormDOM.from(sourceXML);
-  const secondaryInstances = await SecondaryInstancesDefinition.load(xformDOM, {
-    fetchResource: engineConfig.fetchFormAttachment,
-    missingResourceBehavior: engineConfig.missingResourceBehavior
-  });
-  const form = new XFormDefinition(xformDOM);
-  const primaryInstance = new PrimaryInstance(scope, form.model, secondaryInstances, engineConfig);
-  return primaryInstance.root;
+const loadFormResult = async (scope, formResource, options) => {
+  const { fetchFormDefinition, fetchFormAttachment, missingResourceBehavior } = options;
+  try {
+    const sourceXML = await retrieveFormDefinition(formResource, {
+      fetchFormDefinition
+    });
+    const xformDOM = XFormDOM.from(sourceXML);
+    const { model } = new XFormDefinition(xformDOM);
+    const secondaryInstances = await SecondaryInstancesDefinition.load(xformDOM, {
+      fetchResource: fetchFormAttachment,
+      missingResourceBehavior
+    });
+    const instanceOptions = {
+      scope,
+      model,
+      secondaryInstances
+    };
+    return new FormSuccessResult({
+      warnings: null,
+      error: null,
+      scope,
+      formResource,
+      instanceOptions
+    });
+  } catch (caught) {
+    let cause;
+    if (caught instanceof Error) {
+      cause = caught;
+    } else {
+      cause = new Error("Unknown form load error", { cause: caught });
+    }
+    const error = new LoadFormFailureError(formResource, [cause]);
+    return new FormFailureResult({
+      warnings: null,
+      error
+    });
+  }
+};
+const loadForm = (formResource, options) => {
+  const scope = createPotentiallyClientOwnedReactiveScope();
+  const resolvedOptions = resolveOptions(options);
+  return loadFormResult(scope, formResource, resolvedOptions);
+};
+
+const createInstance = async (formResource, options) => {
+  const form = await loadForm(formResource, options?.form);
+  if (form.status === "failure") {
+    throw form.error;
+  }
+  return form.createInstance(options?.instance);
 };
 
-const initializeForm = initializeForm$1;
+const editInstance = async (formResource, input, options) => {
+  const form = await loadForm(formResource, options?.form);
+  if (form.status === "failure") {
+    throw form.error;
+  }
+  return form.editInstance(input, options?.instance);
+};
+
+const restoreInstance = async (formResource, input, options) => {
+  const form = await loadForm(formResource, options?.form);
+  if (form.status === "failure") {
+    throw form.error;
+  }
+  return form.restoreInstance(input, options?.instance);
+};
 
-export { constants, initializeForm };
+export { constants, createInstance, editInstance, loadForm, restoreInstance };
 //# sourceMappingURL=solid.js.map