@getodk/xforms-engine 0.2.0 → 0.4.0

package/src/instance/TriggerControl.ts

@@ -0,0 +1,134 @@
+import type { Accessor } from 'solid-js';
+import type { TextRange } from '../client/TextRange.ts';
+import type { TriggerNode, TriggerNodeDefinition } from '../client/TriggerNode.ts';
+import type { AnyViolation, LeafNodeValidationState } from '../client/validation.ts';
+import { createValueState } from '../lib/reactivity/createValueState.ts';
+import type { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
+import type { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
+import type { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
+import { createSharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
+import { createFieldHint } from '../lib/reactivity/text/createFieldHint.ts';
+import { createNodeLabel } from '../lib/reactivity/text/createNodeLabel.ts';
+import type { SimpleAtomicState } from '../lib/reactivity/types.ts';
+import type { SharedValidationState } from '../lib/reactivity/validation/createValidation.ts';
+import { createValidationState } from '../lib/reactivity/validation/createValidation.ts';
+import type { UnknownAppearanceDefinition } from '../parse/body/appearance/unknownAppearanceParser.ts';
+import type { Root } from './Root.ts';
+import type { DescendantNodeStateSpec } from './abstract/DescendantNode.ts';
+import { DescendantNode } from './abstract/DescendantNode.ts';
+import type { GeneralParentNode } from './hierarchy.ts';
+import type { EvaluationContext } from './internal-api/EvaluationContext.ts';
+import type { SubscribableDependency } from './internal-api/SubscribableDependency.ts';
+import type { ValidationContext } from './internal-api/ValidationContext.ts';
+import type { ValueContext } from './internal-api/ValueContext.ts';
+
+interface TriggerControlStateSpec extends DescendantNodeStateSpec<boolean> {
+	readonly label: Accessor<TextRange<'label'> | null>;
+	readonly hint: Accessor<TextRange<'hint'> | null>;
+	readonly children: null;
+	readonly value: SimpleAtomicState<boolean>;
+	readonly valueOptions: null;
+}
+
+const TRIGGER_ASSIGNED_VALUE = 'OK';
+
+export class TriggerControl
+	extends DescendantNode<TriggerNodeDefinition, TriggerControlStateSpec, null>
+	implements
+		TriggerNode,
+		EvaluationContext,
+		SubscribableDependency,
+		ValidationContext,
+		ValueContext<boolean>
+{
+	private readonly validation: SharedValidationState;
+	protected readonly state: SharedNodeState<TriggerControlStateSpec>;
+
+	// InstanceNode
+	protected engineState: EngineState<TriggerControlStateSpec>;
+
+	// TriggerNode
+	readonly nodeType = 'trigger';
+	readonly appearances: UnknownAppearanceDefinition;
+	readonly currentState: CurrentState<TriggerControlStateSpec>;
+
+	get validationState(): LeafNodeValidationState {
+		return this.validation.currentState;
+	}
+
+	// ValueContext
+	readonly encodeValue: (runtimeValue: boolean) => string;
+	readonly decodeValue: (instanceValue: string) => boolean;
+
+	constructor(parent: GeneralParentNode, definition: TriggerNodeDefinition) {
+		super(parent, definition);
+
+		this.appearances = definition.bodyElement.appearances;
+		this.encodeValue = (runtimeValue) => {
+			return runtimeValue ? TRIGGER_ASSIGNED_VALUE : '';
+		};
+		this.decodeValue = (instanceValue) => {
+			const value = instanceValue.trim();
+
+			switch (value) {
+				case TRIGGER_ASSIGNED_VALUE:
+					return true;
+
+				case '':
+					return false;
+
+				// TODO (robustness principle): Case insensitivity? Handle
+				// XPath-semantic booleans?? Other known/common equivalents?
+				default:
+					throw new Error(`Unexpected trigger value: ${value}`);
+			}
+		};
+
+		const sharedStateOptions = {
+			clientStateFactory: this.engineConfig.stateFactory,
+		};
+
+		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: null,
+				value: createValueState(this),
+			},
+			sharedStateOptions
+		);
+
+		this.state = state;
+		this.engineState = state.engineState;
+		this.currentState = state.currentState;
+		this.validation = createValidationState(this, sharedStateOptions);
+	}
+
+	// ValidationContext
+	getViolation(): AnyViolation | null {
+		return this.validation.engineState.violation;
+	}
+
+	isBlank(): boolean {
+		return this.engineState.value == null;
+	}
+
+	// InstanceNode
+	getChildren(): readonly [] {
+		return [];
+	}
+
+	// TriggerNode
+	setValue(value: boolean): Root {
+		this.state.setProperty('value', value);
+
+		return this.root;
+	}
+}

package/src/instance/abstract/DescendantNode.ts

@@ -3,16 +3,15 @@ import type { Accessor } from 'solid-js';
 import type { BaseNode } from '../../client/BaseNode.ts';
 import { createComputedExpression } from '../../lib/reactivity/createComputedExpression.ts';
 import type { ReactiveScope } from '../../lib/reactivity/scope.ts';
-import type { AnyDescendantNodeDefinition } from '../../model/DescendentNodeDefinition.ts';
-import type { AnyNodeDefinition } from '../../model/NodeDefinition.ts';
-import type { RepeatInstanceDefinition } from '../../model/RepeatInstanceDefinition.ts';
-import type { ValueNodeDefinition } from '../../model/ValueNodeDefinition.ts';
-import type { RepeatInstance } from '../RepeatInstance.ts';
-import type { RepeatRange } from '../RepeatRange.ts';
-import type { Root } from '../Root.ts';
-import type { AnyChildNode, GeneralParentNode } from '../hierarchy.ts';
+import type { AnyDescendantNodeDefinition } from '../../parse/model/DescendentNodeDefinition.ts';
+import type { LeafNodeDefinition } from '../../parse/model/LeafNodeDefinition.ts';
+import type { AnyNodeDefinition } from '../../parse/model/NodeDefinition.ts';
+import type { RepeatInstanceDefinition } from '../../parse/model/RepeatInstanceDefinition.ts';
+import type { AnyChildNode, GeneralParentNode, RepeatRange } from '../hierarchy.ts';
 import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
 import type { SubscribableDependency } from '../internal-api/SubscribableDependency.ts';
+import type { RepeatInstance } from '../repeat/RepeatInstance.ts';
+import type { Root } from '../Root.ts';
 import type { InstanceNodeStateSpec } from './InstanceNode.ts';
 import { InstanceNode } from './InstanceNode.ts';
 
@@ -37,7 +36,7 @@ export type DescendantNodeDefinition = Extract<
 
 // prettier-ignore
 export type DescendantNodeParent<Definition extends DescendantNodeDefinition> =
-	Definition extends ValueNodeDefinition
+	Definition extends LeafNodeDefinition
 		? GeneralParentNode
 	: Definition extends RepeatInstanceDefinition
 		? RepeatRange
@@ -96,7 +95,7 @@ export abstract class DescendantNode<
 		return this.isSelfRelevant();
 	};
 
-	protected readonly isRequired: Accessor<boolean>;
+	readonly isRequired: Accessor<boolean>;
 
 	readonly root: Root;
 	readonly evaluator: XFormsXPathEvaluator;

package/src/instance/abstract/InstanceNode.ts

@@ -3,6 +3,7 @@ import type { Accessor, Signal } from 'solid-js';
 import type { BaseNode } from '../../client/BaseNode.ts';
 import type { NodeAppearances } from '../../client/NodeAppearances.ts';
 import type { InstanceNodeType } from '../../client/node-types.ts';
+import type { NodeValidationState } from '../../client/validation.ts';
 import type { TextRange } from '../../index.ts';
 import type { MaterializedChildren } from '../../lib/reactivity/materializeCurrentStateChildren.ts';
 import type { CurrentState } from '../../lib/reactivity/node-state/createCurrentState.ts';
@@ -11,7 +12,7 @@ import type { SharedNodeState } from '../../lib/reactivity/node-state/createShar
 import type { ReactiveScope } from '../../lib/reactivity/scope.ts';
 import { createReactiveScope } from '../../lib/reactivity/scope.ts';
 import type { SimpleAtomicState } from '../../lib/reactivity/types.ts';
-import type { AnyNodeDefinition } from '../../model/NodeDefinition.ts';
+import type { AnyNodeDefinition } from '../../parse/model/NodeDefinition.ts';
 import type { Root } from '../Root.ts';
 import type { AnyChildNode, AnyNode, AnyParentNode } from '../hierarchy.ts';
 import type { NodeID } from '../identity.ts';
@@ -117,6 +118,8 @@ export abstract class InstanceNode<
 
 	abstract readonly currentState: InstanceNodeCurrentState<Spec, Child>;
 
+	abstract readonly validationState: NodeValidationState;
+
 	// BaseNode: structural
 	abstract readonly root: Root;
 
@@ -230,11 +233,30 @@ export abstract class InstanceNode<
 	subscribe(): void {
 		const { engineState } = this;
 
-		if (engineState.relevant) {
-			engineState.reference;
-			engineState.relevant;
-			engineState.children;
-			engineState.value;
-		}
+		// Note: a previous iteration of this default implementation guarded these
+		// reactive reads behind a relevance check. This caused timing issues for
+		// downstream computations referencing a node whose relevance changes.
+		//
+		// That original guard was intended to reduce excessive redundant
+		// computations, and so removing it is intended as a naive compromise of
+		// performance for obvious correctness improvements.
+		//
+		// This compromise, like many others, will be moot if/when we decide to
+		// decouple XPath evaluation from the browser/XML DOM: reactive
+		// subscriptions would be established by evaluation of the expressions
+		// themselves (as they traverse instance state and access values), rather
+		// than this safer/less focused approach.
+
+		// TODO: typescript-eslint is right to object to these! We should _at least_
+		// make internal reactive reads obvious, i.e. function calls.
+
+		// eslint-disable-next-line @typescript-eslint/no-unused-expressions
+		engineState.reference;
+		// eslint-disable-next-line @typescript-eslint/no-unused-expressions
+		engineState.relevant;
+		// eslint-disable-next-line @typescript-eslint/no-unused-expressions
+		engineState.children;
+		// eslint-disable-next-line @typescript-eslint/no-unused-expressions
+		engineState.value;
 	}
 }

