@getodk/xforms-engine 0.3.0 → 0.5.0

package/src/instance/SelectField.ts

@@ -1,10 +1,13 @@
 import { xmlXPathWhitespaceSeparatedList } from '@getodk/common/lib/string/whitespace.ts';
+import { XPathNodeKindKey } from '@getodk/xpath';
 import type { Accessor } from 'solid-js';
-import { untrack } from 'solid-js';
-import type { AnySelectDefinition } from '../body/control/select/SelectDefinition.ts';
+import { createMemo, untrack } from 'solid-js';
 import type { SelectItem, SelectNode, SelectNodeAppearances } from '../client/SelectNode.ts';
 import type { TextRange } from '../client/TextRange.ts';
+import type { SubmissionState } from '../client/submission/SubmissionState.ts';
 import type { AnyViolation, LeafNodeValidationState } from '../client/validation.ts';
+import type { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
+import { createLeafNodeSubmissionState } from '../lib/client-reactivity/submission/createLeafNodeSubmissionState.ts';
 import { createSelectItems } from '../lib/reactivity/createSelectItems.ts';
 import { createValueState } from '../lib/reactivity/createValueState.ts';
 import type { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
@@ -16,15 +19,16 @@ 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 { LeafNodeDefinition } from '../model/LeafNodeDefinition.ts';
+import type { AnySelectDefinition } from '../parse/body/control/select/SelectDefinition.ts';
+import type { LeafNodeDefinition } from '../parse/model/LeafNodeDefinition.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';
+import type { ClientReactiveSubmittableLeafNode } from './internal-api/submission/ClientReactiveSubmittableLeafNode.ts';
 
 export interface SelectFieldDefinition extends LeafNodeDefinition {
 	readonly bodyElement: AnySelectDefinition;
@@ -39,17 +43,21 @@ interface SelectFieldStateSpec extends DescendantNodeStateSpec<readonly SelectIt
 }
 
 export class SelectField
-	extends DescendantNode<SelectFieldDefinition, SelectFieldStateSpec, null>
+	extends DescendantNode<SelectFieldDefinition, SelectFieldStateSpec, GeneralParentNode, null>
 	implements
 		SelectNode,
+		XFormsXPathElement,
 		EvaluationContext,
-		SubscribableDependency,
 		ValidationContext,
-		ValueContext<readonly SelectItem[]>
+		ValueContext<readonly SelectItem[]>,
+		ClientReactiveSubmittableLeafNode<readonly SelectItem[]>
 {
 	private readonly selectExclusive: boolean;
 	private readonly validation: SharedValidationState;
 
+	// XFormsXPathElement
+	override readonly [XPathNodeKindKey] = 'element';
+
 	// InstanceNode
 	protected readonly state: SharedNodeState<SelectFieldStateSpec>;
 	protected override engineState: EngineState<SelectFieldStateSpec>;
@@ -63,32 +71,35 @@ export class SelectField
 		return this.validation.currentState;
 	}
 
+	readonly submissionState: SubmissionState;
+
 	// ValueContext
+	override readonly contextNode = this;
+
 	readonly encodeValue = (runtimeValue: readonly SelectItem[]): string => {
 		const itemValues = new Set(runtimeValue.map(({ value }) => value));
+		const selectedItems = this.getValueOptions().filter(({ value }) => {
+			return itemValues.has(value);
+		});
 
-		return Array.from(itemValues).join(' ');
+		return selectedItems.map(({ value }) => value).join(' ');
 	};
 
 	readonly decodeValue = (instanceValue: string): readonly SelectItem[] => {
-		return this.scope.runTask(() => {
-			const values = xmlXPathWhitespaceSeparatedList(instanceValue, {
+		const itemValues = new Set(
+			xmlXPathWhitespaceSeparatedList(instanceValue, {
 				ignoreEmpty: true,
-			});
-
-			const items = this.getSelectItemsByValue();
+			})
+		);
 
-			return values
-				.map((value) => {
-					return items.get(value);
-				})
-				.filter((item): item is SelectItem => {
-					return item != null;
-				});
+		// TODO: also want set-like behavior, probably?
+		return this.getValueOptions().filter((option) => {
+			return itemValues.has(option.value);
 		});
 	};
 
 	protected readonly getValueOptions: Accessor<readonly SelectItem[]>;
+	protected readonly getValue: Accessor<readonly SelectItem[]>;
 
 	constructor(parent: GeneralParentNode, definition: SelectFieldDefinition) {
 		super(parent, definition);
@@ -100,6 +111,26 @@ export class SelectField
 
 		this.getValueOptions = valueOptions;
 
+		const [baseGetValue, setValue] = createValueState(this);
+
+		const getValue = this.scope.runTask(() => {
+			const selectItemsByValue = createMemo((): ReadonlyMap<string, SelectItem> => {
+				return new Map(valueOptions().map((item) => [item.value, item]));
+			});
+
+			return createMemo(() => {
+				const items = selectItemsByValue();
+
+				return baseGetValue().filter((item) => {
+					return items.has(item.value);
+				});
+			});
+		});
+
+		this.getValue = getValue;
+
+		const valueState: SimpleAtomicState<readonly SelectItem[]> = [getValue, setValue];
+
 		const sharedStateOptions = {
 			clientStateFactory: this.engineConfig.stateFactory,
 		};
@@ -115,7 +146,7 @@ export class SelectField
 				label: createNodeLabel(this, definition),
 				hint: createFieldHint(this, definition),
 				children: null,
-				value: createValueState(this),
+				value: valueState,
 				valueOptions,
 			},
 			sharedStateOptions
@@ -125,10 +156,7 @@ export class SelectField
 		this.engineState = state.engineState;
 		this.currentState = state.currentState;
 		this.validation = createValidationState(this, sharedStateOptions);
-	}
-
-	getViolation(): AnyViolation | null {
-		return this.validation.engineState.violation;
+		this.submissionState = createLeafNodeSubmissionState(this);
 	}
 
 	protected getSelectItemsByValue(
@@ -167,6 +195,11 @@ export class SelectField
 		this.updateSelectedItemValues([value]);
 	}
 
+	// XFormsXPathElement
+	override getXPathValue(): string {
+		return this.encodeValue(this.engineState.value);
+	}
+
 	// SelectNode
 	select(selectedItem: SelectItem): Root {
 		const { engineState, root } = this;
@@ -220,6 +253,10 @@ export class SelectField
 	}
 
 	// ValidationContext
+	getViolation(): AnyViolation | null {
+		return this.validation.engineState.violation;
+	}
+
 	isBlank(): boolean {
 		return this.engineState.value.length === 0;
 	}

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,39 @@ 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 currentState: MaterializedChildren<CurrentState<SubtreeStateSpec>, GeneralChildNode>;
 	readonly validationState: AncestorNodeValidationState;
+	readonly submissionState: SubmissionState;
 
 	constructor(parent: GeneralParentNode, definition: SubtreeDefinition) {
 		super(parent, definition);
@@ -80,6 +91,7 @@ export class Subtree
 
 		childrenState.setChildren(buildChildren(this));
 		this.validationState = createAggregatedViolations(this, sharedStateOptions);
+		this.submissionState = createParentNodeSubmissionState(this);
 	}
 
 	getChildren(): readonly GeneralChildNode[] {

package/src/instance/{StringField.ts → TriggerControl.ts}

@@ -1,9 +1,11 @@
-import { identity } from '@getodk/common/lib/identity.ts';
+import { XPathNodeKindKey } from '@getodk/xpath';
 import type { Accessor } from 'solid-js';
-import type { InputDefinition } from '../body/control/InputDefinition.ts';
-import type { StringNode, StringNodeAppearances } from '../client/StringNode.ts';
 import type { TextRange } from '../client/TextRange.ts';
+import type { TriggerNode, TriggerNodeDefinition } from '../client/TriggerNode.ts';
+import type { SubmissionState } from '../client/submission/SubmissionState.ts';
 import type { AnyViolation, LeafNodeValidationState } from '../client/validation.ts';
+import type { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
+import { createLeafNodeSubmissionState } from '../lib/client-reactivity/submission/createLeafNodeSubmissionState.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';
@@ -14,61 +16,84 @@ 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 { LeafNodeDefinition } from '../model/LeafNodeDefinition.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';
+import type { ClientReactiveSubmittableLeafNode } from './internal-api/submission/ClientReactiveSubmittableLeafNode.ts';
 
-export interface StringFieldDefinition extends LeafNodeDefinition {
-	readonly bodyElement: InputDefinition;
-}
-
-interface StringFieldStateSpec extends DescendantNodeStateSpec<string> {
+interface TriggerControlStateSpec extends DescendantNodeStateSpec<boolean> {
 	readonly label: Accessor<TextRange<'label'> | null>;
 	readonly hint: Accessor<TextRange<'hint'> | null>;
 	readonly children: null;
-	readonly value: SimpleAtomicState<string>;
+	readonly value: SimpleAtomicState<boolean>;
 	readonly valueOptions: null;
 }
 
-export class StringField
-	extends DescendantNode<StringFieldDefinition, StringFieldStateSpec, null>
+const TRIGGER_ASSIGNED_VALUE = 'OK';
+
+export class TriggerControl
+	extends DescendantNode<TriggerNodeDefinition, TriggerControlStateSpec, GeneralParentNode, null>
 	implements
-		StringNode,
+		TriggerNode,
+		XFormsXPathElement,
 		EvaluationContext,
-		SubscribableDependency,
 		ValidationContext,
-		ValueContext<string>
+		ValueContext<boolean>,
+		ClientReactiveSubmittableLeafNode<boolean>
 {
 	private readonly validation: SharedValidationState;
-	protected readonly state: SharedNodeState<StringFieldStateSpec>;
+
+	// XFormsXPathElement
+	override readonly [XPathNodeKindKey] = 'element';
 
 	// InstanceNode
-	protected engineState: EngineState<StringFieldStateSpec>;
+	protected readonly state: SharedNodeState<TriggerControlStateSpec>;
+	protected readonly engineState: EngineState<TriggerControlStateSpec>;
 
-	// StringNode
-	readonly nodeType = 'string';
-	readonly appearances: StringNodeAppearances;
-	readonly currentState: CurrentState<StringFieldStateSpec>;
+	// TriggerNode
+	readonly nodeType = 'trigger';
+	readonly appearances: UnknownAppearanceDefinition;
+	readonly currentState: CurrentState<TriggerControlStateSpec>;
 
 	get validationState(): LeafNodeValidationState {
 		return this.validation.currentState;
 	}
 
-	// ValueContext
-	readonly encodeValue = identity<string>;
+	readonly submissionState: SubmissionState;
 
-	readonly decodeValue = identity<string>;
+	// ValueContext
+	override readonly contextNode = this;
+	readonly encodeValue: (runtimeValue: boolean) => string;
+	readonly decodeValue: (instanceValue: string) => boolean;
 
-	constructor(parent: GeneralParentNode, definition: StringFieldDefinition) {
+	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,
@@ -95,15 +120,21 @@ export class StringField
 		this.engineState = state.engineState;
 		this.currentState = state.currentState;
 		this.validation = createValidationState(this, sharedStateOptions);
+		this.submissionState = createLeafNodeSubmissionState(this);
 	}
 
+	// XFormsXPathElement
+	override getXPathValue(): string {
+		return this.encodeValue(this.engineState.value);
+	}
+
+	// ValidationContext
 	getViolation(): AnyViolation | null {
 		return this.validation.engineState.violation;
 	}
 
-	// ValidationContext
 	isBlank(): boolean {
-		return this.engineState.value === '';
+		return this.engineState.value == null;
 	}
 
 	// InstanceNode
@@ -111,8 +142,8 @@ export class StringField
 		return [];
 	}
 
-	// StringNode
-	setValue(value: string): Root {
+	// TriggerNode
+	setValue(value: boolean): Root {
 		this.state.setProperty('value', value);
 
 		return this.root;

package/src/instance/abstract/DescendantNode.ts

@@ -1,15 +1,22 @@
-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 '../../model/DescendentNodeDefinition.ts';
-import type { LeafNodeDefinition } from '../../model/LeafNodeDefinition.ts';
-import type { AnyNodeDefinition } from '../../model/NodeDefinition.ts';
-import type { RepeatInstanceDefinition } from '../../model/RepeatInstanceDefinition.ts';
-import type { AnyChildNode, GeneralParentNode, RepeatRange } from '../hierarchy.ts';
+import type { AnyDescendantNodeDefinition } from '../../parse/model/DescendentNodeDefinition.ts';
+import type { AnyNodeDefinition } from '../../parse/model/NodeDefinition.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';
@@ -34,19 +41,13 @@ export type DescendantNodeDefinition = Extract<
 	AnyDescendantNodeDefinition
 >;
 
-// prettier-ignore
-export type DescendantNodeParent<Definition extends DescendantNodeDefinition> =
-	Definition extends LeafNodeDefinition
-		? GeneralParentNode
-	: Definition extends RepeatInstanceDefinition
-		? RepeatRange
-		: GeneralParentNode;
-
 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 +59,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 +105,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;
+			});
+		});
+
+		this.isAttached = this.scope.runTask(() => {
+			return createMemo(() => {
+				return this.parent.isAttached() && this.isAttachedDescendant();
+			});
+		});
+
+		this.evaluator = evaluator;
+		this.getActiveLanguage = parent.getActiveLanguage;
 
-		parentContextNode.append(element);
+		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,
+		});
 	}
 
 	/**