@getodk/xforms-engine 0.6.0 → 0.8.0

package/src/instance/resource.ts

@@ -1,6 +1,6 @@
 import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
 import { getBlobText } from '@getodk/common/lib/web-compat/blob.ts';
-import type { FormResource } from '../client/index.ts';
+import type { FormResource } from '../client/form/FormResource.ts';
 import type { FetchResource, FetchResourceResponse } from '../client/resources.ts';
 
 export type { FetchResource, FetchResourceResponse, FormResource };
@@ -76,3 +76,16 @@ export const retrieveSourceXMLResource = async (
 
 	return text;
 };
+
+interface RetrieveFormDefinitionOptions {
+	readonly fetchFormDefinition: FetchResource;
+}
+
+export const retrieveFormDefinition = async (
+	resource: FormResource,
+	options: RetrieveFormDefinitionOptions
+): Promise<ResourceXML> => {
+	return retrieveSourceXMLResource(resource, {
+		fetchResource: options.fetchFormDefinition,
+	});
+};

package/src/integration/xpath/EngineXPathEvaluator.ts

@@ -1,8 +1,8 @@
 import type { XFormsItextTranslationMap, XFormsSecondaryInstanceMap } from '@getodk/xpath';
 import { XFormsXPathEvaluator } from '@getodk/xpath';
 import type { PrimaryInstance } from '../../instance/PrimaryInstance.ts';
-import type { ItextTranslationRootDefinition } from '../../parse/model/ItextTranslation/ItextTranslationRootDefinition.ts';
-import type { SecondaryInstanceRootDefinition } from '../../parse/model/SecondaryInstance/SecondaryInstanceRootDefinition.ts';
+import type { ItextTranslationRootDefinition } from '../../parse/model/ItextTranslationsDefinition.ts';
+import type { SecondaryInstanceRootDefinition } from '../../parse/model/SecondaryInstance/SecondaryInstancesDefinition.ts';
 import { engineDOMAdapter } from './adapter/engineDOMAdapter.ts';
 import type { EngineXPathNode } from './adapter/kind.ts';
 

package/src/integration/xpath/adapter/kind.ts

@@ -1,17 +1,7 @@
 import type { XPathNodeKind } from '@getodk/xpath';
 import { XPathNodeKindKey } from '@getodk/xpath';
-import type {
-	AnyChildNode,
-	AnyNode,
-	AnyParentNode,
-	AnyValueNode,
-} from '../../../instance/hierarchy.ts';
-import type { ValueContext } from '../../../instance/internal-api/ValueContext.ts';
+import type { AnyChildNode, AnyNode, AnyParentNode } from '../../../instance/hierarchy.ts';
 import type { PrimaryInstance } from '../../../instance/PrimaryInstance.ts';
-import type { ItextTranslationDefinition } from '../../../parse/model/ItextTranslation/ItextTranslationDefinition.ts';
-import type { ItextTranslationRootDefinition } from '../../../parse/model/ItextTranslation/ItextTranslationRootDefinition.ts';
-import type { SecondaryInstanceDefinition } from '../../../parse/model/SecondaryInstance/SecondaryInstanceDefinition.ts';
-import type { SecondaryInstanceRootDefinition } from '../../../parse/model/SecondaryInstance/SecondaryInstanceRootDefinition.ts';
 import type { StaticAttribute } from '../static-dom/StaticAttribute.ts';
 import type { StaticDocument } from '../static-dom/StaticDocument.ts';
 import type { StaticElement } from '../static-dom/StaticElement.ts';
@@ -35,26 +25,14 @@ export type PrimaryInstanceXPathChildNode =
 	| PrimaryInstanceXPathElement
 	| PrimaryInstanceXPathComment;
 
-// prettier-ignore
-export type PrimaryInstanceXPathValueElement<Value> =
-	& AnyValueNode
-	& ValueContext<Value>
-	& XFormsXPathElement;
-
 // prettier-ignore
 export type EngineXPathDocument =
