@getodk/xforms-engine 0.1.0 → 0.2.0

package/src/instance/children.ts

@@ -1,11 +1,12 @@
 import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
-import { SelectDefinition } from '../body/control/select/SelectDefinition.ts';
 import type { GroupDefinition } from '../client/GroupNode.ts';
 import type { SubtreeDefinition } from '../client/SubtreeNode.ts';
 import type { SubtreeDefinition as ModelSubtreeDefinition } from '../model/SubtreeDefinition.ts';
 import { Group } from './Group.ts';
 import { RepeatRange } from './RepeatRange.ts';
-import { SelectField, type SelectFieldDefinition } from './SelectField.ts';
+import type { SelectFieldDefinition } from './SelectField.ts';
+import { SelectField } from './SelectField.ts';
+import type { StringFieldDefinition } from './StringField.ts';
 import { StringField } from './StringField.ts';
 import { Subtree } from './Subtree.ts';
 import type { GeneralChildNode, GeneralParentNode } from './hierarchy.ts';
@@ -32,16 +33,25 @@ export const buildChildren = (parent: GeneralParentNode): GeneralChildNode[] =>
 				return new Group(parent, child as GroupDefinition);
 			}
 
-			case 'repeat-sequence': {
+			case 'repeat-range': {
 				return new RepeatRange(parent, child);
 			}
 
 			case 'value-node': {
-				if (child.bodyElement instanceof SelectDefinition) {
-					return new SelectField(parent, child as SelectFieldDefinition);
+				// TODO: this sort of awkwardness might go away if we embrace a
+				// proliferation of node types throughout.
+				switch (child.bodyElement?.type) {
+					case 'select':
+					case 'select1':
+						return new SelectField(parent, child as SelectFieldDefinition);
+
+					case 'input':
+					case undefined:
+						return new StringField(parent, child as StringFieldDefinition);
+
+					default:
+						throw new UnreachableError(child.bodyElement);
 				}
-
-				return new StringField(parent, child);
 			}
 
 			default: {

package/src/instance/index.ts

@@ -31,7 +31,7 @@ export const initializeForm = async (
 	const sourceXML = await retrieveSourceXMLResource(input, engineConfig);
 	const form = new XFormDefinition(sourceXML);
 
-	return Root.initialize(form.xformDOM, form.model.root, engineConfig);
+	return new Root(form.xformDOM, form.model.root, engineConfig);
 };
 
 initializeForm satisfies InitializeForm;

package/src/instance/internal-api/EvaluationContext.ts

@@ -1,4 +1,5 @@
 import type { XFormsXPathEvaluator } from '@getodk/xpath';
+import type { Accessor } from 'solid-js';
 import type { DependentExpression } from '../../expression/DependentExpression.ts';
 import type { ReactiveScope } from '../../lib/reactivity/scope.ts';
 import type { SubscribableDependency } from './SubscribableDependency.ts';
@@ -27,15 +28,13 @@ export interface EvaluationContext {
 	 * Produces the current absolute reference to the {@link contextNode}, where
 	 * the absolute `/` resolves to the active form state's primary instance root.
 	 */
-	get contextReference(): string;
+	readonly contextReference: Accessor<string>;
 
 	readonly contextNode: Node;
 
 	/**
-	 * Resolves a nodeset reference, possibly relative to the
-	 * {@link EvaluationContext.contextNode}.
+	 * Resolves nodes corresponding to the provided node-set reference, possibly
+	 * relative to the {@link EvaluationContext.contextNode}.
 	 */
-	readonly getSubscribableDependencyByReference: (
-		reference: string
-	) => SubscribableDependency | null;
+	getSubscribableDependenciesByReference(reference: string): readonly SubscribableDependency[];
 }

package/src/instance/internal-api/ValueContext.ts

@@ -19,8 +19,8 @@ export interface ValueContext<RuntimeValue> extends EvaluationContext {
 	readonly definition: ValueContextDefinition;
 	readonly contextNode: Element;
 
-	get isReadonly(): boolean;
-	get isRelevant(): boolean;
+	isReadonly(): boolean;
+	isRelevant(): boolean;
 
 	readonly encodeValue: (this: unknown, runtimeValue: RuntimeValue) => InstanceValue;
 	readonly decodeValue: (this: unknown, instanceValue: InstanceValue) => RuntimeValue;

package/src/lib/TokenListParser.ts

@@ -0,0 +1,156 @@
+import { xmlXPathWhitespaceSeparatedList } from '@getodk/common/lib/string/whitespace.ts';
+import type { PartiallyKnownString } from '@getodk/common/types/string/PartiallyKnownString.ts';
+
+type SymbolIterator = typeof Symbol.iterator;
+
+type TokenListKey<CanonicalToken extends string> =
+	| PartiallyKnownString<CanonicalToken>
+	| SymbolIterator;
+
+type TokenListIterator<CanonicalToken extends string> = IterableIterator<
+	PartiallyKnownString<CanonicalToken>
+>;
+
+/**
+ * @see {@link TokenListParser}
+ */
+// prettier-ignore
+export type TokenList<CanonicalToken extends string = string> = {
+	readonly [Key in TokenListKey<CanonicalToken>]:
+		Key extends SymbolIterator
+			? () => TokenListIterator<CanonicalToken>
+			: boolean;
+};
+
+interface TokenListAlias<CanonicalToken extends string> {
+	readonly fromAlias: string;
+	readonly toCanonical: CanonicalToken;
+}
+
+type TokenAliases<CanonicalToken extends string> = ReadonlyArray<TokenListAlias<CanonicalToken>>;
+
+interface TokenListParserOptions<CanonicalToken extends string> {
+	readonly aliases?: TokenAliases<CanonicalToken>;
+}
+
+type TokenListAttributeName = PartiallyKnownString<'appearance' | 'class'>;
+
+/**
+ * Intended primarily for use in parsing these features:
+ *
+ * - {@link https://getodk.github.io/xforms-spec/#appearances | appearances} ({@link https://xlsform.org/en/#appearance | additional documentation})
+ *
+ * - {@link https://getodk.github.io/xforms-spec/#body-attributes | body `class` attribute}
+ *
+ * This class is named as a reference to {@link DOMTokenList}
+ * ({@link https://developer.mozilla.org/en-US/docs/Web/API/DOMTokenList | MDN}),
+ * with these similarities:
+ *
+ * - Represents a value whose serialization is a space-separated list.
+ * - Each member ("token") is a string (without whitespace).
+ * - Provides set-like semantics to determine presence of members.
+ * - Provides ordering semantics as determined by the serialization.
+ *
+ * This class differs from that prior art in that:
+ *
+ * - It provides a notion of "canonical" members. This is _mostly_ (but not
+ *   entirely) intended as a convenience to client developers, automatically
+ *   populating canonical/known tokens for a given parser type in
+ *   editor-provided autocomplete, etc. **Importantly**, non-canonical tokens
+ *   _are not ignored_ in either the {@link TokenList}'s types or runtime
+ *   values.
+ *
+ * - Provided "canonical" members may also be used to specify
+ *   {@link TokenListParserOptions.aliases | optional aliases}. (Example: when
+ *   parsing "appearances", an alias might map an older deprecated appearance to
+ *   a newer canonical equivalent.) **Importantly**, when a token matches an
+ *   alias, both that alias _and the token as-specified_ will be present in the
+ *   produced {@link TokenList}.
+ *
+ * - As a parser, it is intended to be read-only. The serialized format which it
+ *   parses is _generally_ the source of truth (excepting e.g. aliases).
+ *   Notably, and as mentioned above, ordering is determined by:
+ *
+ *     - Iterating each member, as provided by the serialized representation
+ *
+ *     - If that member corresponds to an alias, that alias is yielded first
+ *
+ *     - Regardless of whether the member corresponds to an alias, the member is
+ *       yielded as-specified
+ *
+ * - A parsed {@link TokenList} is intended to maximize convenience of read-only
+ *   access. Despite many _conceptual similarities_, most of the
+ *   {@link DOMTokenList} **interface** is eschewed in favor of two (mutually
+ *   equivalent) access mechanisms:
+ *
+ *     - `Iterable<Token>`, with the ordering semantics described above
+ *     - `Record<Token, boolean>`
+ *
+ * \* This may change, as we refine requirements. In the future, we may
+ * introduce a notion of mutually exclusive tokens (e.g. "appearances" which
+ * cannot be used together), which may in turn utilize instance-defined ordering
+ * as part of that mechanism.
+ */
+export class TokenListParser<
+	CanonicalToken extends string,
+	// Note: this is a separate type parameter so that specifying an alias does
+	// not cause it to be mistakenly inferred as a `CanonicalToken` which was
+	// not otherwise specified.
+	TokenAlias extends CanonicalToken = CanonicalToken,
+> {
+	private readonly aliases: ReadonlyMap<string, CanonicalToken>;
+
+	constructor(
+		readonly canonicalTokens: readonly CanonicalToken[],
+		options?: TokenListParserOptions<TokenAlias>
+	) {
+		this.aliases = new Map(
+			(options?.aliases ?? []).map(({ fromAlias, toCanonical }) => {
+				return [fromAlias, toCanonical];
+			})
+		);
+	}
+
+	parseFrom(element: Element, attributeName: TokenListAttributeName): TokenList<CanonicalToken> {
+		const serialized = element.getAttribute(attributeName) ?? '';
+		const specified = xmlXPathWhitespaceSeparatedList(serialized, {
+			ignoreEmpty: true,
+		});
+		const { aliases } = this;
+		const resolved = specified.flatMap((token) => {
+			const alias = aliases.get(token);
+
+			if (alias == null) {
+				return token;
+			}
+
+			return [alias, token];
+		});
+		const tokens = new Set(resolved);
+
+		return new Proxy(
+			{
+				[Symbol.iterator]() {
+					return resolved.values();
+				},
+			} satisfies TokenList<string> as TokenList<CanonicalToken>,
+			{
+				get(target, property, receiver) {
+					if (typeof property === 'symbol') {
+						return Reflect.get(target, property, receiver);
+					}
+
+					return tokens.has(property);
+				},
+
+				set() {
+					return false;
+				},
+			}
+		);
+	}
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type ParsedTokenList<Parser extends TokenListParser<any>> =
+	Parser extends TokenListParser<infer CanonicalToken> ? TokenList<CanonicalToken> : never;

package/src/lib/dom/query.ts

@@ -9,6 +9,10 @@ const hintLookup = new ScopedElementLookup(':scope > hint', 'hint');
 const itemLookup = new ScopedElementLookup(':scope > item', 'item');
 const itemsetLookup = new ScopedElementLookup(':scope > itemset[nodeset]', 'itemset[nodeset]');
 const labelLookup = new ScopedElementLookup(':scope > label', 'label');
+const repeatGroupLabelLookup = new ScopedElementLookup(
+	':scope > label[form-definition-source="repeat-group"]',
+	'label[form-definition-source="repeat-group"]'
+);
 const repeatLookup = new ScopedElementLookup(':scope > repeat[nodeset]', 'repeat[nodeset]');
 const valueLookup = new ScopedElementLookup(':scope > value', 'value');
 
@@ -20,6 +24,11 @@ export interface ItemsetElement extends KnownAttributeLocalNamedElement<'itemset
 
 export interface LabelElement extends LocalNamedElement<'label'> {}
 
+export interface RepeatGroupLabelElement extends LabelElement {
+	getAttribute(name: 'form-definition-source'): 'repeat-group';
+	getAttribute(name: string): string;
+}
+
 export interface RepeatElement extends KnownAttributeLocalNamedElement<'repeat', 'nodeset'> {}
 
 export interface ValueElement extends LocalNamedElement<'value'> {}
@@ -40,6 +49,10 @@ export const getLabelElement = (parent: Element): LabelElement | null => {
 	return labelLookup.getElement<LabelElement>(parent);
 };
 
+export const getRepeatGroupLabelElement = (parent: Element): RepeatGroupLabelElement | null => {
+	return repeatGroupLabelLookup.getElement<RepeatGroupLabelElement>(parent);
+};
+
 export const getRepeatElement = (parent: Element): RepeatElement | null => {
 	return repeatLookup.getElement<RepeatElement>(parent);
 };

package/src/lib/reactivity/createChildrenState.ts

@@ -1,4 +1,5 @@
-import { createMemo, createSignal, type Accessor, type Setter, type Signal } from 'solid-js';
+import type { Accessor, Setter, Signal } from 'solid-js';
+import { createSignal } from 'solid-js';
 import type { OpaqueReactiveObjectFactory } from '../../index.ts';
 import type { AnyChildNode, AnyParentNode } from '../../instance/hierarchy.ts';
 import type { NodeID } from '../../instance/identity.ts';
@@ -44,11 +45,55 @@ export const createChildrenState = <Parent extends AnyParentNode, Child extends
 	parent: Parent
 ): ChildrenState<Child> => {
 	return parent.scope.runTask(() => {
-		const children = createSignal<readonly Child[]>([]);
-		const [getChildren, setChildren] = children;
-		const childIds = createMemo((): readonly NodeID[] => {
-			return getChildren().map((child) => child.nodeId);
-		});
+		const baseState = createSignal<readonly Child[]>([]);
+		const [getChildren, baseSetChildren] = baseState;
+
+		/**
+		 * Note: this is clearly derived state. It would be obvious to use
+		 * `createMemo`, which is exactly what a previous iteration did. This caused
+		 * mysterious issues when clients:
+		 *
+		 * - Also used Solid-based reactivity
+		 * - Accessed node children state within their own `createMemo` calls
+		 *
+		 * It's quite likely that there's a more robust and general solution, which
+		 * may be applicable if we also generalize this approach to
+		 * encode/materialize shared structured state (e.g. it may be applicable for
+		 * select values, form language, probably much more in coming features).
+		 *
+		 * In the meantime, while this approach is marginally more complex, it is
+		 * likely also slightly more efficient. We can revisit the tradeoff if/when
+		 * those hypothetical generalizations become a priority.
+		 */
+		const ids = createSignal<readonly NodeID[]>([]);
+		const [childIds, setChildIds] = ids;
+
+		type ChildrenSetterCallback = (prev: readonly Child[]) => readonly Child[];
+		type ChildrenOrSetterCallback = ChildrenSetterCallback | readonly Child[];
+
+		const setChildren: Setter<readonly Child[]> = (
+			valueOrSetterCallback: ChildrenOrSetterCallback
+		) => {
+			let setterCallback: ChildrenSetterCallback;
+
+			if (typeof valueOrSetterCallback === 'function') {
+				setterCallback = valueOrSetterCallback;
+			} else {
+				setterCallback = (_) => valueOrSetterCallback;
+			}
+
+			return baseSetChildren((prev) => {
+				const result = setterCallback(prev);
+
+				setChildIds(() => {
+					return result.map((child) => child.nodeId);
+				});
+
+				return result;
+			});
+		};
+
+		const children: Signal<readonly Child[]> = [getChildren, setChildren];
 
 		return {
 			children,

package/src/lib/reactivity/createComputedExpression.ts

@@ -87,7 +87,7 @@ export const createComputedExpression = <Type extends DependentExpressionResultT
 
 		const getReferencedDependencies = createMemo(() => {
 			return dependencyReferences.flatMap((reference) => {
-				return context.getSubscribableDependencyByReference(reference) ?? [];
+				return context.getSubscribableDependenciesByReference(reference) ?? [];
 			});
 		});
 

package/src/lib/reactivity/createSelectItems.ts

@@ -52,10 +52,7 @@ class ItemsetItemEvaluationContext implements EvaluationContext {
 	readonly scope: ReactiveScope;
 	readonly evaluator: XFormsXPathEvaluator;
 	readonly root: EvaluationContextRoot;
-
-	get contextReference(): string {
-		return this.selectField.contextReference;
-	}
+	readonly contextReference: Accessor<string>;
 
 	constructor(
 		private readonly selectField: SelectField,
@@ -64,10 +61,11 @@ class ItemsetItemEvaluationContext implements EvaluationContext {
 		this.scope = selectField.scope;
 		this.evaluator = selectField.evaluator;
 		this.root = selectField.root;
+		this.contextReference = selectField.contextReference;
 	}
 
-	getSubscribableDependencyByReference(reference: string): SubscribableDependency | null {
-		return this.selectField.getSubscribableDependencyByReference(reference);
+	getSubscribableDependenciesByReference(reference: string): readonly SubscribableDependency[] {
+		return this.selectField.getSubscribableDependenciesByReference(reference);
 	}
 }
 

package/src/lib/reactivity/createValueState.ts

@@ -72,7 +72,7 @@ const createPrimaryInstanceValueState = <RuntimeValue>(
 
 		const persistedValueState = createSignal<PersistedValueState>(
 			{
-				isRelevant: context.isRelevant,
+				isRelevant: context.isRelevant(),
 				value: initialValue,
 			},
 			{
@@ -91,7 +91,7 @@ const createPrimaryInstanceValueState = <RuntimeValue>(
 		const [persistedValue, setValueForPersistence] = persistedValueState;
 
 		createComputed(() => {
-			const isRelevant = context.isRelevant;
+			const isRelevant = context.isRelevant();
 
 			setValueForPersistence((persisted) => {
 				return {
@@ -122,7 +122,7 @@ const createPrimaryInstanceValueState = <RuntimeValue>(
 		const setPrimaryInstanceValue: SimpleAtomicStateSetter<string> = (value) => {
 			// TODO: Check (error?) for non-relevant value change?
 			const persisted = setValueForPersistence({
-				isRelevant: context.isRelevant,
+				isRelevant: context.isRelevant(),
 				value,
 			});
 
@@ -189,8 +189,8 @@ const guardDownstreamReadonlyWrites = <RuntimeValue>(
 	const [getValue, baseSetValue] = baseState;
 
 	const setValue: SimpleAtomicStateSetter<RuntimeValue> = (value) => {
-		if (context.isReadonly) {
-			const reference = untrack(() => context.contextReference);
+		if (context.isReadonly()) {
+			const reference = untrack(() => context.contextReference());
 
 			throw new Error(`Cannot write to readonly field: ${reference}`);
 		}
@@ -215,7 +215,7 @@ const createCalculation = <RuntimeValue>(
 		const calculate = createComputedExpression(context, calculateDefinition);
 
 		createComputed(() => {
-			if (context.isRelevant) {
+			if (context.isRelevant()) {
 				const calculated = calculate();
 				const value = context.decodeValue(calculated);
 

package/src/lib/reactivity/materializeCurrentStateChildren.ts

@@ -3,6 +3,7 @@ import type { NodeID } from '../../instance/identity.ts';
 import type { ChildrenState, createChildrenState } from './createChildrenState.ts';
 import type { ClientState } from './node-state/createClientState.ts';
 import type { CurrentState } from './node-state/createCurrentState.ts';
+import type { ReactiveScope } from './scope.ts';
 
 interface InconsistentChildrenStateDetails {
 	readonly missingIds: readonly NodeID[];
@@ -96,6 +97,7 @@ export const materializeCurrentStateChildren = <
 	Child extends AnyChildNode,
 	ParentState extends EncodedParentState,
 >(
+	scope: ReactiveScope,
 	currentState: ParentState,
 	childrenState: ChildrenState<Child>
 ): MaterializedChildren<ParentState, Child> => {
@@ -105,7 +107,7 @@ export const materializeCurrentStateChildren = <
 	return new Proxy(proxyTarget, {
 		get(_, key) {
 			if (key === 'children') {
-				const expectedChildIDs = currentState.children;
+				const expectedChildIDs = scope.runTask(() => currentState.children);
 				const children = childrenState.getChildren();
 
 				if (import.meta.env.DEV) {

package/src/model/DescendentNodeDefinition.ts

@@ -1,5 +1,4 @@
 import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
-import type { RepeatDefinition } from '../body/RepeatDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import type {
 	ModelNode,
@@ -14,7 +13,7 @@ import type { RootDefinition } from './RootDefinition.ts';
 
 export type DescendentNodeType = Exclude<NodeDefinitionType, 'root'>;
 
-type DescendentNodeBodyElement = AnyBodyElementDefinition | RepeatDefinition;
+type DescendentNodeBodyElement = AnyBodyElementDefinition;
 
 export abstract class DescendentNodeDefinition<
 	Type extends DescendentNodeType,

package/src/model/ModelDefinition.ts

@@ -8,7 +8,7 @@ export class ModelDefinition {
 
 	constructor(readonly form: XFormDefinition) {
 		this.binds = ModelBindMap.fromModel(this);
-		this.root = new RootDefinition(form, this);
+		this.root = new RootDefinition(form, this, form.body.classes);
 	}
 
 	toJSON() {

package/src/model/NodeDefinition.ts

@@ -1,8 +1,8 @@
 import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
-import type { RepeatDefinition } from '../body/RepeatDefinition.ts';
+import type { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import type { RepeatInstanceDefinition } from './RepeatInstanceDefinition.ts';
-import type { RepeatSequenceDefinition } from './RepeatSequenceDefinition.ts';
+import type { RepeatRangeDefinition } from './RepeatRangeDefinition.ts';
 import type { RepeatTemplateDefinition } from './RepeatTemplateDefinition.ts';
 import type { RootDefinition } from './RootDefinition.ts';
 import type { SubtreeDefinition } from './SubtreeDefinition.ts';
@@ -17,13 +17,13 @@ import type { ValueNodeDefinition } from './ValueNodeDefinition.ts';
 export type RootNodeType = 'root';
 
 /**
- * Corresponds to a sequence of model/entry DOM subtrees which in turn
+ * Corresponds to a range/sequence of model/entry DOM subtrees which in turn
  * corresponds to a <repeat> in the form body definition.
  */
-export type RepeatSequenceType = 'repeat-sequence';
+export type RepeatRangeType = 'repeat-range';
 
 /**
- * Corresponds to a template definition for a repeat sequence, which either has
+ * Corresponds to a template definition for a repeat range, which either has
  * an explicit `jr:template=""` attribute in the form definition or is inferred
  * as a template from the form's first element matched by a <repeat nodeset>.
  */
@@ -32,7 +32,7 @@ export type RepeatTemplateType = 'repeat-template';
 /**
  * Corresponds to a single instance of a model/entry DOM subtree which
  * in turn corresponds to a <repeat> in the form body definition, and a
- * 'repeat-sequence' definition.
+ * 'repeat-range' definition.
  */
 export type RepeatInstanceType = 'repeat-instance';
 
@@ -55,7 +55,7 @@ export type ValueNodeType = 'value-node';
 export type NodeDefinitionType =
 	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
 	| RootNodeType
-	| RepeatSequenceType
+	| RepeatRangeType
 	| RepeatTemplateType
 	| RepeatInstanceType
 	| SubtreeNodeType
@@ -71,7 +71,7 @@ export type ParentNodeDefinition =
 
 // prettier-ignore
 export type ChildNodeDefinition =
-	| RepeatSequenceDefinition
+	| RepeatRangeDefinition
 	| SubtreeDefinition
 	| ValueNodeDefinition;
 
@@ -91,7 +91,7 @@ export type NodeChildren<Type extends NodeDefinitionType> =
 
 // prettier-ignore
 export type NodeInstances<Type extends NodeDefinitionType> =
-	Type extends 'repeat-sequence'
+	Type extends 'repeat-range'
 		? readonly RepeatInstanceDefinition[]
 		: null;
 
@@ -104,7 +104,7 @@ export type NodeParent<Type extends NodeDefinitionType> =
 // TODO: value-node may be Attr
 // prettier-ignore
 export type ModelNode<Type extends NodeDefinitionType> =
-	Type extends 'repeat-sequence'
+	Type extends 'repeat-range'
 		? null
 		: Element;
 
@@ -120,7 +120,7 @@ export interface NodeDefinition<Type extends NodeDefinitionType> {
 	readonly bind: BindDefinition;
 	readonly nodeset: string;
 	readonly nodeName: string;
-	readonly bodyElement: AnyBodyElementDefinition | RepeatDefinition | null;
+	readonly bodyElement: AnyBodyElementDefinition | RepeatElementDefinition | null;
 
 	readonly isTranslated: boolean;
 	readonly dependencyExpressions: ReadonlySet<string>;
@@ -137,7 +137,7 @@ export interface NodeDefinition<Type extends NodeDefinitionType> {
 export type AnyNodeDefinition =
 	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
 	| RootDefinition
-	| RepeatSequenceDefinition
+	| RepeatRangeDefinition
 	| RepeatTemplateDefinition
 	| RepeatInstanceDefinition
 	| SubtreeDefinition

package/src/model/RepeatInstanceDefinition.ts

@@ -1,10 +1,10 @@
-import { RepeatDefinition } from '../body/RepeatDefinition.ts';
+import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
 import type { ChildNodeDefinition, NodeDefinition } from './NodeDefinition.ts';
-import type { RepeatSequenceDefinition } from './RepeatSequenceDefinition.ts';
+import type { RepeatRangeDefinition } from './RepeatRangeDefinition.ts';
 
 export class RepeatInstanceDefinition
-	extends DescendentNodeDefinition<'repeat-instance', RepeatDefinition>
+	extends DescendentNodeDefinition<'repeat-instance', RepeatElementDefinition>
 	implements NodeDefinition<'repeat-instance'>
 {
 	readonly type = 'repeat-instance';
@@ -15,24 +15,19 @@ export class RepeatInstanceDefinition
 	readonly defaultValue = null;
 
 	constructor(
-		protected readonly sequence: RepeatSequenceDefinition,
+		range: RepeatRangeDefinition,
 		readonly node: Element
 	) {
-		const {
-			bind,
-			bodyElement: repeatGroupBodyElement,
-			parent: repeatSequenceParent,
-			root,
-		} = sequence;
+		const { bind, bodyElement, parent, root } = range;
 
-		super(repeatSequenceParent, bind, repeatGroupBodyElement.repeat);
+		super(parent, bind, bodyElement);
 
-		this.nodeName = sequence.nodeName;
+		this.nodeName = range.nodeName;
 		this.children = root.buildSubtree(this);
 	}
 
 	toJSON() {
-		const { bind, bodyElement, parent, root, sequence, ...rest } = this;
+		const { bind, bodyElement, parent, root, ...rest } = this;
 
 		return rest;
 	}

package/src/model/{RepeatSequenceDefinition.ts → RepeatRangeDefinition.ts}

@@ -1,13 +1,13 @@
-import { RepeatGroupDefinition } from '../body/group/RepeatGroupDefinition.ts';
+import type { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
 import type { NodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
 import { RepeatInstanceDefinition } from './RepeatInstanceDefinition.ts';
 import { RepeatTemplateDefinition } from './RepeatTemplateDefinition.ts';
 
-export class RepeatSequenceDefinition
-	extends DescendentNodeDefinition<'repeat-sequence', RepeatGroupDefinition>
-	implements NodeDefinition<'repeat-sequence'>
+export class RepeatRangeDefinition
+	extends DescendentNodeDefinition<'repeat-range', RepeatElementDefinition>
+	implements NodeDefinition<'repeat-range'>
 {
 	// TODO: if an implicit template is derived from an instance in a form
 	// definition, should its default values (if any) be cleared? Probably!
@@ -19,7 +19,7 @@ export class RepeatSequenceDefinition
 		return templateElement.cloneNode(true) as Element;
 	}
 
-	readonly type = 'repeat-sequence';
+	readonly type = 'repeat-range';
 
 	readonly template: RepeatTemplateDefinition;
 	readonly children = null;
@@ -32,7 +32,7 @@ export class RepeatSequenceDefinition
 	constructor(
 		parent: ParentNodeDefinition,
 		bind: BindDefinition,
-		bodyElement: RepeatGroupDefinition,
+		bodyElement: RepeatElementDefinition,
 		modelNodes: readonly [Element, ...Element[]]
 	) {
 		super(parent, bind, bodyElement);