@getodk/xforms-engine 0.4.0 → 0.6.0

package/src/instance/internal-api/submission/ClientReactiveSubmittableLeafNode.ts

@@ -0,0 +1,43 @@
+import type { SubmissionState } from '../../../client/submission/SubmissionState.ts';
+import type { QualifiedName } from '../../../lib/names/QualifiedName.ts';
+import type { EscapedXMLText } from '../../../lib/xml-serialization.ts';
+import type {
+	ClientReactiveSubmittableChildNode,
+	ClientReactiveSubmittableParentNode,
+} from './ClientReactiveSubmittableParentNode.ts';
+
+interface ClientReactiveSubmittableLeafNodeCurrentState<RuntimeValue> {
+	get relevant(): boolean;
+	get value(): RuntimeValue;
+}
+
+export type SerializedSubmissionValue = string;
+
+interface ClientReactiveSubmittableLeafNodeDefinition {
+	readonly qualifiedName: QualifiedName;
+}
+
+export interface ClientReactiveSubmittableLeafNode<RuntimeValue> {
+	readonly definition: ClientReactiveSubmittableLeafNodeDefinition;
+	readonly parent: ClientReactiveSubmittableParentNode<ClientReactiveSubmittableChildNode>;
+	readonly currentState: ClientReactiveSubmittableLeafNodeCurrentState<RuntimeValue>;
+
+	/**
+	 * A client-reactive submittable leaf node is responsible for producing a
+	 * string representation of its value state, suitable for serialization for
+	 * submission. It **MUST NOT** perform any further submission-specific
+	 * serialization duties: in particular, the value **MUST NOT** be escaped for
+	 * XML. This responsibility is delegated up the stack, to avoid repeat
+	 * escaping.
+	 *
+	 * Note: excluding {@link EscapedXMLText} here does not have an effect on the
+	 * type system, it is a documentation-only hint, to help guard against future
+	 * double-escaping mistakes.
+	 */
+	readonly encodeValue: (
+		this: unknown,
+		runtimeValue: RuntimeValue
+	) => Exclude<string, EscapedXMLText>;
+
+	readonly submissionState: SubmissionState;
+}

package/src/instance/internal-api/submission/ClientReactiveSubmittableParentNode.ts

@@ -0,0 +1,26 @@
+import type { SubmissionState } from '../../../client/submission/SubmissionState.ts';
+import type { QualifiedName } from '../../../lib/names/QualifiedName.ts';
+
+export interface ClientReactiveSubmittableChildNode {
+	readonly submissionState: SubmissionState;
+}
+
+interface ClientReactiveSubmittableParentNodeCurrentState<
+	Child extends ClientReactiveSubmittableChildNode,
+> {
+	get relevant(): boolean;
+	get children(): readonly Child[];
+}
+
+export interface ClientReactiveSubmittableParentNodeDefinition {
+	readonly qualifiedName: QualifiedName;
+}
+
+export interface ClientReactiveSubmittableParentNode<
+	Child extends ClientReactiveSubmittableChildNode,
+> {
+	readonly definition: ClientReactiveSubmittableParentNodeDefinition;
+	readonly parent: ClientReactiveSubmittableParentNode<ClientReactiveSubmittableChildNode> | null;
+	readonly currentState: ClientReactiveSubmittableParentNodeCurrentState<Child>;
+	readonly submissionState: SubmissionState;
+}

package/src/instance/internal-api/submission/ClientReactiveSubmittableValueNode.ts

@@ -0,0 +1,24 @@
+import type { SubmissionState } from '../../../client/submission/SubmissionState.ts';
+import type { QualifiedName } from '../../../lib/names/QualifiedName.ts';
+import type {
+	ClientReactiveSubmittableChildNode,
+	ClientReactiveSubmittableParentNode,
+} from './ClientReactiveSubmittableParentNode.ts';
+
+interface ClientReactiveSubmittableValueNodeCurrentState {
+	get relevant(): boolean;
+	get instanceValue(): string;
+}
+
+export type SerializedSubmissionValue = string;
+
+interface ClientReactiveSubmittableValueNodeDefinition {
+	readonly qualifiedName: QualifiedName;
+}
+
+export interface ClientReactiveSubmittableValueNode {
+	readonly definition: ClientReactiveSubmittableValueNodeDefinition;
+	readonly parent: ClientReactiveSubmittableParentNode<ClientReactiveSubmittableChildNode>;
+	readonly currentState: ClientReactiveSubmittableValueNodeCurrentState;
+	readonly submissionState: SubmissionState;
+}

