@getodk/xforms-engine 0.4.0 → 0.6.0

package/src/instance/SelectControl.ts

@@ -0,0 +1,219 @@
+import { XPathNodeKindKey } from '@getodk/xpath';
+import type { Accessor } from 'solid-js';
+import { createMemo } from 'solid-js';
+import type {
+	SelectDefinition,
+	SelectItem,
+	SelectNode,
+	SelectNodeAppearances,
+	SelectValueOptions,
+} from '../client/SelectNode.ts';
+import type { TextRange } from '../client/TextRange.ts';
+import type { ValueType } from '../client/ValueType.ts';
+import { SelectValueTypeError } from '../error/SelectValueTypeError.ts';
+import type { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
+import { getSelectCodec } from '../lib/codecs/getSelectCodec.ts';
+import { createItemCollection } from '../lib/reactivity/createItemCollection.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 { SelectType } from '../parse/body/control/SelectControlDefinition.ts';
+import type { Root } from './Root.ts';
+import type { ValueNodeStateSpec } from './abstract/ValueNode.ts';
+import { ValueNode } 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 { ClientReactiveSubmittableValueNode } from './internal-api/submission/ClientReactiveSubmittableValueNode.ts';
+
+export type AnySelectDefinition = {
+	[V in ValueType]: SelectDefinition<V>;
+}[ValueType];
+
+type AssertSupportedSelectValueType = (
+	definition: AnySelectDefinition
+) => asserts definition is SelectDefinition<'string'>;
+
+const assertSupportedSelectValueType: AssertSupportedSelectValueType = (definition) => {
+	if (definition.valueType !== 'string') {
+		throw new SelectValueTypeError(definition);
+	}
+};
+
+type SelectItemMap = ReadonlyMap<string, SelectItem>;
+
+interface SelectControlStateSpec extends ValueNodeStateSpec<readonly string[]> {
+	readonly label: Accessor<TextRange<'label'> | null>;
+	readonly hint: Accessor<TextRange<'hint'> | null>;
+	readonly valueOptions: Accessor<SelectValueOptions>;
+}
+
+export class SelectControl
+	extends ValueNode<'string', SelectDefinition<'string'>, readonly string[], readonly string[]>
+	implements
+		SelectNode,
+		XFormsXPathElement,
+		EvaluationContext,
+		ValidationContext,
+		ClientReactiveSubmittableValueNode
+{
+	static from(parent: GeneralParentNode, definition: SelectDefinition): SelectControl;
+	static from(parent: GeneralParentNode, definition: AnySelectDefinition): SelectControl {
+		assertSupportedSelectValueType(definition);
+
+		return new this(parent, definition);
+	}
+
+	private readonly mapOptionsByValue: Accessor<SelectItemMap>;
+
+	protected override readonly getInstanceValue: Accessor<string>;
+
+	// XFormsXPathElement
+	override readonly [XPathNodeKindKey] = 'element';
+
+	// InstanceNode
+	protected readonly state: SharedNodeState<SelectControlStateSpec>;
+	protected readonly engineState: EngineState<SelectControlStateSpec>;
+
+	// SelectNode
+	readonly nodeType = 'select';
+	readonly selectType: SelectType;
+	readonly appearances: SelectNodeAppearances;
+	readonly nodeOptions = null;
+	readonly currentState: CurrentState<SelectControlStateSpec>;
+
+	private constructor(parent: GeneralParentNode, definition: SelectDefinition<'string'>) {
+		const codec = getSelectCodec(definition);
+
+		super(parent, definition, codec);
+
+		this.appearances = definition.bodyElement.appearances;
+		this.selectType = definition.bodyElement.type;
+
+		const valueOptions = createItemCollection(this);
+
+		const mapOptionsByValue: Accessor<SelectItemMap> = this.scope.runTask(() => {
+			return createMemo(() => {
+				return new Map(valueOptions().map((item) => [item.value, item]));
+			});
+		});
+
+		this.mapOptionsByValue = mapOptionsByValue;
+
+		const baseValueState = this.valueState;
+		const [baseGetValue, setValue] = baseValueState;
+		const getValue = this.scope.runTask(() => {
+			return createMemo(() => {
+				const optionsByValue = mapOptionsByValue();
+
+				return baseGetValue().filter((value) => {
+					return optionsByValue.has(value);
+				});
+			});
+		});
+		const valueState: SimpleAtomicState<readonly string[]> = [getValue, setValue];
+
+		this.getInstanceValue = this.scope.runTask(() => {
+			return createMemo(() => {
+				return codec.encodeValue(getValue());
+			});
+		});
+
+		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,
+				value: valueState,
+				instanceValue: this.getInstanceValue,
+			},
+			sharedStateOptions
+		);
+
+		this.state = state;
+		this.engineState = state.engineState;
+		this.currentState = state.currentState;
+	}
+
+	/**
+	 * Filters {@link values} to include only those values which are currently
+	 * available in the mapping produced by {@link mapOptionsByValue}, i.e. within
+	 * a potentially filtered itemset.
+	 *
+	 * Note: this method effectively produces an intersection of
+	 * {@link sourceValues} and {@link values}. **Importantly**, ordering of the
+	 * results is deterministic, preserving the order of values as yielded _by
+	 * {@link sourceValues}_.
+	 *
+	 * At time of writing, there are several tests (in `@getodk/scenario`, ported
+	 * from JavaRosa) which expect the values of a `<select>` to match the order
+	 * they appear in the control's (potentially filtered) `<itemset>` (or list of
+	 * `<item>`s, for forms defining those inline).
+	 *
+	 * @todo The `<odk:rank>` control, having semantics very similar to
+	 * `<select>`, will likely perform similar filtering logic. However, one of
+	 * the important distinctions between these controls is that `<odk:rank>`
+	 * exists explicitly to control the order of values. It's quite likely that
+	 * would be achieved by invoking the same logic with the parameter order
+	 * reversed.
+	 */
+	private filterValues(
+		sourceValues: Iterable<string>,
+		values: Iterable<string>
+	): readonly string[] {
+		const selectedValues = new Set(values);
+
+		return Array.from(sourceValues).filter((sourceValue) => {
+			return selectedValues.has(sourceValue);
+		});
+	}
+
+	// SelectNode
+	getValueOption(value: string): SelectItem | null {
+		// Note: this method is a client-facing convenience API for reading state,
+		// so it **MUST** read from client-reactive state!
+		const valueOption = this.currentState.valueOptions.find((item) => {
+			return item.value === value;
+		});
+
+		return valueOption ?? null;
+	}
+
+	isSelected(value: string): boolean {
+		// Note: this method is a client-facing convenience API for reading state,
+		// so it **MUST** read from client-reactive state!
+		return this.currentState.value.includes(value);
+	}
+
+	selectValue(value: string | null): Root {
+		if (value == null) {
+			return this.selectValues([]);
+		}
+
+		return this.selectValues([value]);
+	}
+
+	selectValues(values: readonly string[]): Root {
+		const sourceValues = this.mapOptionsByValue().keys();
+		const effectiveValues = this.filterValues(sourceValues, values);
+
+		this.setValueState(effectiveValues);
+
+		return this.root;
+	}
+}