-	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
 	| PrimaryInstance
-	| ItextTranslationDefinition
-	| SecondaryInstanceDefinition
 	| StaticDocument;
 
 // prettier-ignore
 export type EngineXPathElement =
-	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
 	| PrimaryInstanceXPathElement
-	| ItextTranslationRootDefinition
-	| SecondaryInstanceRootDefinition
 	| StaticElement;
 
 // prettier-ignore
@@ -83,12 +61,7 @@ type PrimaryInstanceXPathParentNode = Extract<AnyParentNode, XPathAdapterParentN
 
 // prettier-ignore
 export type EngineXPathParentNode =
-	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
 	| PrimaryInstanceXPathParentNode
-	| ItextTranslationDefinition
-	| SecondaryInstanceDefinition
-	| ItextTranslationRootDefinition
-	| SecondaryInstanceRootDefinition
 	| StaticDocument
 	| StaticElement;
 

package/src/integration/xpath/adapter/traversal.ts

@@ -2,7 +2,7 @@ import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
 import { ErrorProductionDesignPendingError } from '../../../error/ErrorProductionDesignPendingError.ts';
 import { XPathFunctionalityPendingError } from '../../../error/XPathFunctionalityPendingError.ts';
 import type { AnyNode } from '../../../instance/hierarchy.ts';
-import type { AnyStaticNode, StaticParentNode } from '../static-dom/StaticNode.ts';
+import type { AnyStaticNode, StaticNodeParent } from '../static-dom/StaticNode.ts';
 import type {
 	EngineXPathAttribute,
 	EngineXPathDocument,
@@ -168,7 +168,7 @@ const primaryInstanceElementContains = (ancestor: AnyNode, other: AnyNode): bool
 	return primaryInstanceElementContains(ancestor, parent);
 };
 