package/src/instance/repeat/BaseRepeatRange.ts

@@ -1,12 +1,22 @@
 import { insertAtIndex } from '@getodk/common/lib/array/insert.ts';
-import { untrack, type Accessor } from 'solid-js';
+import { XPathNodeKindKey } from '@getodk/xpath';
+import type { Accessor } from 'solid-js';
+import { untrack } from 'solid-js';
+import type { RepeatRangeNode } from '../../client/hierarchy.ts';
+import type { FormNodeID } from '../../client/identity.ts';
 import type { NodeAppearances } from '../../client/NodeAppearances.ts';
 import type { BaseRepeatRangeNode } from '../../client/repeat/BaseRepeatRangeNode.ts';
+import type { SubmissionState } from '../../client/submission/SubmissionState.ts';
 import type { TextRange } from '../../client/TextRange.ts';
 import type { AncestorNodeValidationState } from '../../client/validation.ts';
+import type {
+	XFormsXPathNodeRange,
+	XFormsXPathNodeRangeKind,
+} from '../../integration/xpath/adapter/XFormsXPathNode.ts';
+import { XFORMS_XPATH_NODE_RANGE_KIND } from '../../integration/xpath/adapter/XFormsXPathNode.ts';
+import { createNodeRangeSubmissionState } from '../../lib/client-reactivity/submission/createNodeRangeSubmissionState.ts';
 import type { ChildrenState } from '../../lib/reactivity/createChildrenState.ts';
 import { createChildrenState } from '../../lib/reactivity/createChildrenState.ts';
-import { createComputedExpression } from '../../lib/reactivity/createComputedExpression.ts';
 import type { MaterializedChildren } from '../../lib/reactivity/materializeCurrentStateChildren.ts';
 import { materializeCurrentStateChildren } from '../../lib/reactivity/materializeCurrentStateChildren.ts';
 import type { CurrentState } from '../../lib/reactivity/node-state/createCurrentState.ts';
@@ -20,20 +30,18 @@ import type {
 } from '../../parse/model/RepeatRangeDefinition.ts';
 import type {
 	AnyDescendantNode,
-	DescendantNodeParent,
 	DescendantNodeSharedStateSpec,
 } from '../abstract/DescendantNode.ts';
 import { DescendantNode } from '../abstract/DescendantNode.ts';
-import type { RepeatRange } from '../hierarchy.ts';
-import type { NodeID } from '../identity.ts';
+import type { GeneralParentNode, RepeatRange } from '../hierarchy.ts';
 import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
-import type { SubscribableDependency } from '../internal-api/SubscribableDependency.ts';
+import type { ClientReactiveSubmittableParentNode } from '../internal-api/submission/ClientReactiveSubmittableParentNode.ts';
 import { RepeatInstance, type RepeatDefinition } from './RepeatInstance.ts';
 
 interface RepeatRangeStateSpec extends DescendantNodeSharedStateSpec {
 	readonly hint: null;
 	readonly label: Accessor<TextRange<'label'> | null>;
-	readonly children: Accessor<readonly NodeID[]>;
+	readonly children: Accessor<readonly FormNodeID[]>;
 	readonly valueOptions: null;
 	readonly value: null;
 }
@@ -45,59 +53,48 @@ type BaseRepeatRangeNodeType<Definition extends AnyRepeatRangeDefinition> =
 		: 'repeat-range:uncontrolled';
 
 export abstract class BaseRepeatRange<Definition extends AnyRepeatRangeDefinition>
