@getodk/xforms-engine 0.5.0 → 0.7.0

package/src/instance/repeat/BaseRepeatRange.ts

@@ -4,9 +4,10 @@ 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 { AnyRepeatDefinition } from '../../client/index.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 { InstanceState } from '../../client/serialization/InstanceState.ts';
 import type { TextRange } from '../../client/TextRange.ts';
 import type { AncestorNodeValidationState } from '../../client/validation.ts';
 import type {
@@ -14,7 +15,8 @@ import type {
 	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 { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+import { createNodeRangeInstanceState } from '../../lib/client-reactivity/instance-state/createNodeRangeInstanceState.ts';
 import type { ChildrenState } from '../../lib/reactivity/createChildrenState.ts';
 import { createChildrenState } from '../../lib/reactivity/createChildrenState.ts';
 import type { MaterializedChildren } from '../../lib/reactivity/materializeCurrentStateChildren.ts';
@@ -24,10 +26,7 @@ import type { EngineState } from '../../lib/reactivity/node-state/createEngineSt
 import type { SharedNodeState } from '../../lib/reactivity/node-state/createSharedNodeState.ts';
 import { createSharedNodeState } from '../../lib/reactivity/node-state/createSharedNodeState.ts';
 import { createNodeLabel } from '../../lib/reactivity/text/createNodeLabel.ts';
-import type {
-	AnyRepeatRangeDefinition,
-	ControlledRepeatRangeDefinition,
-} from '../../parse/model/RepeatRangeDefinition.ts';
+import type { ControlledRepeatDefinition } from '../../parse/model/RepeatDefinition.ts';
 import type {
 	AnyDescendantNode,
 	DescendantNodeSharedStateSpec,
@@ -35,8 +34,8 @@ import type {
 import { DescendantNode } from '../abstract/DescendantNode.ts';
 import type { GeneralParentNode, RepeatRange } from '../hierarchy.ts';
 import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
-import type { ClientReactiveSubmittableParentNode } from '../internal-api/submission/ClientReactiveSubmittableParentNode.ts';
-import { RepeatInstance, type RepeatDefinition } from './RepeatInstance.ts';
+import type { ClientReactiveSerializableParentNode } from '../internal-api/serialization/ClientReactiveSerializableParentNode.ts';
+import { RepeatInstance } from './RepeatInstance.ts';
 
 interface RepeatRangeStateSpec extends DescendantNodeSharedStateSpec {
 	readonly hint: null;
@@ -47,18 +46,18 @@ interface RepeatRangeStateSpec extends DescendantNodeSharedStateSpec {
 }
 
 // prettier-ignore
-type BaseRepeatRangeNodeType<Definition extends AnyRepeatRangeDefinition> =
-	Definition extends ControlledRepeatRangeDefinition
+type BaseRepeatRangeNodeType<Definition extends AnyRepeatDefinition> =
+	Definition extends ControlledRepeatDefinition
 		? 'repeat-range:controlled'
 		: 'repeat-range:uncontrolled';
 
-export abstract class BaseRepeatRange<Definition extends AnyRepeatRangeDefinition>
+export abstract class BaseRepeatRange<Definition extends AnyRepeatDefinition>
 	extends DescendantNode<Definition, RepeatRangeStateSpec, GeneralParentNode, RepeatInstance>
 	implements
 		BaseRepeatRangeNode,
 		XFormsXPathNodeRange,
 		EvaluationContext,
-		ClientReactiveSubmittableParentNode<RepeatInstance>
+		ClientReactiveSerializableParentNode<RepeatInstance>
 {
 	protected readonly childrenState: ChildrenState<RepeatInstance>;
 
@@ -143,14 +142,16 @@ 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;
 
-	readonly submissionState: SubmissionState;
+	readonly instanceState: InstanceState;
 
 	constructor(parent: GeneralParentNode, definition: Definition) {
-		super(parent, definition);
+		super(parent, definition.template, definition);
 
 		const repeatRange = this as AnyDescendantNode as RepeatRange;
 
@@ -158,10 +159,6 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatRangeDefinitio
 
 		this.childrenState = childrenState;
 
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
-
 		const state = createSharedNodeState(
 			this.scope,
 			{
@@ -176,7 +173,7 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatRangeDefinitio
 				valueOptions: null,
 				value: null,
 			},
-			sharedStateOptions
+			this.instanceConfig
 		);
 
 		this.state = state;
@@ -186,7 +183,7 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatRangeDefinitio
 			state.currentState,
 			childrenState
 		);
-		this.submissionState = createNodeRangeSubmissionState(this);
+		this.instanceState = createNodeRangeInstanceState(this);
 	}
 
 	protected getLastIndex(): number {
@@ -199,7 +196,7 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatRangeDefinitio
 
 	private createChildren(
 		afterIndex: number,
-		definitions: readonly RepeatDefinition[]
+		instanceNodes: readonly StaticElement[]
 	): readonly RepeatInstance[] {
 		return this.scope.runTask(() => {
 			let initialPrecedingInstance: RepeatInstance | null;
@@ -218,7 +215,7 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatRangeDefinitio
 
 			const repeatRange = this as AnyDescendantNode as RepeatRange;
 
-			return definitions.reduce<RepeatInstance[]>((acc, definition) => {
+			return instanceNodes.reduce<RepeatInstance[]>((acc, definition) => {
 				const precedingInstance = acc[acc.length - 1] ?? initialPrecedingInstance;
 				const newInstance = new RepeatInstance(repeatRange, definition, {
 					precedingInstance,
@@ -233,11 +230,11 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatRangeDefinitio
 
 	protected addChildren(
 		afterIndex: number,
-		definitions: readonly RepeatDefinition[]
+		instanceNodes: readonly StaticElement[]
 	): readonly RepeatInstance[] {
 		return this.scope.runTask(() => {
 			const initialIndex = afterIndex + 1;
-			const newInstances = this.createChildren(afterIndex, definitions);
+			const newInstances = this.createChildren(afterIndex, instanceNodes);
 
 			return this.childrenState.setChildren((currentInstances) => {
 				return insertAtIndex(currentInstances, initialIndex, newInstances);

package/src/instance/repeat/RepeatInstance.ts

@@ -3,15 +3,17 @@ import type { Accessor } from 'solid-js';
 import { createComputed, createSignal, on } from 'solid-js';
 import type { FormNodeID } from '../../client/identity.ts';
 import type {
-	RepeatDefinition,
+	AnyRepeatDefinition,
 	RepeatInstanceNode,
 	RepeatInstanceNodeAppearances,
 } from '../../client/repeat/RepeatInstanceNode.ts';
-import type { SubmissionState } from '../../client/submission/SubmissionState.ts';
+import type { InstanceState } from '../../client/serialization/InstanceState.ts';
 import type { TextRange } from '../../client/TextRange.ts';
 import type { AncestorNodeValidationState } from '../../client/validation.ts';
+import type { TemplatedNodeAttributeSerializationError } from '../../error/TemplatedNodeAttributeSerializationError.ts';
 import type { XFormsXPathElement } from '../../integration/xpath/adapter/XFormsXPathNode.ts';
-import { createParentNodeSubmissionState } from '../../lib/client-reactivity/submission/createParentNodeSubmissionState.ts';
+import type { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+import { createTemplatedNodeInstanceState } from '../../lib/client-reactivity/instance-state/createTemplatedNodeInstanceState.ts';
 import type { ChildrenState } from '../../lib/reactivity/createChildrenState.ts';
 import { createChildrenState } from '../../lib/reactivity/createChildrenState.ts';
 import type { MaterializedChildren } from '../../lib/reactivity/materializeCurrentStateChildren.ts';
@@ -24,16 +26,18 @@ import { createNodeLabel } from '../../lib/reactivity/text/createNodeLabel.ts';
 import { createAggregatedViolations } from '../../lib/reactivity/validation/createAggregatedViolations.ts';
 import type { DescendantNodeSharedStateSpec } from '../abstract/DescendantNode.ts';
 import { DescendantNode } from '../abstract/DescendantNode.ts';
-import { buildChildren } from '../children.ts';
+import { buildChildren } from '../children/buildChildren.ts';
 import type { GeneralChildNode, RepeatRange } from '../hierarchy.ts';
 import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
-import type { ClientReactiveSubmittableParentNode } from '../internal-api/submission/ClientReactiveSubmittableParentNode.ts';
-
-export type { RepeatDefinition };
+import type { ClientReactiveSerializableTemplatedNode } from '../internal-api/serialization/ClientReactiveSerializableTemplatedNode.ts';
 
 interface RepeatInstanceStateSpec extends DescendantNodeSharedStateSpec {
 	readonly label: Accessor<TextRange<'label'> | null>;
 	readonly hint: null;
+
+	/** @see {@link TemplatedNodeAttributeSerializationError} */
+	readonly attributes: null;
+
 	readonly children: Accessor<readonly FormNodeID[]>;
 	readonly valueOptions: null;
 	readonly value: null;
@@ -44,12 +48,17 @@ interface RepeatInstanceOptions {
 }
 
 export class RepeatInstance
-	extends DescendantNode<RepeatDefinition, RepeatInstanceStateSpec, RepeatRange, GeneralChildNode>
+	extends DescendantNode<
+		AnyRepeatDefinition,
+		RepeatInstanceStateSpec,
+		RepeatRange,
+		GeneralChildNode
+	>
 	implements
 		RepeatInstanceNode,
 		XFormsXPathElement,
 		EvaluationContext,
-		ClientReactiveSubmittableParentNode<GeneralChildNode>
+		ClientReactiveSerializableTemplatedNode
 {
 	private readonly childrenState: ChildrenState<GeneralChildNode>;
 	private readonly currentIndex: Accessor<number>;
@@ -92,25 +101,27 @@ 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;
+	readonly instanceState: InstanceState;
 
 	constructor(
 		override readonly parent: RepeatRange,
-		definition: RepeatDefinition,
+		instanceNode: StaticElement | null,
 		options: RepeatInstanceOptions
 	) {
+		const { definition } = parent;
 		const { precedingInstance } = options;
 		const precedingIndex = precedingInstance?.currentIndex ?? (() => -1);
 		const initialIndex = precedingIndex() + 1;
 		const [currentIndex, setCurrentIndex] = createSignal(initialIndex);
 
-		super(parent, definition, {
+		super(parent, instanceNode, definition, {
 			computeReference: (): string => {
 				const currentPosition = currentIndex() + 1;
 
@@ -125,10 +136,6 @@ export class RepeatInstance
 		this.childrenState = childrenState;
 		this.currentIndex = currentIndex;
 
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
-
 		const state = createSharedNodeState(
 			this.scope,
 			{
@@ -140,11 +147,12 @@ export class RepeatInstance
 				// TODO: only-child <group><label>
 				label: createNodeLabel(this, definition),
 				hint: null,
+				attributes: null,
 				children: childrenState.childIds,
 				valueOptions: null,
 				value: null,
 			},
-			sharedStateOptions
+			this.instanceConfig
 		);
 
 		this.state = state;
@@ -177,8 +185,8 @@ export class RepeatInstance
 		});
 
 		childrenState.setChildren(buildChildren(this));
-		this.validationState = createAggregatedViolations(this, sharedStateOptions);
-		this.submissionState = createParentNodeSubmissionState(this);
+		this.validationState = createAggregatedViolations(this, this.instanceConfig);
+		this.instanceState = createTemplatedNodeInstanceState(this);
 	}
 
 	getChildren(): readonly GeneralChildNode[] {

package/src/instance/repeat/RepeatRangeControlled.ts

@@ -1,45 +1,69 @@
 import { createComputed } from 'solid-js';
+import type { LoadFormWarnings } from '../../client/form/LoadFormResult.ts';
 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 type { StaticElement } from '../../integration/xpath/static-dom/StaticElement.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 { ControlledRepeatDefinition } from '../../parse/model/RepeatDefinition.ts';
 import type { GeneralParentNode } from '../hierarchy.ts';
 import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
 import { BaseRepeatRange } from './BaseRepeatRange.ts';
-import type { RepeatDefinition } from './RepeatInstance.ts';
+
+// prettier-ignore
+type RepeatCountControlType =
+	| 'REPEAT_COUNT_CONTROL_DYNAMIC'
+	| 'REPEAT_COUNT_CONTROL_FIXED';
 
 export class RepeatRangeControlled
-	extends BaseRepeatRange<ControlledRepeatRangeDefinition>
+	extends BaseRepeatRange<ControlledRepeatDefinition>
 	implements RepeatRangeControlledNode, XFormsXPathNodeRange, EvaluationContext
 {
+	private readonly isInstanceCreation: boolean;
+	private readonly countControlType: RepeatCountControlType;
+
 	// RepeatRangeControlledNode
 	readonly nodeType = 'repeat-range:controlled';
 	readonly appearances: RepeatRangeNodeAppearances;
 	readonly validationState: AncestorNodeValidationState;
 
-	constructor(parent: GeneralParentNode, definition: ControlledRepeatRangeDefinition) {
+	constructor(
+		parent: GeneralParentNode,
+		instanceNodes: readonly StaticElement[],
+		definition: ControlledRepeatDefinition
+	) {
 		super(parent, definition);
 
+		this.isInstanceCreation = parent.rootDocument.initializationMode === 'create';
 		this.appearances = definition.bodyElement.appearances;
 
-		this.initializeControlledChildrenState(definition);
+		if (definition.count.isConstantExpression()) {
+			this.countControlType = 'REPEAT_COUNT_CONTROL_FIXED';
+		} else {
+			this.countControlType = 'REPEAT_COUNT_CONTROL_DYNAMIC';
+		}
 
-		this.validationState = createAggregatedViolations(this, {
-			clientStateFactory: this.engineConfig.stateFactory,
-		});
+		this.initializeControlledChildrenState(definition, instanceNodes);
+
+		this.validationState = createAggregatedViolations(this, this.instanceConfig);
 	}
 
-	private initializeControlledChildrenState(definition: ControlledRepeatRangeDefinition): void {
+	private initializeControlledChildrenState(
+		definition: ControlledRepeatDefinition,
+		instanceNodes: readonly StaticElement[]
+	): void {
 		this.scope.runTask(() => {
-			const { count, instances, template } = definition;
+			const { count, template } = definition;
+			const repeatInstanceNodes = definition.omitTemplate(instanceNodes);
 			const computeCount = createComputedExpression(this, count, {
 				defaultValue: 0,
 			});
 
-			createComputed<number>((previousCount) => {
+			createComputed((previousCountComputation: number | null = null): number => {
+				const previousCount = previousCountComputation ?? 0;
+
 				let currentCount = computeCount();
 
 				if (Number.isFinite(currentCount) && currentCount < 0) {
@@ -58,17 +82,19 @@ export class RepeatRangeControlled
 					return previousCount;
 				}
 
+				this.warnDroppedInstanceNodes(repeatInstanceNodes, previousCountComputation, currentCount);
+
 				if (currentCount > previousCount) {
 					const delta = currentCount - previousCount;
-					const definitions = Array<RepeatDefinition>(delta)
-						.fill(template)
-						.map((baseDefinition, index) => {
+					const inputNodes = Array(delta)
+						.fill(null)
+						.map((_, index) => {
 							const instanceIndex = previousCount + index;
 
-							return instances[instanceIndex] ?? baseDefinition;
+							return repeatInstanceNodes[instanceIndex] ?? template;
 						});
 
-					this.addChildren(previousCount - 1, definitions);
+					this.addChildren(previousCount - 1, inputNodes);
 				} else {
 					const delta = previousCount - currentCount;
 
@@ -76,7 +102,54 @@ export class RepeatRangeControlled
 				}
 
 				return currentCount;
-			}, 0);
+			});
 		});
 	}
+
+	/**
+	 * Note: we do not warn about dropping "excess" repeat instances...
+	 *
+	 * - ... after the instance is fully loaded: dropping repeat instances after
+	 *   that point is an expected behavior of _dynamically-controlled repeats_
+	 *   (i.e. those defined with `jr:count`), and it does not occur for
+	 *   _fixed-controlled repeats_ (i.e. defined with `jr:noAddRemove`);
+	 *
+	 * - ... for dynamic (`jr:count`) repeats _in newly created form instances_, i.e. instances whose input instance
+	 *   nodes are derived from the _form definition_: those form-defined repeat
+	 *   instances are not "dropped", instead they're retained in memory to be
+	 *   added as count is recomputed to a larger value.
+	 *
+	 * @todo ^ it is pretty likely that retain-in-memory behavior also applies to
+	 * instance state which has been serialized and restored as well! In this way,
+	 * it's possible we're not really "dropping" those nodes, only deferring their
+	 * restoration. Is this what we want?
+	 *
+	 * @todo Design and produce {@link LoadFormWarnings | warnings} as values!
+	 */
+	private warnDroppedInstanceNodes(
+		repeatInstanceNodes: readonly StaticElement[],
+		previousCountComputation: number | null,
+		initialCount: number
+	): void {
+		// See this method's JSDoc notes for reasoning!
+		if (this.isInstanceCreation) {
+			return;
+		}
+
+		// See this method's JSDoc notes for reasoning!
+		const isInstanceLoad = previousCountComputation == null;
+
+		if (isInstanceLoad && this.countControlType === 'REPEAT_COUNT_CONTROL_DYNAMIC') {
+			return;
+		}
+
+		const droppedCount = repeatInstanceNodes.length - initialCount;
+
+		if (droppedCount > 0) {
+			// eslint-disable-next-line no-console
+			console.warn(
+				`Dropped ${droppedCount} repeat instances for repeat range ${this.contextReference()}`
+			);
+		}
+	}
 }

package/src/instance/repeat/RepeatRangeUncontrolled.ts

@@ -2,8 +2,9 @@ import type { RepeatRangeNodeAppearances } from '../../client/repeat/BaseRepeatR
 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 type { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import { createAggregatedViolations } from '../../lib/reactivity/validation/createAggregatedViolations.ts';
-import type { UncontrolledRepeatRangeDefinition } from '../../parse/model/RepeatRangeDefinition.ts';
+import type { UncontrolledRepeatDefinition } from '../../parse/model/RepeatDefinition.ts';
 import type { GeneralParentNode } from '../hierarchy.ts';
 import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
 import type { Root } from '../Root.ts';
@@ -11,7 +12,7 @@ import { BaseRepeatRange } from './BaseRepeatRange.ts';
 import { RepeatInstance } from './RepeatInstance.ts';
 
 export class RepeatRangeUncontrolled
-	extends BaseRepeatRange<UncontrolledRepeatRangeDefinition>
+	extends BaseRepeatRange<UncontrolledRepeatDefinition>
 	implements RepeatRangeUncontrolledNode, XFormsXPathNodeRange, EvaluationContext
 {
 	// RepeatRangeUncontrolledNode
@@ -19,16 +20,16 @@ export class RepeatRangeUncontrolled
 	readonly appearances: RepeatRangeNodeAppearances;
 	readonly validationState: AncestorNodeValidationState;
 
-	constructor(parent: GeneralParentNode, definition: UncontrolledRepeatRangeDefinition) {
+	constructor(
+		parent: GeneralParentNode,
+		instanceNodes: readonly StaticElement[],
+		definition: UncontrolledRepeatDefinition
+	) {
 		super(parent, definition);
 
 		this.appearances = definition.bodyElement.appearances;
-
-		this.addChildren(-1, definition.instances);
-
-		this.validationState = createAggregatedViolations(this, {
-			clientStateFactory: this.engineConfig.stateFactory,
-		});
+		this.addChildren(-1, definition.omitTemplate(instanceNodes));
+		this.validationState = createAggregatedViolations(this, this.instanceConfig);
 	}
 
 	// RepeatRangeUncontrolledNode

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 };
@@ -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();
 };
@@ -73,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/instance/unsupported/UploadControl.ts

@@ -1,9 +1,120 @@
-import { UnsupportedControl } from '../abstract/UnsupportedControl.ts';
-import type { ValueContext } from '../internal-api/ValueContext.ts';
+import { XPathNodeKindKey } from '@getodk/xpath';
+import type { Accessor } from 'solid-js';
+import type { TextRange } from '../../client/TextRange.ts';
+import type { ValueType } from '../../client/ValueType.ts';
+import type { UnsupportedControlNodeType } from '../../client/node-types.ts';
+import type { UploadNode, UploadNodeDefinition } from '../../client/unsupported/UploadNode.ts';
+import type { XFormsXPathElement } from '../../integration/xpath/adapter/XFormsXPathNode.ts';
+import type { StaticLeafElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+import type {
+	TempUnsupportedInputValue,
+	TempUnsupportedRuntimeValue,
+} from '../../lib/codecs/TempUnsupportedControlCodec.ts';
+import { TempUnsupportedControlCodec } from '../../lib/codecs/TempUnsupportedControlCodec.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 { UnknownAppearanceDefinition } from '../../parse/body/appearance/unknownAppearanceParser.ts';
+import { ValueNode, type ValueNodeStateSpec } from '../abstract/ValueNode.ts';
+import type { GeneralParentNode } from '../hierarchy.ts';
+import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
+import type { ValidationContext } from '../internal-api/ValidationContext.ts';
+import type { ClientReactiveSerializableValueNode } from '../internal-api/serialization/ClientReactiveSerializableValueNode.ts';
 
-export class UploadControl extends UnsupportedControl<'upload'> implements ValueContext<unknown> {
+interface UploadControlStateSpec extends ValueNodeStateSpec<TempUnsupportedRuntimeValue> {
+	readonly label: Accessor<TextRange<'label'> | null>;
+	readonly hint: Accessor<TextRange<'hint'> | null>;
+	readonly valueOptions: null;
+}
+
+const codecs = {
+	string: new TempUnsupportedControlCodec('string'),
+	int: new TempUnsupportedControlCodec('int'),
+	decimal: new TempUnsupportedControlCodec('decimal'),
+	boolean: new TempUnsupportedControlCodec('boolean'),
+	date: new TempUnsupportedControlCodec('date'),
+	time: new TempUnsupportedControlCodec('time'),
+	dateTime: new TempUnsupportedControlCodec('dateTime'),
+	geopoint: new TempUnsupportedControlCodec('geopoint'),
+	geotrace: new TempUnsupportedControlCodec('geotrace'),
+	geoshape: new TempUnsupportedControlCodec('geoshape'),
+	binary: new TempUnsupportedControlCodec('binary'),
+	barcode: new TempUnsupportedControlCodec('barcode'),
+	intent: new TempUnsupportedControlCodec('intent'),
+} as const;
+
+class UnsupportedControlWriteError extends Error {
+	constructor(type: UnsupportedControlNodeType) {
+		super(`Cannot write state for node (type: ${type}) - not implemented`);
+	}
+}
+
+export class UploadControl
+	extends ValueNode<
+		ValueType,
+		UploadNodeDefinition,
+		TempUnsupportedRuntimeValue,
+		TempUnsupportedInputValue
+	>
+	implements
+		UploadNode,
+		XFormsXPathElement,
+		EvaluationContext,
+		ValidationContext,
+		ClientReactiveSerializableValueNode
+{
+	// XFormsXPathElement
+	override readonly [XPathNodeKindKey] = 'element';
+
+	// InstanceNode
+	protected readonly state: SharedNodeState<UploadControlStateSpec>;
+	protected readonly engineState: EngineState<UploadControlStateSpec>;
+
+	// UploadNode
 	readonly nodeType = 'upload';
+	readonly appearances: UnknownAppearanceDefinition;
+	readonly nodeOptions = null;
+	readonly currentState: CurrentState<UploadControlStateSpec>;
+
+	constructor(
+		parent: GeneralParentNode,
+		instanceNode: StaticLeafElement | null,
+		definition: UploadNodeDefinition
+	) {
+		const codec = codecs[definition.valueType];
+
+		super(parent, instanceNode, definition, codec);
+
+		this.appearances = definition.bodyElement.appearances;
+
+		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: this.valueState,
+				instanceValue: this.getInstanceValue,
+			},
+			this.instanceConfig
+		);
+
+		this.state = state;
+		this.engineState = state.engineState;
+		this.currentState = state.currentState;
+	}
 
-	// ValueContext
-	readonly contextNode = this;
+	// UnsupportedControlNode
+	setValue(_: never): never {
+		throw new UnsupportedControlWriteError(this.nodeType);
+	}
 }

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';