@getodk/xforms-engine 0.15.0 → 0.16.1

package/src/instance/internal-api/serialization/ClientReactiveSerializableValueNode.ts

@@ -1,5 +1,7 @@
 import type { InstanceState } from '../../../client/serialization/InstanceState.ts';
 import type { QualifiedName } from '../../../lib/names/QualifiedName.ts';
+import type { BindDefinition } from '../../../parse/model/BindDefinition.ts';
+import type { Attribute } from '../../Attribute.ts';
 import type {
 	ClientReactiveSerializableChildNode,
 	ClientReactiveSerializableParentNode,
@@ -14,10 +16,12 @@ interface ClientReactiveSerializableValueNodeCurrentState {
 	 * @todo Consider moving into {@link InstanceState}
 	 */
 	get instanceValue(): SerializedInstanceValue;
+	get attributes(): readonly Attribute[];
 }
 
 interface ClientReactiveSerializableValueNodeDefinition {
 	readonly qualifiedName: QualifiedName;
+	readonly bind: BindDefinition;
 }
 
 export interface ClientReactiveSerializableValueNode {

package/src/instance/repeat/RepeatInstance.ts

@@ -135,10 +135,9 @@ export class RepeatInstance
 		this.appearances = definition.bodyElement.appearances;
 
 		const childrenState = createChildrenState<RepeatInstance, GeneralChildNode>(this);
-		const attributeState = createAttributeState(this.scope);
+		this.attributeState = createAttributeState(this.scope);
 
 		this.childrenState = childrenState;
-		this.attributeState = attributeState;
 		this.currentIndex = currentIndex;
 
 		const state = createSharedNodeState(
@@ -152,7 +151,7 @@ export class RepeatInstance
 				// TODO: only-child <group><label>
 				label: createNodeLabel(this, definition),
 				hint: null,
-				attributes: attributeState.getAttributes,
+				attributes: this.attributeState.getAttributes,
 				children: childrenState.childIds,
 				valueOptions: null,
 				value: null,
@@ -198,7 +197,7 @@ export class RepeatInstance
 		return this.childrenState.getChildren();
 	}
 
-	getAttributes(): readonly Attribute[] {
+	override getAttributes(): readonly Attribute[] {
 		return this.attributeState.getAttributes();
 	}
 }

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

@@ -120,6 +120,7 @@ export interface XFormsXPathPrimaryInstanceNode extends XFormsXPathNode {
 // prettier-ignore
 export type XFormsXPathPrimaryInstanceDescendantNodeKind =
 	| XFormsXPathNodeRangeKind
+	| XPathAttributeKind
 	| XPathElementKind
 	| XPathTextKind;
 

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

@@ -10,10 +10,10 @@ import {
 } from './names.ts';
 import {
 	compareDocumentOrder,
+	getAttributes,
 	getChildElements,
 	getChildNodes,
 	getContainingEngineXPathDocument,
-	getEngineXPathAttributes,
 	getNamespaceDeclarations,
 	getNextSiblingElement,
 	getNextSiblingNode,
@@ -43,7 +43,7 @@ export const engineDOMAdapter: EngineDOMAdapter = {
 
 	// XPathTraversalAdapter
 	compareDocumentOrder,
-	getAttributes: getEngineXPathAttributes,
+	getAttributes: getAttributes,
 	getChildElements: getChildElements,
 	getChildNodes: getChildNodes,
 	getContainingDocument: getContainingEngineXPathDocument,

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

@@ -1,5 +1,6 @@
 import type { XPathNodeKind } from '@getodk/xpath';
 import { XPathNodeKindKey } from '@getodk/xpath';
+import type { Attribute } from '../../../instance/Attribute.ts';
 import type { AnyChildNode, AnyNode, AnyParentNode } from '../../../instance/hierarchy.ts';
 import type { PrimaryInstance } from '../../../instance/PrimaryInstance.ts';
 import type { StaticAttribute } from '../static-dom/StaticAttribute.ts';
@@ -7,6 +8,7 @@ import type { StaticDocument } from '../static-dom/StaticDocument.ts';
 import type { StaticElement } from '../static-dom/StaticElement.ts';
 import type { StaticText } from '../static-dom/StaticText.ts';
 import type {
+	XFormsXPathAttribute,
 	XFormsXPathComment,
 	XFormsXPathDocument,
 	XFormsXPathElement,
@@ -17,12 +19,15 @@ export type PrimaryInstanceXPathNode = Extract<AnyNode, XFormsXPathPrimaryInstan
 
 export type PrimaryInstanceXPathElement = Extract<AnyChildNode, XFormsXPathElement>;
 
+export type PrimaryInstanceXPathAttribute = Extract<Attribute, XFormsXPathAttribute>;
+
 export type PrimaryInstanceXPathComment = Extract<AnyChildNode, XFormsXPathComment>;
 
 // prettier-ignore
 export type PrimaryInstanceXPathChildNode =
 	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
 	| PrimaryInstanceXPathElement
+	| PrimaryInstanceXPathAttribute
 	| PrimaryInstanceXPathComment;
 
 // prettier-ignore
@@ -41,7 +46,7 @@ export type EngineXPathComment =
 
 // Giving this a type alias anticipates eventually implementing attributes
 // in primary instance state as well
-export type EngineXPathAttribute = StaticAttribute;
+export type EngineXPathAttribute = PrimaryInstanceXPathAttribute | StaticAttribute;
 
 export type EngineXPathText = StaticText;
 

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

@@ -128,6 +128,7 @@ export const resolveEngineXPathNodeNamespaceURI = (
 		case 'static-text':
 			return resolveNamespaceURIFromStaticNodeContext(node, prefix);
 
+		case 'attribute':
 		case 'group':
 		case 'input':
 		case 'model-value':

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

@@ -8,7 +8,6 @@ import type {
 	EngineXPathDocument,
 	EngineXPathElement,
 	EngineXPathNode,
-	EngineXPathParentNode,
 	PrimaryInstanceXPathChildNode,
 	XFormsXPathChildNode,
 } from './kind.ts';
@@ -18,13 +17,13 @@ export const getContainingEngineXPathDocument = (node: EngineXPathNode): EngineX
 	return node.rootDocument;
 };
 
-export const getEngineXPathAttributes = (
-	node: EngineXPathNode
-): readonly EngineXPathAttribute[] => {
+export const getAttributes = (node: EngineXPathNode): readonly EngineXPathAttribute[] => {
 	if (node.nodeType === 'static-element') {
 		return node.attributes;
 	}
-
+	if (isEngineXPathElement(node)) {
+		return node.getAttributes();
+	}
 	return [];
 };
 
@@ -43,7 +42,7 @@ export const getEngineXPathAttributes = (
  */
 export const getNamespaceDeclarations = (): readonly [] => [];
 
-export const getParentNode = (node: EngineXPathNode): EngineXPathParentNode | null => {
+export const getParentNode = (node: EngineXPathNode): EngineXPathNode | null => {
 	if (node.nodeType === 'repeat-instance') {
 		return node.parent.parent;
 	}

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

@@ -20,6 +20,7 @@ export class StaticAttribute extends StaticNode<'attribute'> implements XFormsXP
 	readonly nodeset: string;
 	readonly attributes = [] as const;
 	readonly children = null;
+	readonly childElements = [];
 	readonly value: string;
 
 	constructor(

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

@@ -14,8 +14,9 @@ export const createValueNodeInstanceState = (
 			}
 
 			const xmlValue = escapeXMLText(node.currentState.instanceValue);
+			const attributes = node.currentState.attributes;
 
-			return serializeLeafElementXML(qualifiedName, xmlValue);
+			return serializeLeafElementXML(qualifiedName, xmlValue, attributes);
 		},
 	};
 };

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

@@ -208,6 +208,7 @@ export const prepareInstancePayload = <PayloadType extends InstancePayloadType>(
 	instanceRoot: ClientReactiveSerializableInstance,
 	options: PrepareInstancePayloadOptions<PayloadType>
 ): InstancePayload<PayloadType> => {
+	instanceRoot.root.parent.model.triggerXformsRevalidateListeners();
 	const validation = validateInstance(instanceRoot);
 	const submissionMeta = instanceRoot.definition.submission;
 	const instanceFile = new InstanceFile(instanceRoot);

package/src/lib/codecs/NoteCodec.ts

@@ -10,7 +10,7 @@ export type NoteRuntimeValue<V extends ValueType> =
 // prettier-ignore
 export type NoteInputValue<V extends ValueType> =
 	| RuntimeInputValue<V>
-	| RuntimeValue<V>
+	| RuntimeValue<V> // eslint-disable-line @typescript-eslint/no-redundant-type-constituents
 	| null;
 
 export class NoteCodec<V extends ValueType> extends ValueCodec<

package/src/lib/codecs/items/SingleValueItemCodec.ts

@@ -12,9 +12,7 @@ export type SingleValueSelectRuntimeValues =
  * @see {@link encodeValueFactory}
  */
 // prettier-ignore
-type SingleValueSelectCodecValues =
-	| SingleValueSelectRuntimeValues
-	| readonly string[];
+type SingleValueSelectCodecValues = readonly string[];
 
 /**
  * @todo This is more permissive than it should be, allowing an array of any

package/src/lib/reactivity/createInstanceValueState.ts

@@ -1,24 +1,35 @@
 import type { Signal } from 'solid-js';
 import { createComputed, createMemo, createSignal, untrack } from 'solid-js';
+import type { AttributeContext } from '../../instance/internal-api/AttributeContext.ts';
 import type { InstanceValueContext } from '../../instance/internal-api/InstanceValueContext.ts';
+import { ActionComputationExpression } from '../../parse/expression/ActionComputationExpression.ts';
 import type { BindComputationExpression } from '../../parse/expression/BindComputationExpression.ts';
+import { ActionDefinition } from '../../parse/model/ActionDefinition.ts';
+import type { AnyBindPreloadDefinition } from '../../parse/model/BindPreloadDefinition.ts';
+import { XFORM_EVENT } from '../../parse/model/Event.ts';
 import { createComputedExpression } from './createComputedExpression.ts';
 import type { SimpleAtomicState, SimpleAtomicStateSetter } from './types.ts';
 
-const isInstanceFirstLoad = (context: InstanceValueContext) => {
+const REPEAT_INDEX_REGEX = /([^[]*)(\[[0-9]+\])/g;
+
+type ValueContext = AttributeContext | InstanceValueContext;
+
+const isInstanceFirstLoad = (context: ValueContext) => {
 	return context.rootDocument.initializationMode === 'create';
 };
 
+const isAddingRepeatChild = (context: ValueContext) => {
+	return context.rootDocument.isAttached();
+};
+
 /**
  * Special case, does not correspond to any event.
- *
- * @see {@link shouldPreloadUID}
  */
-const isEditInitialLoad = (context: InstanceValueContext) => {
+const isEditInitialLoad = (context: ValueContext) => {
 	return context.rootDocument.initializationMode === 'edit';
 };
 
-const getInitialValue = (context: InstanceValueContext): string => {
+const getInitialValue = (context: ValueContext): string => {
 	const sourceNode = context.instanceNode ?? context.definition.template;
 
 	return context.decodeInstanceValue(sourceNode.value);
@@ -36,7 +47,7 @@ type RelevantValueState = SimpleAtomicState<string>;
  *   node/context's relevance is restored
  */
 const createRelevantValueState = (
-	context: InstanceValueContext,
+	context: ValueContext,
 	baseValueState: BaseValueState
 ): RelevantValueState => {
 	return context.scope.runTask(() => {
@@ -59,7 +70,7 @@ const createRelevantValueState = (
  * (client/user) writes when the field is in a `readonly` state.
  */
 const guardDownstreamReadonlyWrites = (
-	context: InstanceValueContext,
+	context: ValueContext,
 	baseState: SimpleAtomicState<string>
 ): SimpleAtomicState<string> => {
 	const { readonly } = context.definition.bind;
@@ -83,47 +94,86 @@ const guardDownstreamReadonlyWrites = (
 	return [getValue, setValue];
 };
 
-/**
- * Per {@link https://getodk.github.io/xforms-spec/#preload-attributes:~:text=concatenation%20of%20%E2%80%98uuid%3A%E2%80%99%20and%20uuid()}
- */
-const PRELOAD_UID_EXPRESSION = 'concat("uuid:", uuid())';
-
 /**
  * @todo It feels increasingly awkward to keep piling up preload stuff here, but it won't stay that way for long. In the meantime, this seems like the best way to express the cases where `preload="uid"` should be effective, i.e.:
  *
  * - When an instance is first loaded ({@link isInstanceFirstLoad})
  * - When an instance is initially loaded for editing ({@link isEditInitialLoad})
  */
-const shouldPreloadUID = (context: InstanceValueContext) => {
+const isLoading = (context: ValueContext) => {
 	return isInstanceFirstLoad(context) || isEditInitialLoad(context);
 };
 
-/**
- * @todo This is a temporary one-off, until we support the full range of
- * {@link https://getodk.github.io/xforms-spec/#preload-attributes | preloads}.
- *
- * @todo ALSO, IMPORTANTLY(!): the **call site** for this function is
- * semantically where we would expect to trigger a
- * {@link https://getodk.github.io/xforms-spec/#event:odk-instance-first-load | odk-instance-first-load event},
- * _and compute_ preloads semantically associated with that event.
- */
-const setPreloadUIDValue = (
-	context: InstanceValueContext,
-	valueState: RelevantValueState
-): void => {
+const setValueIfPreloadDefined = (
+	context: ValueContext,
+	setValue: SimpleAtomicStateSetter<string>,
+	preload: AnyBindPreloadDefinition
+) => {
+	const value = preload.getValue(context);
+	if (value) {
+		setValue(value);
+	}
+};
+
+const postloadValue = (
+	context: ValueContext,
+	setValue: SimpleAtomicStateSetter<string>,
+	preload: AnyBindPreloadDefinition
+) => {
+	const ref = context.contextReference();
+	context.definition.model.registerXformsRevalidateListener(ref, () => {
+		setValueIfPreloadDefined(context, setValue, preload);
+	});
+};
+
+const preloadValue = (context: ValueContext, setValue: SimpleAtomicStateSetter<string>): void => {
 	const { preload } = context.definition.bind;
+	if (!preload) {
+		return;
+	}
 
-	if (preload?.type !== 'uid' || !shouldPreloadUID(context)) {
+	if (preload.event === XFORM_EVENT.xformsRevalidate) {
+		postloadValue(context, setValue, preload);
 		return;
 	}
 
-	const preloadUIDValue = context.evaluator.evaluateString(PRELOAD_UID_EXPRESSION, {
+	if (isLoading(context)) {
+		setValueIfPreloadDefined(context, setValue, preload);
+	}
+};
+
+const referencesCurrentNode = (context: ValueContext, ref: string): boolean => {
+	const nodes = context.evaluator.evaluateNodes(ref, {
 		contextNode: context.contextNode,
 	});
+	if (nodes.length > 1) {
+		throw new Error(
+			'You are trying to target a repeated field. Currently you may only target a field in a specific repeat instance. XPath nodeset has more than one node.'
+		);
+	}
+	return nodes.includes(context.contextNode);
+};
 
-	const [, setValue] = valueState;
-
-	setValue(preloadUIDValue);
+// Replaces the unbound repeat references in source and ref, with references
+// bound to the repeat instace of the context.
+const bindToRepeatInstance = (
+	context: ValueContext,
+	action: ActionDefinition
+): { source: string | undefined; ref: string } => {
+	let source = action.source;
+	let ref = action.ref;
+	if (source) {
+		const contextRef = context.contextReference();
+		for (const part of contextRef.matchAll(REPEAT_INDEX_REGEX)) {
+			const unbound = part[1] + '/';
+			if (source.includes(unbound)) {
+				const bound = part[0] + '/';
+				source = source.replace(unbound, bound);
+				ref = ref.replace(unbound, bound);
+			}
+		}
+	}
+	return { source, ref };
 };
 
 /**
@@ -131,30 +181,104 @@ const setPreloadUIDValue = (
  * computations to the provided value setter, on initialization and any
  * subsequent reactive update.
  *
- * @see {@link setPreloadUIDValue} for important details about spec ordering of
+ * @see {@link preloadValue} for important details about spec ordering of
  * events and computations.
  */
 const createCalculation = (
-	context: InstanceValueContext,
+	context: ValueContext,
 	setRelevantValue: SimpleAtomicStateSetter<string>,
-	calculateDefinition: BindComputationExpression<'calculate'>
+	computation: ActionComputationExpression<'string'> | BindComputationExpression<'calculate'>
 ): void => {
-	context.scope.runTask(() => {
-		const calculate = createComputedExpression(context, calculateDefinition, {
-			defaultValue: '',
-		});
+	const calculate = createComputedExpression(context, computation);
+	createComputed(() => {
+		if (context.isAttached() && context.isRelevant()) {
+			const calculated = calculate();
+			const value = context.decodeInstanceValue(calculated);
+			setRelevantValue(value);
+		}
+	});
+};
 
-		createComputed(() => {
-			if (context.isAttached() && context.isRelevant()) {
-				const calculated = calculate();
-				const value = context.decodeInstanceValue(calculated);
+/**
+ * Runs the computation without maintaining a reactive listener, so
+ * actions that should run only at a specific time are not triggered
+ * when referenced elements are updated.
+ */
+const createActionCalculation = (
+	context: ValueContext,
+	setRelevantValue: SimpleAtomicStateSetter<string>,
+	computation: ActionComputationExpression<'string'>
+): void => {
+	createComputed(() => {
+		if (context.isAttached()) {
+			// use untrack so the expression evaluation isn't reactive
+			const relevant = untrack(() => context.isRelevant());
+			if (!relevant) {
+				return;
+			}
+			const calculated = untrack(() => {
+				return context.evaluator.evaluateString(computation.expression, context);
+			});
+			const value = context.decodeInstanceValue(calculated);
+			setRelevantValue(value);
+		}
+	});
+};
 
-				setRelevantValue(value);
+const createValueChangedCalculation = (
+	context: ValueContext,
+	setRelevantValue: SimpleAtomicStateSetter<string>,
+	action: ActionDefinition
+): void => {
+	const { source, ref } = bindToRepeatInstance(context, action);
+	if (!source) {
+		// no element to listen to
+		return;
+	}
+	let previous = '';
+	const sourceElementExpression = new ActionComputationExpression('string', source);
+	const calculateValueSource = createComputedExpression(context, sourceElementExpression); // registers listener
+	createComputed(() => {
+		if (context.isAttached() && context.isRelevant()) {
+			const valueSource = calculateValueSource();
+			if (previous !== valueSource) {
+				// only update if value has changed
+				if (referencesCurrentNode(context, ref)) {
+					const calc = context.evaluator.evaluateString(action.computation.expression, context);
+					const value = context.decodeInstanceValue(calc);
+					setRelevantValue(value);
+				}
 			}
-		});
+			previous = valueSource;
+		}
 	});
 };
 
+const registerAction = (
+	context: ValueContext,
+	setValue: SimpleAtomicStateSetter<string>,
+	action: ActionDefinition
+) => {
+	if (action.events.includes(XFORM_EVENT.odkInstanceFirstLoad)) {
+		if (isInstanceFirstLoad(context)) {
+			createActionCalculation(context, setValue, action.computation);
+		}
+	}
+	if (action.events.includes(XFORM_EVENT.odkInstanceLoad)) {
+		if (!isAddingRepeatChild(context)) {
+			createActionCalculation(context, setValue, action.computation);
+		}
+	}
+	if (action.events.includes(XFORM_EVENT.odkNewRepeat)) {
+		if (isAddingRepeatChild(context)) {
+			createActionCalculation(context, setValue, action.computation);
+		}
+	}
+	if (action.events.includes(XFORM_EVENT.xformsValueChanged)) {
+		createValueChangedCalculation(context, setValue, action);
+	}
+};
+
 export type InstanceValueState = SimpleAtomicState<string>;
 
 /**
@@ -168,25 +292,26 @@ export type InstanceValueState = SimpleAtomicState<string>;
  *   nodes defined with one
  * - prevents downstream writes to nodes in a readonly state
  */
-export const createInstanceValueState = (context: InstanceValueContext): InstanceValueState => {
+export const createInstanceValueState = (context: ValueContext): InstanceValueState => {
 	return context.scope.runTask(() => {
 		const initialValue = getInitialValue(context);
 		const baseValueState = createSignal(initialValue);
 		const relevantValueState = createRelevantValueState(context, baseValueState);
 
-		/**
-		 * @see {@link setPreloadUIDValue} for important details about spec ordering of events and computations.
-		 */
-		setPreloadUIDValue(context, relevantValueState);
+		const [, setValue] = relevantValueState;
 
-		const { calculate } = context.definition.bind;
+		preloadValue(context, setValue);
 
+		const { calculate } = context.definition.bind;
 		if (calculate != null) {
-			const [, setValue] = relevantValueState;
-
 			createCalculation(context, setValue, calculate);
 		}
 
+		const action = context.definition.model.actions.get(context.contextReference());
+		if (action) {
+			registerAction(context, setValue, action);
+		}
+
 		return guardDownstreamReadonlyWrites(context, relevantValueState);
 	});
 };

package/src/lib/reactivity/node-state/createSharedNodeState.ts

@@ -13,10 +13,10 @@ import { isComputedPropertySpec, isMutablePropertySpec } from './createSpecified
 // prettier-ignore
 type MutableKeyOf<Spec extends StateSpec> = {
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	[K in string & keyof Spec]: Spec[K] extends MutablePropertySpec<any>
+	[K in Extract<keyof Spec, string>]: Spec[K] extends MutablePropertySpec<any>
 		? K
 		: never;
-}[string & keyof Spec];
+}[Extract<keyof Spec, string>];
 
 type SetEnginePropertyState<Spec extends StateSpec> = <K extends MutableKeyOf<Spec>>(
 	key: K,

package/src/lib/xml-serialization.ts

@@ -153,7 +153,15 @@ export const serializeParentElementXML = (
 export const serializeLeafElementXML = (
 	qualifiedName: QualifiedName,
 	xmlValue: EscapedXMLText,
+	attributes: readonly Attribute[],
 	namespaceDeclarations?: NamespaceDeclarationMap
 ): string => {
-	return serializeElementXML(qualifiedName, xmlValue.normalize(), '', namespaceDeclarations);
+	const serializedAttributes =
+		attributes?.map((attribute) => attribute.instanceState.instanceXML).join('') ?? '';
+	return serializeElementXML(
+		qualifiedName,
+		xmlValue.normalize(),
+		serializedAttributes,
+		namespaceDeclarations
+	);
 };

package/src/parse/XFormDOM.ts

@@ -11,6 +11,7 @@ import type {
 import { DefaultEvaluator } from '@getodk/xpath';
 
 interface DOMBindElement extends KnownAttributeLocalNamedElement<'bind', 'nodeset'> {}
+interface DOMSetValueElement extends KnownAttributeLocalNamedElement<'setvalue', 'event'> {}
 
 const getMetaElement = (primaryInstanceRoot: Element): Element | null => {
 	for (const child of primaryInstanceRoot.children) {
@@ -336,6 +337,7 @@ export class XFormDOM {
 
 	readonly model: Element;
 	readonly binds: readonly DOMBindElement[];
+	readonly setValues: readonly DOMSetValueElement[];
 	readonly primaryInstance: Element;
 	readonly primaryInstanceRoot: Element;
 
@@ -368,6 +370,12 @@ export class XFormDOM {
 				contextNode: model,
 			}
 		);
+		const setValues: readonly DOMSetValueElement[] = evaluator.evaluateNodes<DOMSetValueElement>(
+			'./xf:setvalue[@event]',
+			{
+				contextNode: model,
+			}
+		);
 
 		const instances = evaluator.evaluateNodes<DOMInstanceElement>('./xf:instance', {
 			contextNode: model,
@@ -417,6 +425,7 @@ export class XFormDOM {
 		this.title = title;
 		this.model = model;
 		this.binds = binds;
+		this.setValues = setValues;
 		this.primaryInstance = primaryInstance;
 		this.primaryInstanceRoot = primaryInstanceRoot;
 		this.itextTranslationElements = itextTranslationElements;

package/src/parse/body/GroupElementDefinition.ts

@@ -39,8 +39,8 @@ export class GroupElementDefinition extends BodyElementDefinition<'group'> {
 			return childName !== 'label';
 		});
 
-		this.children = this.body.getChildElementDefinitions(form, this, element, childElements);
 		this.reference = parseNodesetReference(parent, element, 'ref');
+		this.children = this.body.getChildElementDefinitions(form, this, element, childElements);
 		this.appearances = structureElementAppearanceParser.parseFrom(element, 'appearance');
 		this.label = LabelDefinition.forGroup(form, this);
 	}

package/src/parse/body/control/InputControlDefinition.ts

@@ -1,8 +1,8 @@
+import { parseToFloat, parseToInteger } from '../../../lib/number-parsers.ts';
 import type { XFormDefinition } from '../../XFormDefinition.ts';
 import type { InputAppearanceDefinition } from '../appearance/inputAppearanceParser.ts';
 import { inputAppearanceParser } from '../appearance/inputAppearanceParser.ts';
 import type { BodyElementParentContext } from '../BodyDefinition.ts';
-import { parseToFloat, parseToInteger } from '../../../lib/number-parsers.ts';
 import { ControlDefinition } from './ControlDefinition.ts';
 
 export class InputControlDefinition extends ControlDefinition<'input'> {

package/src/parse/expression/ActionComputationExpression.ts

@@ -0,0 +1,12 @@
+import {
+	DependentExpression,
+	type DependentExpressionResultType,
+} from './abstract/DependentExpression.ts';
+
+export class ActionComputationExpression<
+	Type extends DependentExpressionResultType,
+> extends DependentExpression<Type> {
+	constructor(resultType: Type, expression: string) {
+		super(resultType, expression);
+	}
+}