-	extends DescendantNode<Definition, RepeatRangeStateSpec, RepeatInstance>
-	implements BaseRepeatRangeNode, EvaluationContext, SubscribableDependency
+	extends DescendantNode<Definition, RepeatRangeStateSpec, GeneralParentNode, RepeatInstance>
+	implements
+		BaseRepeatRangeNode,
+		XFormsXPathNodeRange,
+		EvaluationContext,
+		ClientReactiveSubmittableParentNode<RepeatInstance>
 {
+	protected readonly childrenState: ChildrenState<RepeatInstance>;
+
 	/**
 	 * A repeat range doesn't have a corresponding primary instance element of its
-	 * own, and its instances are appended to the range's parent element. During
-	 * creation of the initial primary instance state and DOM trees, we _could_
-	 * reliably append all of the range's instances in order as the definition
-	 * tree is recursed. But that would fail to handle some instance addition
-	 * cases afterwards.
+	 * own. It is represented in the following ways:
 	 *
-	 * Most notably, we need to know where in the primary instance tree to append
-	 * instances created for a range which is currently empty. As a lucky
-	 * coincidence, this need coincides with the ability to add instances at any
-	 * arbitrary index within the range. In each case, we can reference a primary
-	 * instance DOM node which will become the new instance's preceding sibling.
-	 * Where the range is empty, we use this {@link Comment} node (itself created
-	 * and appended during range initialization) in lieu of a nonexistent
-	 * preceding instance's {@link contextNode}.
+	 * - As a comment node (in terms of XPath semantics), immediately preceding
+	 *   the repeat range's {@link RepeatInstance | repeat instances} (if it
+	 *   presently has any; as a placeholder where they may be appended
+	 *   otherwise). This is necessary to support certain ODK XForms functionality
+	 *   where an expression is expected to be evaluated against "repeats" as a
+	 *   conceptual unit. Most typically, this includes:
 	 *
-	 * @todo We likely want to remove these during submission serialization.
-	 * @todo Can we use a
-	 * {@link https://developer.mozilla.org/en-US/docs/Web/API/Range | DOM Range}
-	 * instead?
-	 */
-	protected readonly anchorNode: Comment;
-
-	protected readonly childrenState: ChildrenState<RepeatInstance>;
-
-	/**
-	 * Provides an {@link EvaluationContext} from which to evaluate expressions
-	 * where some LocationPath sub-expressions may be **relative to the repeat
-	 * range itself**. This is useful for evaluation of expressions where:
+	 *   - `jr:count` expressions associated with the repeat's body element
+	 *   - `relevant` bind computations associated with the repeat's nodeset
 	 *
-	 * - the expression is typically contextualized to any of its
-	 *   {@link RepeatInstance} children, but it presently has none (i.e.
-	 *   `relevant`)
+	 * - As a subtree with {@link RepeatInstance | repeat instance} **children**,
+	 *   in service of the client-facing {@link RepeatRangeNode} API (and with the
+	 *   same structural semantics internally)
 	 *
-	 * - the expression is conceptually intended to be evaluated in the context of
-	 *   the repeat range itself (i.e. `jr:count`)
-	 */
-	protected readonly selfEvaluationContext: EvaluationContext & {
-		readonly contextNode: Comment;
-	};
-
-	/**
-	 * @see {@link isSelfRelevant}
+	 * Ultimately, this means there is a fundamental impedance mismatch between
+	 * two representations which are either necessary (XPath) or high value
+	 * (providing a coherent mental model for clients and the engine
+	 * implementation servicing that client-facing model).
+	 *
+	 * In recognition that this is a truly odd mix of inherent and incidental
+	 * complexity, here we use the special {@link XFormsXPathNodeRangeKind}
+	 * branded type as a dedicated point of (internal) documentation where the two
+	 * models diverge.
 	 */
-	protected readonly isEmptyRangeSelfRelevant: Accessor<boolean>;
+	override readonly [XPathNodeKindKey]: XFormsXPathNodeRangeKind = XFORMS_XPATH_NODE_RANGE_KIND;
 
 	// InstanceNode
 	protected readonly state: SharedNodeState<RepeatRangeStateSpec>;
-	protected override engineState: EngineState<RepeatRangeStateSpec>;
+	protected readonly engineState: EngineState<RepeatRangeStateSpec>;
 
 	// DescendantNode
 	/**
@@ -108,49 +105,6 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatRangeDefinitio
 	 */
 	declare isSelfReadonly: Accessor<boolean>;
 
-	/**
-	 * A repeat range does not exist in the primary instance tree. A `relevant`
-	 * expression applies to each {@link RepeatInstance} child of the repeat
-	 * range. Determining whether a repeat range itself "is relevant" isn't a
-	 * concept the spec addresses, but it may be used by clients to determine
-	 * whether to allow interaction with the range (e.g. by adding a repeat
-	 * instance, or presenting the range's label when empty).
-	 *
-	 * As a naive first pass, it seems like the heuristic for this should be:
-	 *
-	 * 1. Does the repeat range have any repeat instance children?
-	 *
-	 *     - If yes, go to 2.
-	 *     - If no, go to 3.
-	 *
-	 * 2. Does one or more of those children return `true` for the node's
-	 *    `relevant` expression (i.e. is the repeat instance "self relevant")?
-	 *
-	 * 3. Does the relevant expression return `true` for the repeat range itself
-	 *    (where, at least for now, the context of that evaluation would be the
-	 *    repeat range's {@link anchorNode} to ensure correct relative expressions
-	 *    resolve correctly)?
-	 *
-	 * @todo While (3) is proactively implemented, there isn't presently a test
-	 * exercising it. It felt best for now to surface this for discussion in
-	 * review to validate that it's going in the right direction.
-	 *
-	 * @todo While (2) **is actually tested**, the tests currently in place behave
-	 * the same way with only the logic for (3), regardless of whether the repeat
-	 * range actually has any repeat instance children. It's unclear (a) if that's
-	 * a preferable simplification and (b) how that might affect performance (in
-	 * theory it could vary depending on form structure and runtime state).
-	 */
-	override readonly isSelfRelevant: Accessor<boolean> = () => {
-		const instances = this.childrenState.getChildren();
-
-		if (instances.length > 0) {
-			return instances.some((instance) => instance.isSelfRelevant());
-		}
-
-		return this.isEmptyRangeSelfRelevant();
-	};
-
 	// BaseRepeatRangeNode
 	abstract override readonly nodeType: BaseRepeatRangeNodeType<Definition>;
 
@@ -189,11 +143,15 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatRangeDefinitio
 	 */
 	abstract override readonly appearances: NodeAppearances<Definition>;
 
+	readonly nodeOptions = null;
+
 	readonly currentState: MaterializedChildren<CurrentState<RepeatRangeStateSpec>, RepeatInstance>;
 
 	abstract override readonly validationState: AncestorNodeValidationState;
 
-	constructor(parent: DescendantNodeParent<Definition>, definition: Definition) {
+	readonly submissionState: SubmissionState;
+
+	constructor(parent: GeneralParentNode, definition: Definition) {
 		super(parent, definition);
 
 		const repeatRange = this as AnyDescendantNode as RepeatRange;
@@ -202,28 +160,6 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatRangeDefinitio
 
 		this.childrenState = childrenState;
 
-		this.anchorNode = this.contextNode.ownerDocument.createComment(
-			`Begin repeat range: ${definition.nodeset}`
-		);
-		this.contextNode.append(this.anchorNode);
-
-		this.selfEvaluationContext = {
-			scope: this.scope,
-			evaluator: this.evaluator,
-			root: this.root,
-			contextReference: this.contextReference,
-			contextNode: this.anchorNode,
-
-			getSubscribableDependenciesByReference: (reference) => {
-				return repeatRange.getSubscribableDependenciesByReference(reference);
-			},
-		};
-
-		this.isEmptyRangeSelfRelevant = createComputedExpression(
-			this.selfEvaluationContext,
-			definition.bind.relevant
-		);
-
 		const sharedStateOptions = {
 			clientStateFactory: this.engineConfig.stateFactory,
 		};
@@ -252,16 +188,13 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatRangeDefinitio
 			state.currentState,
 			childrenState
 		);
+		this.submissionState = createNodeRangeSubmissionState(this);
 	}
 
 	protected getLastIndex(): number {
 		return this.engineState.children.length - 1;
 	}
 
-	protected override initializeContextNode(parentContextNode: Element): Element {
-		return parentContextNode;
-	}
-
 	getInstanceIndex(instance: RepeatInstance): number {
 		return this.engineState.children.indexOf(instance.nodeId);
 	}
@@ -289,9 +222,7 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatRangeDefinitio
 
 			return definitions.reduce<RepeatInstance[]>((acc, definition) => {
 				const precedingInstance = acc[acc.length - 1] ?? initialPrecedingInstance;
-				const precedingPrimaryInstanceNode = precedingInstance?.contextNode ?? this.anchorNode;
 				const newInstance = new RepeatInstance(repeatRange, definition, {
-					precedingPrimaryInstanceNode,
 					precedingInstance,
 				});
 
@@ -331,16 +262,6 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatRangeDefinitio
 		});
 	}
 