package/src/instance/Subtree.ts

@@ -1,6 +1,11 @@
-import { type Accessor } from 'solid-js';
+import { XPathNodeKindKey } from '@getodk/xpath';
+import type { Accessor } from 'solid-js';
+import type { FormNodeID } from '../client/identity.ts';
+import type { SubmissionState } from '../client/submission/SubmissionState.ts';
 import type { SubtreeDefinition, SubtreeNode } from '../client/SubtreeNode.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';
@@ -14,33 +19,40 @@ import type { DescendantNodeSharedStateSpec } from './abstract/DescendantNode.ts
 import { DescendantNode } from './abstract/DescendantNode.ts';
 import { buildChildren } from './children.ts';
 import type { GeneralChildNode, GeneralParentNode } from './hierarchy.ts';
-import type { NodeID } from './identity.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';
 
 interface SubtreeStateSpec extends DescendantNodeSharedStateSpec {
 	readonly label: null;
 	readonly hint: null;
-	readonly children: Accessor<readonly NodeID[]>;
+	readonly children: Accessor<readonly FormNodeID[]>;
 	readonly valueOptions: null;
 	readonly value: null;
 }
 
 export class Subtree
-	extends DescendantNode<SubtreeDefinition, SubtreeStateSpec, GeneralChildNode>
-	implements SubtreeNode, EvaluationContext, SubscribableDependency
+	extends DescendantNode<SubtreeDefinition, SubtreeStateSpec, GeneralParentNode, GeneralChildNode>
+	implements
+		SubtreeNode,
+		XFormsXPathElement,
+		EvaluationContext,
+		ClientReactiveSubmittableParentNode<GeneralChildNode>
 {
 	private readonly childrenState: ChildrenState<GeneralChildNode>;
 
+	override readonly [XPathNodeKindKey] = 'element';
+
 	// InstanceNode
 	protected readonly state: SharedNodeState<SubtreeStateSpec>;
-	protected engineState: EngineState<SubtreeStateSpec>;
+	protected readonly engineState: EngineState<SubtreeStateSpec>;
 
 	// SubtreeNode
 	readonly nodeType = 'subtree';
 	readonly appearances = null;
+	readonly nodeOptions = null;
 	readonly currentState: MaterializedChildren<CurrentState<SubtreeStateSpec>, GeneralChildNode>;
 	readonly validationState: AncestorNodeValidationState;
+	readonly submissionState: SubmissionState;
 
 	constructor(parent: GeneralParentNode, definition: SubtreeDefinition) {
 		super(parent, definition);
@@ -80,6 +92,7 @@ export class Subtree
 
 		childrenState.setChildren(buildChildren(this));
 		this.validationState = createAggregatedViolations(this, sharedStateOptions);
+		this.submissionState = createParentNodeSubmissionState(this);
 	}
 
 	getChildren(): readonly GeneralChildNode[] {

package/src/instance/TriggerControl.ts

@@ -1,88 +1,80 @@
+import { XPathNodeKindKey } from '@getodk/xpath';
 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 { ValueType } from '../client/ValueType.ts';
+import { ErrorProductionDesignPendingError } from '../error/ErrorProductionDesignPendingError.ts';
+import type { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
+import type { TriggerInputValue, TriggerRuntimeValue } from '../lib/codecs/TriggerCodec.ts';
+import { TriggerCodec } from '../lib/codecs/TriggerCodec.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 { ValueNode, type ValueNodeStateSpec } from './abstract/ValueNode.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 type { ClientReactiveSubmittableValueNode } from './internal-api/submission/ClientReactiveSubmittableValueNode.ts';
 
-interface TriggerControlStateSpec extends DescendantNodeStateSpec<boolean> {
+interface TriggerControlStateSpec extends ValueNodeStateSpec<TriggerRuntimeValue> {
 	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';
+type AnyTriggerNodeDefinition = {
+	[V in ValueType]: TriggerNodeDefinition<V>;
+}[ValueType];
+
+const codec = new TriggerCodec();
 
 export class TriggerControl
-	extends DescendantNode<TriggerNodeDefinition, TriggerControlStateSpec, null>
+	extends ValueNode<
+		'string',
+		TriggerNodeDefinition<'string'>,
+		TriggerRuntimeValue,
+		TriggerInputValue
+	>
 	implements
 		TriggerNode,
+		XFormsXPathElement,
 		EvaluationContext,
-		SubscribableDependency,
 		ValidationContext,
-		ValueContext<boolean>
+		ClientReactiveSubmittableValueNode
 {
-	private readonly validation: SharedValidationState;
-	protected readonly state: SharedNodeState<TriggerControlStateSpec>;
+	static from(parent: GeneralParentNode, definition: TriggerNodeDefinition): TriggerControl;
+	static from(parent: GeneralParentNode, definition: AnyTriggerNodeDefinition): TriggerControl {
+		if (definition.valueType !== 'string') {
+			throw new ErrorProductionDesignPendingError(
+				`Unsupported trigger value type: ${definition.valueType}`
+			);
+		}
+
+		return new this(parent, definition);
+	}
+
+	// XFormsXPathElement
+	override readonly [XPathNodeKindKey] = 'element';
 
 	// InstanceNode
-	protected engineState: EngineState<TriggerControlStateSpec>;
+	protected readonly state: SharedNodeState<TriggerControlStateSpec>;
+	protected readonly engineState: EngineState<TriggerControlStateSpec>;
 
 	// TriggerNode
 	readonly nodeType = 'trigger';
 	readonly appearances: UnknownAppearanceDefinition;
+	readonly nodeOptions = null;
 	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);
+	private constructor(parent: GeneralParentNode, definition: TriggerNodeDefinition<'string'>) {
+		super(parent, definition, codec);
 
 		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,
@@ -100,7 +92,8 @@ export class TriggerControl
 				hint: createFieldHint(this, definition),
 				children: null,
 				valueOptions: null,
-				value: createValueState(this),
+				value: this.valueState,
+				instanceValue: this.getInstanceValue,
 			},
 			sharedStateOptions
 		);
@@ -108,26 +101,11 @@ export class TriggerControl
 		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);
+	setValue(value: TriggerInputValue): Root {
+		this.setValueState(value);
 
 		return this.root;
 	}

package/src/instance/abstract/DescendantNode.ts

@@ -1,15 +1,21 @@
-import type { XFormsXPathEvaluator } from '@getodk/xpath';
+import { XPathNodeKindKey } from '@getodk/xpath';
 import type { Accessor } from 'solid-js';
+import { createMemo } from 'solid-js';
 import type { BaseNode } from '../../client/BaseNode.ts';
+import type { ActiveLanguage } from '../../client/FormLanguage.ts';
+import type { InstanceNodeType } from '../../client/node-types.ts';
+import type { PrimaryInstanceXPathChildNode } from '../../integration/xpath/adapter/kind.ts';
+import type {
+	XFormsXPathPrimaryInstanceDescendantNode,
+	XFormsXPathPrimaryInstanceDescendantNodeKind,
+} from '../../integration/xpath/adapter/XFormsXPathNode.ts';
+import { XFORMS_XPATH_NODE_RANGE_KIND } from '../../integration/xpath/adapter/XFormsXPathNode.ts';
+import type { EngineXPathEvaluator } from '../../integration/xpath/EngineXPathEvaluator.ts';
 import { createComputedExpression } from '../../lib/reactivity/createComputedExpression.ts';
 import type { ReactiveScope } from '../../lib/reactivity/scope.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 { AnyChildNode, AnyParentNode, 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';
@@ -28,25 +34,15 @@ export type DescendantNodeStateSpec<Value = never> =
 	& InstanceNodeStateSpec<Value>
 	& DescendantNodeSharedStateSpec;
 
-// prettier-ignore
-export type DescendantNodeDefinition = Extract<
-	AnyNodeDefinition,
-	AnyDescendantNodeDefinition
->;
-
-// prettier-ignore
-export type DescendantNodeParent<Definition extends DescendantNodeDefinition> =
-	Definition extends LeafNodeDefinition
-		? GeneralParentNode
-	: Definition extends RepeatInstanceDefinition
-		? RepeatRange
-		: GeneralParentNode;
+export type DescendantNodeDefinition = AnyNodeDefinition;
 
 export type AnyDescendantNode = DescendantNode<
 	DescendantNodeDefinition,
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	DescendantNodeStateSpec<any>,
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	any,
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	any
 >;
 
@@ -58,11 +54,18 @@ export abstract class DescendantNode<
 		Definition extends DescendantNodeDefinition,
 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
 		Spec extends DescendantNodeStateSpec<any>,
+		Parent extends AnyParentNode,
 		Child extends AnyChildNode | null = null,
 	>
-	extends InstanceNode<Definition, Spec, Child>
-	implements BaseNode, EvaluationContext, SubscribableDependency
+	extends InstanceNode<Definition, Spec, Parent, Child>
+	implements BaseNode, XFormsXPathPrimaryInstanceDescendantNode, EvaluationContext
 {
+	/**
+	 * Partial implementation of {@link isAttached}, used to check whether `this`
+	 * is present in {@link parent}'s children state.
+	 */
+	protected readonly isAttachedDescendant: Accessor<boolean>;
+
 	readonly hasReadonlyAncestor: Accessor<boolean> = () => {
 		const { parent } = this;
 
@@ -97,51 +100,88 @@ export abstract class DescendantNode<
 
 	readonly isRequired: Accessor<boolean>;
 
+	// XFormsXPathPrimaryInstanceDescendantNode
+
+	/**
+	 * WARNING! Ideally, this would be an abstract property, defined by each
+	 * concrete subclass (or other intermediate abstract classes, where
+	 * appropriate). Unfortunately it must be assigned here, so it will be present
+	 * for certain XPath DOM adapter functionality **during** each concrete node's
+	 * construction.
+	 *
+	 * Those subclasses nevertheless override this same property, assigning the
+	 * same value, for the purposes of narrowing the XPath node kind semantics
+	 * appropriate for each node type.
+	 */
+	override readonly [XPathNodeKindKey]: XFormsXPathPrimaryInstanceDescendantNodeKind;
 	readonly root: Root;
-	readonly evaluator: XFormsXPathEvaluator;
-	readonly contextNode: Element;
+
+	// BaseNode
+	abstract override readonly nodeType: InstanceNodeType;
+
+	// EvaluationContext
+	readonly isAttached: Accessor<boolean>;
+	readonly evaluator: EngineXPathEvaluator;
+	override readonly contextNode: PrimaryInstanceXPathChildNode =
+		this as AnyDescendantNode as PrimaryInstanceXPathChildNode;
+	readonly getActiveLanguage: Accessor<ActiveLanguage>;
 
 	constructor(
-		override readonly parent: DescendantNodeParent<Definition>,
+		override readonly parent: Parent,
 		override readonly definition: Definition,
 		options?: DescendantNodeOptions
 	) {
 		super(parent.engineConfig, parent, definition, options);
 
-		const { evaluator, root } = parent;
+		if (this.isRoot()) {
+			this.root = this;
+		} else {
+			this.root = parent.root;
+		}
 
-		this.root = root;
-		this.evaluator = evaluator;
-		this.contextNode = this.initializeContextNode(parent.contextNode, definition.nodeName);
+		const { evaluator } = parent;
 
-		const { readonly, relevant, required } = definition.bind;
+		// See notes on property declaration
+		if (definition.type === 'repeat-range') {
+			this[XPathNodeKindKey] = XFORMS_XPATH_NODE_RANGE_KIND;
+		} else {
+			this[XPathNodeKindKey] = 'element';
+		}
 
-		this.isSelfReadonly = createComputedExpression(this, readonly);
-		this.isSelfRelevant = createComputedExpression(this, relevant);
-		this.isRequired = createComputedExpression(this, required);
-	}
+		const self = this as AnyDescendantNode as AnyChildNode;
 
-	protected createContextNode(parentContextNode: Element, nodeName: string): Element {
-		return parentContextNode.ownerDocument.createElement(nodeName);
-	}
+		this.isAttachedDescendant = this.scope.runTask(() => {
+			return createMemo(() => {
+				for (const child of parent.getChildren()) {
+					if (child === self) {
+						return true;
+					}
+				}
 
-	/**
-	 * Currently expected to be overridden by...
-	 *
-	 * - Repeat range: returns its parent's context node, because it doesn't have
-	 *   a node in the primary instance tree.
-	 *
-	 * - Repeat instance: returns its created context node, but overrides handles
-	 *   appending behavior separately (for inserting at the end of its parent
-	 *   range, or even at an arbitrary index within the range, after instance
-	 *   creation is has completed).
-	 */
-	protected initializeContextNode(parentContextNode: Element, nodeName: string): Element {
-		const element = this.createContextNode(parentContextNode, nodeName);
+				return false;
+			});
+		});
 
-		parentContextNode.append(element);
+		this.isAttached = this.scope.runTask(() => {
+			return createMemo(() => {
+				return this.parent.isAttached() && this.isAttachedDescendant();
+			});
+		});
+
+		this.evaluator = evaluator;
+		this.getActiveLanguage = parent.getActiveLanguage;
+
+		const { readonly, relevant, required } = definition.bind;
 
-		return element;
+		this.isSelfReadonly = createComputedExpression(this, readonly, {
+			defaultValue: true,
+		});
+		this.isSelfRelevant = createComputedExpression(this, relevant, {
+			defaultValue: false,
+		});
+		this.isRequired = createComputedExpression(this, required, {
+			defaultValue: false,
+		});
 	}
 
 	/**