@getodk/xforms-engine 0.1.1 → 0.2.0

package/src/body/text/TextElementDefinition.ts

@@ -3,10 +3,10 @@ import type { XFormDefinition } from '../../XFormDefinition.ts';
 import { type AnyDependentExpression } from '../../expression/DependentExpression.ts';
 import type { AnyGroupElementDefinition } from '../BodyDefinition.ts';
 import { BodyElementDefinition } from '../BodyElementDefinition.ts';
-import type { InputDefinition } from '../control/InputDefinition.ts';
+import type { RepeatElementDefinition } from '../RepeatElementDefinition.ts';
+import type { AnyControlDefinition } from '../control/ControlDefinition.ts';
 import type { ItemDefinition } from '../control/select/ItemDefinition.ts';
 import type { ItemsetDefinition } from '../control/select/ItemsetDefinition.ts';
-import type { AnySelectDefinition } from '../control/select/SelectDefinition.ts';
 import { TextElementOutputPart } from './TextElementOutputPart.ts';
 import { TextElementReferencePart } from './TextElementReferencePart.ts';
 import { TextElementStaticPart } from './TextElementStaticPart.ts';
@@ -18,11 +18,11 @@ export interface TextElement extends Element {
 }
 
 export type TextElementOwner =
+	| AnyControlDefinition
 	| AnyGroupElementDefinition
-	| AnySelectDefinition
-	| InputDefinition
 	| ItemDefinition
-	| ItemsetDefinition;
+	| ItemsetDefinition
+	| RepeatElementDefinition;
 
 export type TextElementChild = TextElementOutputPart | TextElementStaticPart;
 

package/src/client/BaseNode.ts

@@ -1,7 +1,9 @@
+import type { TokenListParser } from '../lib/TokenListParser.ts';
 import type { AnyNodeDefinition } from '../model/NodeDefinition.ts';
-import type { InstanceNodeType } from './node-types.js';
+import type { NodeAppearances } from './NodeAppearances.ts';
 import type { OpaqueReactiveObjectFactory } from './OpaqueReactiveObjectFactory.ts';
 import type { TextRange } from './TextRange.ts';