-	override subscribe(): void {
-		super.subscribe();
-
-		// Subscribing to children can support reactive expressions dependent on the
-		// repeat range itself (e.g. `count()`).
-		this.childrenState.getChildren().forEach((child) => {
-			child.subscribe();
-		});
-	}
-
 	getChildren(): readonly RepeatInstance[] {
 		return this.childrenState.getChildren();
 	}

package/src/instance/repeat/RepeatInstance.ts

@@ -1,12 +1,17 @@
+import { XPathNodeKindKey } from '@getodk/xpath';
 import type { Accessor } from 'solid-js';
 import { createComputed, createSignal, on } from 'solid-js';
+import type { FormNodeID } from '../../client/identity.ts';
 import type {
 	RepeatDefinition,
 	RepeatInstanceNode,
 	RepeatInstanceNodeAppearances,
 } from '../../client/repeat/RepeatInstanceNode.ts';
+import type { SubmissionState } from '../../client/submission/SubmissionState.ts';
 import type { TextRange } from '../../client/TextRange.ts';
 import type { AncestorNodeValidationState } from '../../client/validation.ts';
+import type { XFormsXPathElement } from '../../integration/xpath/adapter/XFormsXPathNode.ts';
+import { createParentNodeSubmissionState } from '../../lib/client-reactivity/submission/createParentNodeSubmissionState.ts';
 import type { ChildrenState } from '../../lib/reactivity/createChildrenState.ts';
 import { createChildrenState } from '../../lib/reactivity/createChildrenState.ts';
 import type { MaterializedChildren } from '../../lib/reactivity/materializeCurrentStateChildren.ts';