package/src/instance/abstract/UnsupportedControl.ts

@@ -0,0 +1,151 @@
+import { identity } from '@getodk/common/lib/identity.ts';
+import type { Accessor } from 'solid-js';
+import type { UnsupportedControlNodeType } from '../../client/node-types.ts';
+import type { TextRange } from '../../client/TextRange.ts';
+import type {
+	UnsupportedControlDefinition,
+	UnsupportedControlElementDefinition,
+	UnsupportedControlNode,
+} from '../../client/unsupported/UnsupportedControlNode.ts';
+import type { AnyViolation, LeafNodeValidationState } from '../../client/validation.ts';
+import { createValueState } from '../../lib/reactivity/createValueState.ts';
+import type { CurrentState } from '../../lib/reactivity/node-state/createCurrentState.ts';
+import type { EngineState } from '../../lib/reactivity/node-state/createEngineState.ts';
+import {
+	createSharedNodeState,
+	type SharedNodeState,
+} from '../../lib/reactivity/node-state/createSharedNodeState.ts';
+import { createFieldHint } from '../../lib/reactivity/text/createFieldHint.ts';
+import { createNodeLabel } from '../../lib/reactivity/text/createNodeLabel.ts';
+import type { SimpleAtomicState } from '../../lib/reactivity/types.ts';
+import {
+	createValidationState,
+	type SharedValidationState,
+} from '../../lib/reactivity/validation/createValidation.ts';
+import type { UnknownAppearanceDefinition } from '../../parse/body/appearance/unknownAppearanceParser.ts';
+import type { GeneralParentNode } from '../hierarchy.ts';
+import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
+import type { SubscribableDependency } from '../internal-api/SubscribableDependency.ts';
+import type { ValidationContext } from '../internal-api/ValidationContext.ts';
+import type { ValueContext } from '../internal-api/ValueContext.ts';
+import { DescendantNode, type DescendantNodeStateSpec } from './DescendantNode.ts';
+
+type TypedUnsupportedControlElementDefinition<Type extends UnsupportedControlNodeType> = Extract<
+	UnsupportedControlElementDefinition,
+	{ readonly type: Type }
+>;
+
+interface TypedUnsupportedControlDefinition<Type extends UnsupportedControlNodeType>
+	extends UnsupportedControlDefinition {
+	readonly bodyElement: TypedUnsupportedControlElementDefinition<Type>;
+}
+
+interface UnsupportedControlStateSpec extends DescendantNodeStateSpec<unknown> {
+	readonly label: Accessor<TextRange<'label'> | null>;
+	readonly hint: Accessor<TextRange<'hint'> | null>;
+	readonly children: null;
+	readonly value: SimpleAtomicState<unknown>;
+	readonly valueOptions: never;
+}
+
+class UnsupportedControlValueEncodeError extends Error {
+	constructor(type: UnsupportedControlNodeType) {
+		super(`Cannot encode state for node (type: ${type}) - not implemented`);
+	}
+}
+
+class UnsupportedControlWriteError extends Error {
+	constructor(type: UnsupportedControlNodeType) {
+		super(`Cannot write state for node (type: ${type}) - not implemented`);
+	}
+}
+
+export abstract class UnsupportedControl<Type extends UnsupportedControlNodeType>
+	extends DescendantNode<TypedUnsupportedControlDefinition<Type>, UnsupportedControlStateSpec, null>
+	implements
+		UnsupportedControlNode,
+		EvaluationContext,
+		SubscribableDependency,
+		ValidationContext,
+		ValueContext<unknown>
+{
+	private readonly validation: SharedValidationState;
+	protected readonly state: SharedNodeState<UnsupportedControlStateSpec>;
+
+	// InstanceNode
+	protected readonly engineState: EngineState<UnsupportedControlStateSpec>;
+
+	// UnsupportedControlNode
+	abstract override readonly nodeType: Type;
+
+	readonly appearances: UnknownAppearanceDefinition;
+	readonly currentState: CurrentState<UnsupportedControlStateSpec>;
+
+	get validationState(): LeafNodeValidationState {
+		return this.validation.currentState;
+	}
+
+	// ValueContext
+	readonly encodeValue = (instanceValue: unknown): string => {
+		const encoded = instanceValue;
+
+		if (typeof encoded === 'string') {
+			return encoded;
+		}
+
+		throw new UnsupportedControlValueEncodeError(this.nodeType);
+	};
+
+	readonly decodeValue = (instanceValue: unknown): unknown => {
+		return identity(instanceValue);
+	};
+
+	constructor(parent: GeneralParentNode, definition: TypedUnsupportedControlDefinition<Type>) {
+		super(parent, definition);
+
+		this.appearances = definition.bodyElement.appearances;
+
+		const sharedStateOptions = {
+			clientStateFactory: this.engineConfig.stateFactory,
+		};
+
+		const stateSpec: UnsupportedControlStateSpec = {
+			reference: this.contextReference,
+			readonly: this.isReadonly,
+			relevant: this.isRelevant,
+			required: this.isRequired,
+
+			label: createNodeLabel(this, definition),
+			hint: createFieldHint(this, definition),
+			children: null,
+			valueOptions: null as never,
+			value: createValueState<unknown>(this),
+		};
+
+		const state = createSharedNodeState(this.scope, stateSpec, sharedStateOptions);
+
+		this.state = state;
+		this.engineState = state.engineState;
+		this.currentState = state.currentState;
+		this.validation = createValidationState(this, sharedStateOptions);
+	}
+
+	// ValidationContext
+	getViolation(): AnyViolation | null {
+		return this.validation.engineState.violation;
+	}
+
+	isBlank(): boolean {
+		return this.engineState.value === '';
+	}
+
+	// InstanceNode
+	getChildren(): readonly [] {
+		return [];
+	}
+
+	// UnsupportedControlNode
+	setValue(_: never): never {
+		throw new UnsupportedControlWriteError(this.nodeType);
+	}
+}