-const staticParentNodeContains = (ancestor: StaticParentNode, other: AnyStaticNode): boolean => {
+const staticParentNodeContains = (ancestor: StaticNodeParent, other: AnyStaticNode): boolean => {
 	if (ancestor === other) {
 		return false;
 	}

package/src/integration/xpath/static-dom/StaticAttribute.ts

@@ -4,11 +4,10 @@ import type { XFormsXPathAttribute } from '../adapter/XFormsXPathNode.ts';
 import type { StaticDocument } from './StaticDocument.ts';
 import type { StaticElement } from './StaticElement.ts';
 import { StaticNode } from './StaticNode.ts';
+import { staticNodeName, type StaticNodeNameSource } from './staticNodeName.ts';
 
-interface StaticAttributeOptions {
-	readonly namespaceURI: string | null;
-	readonly prefix?: string | null;
-	readonly localName: string;
+export interface StaticAttributeOptions {
+	readonly name: StaticNodeNameSource;
 	readonly value: string;
 }
 
@@ -18,6 +17,7 @@ export class StaticAttribute extends StaticNode<'attribute'> implements XFormsXP
 	readonly rootDocument: StaticDocument;
 	readonly root: StaticElement;
 	readonly qualifiedName: QualifiedName;
+	readonly nodeset: string;
 	readonly attributes = [] as const;
 	readonly children = null;
 	readonly value: string;
@@ -30,7 +30,8 @@ export class StaticAttribute extends StaticNode<'attribute'> implements XFormsXP
 
 		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;
 	}
 

package/src/integration/xpath/static-dom/StaticDocument.ts

@@ -1,32 +1,33 @@
-import { XPathNodeKindKey } from '@getodk/xpath';
 import type { XFormsXPathDocument } from '../adapter/XFormsXPathNode.ts';
+import type { StaticElementOptions } from './StaticElement.ts';
 import { StaticElement } from './StaticElement.ts';
-import { StaticNode } from './StaticNode.ts';
+import { StaticParentNode } from './StaticParentNode.ts';
 
-export type StaticDocumentRootFactory<T extends StaticDocument, Root extends StaticElement> = (
-	staticDocument: T
-) => Root;
+interface StaticDocumentOptions {
+	readonly documentRoot: StaticElementOptions;
+	readonly nodesetPrefix?: string;
+}
 
-export abstract class StaticDocument<DocumentRoot extends StaticElement = StaticElement>
-	extends StaticNode<'document'>
-	implements XFormsXPathDocument
-{
-	readonly [XPathNodeKindKey] = 'document';
-	readonly nodeType = 'static-document';
+export class StaticDocument extends StaticParentNode<'document'> implements XFormsXPathDocument {
 	readonly rootDocument: StaticDocument;
-	readonly root: DocumentRoot;
+	readonly root: StaticElement;
 	readonly parent = null;
-	readonly children: readonly [root: DocumentRoot];
+	readonly nodeset: string;
+	readonly children: readonly [root: StaticElement];
+	readonly childElements: readonly [root: StaticElement];
 
-	constructor(rootFactory: StaticDocumentRootFactory<StaticDocument<DocumentRoot>, DocumentRoot>) {
-		super();
+	constructor(options: StaticDocumentOptions) {
+		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

package/src/integration/xpath/static-dom/StaticElement.ts

@@ -1,81 +1,218 @@
-import { XFORMS_KNOWN_ATTRIBUTE, XFORMS_LOCAL_NAME, XPathNodeKindKey } from '@getodk/xpath';
+import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
+import { ErrorProductionDesignPendingError } from '../../../error/ErrorProductionDesignPendingError.ts';
+import type { QualifiedNameSource } from '../../../lib/names/QualifiedName.ts';
 import { QualifiedName } from '../../../lib/names/QualifiedName.ts';
 import type { EngineDOMAdapter } from '../adapter/engineDOMAdapter.ts';
 import type { XFormsXPathElement } from '../adapter/XFormsXPathNode.ts';
+import type { StaticAttributeOptions } from './StaticAttribute.ts';
 import { StaticAttribute } from './StaticAttribute.ts';
 import type { StaticDocument } from './StaticDocument.ts';
-import type { StaticChildNode, StaticParentNode } from './StaticNode.ts';
-import { StaticNode } from './StaticNode.ts';
+import type { StaticChildNode } from './StaticNode.ts';
+import { staticNodeName } from './staticNodeName.ts';
+import { StaticParentNode } from './StaticParentNode.ts';
+import { StaticText } from './StaticText.ts';
 
-export type StaticElementAttributesFactory = (element: StaticElement) => readonly StaticAttribute[];
-
-export type StaticElementChildNodesFactory = (element: StaticElement) => readonly StaticChildNode[];
+// prettier-ignore
+export type StaticElementChildOption =
+	| StaticElementOptions
+	| string;
 
 export interface StaticElementOptions {
-	readonly namespaceURI: string | null;
-	readonly prefix?: string | null;
-	readonly localName: string;
+	readonly name: QualifiedNameSource | string;
+	readonly attributes?: readonly StaticAttributeOptions[];
+	readonly children?: readonly StaticElementChildOption[];
+}
+
+interface StaticElementChildrenResult {
+	readonly children: readonly StaticChildNode[];
+	readonly childElements: readonly StaticElement[];
+	readonly leafValue: string | null;
 }
 
-type StaticElementKnownAttributeValue<
-	T extends StaticElement,
-	LocalName extends string,
-> = T extends { readonly [XFORMS_KNOWN_ATTRIBUTE]: LocalName } ? string : string | null;
-
-type AssertStaticElementKnownAttributeValue = <T extends StaticElement, LocalName extends string>(
-	element: T,
-	localName: LocalName,
-	value: string | null
-) => asserts value is StaticElementKnownAttributeValue<T, LocalName>;
-
-const assertStaticElementKnownAttributeValue: AssertStaticElementKnownAttributeValue = (
-	element,
-	localName,
-	value
-) => {
-	if (localName === element[XFORMS_KNOWN_ATTRIBUTE] && value == null) {
-		throw new Error(`Expected attribute: ${element[XFORMS_KNOWN_ATTRIBUTE]}`);
+const leafElementChildrenResult = (
+	parent: StaticElement,
+	leafValue: string
+): StaticElementChildrenResult => {
+	const child = new StaticText(parent, leafValue);
+
+	return {
+		children: [child],
+		childElements: [],
+		leafValue: leafValue,
+	};
+};
+
+const blankLeafElementChildrenResult = (parent: StaticElement): StaticElementChildrenResult => {
+	return leafElementChildrenResult(parent, '');
+};
+
+/**
+ * Builds several "views" into a {@link StaticElement}'s children as:
+ *
+ * - An array of all of its {@link StaticChildNode | child nodes}
+ * - A subset array of only its {@link StaticElement | child elements}
+ * - A {@link StaticElementChildrenResult.leafValue | "leaf value"} which is
+ *   populated with the text value of a {@link StaticText | text node} if **and
+ *   only if** that text node is the element's sole child node (which is in turn
+ *   used to identify which _elements_ are {@link StaticLeafElement | leaf}
+ *   nodes)
+ *
+ * @todo this is awkwardly named and awkward to describe! It's done this way for
+ * efficiency (which makes a substantial difference for large forms), at the
+ * expense of code clarity.
+ *
+ * @todo Handle comment nodes (1): we have discussed the possibility of using
+ * comments as a placeholder for omitted non-relevant repeat instances, as an
+ * aide to recreating them in restore/edit modes.
+ *
+ * @todo Handle comment nodes (2): comments are currently _effectively implied_
+ * in the function-body comment about a homogenous sequence of 2+ strings, i.e.
+ * in a structure like `<foo>bar<!-- bat -->quux</foo>`. If we handle comment
+ * nodes, the only way we'd encounter that scenario is if we're parsing a
+ * `StaticElement` from a DOM `Element` (or some other source with similar
+ * semantics) where its child nodes have been manipulated into that state. As
+ * such, if we do handle comments, that comment should likely be removed.
+ */
+const buildStaticElementChildren = (
+	parent: StaticElement,
+	options: StaticElementOptions
+): StaticElementChildrenResult => {
+	const children = Array<StaticChildNode>();
+	const childElements = Array<StaticElement>();
+	const childOptions = options.children ?? [''];
+
+	// No children: blank value
+	if (childOptions.length === 0) {
+		return {
+			children,
+			childElements,
+			leafValue: '',
+		};
 	}
+
+	const [head, ...tail] = childOptions;
+
+	if (tail.length === 0) {
+		// - If no child options are specified, default to a single empty/blank
+		//   `StaticText` child node, and assign its value
+		if (head == null) {
+			return blankLeafElementChildrenResult(parent);
+		}
+
+		// - If exactly one child option is specified, and it is a string, create
+		//   `StaticText` child and assign its value
+		if (typeof head === 'string') {
+			return leafElementChildrenResult(parent, head);
+		}
+	}
+
+	// If 2+ child options, for each:
+	//
+	// - Populate `children` (and `childElements`, as appopriate)
+	// - Do not populate `value`. For cases which need an arbitrary
+	//   `StaticElement`'s text value (i.e. `XPath`, perhaps eventually some
+	//   serialization use cases), it will be computed recursively as needed.
+	//
+	// Note: in theory, we may encounter a homogenous sequence of 2+ strings! In
+	// theory we should normalize those into a single string.
+	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(item);
+		}
+	}
+
+	return {
+		children,
+		childElements,
+		leafValue: null,
+	};
 };
 
-export class StaticElement<Parent extends StaticParentNode = StaticParentNode>
-	extends StaticNode<'element'>
-	implements XFormsXPathElement
-{
-	readonly [XFORMS_LOCAL_NAME]?: string;
-	readonly [XFORMS_KNOWN_ATTRIBUTE]?: string;
+export class StaticElement extends StaticParentNode<'element'> implements XFormsXPathElement {
+	private computedValue: string | null;
 
-	readonly [XPathNodeKindKey] = 'element';
-	readonly nodeType = 'static-element';
 	readonly rootDocument: StaticDocument;
 	readonly root: StaticElement;
 	readonly qualifiedName: QualifiedName;
+	readonly nodeset: string;
 	readonly attributes: readonly StaticAttribute[];
 	readonly children: readonly StaticChildNode[];
-	readonly value = null;
+	readonly childElements: readonly StaticElement[];
+	readonly value: string | null;
 
 	constructor(
-		readonly parent: Parent,
-		attributesFactory: StaticElementAttributesFactory,
-		childNodesFactory: StaticElementChildNodesFactory,
+		readonly parent: StaticDocument | StaticElement,
 		options: StaticElementOptions
 	) {
-		super();
+		super('element');
 
 		const { rootDocument } = parent;
+		let nodesetPrefix = parent.nodeset;
 
 		this.rootDocument = rootDocument;
 
 		// Account for the fact that we may be constructing the document root!
 		if (parent === rootDocument) {
 			this.root = this;
+
+			// Avoid nodeset like `//foo` when `/foo` is expected/intended
+			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;
+	}
+
+	isLeafElement(): this is StaticLeafElement {
+		return this.value != null;
+	}
+
+	assertLeafElement(): asserts this is StaticLeafElement {
+		if (!this.isLeafElement()) {
+			throw new ErrorProductionDesignPendingError();
+		}
 	}
 
 	/**
@@ -100,20 +237,29 @@ export class StaticElement<Parent extends StaticParentNode = StaticParentNode>
 	 * up. (This was put off because the types are already plenty complex as it
 	 * is.)
 	 */
-	getAttributeValue<This extends StaticElement, LocalName extends string>(
-		this: This,
-		localName: LocalName
-	): StaticElementKnownAttributeValue<This, LocalName> {
+	getAttributeValue(localName: string): string | null {
 		const attribute = this.getAttributeNode(localName);
 		const value = attribute?.value ?? null;
 
-		assertStaticElementKnownAttributeValue(this, localName, value);
-
 		return value;
 	}
 
 	// XFormsXPathElement
 	getXPathValue(): string {
-		return this.children.map((child) => child.getXPathValue()).join('');
+		const { computedValue } = this;
+
+		if (computedValue != null) {
+			return computedValue;
+		}
+
+		const result = this.children.map((child) => child.getXPathValue()).join('');
+
+		this.computedValue = result;
+
+		return result;
 	}
 }
+
+export interface StaticLeafElement extends StaticElement {
+	readonly value: string;
+}

package/src/integration/xpath/static-dom/StaticNode.ts

@@ -58,7 +58,7 @@ export type AnyStaticNode =
 	| StaticText;
 
 // prettier-ignore
-export type StaticParentNode =
+export type StaticNodeParent =
 	| StaticDocument
 	| StaticElement;
 

package/src/integration/xpath/static-dom/StaticParentNode.ts

@@ -0,0 +1,22 @@
+import { XPathNodeKindKey } from '@getodk/xpath';
+import type { StaticElement } from './StaticElement.ts';
+import { StaticNode, type StaticChildNode } from './StaticNode.ts';
+
+type StaticParentNodeKind = 'document' | 'element';
+
+type StaticParentNodeType<Kind extends StaticParentNodeKind> = `static-${Kind}`;
+
+export abstract class StaticParentNode<Kind extends StaticParentNodeKind> extends StaticNode<Kind> {
+	abstract override readonly children: readonly StaticChildNode[];
+	abstract readonly childElements: readonly StaticElement[];
+
+	readonly [XPathNodeKindKey]: Kind;
+	readonly nodeType: StaticParentNodeType<Kind>;
+
+	constructor(kind: Kind) {
+		super();
+
+		this[XPathNodeKindKey] = kind;
+		this.nodeType = `static-${kind}`;
+	}
+}

package/src/integration/xpath/static-dom/staticNodeName.ts

@@ -0,0 +1,20 @@
+import { QualifiedName, type QualifiedNameSource } from '../../../lib/names/QualifiedName.ts';
+import { UnprefixedXFormsName } from '../../../lib/names/UnprefixedXFormsName.ts';
+
+// prettier-ignore
+export type StaticNodeNameSource =
+	| QualifiedName
+	| QualifiedNameSource
+	| string;
+
+export const staticNodeName = (source: StaticNodeNameSource): QualifiedName => {
+	if (source instanceof QualifiedName) {
+		return source;
+	}
+
+	if (typeof source === 'string') {
+		return new UnprefixedXFormsName(source);
+	}
+
+	return new QualifiedName(source);
+};

package/src/lib/client-reactivity/instance-state/createNodeRangeInstanceState.ts

@@ -0,0 +1,17 @@
+import type { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import type { ClientReactiveSerializableParentNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableParentNode.ts';
+import type { RepeatInstance } from '../../../instance/repeat/RepeatInstance.ts';
+
+export const createNodeRangeInstanceState = (
+	node: ClientReactiveSerializableParentNode<RepeatInstance>
+): InstanceState => {
+	return {
+		get instanceXML() {
+			const serializedChildren = node.currentState.children.map((child) => {
+				return child.instanceState.instanceXML;
+			});
+
+			return serializedChildren.join('');
+		},
+	};
+};

package/src/lib/client-reactivity/instance-state/createParentNodeInstanceState.ts

@@ -0,0 +1,22 @@
+import type { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import type { GeneralChildNode } from '../../../instance/hierarchy.ts';
+import type { ClientReactiveSerializableParentNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableParentNode.ts';
+import { serializeParentElementXML } from '../../xml-serialization.ts';
+
+export const createParentNodeInstanceState = (
+	node: ClientReactiveSerializableParentNode<GeneralChildNode>
+): InstanceState => {
+	return {
+		get instanceXML() {
+			if (!node.currentState.relevant) {
+				return '';
+			}
+
+			const serializedChildren = node.currentState.children.map((child) => {
+				return child.instanceState.instanceXML;
+			});
+
+			return serializeParentElementXML(node.definition.qualifiedName, serializedChildren);
+		},
+	};
+};

package/src/lib/client-reactivity/instance-state/createPrimaryInstanceState.ts

@@ -0,0 +1,12 @@
+import type { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import type { ClientReactiveSerializableInstance } from '../../../instance/internal-api/serialization/ClientReactiveSerializableInstance.ts';
+
+export const createPrimaryInstanceState = (
+	node: ClientReactiveSerializableInstance
+): InstanceState => {
+	return {
+		get instanceXML(): string {
+			return node.root.instanceState.instanceXML;
+		},
+	};
+};

package/src/lib/client-reactivity/{submission/createRootSubmissionState.ts → instance-state/createRootInstanceState.ts}

@@ -1,13 +1,13 @@
-import type { SubmissionState } from '../../../client/submission/SubmissionState.ts';
+import type { InstanceState } from '../../../client/serialization/InstanceState.ts';
 import type { Root } from '../../../instance/Root.ts';
 import { serializeParentElementXML } from '../../xml-serialization.ts';
 
-export const createRootSubmissionState = (node: Root): SubmissionState => {
+export const createRootInstanceState = (node: Root): InstanceState => {
 	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, {

package/src/lib/client-reactivity/instance-state/createTemplatedNodeInstanceState.ts

@@ -0,0 +1,31 @@
+import type { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import { TemplatedNodeAttributeSerializationError } from '../../../error/TemplatedNodeAttributeSerializationError.ts';
+import type { ClientReactiveSerializableTemplatedNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableTemplatedNode.ts';
+import { serializeParentElementXML } from '../../xml-serialization.ts';
+
+/**
+ * @see {@link TemplatedNodeAttributeSerializationError}
+ */
+export const createTemplatedNodeInstanceState = (
+	node: ClientReactiveSerializableTemplatedNode
+): InstanceState => {
+	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);
+		},
+	};
+};