@@ -20,36 +25,40 @@ import { createAggregatedViolations } from '../../lib/reactivity/validation/crea
 import type { DescendantNodeSharedStateSpec } from '../abstract/DescendantNode.ts';
 import { DescendantNode } from '../abstract/DescendantNode.ts';
 import { buildChildren } from '../children.ts';
-import type { AnyChildNode, GeneralChildNode, RepeatRange } from '../hierarchy.ts';
-import type { NodeID } from '../identity.ts';
+import type { GeneralChildNode, RepeatRange } from '../hierarchy.ts';
 import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
-import type { SubscribableDependency } from '../internal-api/SubscribableDependency.ts';
+import type { ClientReactiveSubmittableParentNode } from '../internal-api/submission/ClientReactiveSubmittableParentNode.ts';
 
 export type { RepeatDefinition };
 
 interface RepeatInstanceStateSpec extends DescendantNodeSharedStateSpec {
 	readonly label: Accessor<TextRange<'label'> | null>;
 	readonly hint: null;
-	readonly children: Accessor<readonly NodeID[]>;
+	readonly children: Accessor<readonly FormNodeID[]>;
 	readonly valueOptions: null;
 	readonly value: null;
 }
 
 interface RepeatInstanceOptions {
-	readonly precedingPrimaryInstanceNode: Comment | Element;
 	readonly precedingInstance: RepeatInstance | null;
 }
 
 export class RepeatInstance
-	extends DescendantNode<RepeatDefinition, RepeatInstanceStateSpec, GeneralChildNode>
-	implements RepeatInstanceNode, EvaluationContext, SubscribableDependency
+	extends DescendantNode<RepeatDefinition, RepeatInstanceStateSpec, RepeatRange, GeneralChildNode>
+	implements
+		RepeatInstanceNode,
+		XFormsXPathElement,
+		EvaluationContext,
+		ClientReactiveSubmittableParentNode<GeneralChildNode>
 {
 	private readonly childrenState: ChildrenState<GeneralChildNode>;
 	private readonly currentIndex: Accessor<number>;
 
+	override readonly [XPathNodeKindKey] = 'element';
+
 	// InstanceNode
 	protected readonly state: SharedNodeState<RepeatInstanceStateSpec>;
-	protected override engineState: EngineState<RepeatInstanceStateSpec>;
+	protected readonly engineState: EngineState<RepeatInstanceStateSpec>;
 
 	/**
 	 * @todo Should we special case repeat `readonly` inheritance the same way
@@ -83,12 +92,14 @@ export class RepeatInstance
 	 * @see {@link RepeatRange.appearances}
 	 */
 	readonly appearances: RepeatInstanceNodeAppearances;
+	readonly nodeOptions = null;
 
 	readonly currentState: MaterializedChildren<
 		CurrentState<RepeatInstanceStateSpec>,
 		GeneralChildNode
 	>;
 	readonly validationState: AncestorNodeValidationState;
+	readonly submissionState: SubmissionState;
 
 	constructor(
 		override readonly parent: RepeatRange,
@@ -113,9 +124,6 @@ export class RepeatInstance
 		const childrenState = createChildrenState<RepeatInstance, GeneralChildNode>(this);
 
 		this.childrenState = childrenState;
-
-		options.precedingPrimaryInstanceNode.after(this.contextNode);
-
 		this.currentIndex = currentIndex;
 
 		const sharedStateOptions = {
@@ -166,48 +174,15 @@ export class RepeatInstance
 			// other reactive implementations of specific XForms semantics)?
 			const computeCurrentIndex = parent.getInstanceIndex.bind(parent, this);
 
-			createComputed(on(computeCurrentIndex, setCurrentIndex, { defer: true }));
+			createComputed(on<number, number>(computeCurrentIndex, setCurrentIndex, { defer: true }));
 		});
 
 		childrenState.setChildren(buildChildren(this));
 		this.validationState = createAggregatedViolations(this, sharedStateOptions);
-	}
-
-	protected override initializeContextNode(parentContextNode: Element, nodeName: string): Element {
-		return this.createContextNode(parentContextNode, nodeName);
-	}
-
-	override subscribe(): void {
-		super.subscribe();
-		this.currentIndex();
+		this.submissionState = createParentNodeSubmissionState(this);
 	}
 
 	getChildren(): readonly GeneralChildNode[] {
 		return this.childrenState.getChildren();
 	}