package/src/instance/children.ts

@@ -1,15 +1,29 @@
 import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
 import type { GroupDefinition } from '../client/GroupNode.ts';
 import type { SubtreeDefinition } from '../client/SubtreeNode.ts';
-import type { SubtreeDefinition as ModelSubtreeDefinition } from '../model/SubtreeDefinition.ts';
+import type { TriggerNodeDefinition } from '../client/TriggerNode.ts';
+import type { RangeNodeDefinition } from '../client/unsupported/RangeNode.ts';
+import type { RankNodeDefinition } from '../client/unsupported/RankNode.ts';
+import type { UnsupportedControlDefinition } from '../client/unsupported/UnsupportedControlNode.ts';
+import type { UploadNodeDefinition } from '../client/unsupported/UploadNode.ts';
+import type { LeafNodeDefinition } from '../parse/model/LeafNodeDefinition.ts';
+import { NoteNodeDefinition } from '../parse/model/NoteNodeDefinition.ts';
+import type { SubtreeDefinition as ModelSubtreeDefinition } from '../parse/model/SubtreeDefinition.ts';
 import { Group } from './Group.ts';
-import { RepeatRange } from './RepeatRange.ts';
+import type { GeneralChildNode, GeneralParentNode } from './hierarchy.ts';
+import { ModelValue, type ModelValueDefinition } from './ModelValue.ts';
+import { Note } from './Note.ts';
+import { RepeatRangeControlled } from './repeat/RepeatRangeControlled.ts';
+import { RepeatRangeUncontrolled } from './repeat/RepeatRangeUncontrolled.ts';
 import type { SelectFieldDefinition } from './SelectField.ts';
 import { SelectField } from './SelectField.ts';
 import type { StringFieldDefinition } from './StringField.ts';
 import { StringField } from './StringField.ts';
 import { Subtree } from './Subtree.ts';