+import type { InstanceNodeType } from './node-types.ts';
 
 export interface BaseNodeState {
 	/**
@@ -126,6 +128,12 @@ export interface BaseNode {
 	 */
 	readonly nodeId: FormNodeID;
 
+	/**
+	 * @see {@link TokenListParser} for details.
+	 */
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	readonly appearances: NodeAppearances<any> | null;
+
 	/**
 	 * Each node has a definition which specifies aspects of the node defined in
 	 * the form. These aspects include (but are not limited to) the node's data

package/src/client/GroupNode.ts

@@ -1,6 +1,7 @@
-import type { NonRepeatGroupElementDefinition } from '../body/BodyDefinition.ts';
+import type { AnyGroupElementDefinition } from '../body/BodyDefinition.ts';
 import type { SubtreeDefinition } from '../model/SubtreeDefinition.ts';
 import type { BaseNode, BaseNodeState } from './BaseNode.ts';
+import type { NodeAppearances } from './NodeAppearances.ts';
 import type { RootNode } from './RootNode.ts';
 import type { GeneralChildNode, GeneralParentNode } from './hierarchy.ts';
 
@@ -14,9 +15,11 @@ export interface GroupNodeState extends BaseNodeState {
 // TODO: as with `SubtreeNode`'s `SubtreeDefinition`, there is a naming
 // inconsistency emerging here.
 export interface GroupDefinition extends SubtreeDefinition {
-	readonly bodyElement: NonRepeatGroupElementDefinition;
+	readonly bodyElement: AnyGroupElementDefinition;
 }
 
+export type GroupNodeAppearances = NodeAppearances<GroupDefinition>;
+
 /**
  * A node corresponding to an XForms `<group>`.
  */
@@ -26,6 +29,7 @@ export interface GroupDefinition extends SubtreeDefinition {
 // for context.
 export interface GroupNode extends BaseNode {
 	readonly nodeType: 'group';
+	readonly appearances: GroupNodeAppearances;
 	readonly definition: GroupDefinition;
 	readonly root: RootNode;
 	readonly parent: GeneralParentNode;

package/src/client/NodeAppearances.ts

@@ -0,0 +1,22 @@
+import type { ParsedTokenList } from '../lib/TokenListParser.ts';
+import type { NodeDefinition } from '../model/NodeDefinition.ts';
+
+/**
+ * - Provides a means to distinguish between internal and client-facing names
+ *   for the same {@link ParsedTokenList} types.
+ *
+ * - Anticipates some iteration on both parsed ("definition") types and
+ *   client-facing node types, which may not happen in tandem.
+ */
+// prettier-ignore
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type NodeAppearances<Definition extends NodeDefinition<any>> =
+	Definition extends {
+		readonly bodyElement: {
+			readonly appearances:
+				// eslint-disable-next-line @typescript-eslint/no-explicit-any
+				infer Appearances extends ParsedTokenList<any>
+		};
+	}
+		? Appearances
+		: null;

package/src/client/RepeatInstanceNode.ts

@@ -1,6 +1,7 @@
 import type { RepeatInstanceDefinition } from '../model/RepeatInstanceDefinition.ts';
 import type { RepeatTemplateDefinition } from '../model/RepeatTemplateDefinition.ts';
 import type { BaseNode, BaseNodeState } from './BaseNode.ts';
+import type { NodeAppearances } from './NodeAppearances.ts';
 import type { RepeatRangeNode } from './RepeatRangeNode.ts';
 import type { RootNode } from './RootNode.ts';
 import type { GeneralChildNode } from './hierarchy.ts';
@@ -22,8 +23,11 @@ export type RepeatDefinition =
 	| RepeatInstanceDefinition
 	| RepeatTemplateDefinition;
 
+export type RepeatInstanceNodeAppearances = NodeAppearances<RepeatDefinition>;
+
 export interface RepeatInstanceNode extends BaseNode {
 	readonly nodeType: 'repeat-instance';
+	readonly appearances: RepeatInstanceNodeAppearances;
 	readonly definition: RepeatDefinition;
 	readonly root: RootNode;
 

package/src/client/RepeatRangeNode.ts

@@ -1,5 +1,6 @@
-import type { RepeatSequenceDefinition } from '../model/RepeatSequenceDefinition.ts';
+import type { RepeatRangeDefinition } from '../model/RepeatRangeDefinition.ts';
 import type { BaseNode, BaseNodeState } from './BaseNode.ts';
+import type { NodeAppearances } from './NodeAppearances.ts';
 import type { RepeatInstanceNode } from './RepeatInstanceNode.ts';
 import type { RootNode } from './RootNode.ts';
 import type { TextRange } from './TextRange.ts';
@@ -23,6 +24,8 @@ export interface RepeatRangeNodeState extends BaseNodeState {
 	get value(): null;
 }
 
+export type RepeatRangeNodeAppearances = NodeAppearances<RepeatRangeDefinition>;
+
 /**
  * Represents a contiguous set of zero or more {@link RepeatInstanceNode}s
  * (accessed by its
@@ -89,7 +92,8 @@ export interface RepeatRangeNodeState extends BaseNodeState {
  */
 export interface RepeatRangeNode extends BaseNode {
 	readonly nodeType: 'repeat-range';
-	readonly definition: RepeatSequenceDefinition;
+	readonly appearances: RepeatRangeNodeAppearances;
+	readonly definition: RepeatRangeDefinition;
 	readonly root: RootNode;
 	readonly parent: GeneralParentNode;
 	readonly currentState: RepeatRangeNodeState;

package/src/client/RootNode.ts

@@ -1,3 +1,4 @@
+import type { BodyClassList } from '../body/BodyDefinition.ts';
 import type { RootDefinition } from '../model/RootDefinition.ts';
 import type { BaseNode, BaseNodeState } from './BaseNode.ts';
 import type { ActiveLanguage, FormLanguage, FormLanguages } from './FormLanguage.ts';
@@ -21,6 +22,27 @@ export interface RootNodeState extends BaseNodeState {
 
 export interface RootNode extends BaseNode {
 	readonly nodeType: 'root';
+
+	/**
+	 * @todo this along with {@link classes} is... awkward.
+	 */
+	readonly appearances: null;
+
+	/**
+	 * @todo This is another odd deviation in {@link RootNode}. Unlike
+	 * {@link languages}, it doesn't feel particularly **essential**. While it
+	 * would deviate from XForms spec terminology, it seems like it _might be
+	 * reasonable_ to instead convey `<h:body class="...">` as
+	 * {@link RootNode.appearances} in the client interface. They do have slightly
+	 * different spec semantics (i.e. a body class can be anything, to trigger
+	 * styling in a form UI). But the **most likely anticipated** use case in Web
+	 * Forms would be the "pages" class, and perhaps "theme-grid". The former is
+	 * definitely conceptually similar to a XForms `appearance` (albeit
+	 * form-global, which is not a spec concept). The latter does as well, and we
+	 * already anticipate applying that concept in non-form-global ways.
+	 */
+	readonly classes: BodyClassList;
+
 	readonly definition: RootDefinition;
 	readonly root: RootNode;
 	readonly parent: null;

package/src/client/SelectNode.ts

@@ -1,6 +1,7 @@
 import type { AnySelectDefinition } from '../body/control/select/SelectDefinition.ts';
 import type { ValueNodeDefinition } from '../model/ValueNodeDefinition.ts';
 import type { BaseNode, BaseNodeState } from './BaseNode.ts';
+import type { NodeAppearances } from './NodeAppearances.ts';
 import type { RootNode } from './RootNode.ts';
 import type { StringNode } from './StringNode.ts';
 import type { TextRange } from './TextRange.ts';
@@ -38,8 +39,11 @@ export interface SelectDefinition extends ValueNodeDefinition {
 	readonly bodyElement: AnySelectDefinition;
 }
 
+export type SelectNodeAppearances = NodeAppearances<SelectDefinition>;
+
 export interface SelectNode extends BaseNode {
 	readonly nodeType: 'select';
+	readonly appearances: SelectNodeAppearances;
 	readonly definition: SelectDefinition;
 	readonly root: RootNode;
 	readonly parent: GeneralParentNode;

package/src/client/StringNode.ts

@@ -1,6 +1,7 @@
 import type { InputDefinition } from '../body/control/InputDefinition.ts';
 import type { ValueNodeDefinition } from '../model/ValueNodeDefinition.ts';
 import type { BaseNode, BaseNodeState } from './BaseNode.ts';
+import type { NodeAppearances } from './NodeAppearances.ts';
 import type { RootNode } from './RootNode.ts';
 import type { GeneralParentNode } from './hierarchy.ts';
 
@@ -21,6 +22,8 @@ export interface StringDefinition extends ValueNodeDefinition {
 	readonly bodyElement: InputDefinition | null;
 }
 
+export type StringNodeAppearances = NodeAppearances<StringDefinition>;
+
 /**
  * A node which can be assigned a string/text value. A string node **MAY**
  * correspond to form field defined as an XForms `<input>`, which a user-facing
@@ -30,6 +33,7 @@ export interface StringDefinition extends ValueNodeDefinition {
  */
 export interface StringNode extends BaseNode {
 	readonly nodeType: 'string';
+	readonly appearances: StringNodeAppearances;
 	readonly definition: StringDefinition;
 	readonly root: RootNode;
 	readonly parent: GeneralParentNode;

package/src/client/SubtreeNode.ts

@@ -50,6 +50,7 @@ export interface SubtreeDefinition extends BaseSubtreeDefinition {
 // TODO: directly test presentation of non-group subtree children/descendants
 export interface SubtreeNode extends BaseNode {
 	readonly nodeType: 'subtree';
+	readonly appearances: null;
 	readonly definition: SubtreeDefinition;
 	readonly root: RootNode;
 	readonly parent: GeneralParentNode;

package/src/instance/Group.ts

@@ -1,5 +1,5 @@
 import type { Accessor } from 'solid-js';
-import type { GroupDefinition, GroupNode } from '../client/GroupNode.ts';
+import type { GroupDefinition, GroupNode, GroupNodeAppearances } from '../client/GroupNode.ts';
 import type { TextRange } from '../index.ts';
 import type { ChildrenState } from '../lib/reactivity/createChildrenState.ts';
 import { createChildrenState } from '../lib/reactivity/createChildrenState.ts';
@@ -38,13 +38,15 @@ export class Group
 	protected override engineState: EngineState<GroupStateSpec>;
 
 	// GroupNode
-	readonly currentState: MaterializedChildren<CurrentState<GroupStateSpec>, GeneralChildNode>;
-
 	readonly nodeType = 'group';
+	readonly appearances: GroupNodeAppearances;
+	readonly currentState: MaterializedChildren<CurrentState<GroupStateSpec>, GeneralChildNode>;
 
 	constructor(parent: GeneralParentNode, definition: GroupDefinition) {
 		super(parent, definition);
 
+		this.appearances = definition.bodyElement.appearances;
+
 		const childrenState = createChildrenState<Group, GeneralChildNode>(this);
 
 		this.childrenState = childrenState;
@@ -52,7 +54,10 @@ export class Group
 		const state = createSharedNodeState(
 			this.scope,
 			{
-				...this.buildSharedStateSpec(parent, definition),
+				reference: this.contextReference,
+				readonly: this.isReadonly,
+				relevant: this.isRelevant,
+				required: this.isRequired,
 
 				label: createNodeLabel(this, definition),
 				hint: null,
@@ -67,15 +72,15 @@ export class Group
 
 		this.state = state;
 		this.engineState = state.engineState;
-		this.currentState = materializeCurrentStateChildren(state.currentState, childrenState);
+		this.currentState = materializeCurrentStateChildren(
+			this.scope,
+			state.currentState,
+			childrenState
+		);
 
 		childrenState.setChildren(buildChildren(this));
 	}
 
-	protected computeReference(parent: GeneralParentNode): string {
-		return this.computeChildStepReference(parent);
-	}
-
 	getChildren(): readonly GeneralChildNode[] {
 		return this.childrenState.getChildren();
 	}

package/src/instance/RepeatInstance.ts

@@ -1,6 +1,10 @@
 import type { Accessor } from 'solid-js';
 import { createComputed, createSignal, on } from 'solid-js';
-import type { RepeatDefinition, RepeatInstanceNode } from '../client/RepeatInstanceNode.ts';
+import type {
+	RepeatDefinition,
+	RepeatInstanceNode,
+	RepeatInstanceNodeAppearances,
+} from '../client/RepeatInstanceNode.ts';
 import type { TextRange } from '../index.ts';
 import type { ChildrenState } from '../lib/reactivity/createChildrenState.ts';
 import { createChildrenState } from '../lib/reactivity/createChildrenState.ts';
@@ -46,9 +50,39 @@ export class RepeatInstance
 	protected readonly state: SharedNodeState<RepeatInstanceStateSpec>;
 	protected override engineState: EngineState<RepeatInstanceStateSpec>;
 
+	/**
+	 * @todo Should we special case repeat `readonly` inheritance the same way
+	 * we do for `relevant`?
+	 *
+	 * @see {@link hasNonRelevantAncestor}
+	 */
+	declare readonly hasReadonlyAncestor: Accessor<boolean>;
+
+	/**
+	 * A repeat instance can inherit non-relevance, just like any other node. That
+	 * inheritance is derived from the repeat instance's parent node in the
+	 * primary instance XML/DOM tree (and would be semantically expected to do so
+	 * even if we move away from that implementation detail).
+	 *
+	 * Since {@link RepeatInstance.parent} is a {@link RepeatRange}, which is a
+	 * runtime data model fiction that does not exist in that hierarchy, we pass
+	 * this call through, allowing the {@link RepeatRange} to check the actual
+	 * primary instance parent node's relevance state.
+	 *
+	 * @todo Should we apply similar reasoning in {@link hasReadonlyAncestor}?
+	 */
+	override readonly hasNonRelevantAncestor: Accessor<boolean> = () => {
+		return this.parent.hasNonRelevantAncestor();
+	};
+
 	// RepeatInstanceNode
 	readonly nodeType = 'repeat-instance';
 
+	/**
+	 * @see {@link RepeatRange.appearances}
+	 */
+	readonly appearances: RepeatInstanceNodeAppearances;
+
 	readonly currentState: MaterializedChildren<
 		CurrentState<RepeatInstanceStateSpec>,
 		GeneralChildNode
@@ -59,7 +93,20 @@ export class RepeatInstance
 		definition: RepeatDefinition,
 		options: RepeatInstanceOptions
 	) {
-		super(parent, definition);
+		const { precedingInstance } = options;
+		const precedingIndex = precedingInstance?.currentIndex ?? (() => -1);
+		const initialIndex = precedingIndex() + 1;
+		const [currentIndex, setCurrentIndex] = createSignal(initialIndex);
+
+		super(parent, definition, {
+			computeReference: (): string => {
+				const currentPosition = currentIndex() + 1;
+
+				return `${parent.contextReference()}[${currentPosition}]`;
+			},
+		});
+
+		this.appearances = definition.bodyElement.appearances;
 
 		const childrenState = createChildrenState<RepeatInstance, GeneralChildNode>(this);
 
@@ -67,18 +114,17 @@ export class RepeatInstance
 
 		options.precedingPrimaryInstanceNode.after(this.contextNode);
 
-		const { precedingInstance } = options;
-		const precedingIndex = precedingInstance?.currentIndex ?? (() => -1);
-		const initialIndex = precedingIndex() + 1;
-		const [currentIndex, setCurrentIndex] = createSignal(initialIndex);
-
 		this.currentIndex = currentIndex;
 
 		const state = createSharedNodeState(
 			this.scope,
 			{
-				...this.buildSharedStateSpec(parent, definition),
+				reference: this.contextReference,
+				readonly: this.isReadonly,
+				relevant: this.isRelevant,
+				required: this.isRequired,
 
+				// TODO: only-child <group><label>
 				label: createNodeLabel(this, definition),
 				hint: null,
 				children: childrenState.childIds,
@@ -92,7 +138,11 @@ export class RepeatInstance
 
 		this.state = state;
 		this.engineState = state.engineState;
-		this.currentState = materializeCurrentStateChildren(state.currentState, childrenState);
+		this.currentState = materializeCurrentStateChildren(
+			this.scope,
+			state.currentState,
+			childrenState
+		);
 
 		// Maintain current index state, updating as the parent range's children
 		// state is changed. Notable Solid reactivity nuances:
@@ -118,12 +168,6 @@ export class RepeatInstance
 		childrenState.setChildren(buildChildren(this));
 	}
 
-	protected computeReference(parent: RepeatRange): string {
-		const currentPosition = this.currentIndex() + 1;
-
-		return `${parent.contextReference}[${currentPosition}]`;
-	}
-
 	protected override initializeContextNode(parentContextNode: Element, nodeName: string): Element {
 		return this.createContextNode(parentContextNode, nodeName);
 	}

package/src/instance/RepeatRange.ts

@@ -1,8 +1,9 @@
 import { insertAtIndex } from '@getodk/common/lib/array/insert.ts';
 import type { Accessor } from 'solid-js';
-import type { RepeatRangeNode } from '../client/RepeatRangeNode.ts';
+import type { RepeatRangeNode, RepeatRangeNodeAppearances } from '../client/RepeatRangeNode.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';
@@ -10,7 +11,7 @@ import type { EngineState } from '../lib/reactivity/node-state/createEngineState
 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 { RepeatSequenceDefinition } from '../model/RepeatSequenceDefinition.ts';
+import type { RepeatRangeDefinition } from '../model/RepeatRangeDefinition.ts';
 import type { RepeatDefinition } from './RepeatInstance.ts';
 import { RepeatInstance } from './RepeatInstance.ts';
 import type { Root } from './Root.ts';
@@ -31,7 +32,7 @@ interface RepeatRangeStateSpec extends DescendantNodeSharedStateSpec {
 }
 
 export class RepeatRange
-	extends DescendantNode<RepeatSequenceDefinition, RepeatRangeStateSpec, RepeatInstance>
+	extends DescendantNode<RepeatRangeDefinition, RepeatRangeStateSpec, RepeatInstance>
 	implements RepeatRangeNode, EvaluationContext, SubscribableDependency
 {
 	/**
@@ -64,22 +65,144 @@ export class RepeatRange
 	protected readonly state: SharedNodeState<RepeatRangeStateSpec>;
 	protected override engineState: EngineState<RepeatRangeStateSpec>;
 
+	/**
+	 * @todo Should we special case repeat `readonly` state the same way
+	 * we do for `relevant`?
+	 *
+	 * @see {@link isSelfRelevant}
+	 */
+	declare isSelfReadonly: Accessor<boolean>;
+
+	private readonly emptyRangeEvaluationContext: EvaluationContext & {
+		readonly contextNode: Comment;
+	};
+
+	/**
+	 * @see {@link isSelfRelevant}
+	 */
+	private readonly isEmptyRangeSelfRelevant: 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();
+	};
+
 	// RepeatRangeNode
 	readonly nodeType = 'repeat-range';
 
+	/**
+	 * @todo RepeatRange*, RepeatInstance* (and RepeatTemplate*) all share the
+	 * same body element, and thus all share the same definition `bodyElement`. As
+	 * such, they also all share the same `appearances`. At time of writing,
+	 * `web-forms` (Vue UI package) treats a `RepeatRangeNode`...
+	 *
+	 * - ... as a group, if the node has a label (i.e.
+	 *   `<group><label/><repeat/></group>`)
+	 * - ... effectively as a fragment containing only its instances, otherwise
+	 *
+	 * We now collapse `<group><repeat>` into `<repeat>`, and no longer treat
+	 * "repeat group" as a concept (after parsing). According to the spec, these
+	 * appearances **are supposed to** come from that "repeat group" in the form
+	 * definition. In practice, many forms do define appearances directly on a
+	 * repeat element. The engine currently produces an error if both are defined
+	 * simultaneously, but otherwise makes no distinction between appearances in
+	 * these form definition shapes:
+	 *
+	 * ```xml
+	 * <group ref="/data/rep1" appearance="...">
+	 *   <repeat nodeset="/data/rep1"/>
+	 * </group>
+	 *
+	 * <group ref="/data/rep1">
+	 *   <repeat nodeset="/data/rep1"/ appearance="...">
+	 * </group>
+	 *
+	 * <repeat nodeset="/data/rep1"/ appearance="...">
+	 * ```
+	 *
+	 * All of the above creates considerable ambiguity about where "repeat
+	 * appearances" should apply, under which circumstances.
+	 */
+	readonly appearances: RepeatRangeNodeAppearances;
+
 	readonly currentState: MaterializedChildren<CurrentState<RepeatRangeStateSpec>, RepeatInstance>;
 
-	constructor(parent: GeneralParentNode, definition: RepeatSequenceDefinition) {
+	constructor(parent: GeneralParentNode, definition: RepeatRangeDefinition) {
 		super(parent, definition);
 
+		this.appearances = definition.bodyElement.appearances;
+
 		const childrenState = createChildrenState<RepeatRange, RepeatInstance>(this);
 
 		this.childrenState = childrenState;
 
+		this.anchorNode = this.contextNode.ownerDocument.createComment(
+			`Begin repeat range: ${definition.nodeset}`
+		);
+		this.contextNode.append(this.anchorNode);
+
+		this.emptyRangeEvaluationContext = {
+			scope: this.scope,
+			evaluator: this.evaluator,
+			root: this.root,
+			contextReference: this.contextReference,
+			contextNode: this.anchorNode,
+
+			getSubscribableDependenciesByReference: (reference) => {
+				return this.getSubscribableDependenciesByReference(reference);
+			},
+		};
+
+		this.isEmptyRangeSelfRelevant = createComputedExpression(
+			this.emptyRangeEvaluationContext,
+			definition.bind.relevant
+		);
+
 		const state = createSharedNodeState(
 			this.scope,
 			{
-				...this.buildSharedStateSpec(parent, definition),
+				reference: this.contextReference,
+				readonly: this.isReadonly,
+				relevant: this.isRelevant,
+				required: this.isRequired,
 
 				label: createNodeLabel(this, definition),
 				hint: null,
@@ -92,14 +215,13 @@ export class RepeatRange
 			}
 		);
 
-		this.anchorNode = this.contextNode.ownerDocument.createComment(
-			`Begin repeat range: ${definition.nodeset}`
-		);
-		this.contextNode.append(this.anchorNode);
-
 		this.state = state;
 		this.engineState = state.engineState;
-		this.currentState = materializeCurrentStateChildren(state.currentState, childrenState);
+		this.currentState = materializeCurrentStateChildren(
+			this.scope,
+			state.currentState,
+			childrenState
+		);
 
 		definition.instances.forEach((instanceDefinition, index) => {
 			const afterIndex = index - 1;
@@ -116,10 +238,6 @@ export class RepeatRange
 		return parentContextNode;
 	}
 
-	protected computeReference(parent: GeneralParentNode): string {
-		return this.computeChildStepReference(parent);
-	}
-
 	getInstanceIndex(instance: RepeatInstance): number {
 		return this.engineState.children.indexOf(instance.nodeId);
 	}