-
-	/**
-	 * Performs repeat instance node-specific removal logic, then general node
-	 * removal logic, in that order:
-	 *
-	 * 1. At present, before any reactive state change is performed, the repeat
-	 *    instance's {@link contextNode} is removed from the primary instance's
-	 *    XML DOM backing store (which also removes any descendant nodes from that
-	 *    store, as a side effect). This behavior may become unnecessary if/when
-	 *    we phase out use of this XML DOM backing store. This should be peformed
-	 *    first, so that any following reactive logic which evaluates affected
-	 *    XPath expressions will be performed against a state consistent with the
-	 *    repeat instance's removal (and that of its XML DOM descendants).
-	 *
-	 * 2. Performs any remaining removal logic as defined in
-	 *    {@link DescendantNode.remove}.
-	 *
-	 * These removal steps **must also** occur before any update to the parent
-	 * {@link RepeatRange}'s reactive children state.
-	 */
-	override remove(this: AnyChildNode): void {
-		this.contextNode.remove();
-
-		super.remove();
-	}
 }

package/src/instance/repeat/RepeatRangeControlled.ts

@@ -2,24 +2,22 @@ import { createComputed } from 'solid-js';
 import type { RepeatRangeNodeAppearances } from '../../client/repeat/BaseRepeatRangeNode.ts';
 import type { RepeatRangeControlledNode } from '../../client/repeat/RepeatRangeControlledNode.ts';
 import type { AncestorNodeValidationState } from '../../client/validation.ts';
+import type { XFormsXPathNodeRange } from '../../integration/xpath/adapter/XFormsXPathNode.ts';
 import { createComputedExpression } from '../../lib/reactivity/createComputedExpression.ts';
 import { createAggregatedViolations } from '../../lib/reactivity/validation/createAggregatedViolations.ts';
 import type { ControlledRepeatRangeDefinition } from '../../parse/model/RepeatRangeDefinition.ts';
 import type { GeneralParentNode } from '../hierarchy.ts';
 import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
-import type { SubscribableDependency } from '../internal-api/SubscribableDependency.ts';
 import { BaseRepeatRange } from './BaseRepeatRange.ts';
 import type { RepeatDefinition } from './RepeatInstance.ts';
 
 export class RepeatRangeControlled
 	extends BaseRepeatRange<ControlledRepeatRangeDefinition>