-import type { GeneralChildNode, GeneralParentNode } from './hierarchy.ts';
+import { TriggerControl } from './TriggerControl.ts';
+import { RangeControl } from './unsupported/RangeControl.ts';
+import { RankControl } from './unsupported/RankControl.ts';
+import { UploadControl } from './unsupported/UploadControl.ts';
 
 const isSubtreeDefinition = (
 	definition: ModelSubtreeDefinition
@@ -17,6 +31,63 @@ const isSubtreeDefinition = (
 	return definition.bodyElement == null;
 };
 
+type AnyUnsupportedControlDefinition =
+	| RangeNodeDefinition
+	| RankNodeDefinition
+	| UploadNodeDefinition;
+
+// prettier-ignore
+type ControlNodeDefinition =
+	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
+	| SelectFieldDefinition
+	| StringFieldDefinition
+	| TriggerNodeDefinition
+	| AnyUnsupportedControlDefinition;
+
+type AnyLeafNodeDefinition = ControlNodeDefinition | ModelValueDefinition;
+
+const isModelValueDefinition = (
+	definition: LeafNodeDefinition
+): definition is ModelValueDefinition => {
+	return definition.bodyElement == null;
+};
+
+const isStringFieldDefinition = (
+	definition: ControlNodeDefinition
+): definition is StringFieldDefinition => {
+	return definition.bodyElement.type === 'input';
+};
+
+const isSelectFieldDefinition = (
+	definition: ControlNodeDefinition
+): definition is SelectFieldDefinition => {
+	return definition.bodyElement.type === 'select' || definition.bodyElement.type === 'select1';
+};
+
+const isRangeNodeDefinition = (
+	definition: UnsupportedControlDefinition
+): definition is RangeNodeDefinition => {
+	return definition.bodyElement.type === 'range';
+};
+
+const isRankNodeDefinition = (
+	definition: UnsupportedControlDefinition
+): definition is RankNodeDefinition => {
+	return definition.bodyElement.type === 'rank';
+};
+
+const isTriggerNodeDefinition = (
+	definition: ControlNodeDefinition
+): definition is TriggerNodeDefinition => {
+	return definition.bodyElement.type === 'trigger';
+};
+
+const isUploadNodeDefinition = (
+	definition: ControlNodeDefinition
+): definition is UploadNodeDefinition => {
+	return definition.bodyElement.type === 'upload';
+};
+
 export const buildChildren = (parent: GeneralParentNode): GeneralChildNode[] => {
 	const { children } = parent.definition;
 
@@ -34,24 +105,50 @@ export const buildChildren = (parent: GeneralParentNode): GeneralChildNode[] =>
 			}
 
 			case 'repeat-range': {
-				return new RepeatRange(parent, child);
+				if (child.isControlled()) {
+					return new RepeatRangeControlled(parent, child);
+				}
+
+				return new RepeatRangeUncontrolled(parent, child);
 			}
 
-			case 'value-node': {
-				// TODO: this sort of awkwardness might go away if we embrace a
-				// proliferation of node types throughout.
-				switch (child.bodyElement?.type) {
-					case 'select':
-					case 'select1':
-						return new SelectField(parent, child as SelectFieldDefinition);
+			case 'leaf-node': {
+				if (child instanceof NoteNodeDefinition) {
+					return new Note(parent, child);
+				}
+
+				// More specific type helps with narrowing below
+				const leafChild: AnyLeafNodeDefinition = child;
+
+				if (isModelValueDefinition(leafChild)) {
+					return new ModelValue(parent, leafChild);
+				}
+
+				if (isStringFieldDefinition(leafChild)) {
+					return new StringField(parent, leafChild);
+				}
 
-					case 'input':
-					case undefined:
-						return new StringField(parent, child as StringFieldDefinition);
+				if (isSelectFieldDefinition(leafChild)) {
+					return new SelectField(parent, leafChild);
+				}
 
-					default:
-						throw new UnreachableError(child.bodyElement);
+				if (isTriggerNodeDefinition(leafChild)) {
+					return new TriggerControl(parent, leafChild);
 				}
+
+				if (isRangeNodeDefinition(leafChild)) {
+					return new RangeControl(parent, leafChild);
+				}
+
+				if (isRankNodeDefinition(leafChild)) {
+					return new RankControl(parent, leafChild);
+				}
+
+				if (isUploadNodeDefinition(leafChild)) {
+					return new UploadControl(parent, leafChild);
+				}
+
+				throw new UnreachableError(leafChild);
 			}
 
 			default: {

package/src/instance/hierarchy.ts

@@ -1,10 +1,25 @@
 import type { Group } from './Group.ts';
-import type { RepeatInstance } from './RepeatInstance.ts';
-import type { RepeatRange } from './RepeatRange.ts';
+import type { ModelValue } from './ModelValue.ts';
+import type { Note } from './Note.ts';
+import type { RepeatInstance } from './repeat/RepeatInstance.ts';
+import type { RepeatRangeControlled } from './repeat/RepeatRangeControlled.ts';
+import type { RepeatRangeUncontrolled } from './repeat/RepeatRangeUncontrolled.ts';
 import type { Root } from './Root.ts';
 import type { SelectField } from './SelectField.ts';
 import type { StringField } from './StringField.ts';
 import type { Subtree } from './Subtree.ts';
+import type { TriggerControl } from './TriggerControl.ts';
+import type { RangeControl } from './unsupported/RangeControl.ts';
+import type { RankControl } from './unsupported/RankControl.ts';
+import type { UploadControl } from './unsupported/UploadControl.ts';
+
+export type RepeatRange = RepeatRangeControlled | RepeatRangeUncontrolled;
+
+// prettier-ignore
+export type UnsupportedControl =
+	| RangeControl
+	| RankControl
+	| UploadControl;
 
 // prettier-ignore
 export type AnyNode =
@@ -14,8 +29,12 @@ export type AnyNode =
 	| Subtree
 	| RepeatRange
 	| RepeatInstance
+	| Note
+	| ModelValue
 	| StringField
-	| SelectField;
+	| SelectField
+	| TriggerControl
+	| UnsupportedControl;
 
 // prettier-ignore
 export type AnyParentNode =
@@ -41,8 +60,12 @@ export type AnyChildNode =
 	| Subtree
 	| RepeatRange
 	| RepeatInstance
+	| ModelValue
+	| Note
 	| StringField
-	| SelectField;
+	| SelectField
+	| TriggerControl
+	| UnsupportedControl;
 
 // prettier-ignore
 export type GeneralChildNode =
@@ -50,5 +73,19 @@ export type GeneralChildNode =
 	| Group
 	| Subtree
 	| RepeatRange
+	| ModelValue
+	| Note
+	| StringField
+	| SelectField
+	| TriggerControl
+	| UnsupportedControl;
+
+// prettier-ignore
+export type AnyValueNode =
+	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
+	| ModelValue
+	| Note
 	| StringField
-	| SelectField;
+	| SelectField
+	| TriggerControl
+	| UnsupportedControl;

package/src/instance/index.ts

@@ -1,5 +1,4 @@
 import { identity } from '@getodk/common/lib/identity.ts';
-import { XFormDefinition } from '../XFormDefinition.ts';
 import type { RootNode } from '../client/RootNode.ts';
 import type {
 	InitializeFormOptions as BaseInitializeFormOptions,
@@ -8,6 +7,7 @@ import type {
 } from '../client/index.ts';
 import { retrieveSourceXMLResource } from '../instance/resource.ts';
 import { createUniqueId } from '../lib/unique-id.ts';
+import { XFormDefinition } from '../parse/XFormDefinition.ts';
 import { Root } from './Root.ts';
 import type { InstanceConfig } from './internal-api/InstanceConfig.ts';
 

package/src/instance/internal-api/EvaluationContext.ts

@@ -1,7 +1,7 @@
 import type { XFormsXPathEvaluator } from '@getodk/xpath';
 import type { Accessor } from 'solid-js';
-import type { DependentExpression } from '../../expression/DependentExpression.ts';
 import type { ReactiveScope } from '../../lib/reactivity/scope.ts';
+import type { DependentExpression } from '../../parse/expression/abstract/DependentExpression.ts';
 import type { SubscribableDependency } from './SubscribableDependency.ts';
 import type { TranslationContext } from './TranslationContext.ts';