-	implements RepeatRangeControlledNode, EvaluationContext, SubscribableDependency
+	implements RepeatRangeControlledNode, XFormsXPathNodeRange, EvaluationContext
 {
 	// RepeatRangeControlledNode
 	readonly nodeType = 'repeat-range:controlled';
-
 	readonly appearances: RepeatRangeNodeAppearances;
-
 	readonly validationState: AncestorNodeValidationState;
 
 	constructor(parent: GeneralParentNode, definition: ControlledRepeatRangeDefinition) {
@@ -37,7 +35,9 @@ export class RepeatRangeControlled
 	private initializeControlledChildrenState(definition: ControlledRepeatRangeDefinition): void {
 		this.scope.runTask(() => {
 			const { count, instances, template } = definition;
-			const computeCount = createComputedExpression(this.selfEvaluationContext, count);
+			const computeCount = createComputedExpression(this, count, {
+				defaultValue: 0,
+			});
 
 			createComputed<number>((previousCount) => {
 				let currentCount = computeCount();

package/src/instance/repeat/RepeatRangeUncontrolled.ts

@@ -1,24 +1,22 @@
 import type { RepeatRangeNodeAppearances } from '../../client/repeat/BaseRepeatRangeNode.ts';
 import type { RepeatRangeUncontrolledNode } from '../../client/repeat/RepeatRangeUncontrolledNode.ts';
 import type { AncestorNodeValidationState } from '../../client/validation.ts';
+import type { XFormsXPathNodeRange } from '../../integration/xpath/adapter/XFormsXPathNode.ts';
 import { createAggregatedViolations } from '../../lib/reactivity/validation/createAggregatedViolations.ts';
 import type { UncontrolledRepeatRangeDefinition } from '../../parse/model/RepeatRangeDefinition.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 { Root } from '../Root.ts';
 import { BaseRepeatRange } from './BaseRepeatRange.ts';
 import { RepeatInstance } from './RepeatInstance.ts';
 
 export class RepeatRangeUncontrolled
 	extends BaseRepeatRange<UncontrolledRepeatRangeDefinition>
-	implements RepeatRangeUncontrolledNode, EvaluationContext, SubscribableDependency
+	implements RepeatRangeUncontrolledNode, XFormsXPathNodeRange, EvaluationContext
 {
 	// RepeatRangeUncontrolledNode
 	readonly nodeType = 'repeat-range:uncontrolled';
-
 	readonly appearances: RepeatRangeNodeAppearances;
-
 	readonly validationState: AncestorNodeValidationState;
 
 	constructor(parent: GeneralParentNode, definition: UncontrolledRepeatRangeDefinition) {

package/src/instance/resource.ts

@@ -1,7 +1,7 @@
 import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
 import { getBlobText } from '@getodk/common/lib/web-compat/blob.ts';
-import type { FetchResource, FetchResourceResponse } from '../client/EngineConfig.ts';
 import type { FormResource } from '../client/index.ts';
+import type { FetchResource, FetchResourceResponse } from '../client/resources.ts';
 
 export type { FetchResource, FetchResourceResponse, FormResource };
 
@@ -10,7 +10,10 @@ export interface ResourceOptions {
 }
 
 const fetchTextFromURL = async (resource: URL, options: ResourceOptions): Promise<string> => {
-	const response = await options.fetchResource(resource);
+	// destructuring prevents "Failed to execute 'fetch' on 'Window': Illegal invocation"
+	const { fetchResource } = options;
+
+	const response = await fetchResource(resource);
 
 	return response.text();
 };

package/src/instance/text/TextChunk.ts

@@ -9,7 +9,7 @@ export class TextChunk implements ClientTextChunk {
 	}
 
 	get language(): ActiveLanguage {
-		return this.context.activeLanguage;
+		return this.context.getActiveLanguage();
 	}
 
 	constructor(

package/src/instance/unsupported/UploadControl.ts

@@ -1,5 +1,9 @@
 import { UnsupportedControl } from '../abstract/UnsupportedControl.ts';
+import type { ValueContext } from '../internal-api/ValueContext.ts';
 
-export class UploadControl extends UnsupportedControl<'upload'> {
+export class UploadControl extends UnsupportedControl<'upload'> implements ValueContext<unknown> {
 	readonly nodeType = 'upload';
+
+	// ValueContext
+	readonly contextNode = this;
 }

package/src/integration/xpath/EngineXPathEvaluator.ts

@@ -0,0 +1,22 @@
+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 { engineDOMAdapter } from './adapter/engineDOMAdapter.ts';
+import type { EngineXPathNode } from './adapter/kind.ts';
+
+interface EngineXPathEvaluatorOptions {
+	readonly rootNode: PrimaryInstance;
+	readonly itextTranslationsByLanguage: XFormsItextTranslationMap<ItextTranslationRootDefinition>;
+	readonly secondaryInstancesById: XFormsSecondaryInstanceMap<SecondaryInstanceRootDefinition>;
+}
+
+export class EngineXPathEvaluator extends XFormsXPathEvaluator<EngineXPathNode> {
+	constructor(options: EngineXPathEvaluatorOptions) {
+		super({
+			domAdapter: engineDOMAdapter,
+			...options,
+		});
+	}
+}