@getodk/xforms-engine 0.1.0

package/src/expression/DependencyContext.ts

@@ -0,0 +1,53 @@
+import type { AnyDependentExpression } from './DependentExpression.ts';
+
+export abstract class DependencyContext {
+	abstract get parentReference(): string | null;
+	abstract get reference(): string | null;
+
+	protected readonly dependentExpressions = new Set<AnyDependentExpression>();
+
+	protected dependencyExpressionsCache: ReadonlySet<string> | null = null;
+
+	get dependencyExpressions(): ReadonlySet<string> {
+		let { dependencyExpressionsCache } = this;
+
+		if (dependencyExpressionsCache == null) {
+			dependencyExpressionsCache = new Set(
+				Array.from(this.dependentExpressions).flatMap((expression) => {
+					return Array.from(expression.dependencyReferences);
+				})
+			);
+			this.dependencyExpressionsCache = dependencyExpressionsCache;
+		}
+
+		return dependencyExpressionsCache;
+	}
+
+	get isTranslated(): boolean {
+		return this._isTranslated;
+	}
+
+	// Note: this is a bit of type system "cleverness" that helped to prevent a
+	// bug repeatedly encountered in earlier prototyping. The default value is
+	// false (currently backed by _isTranslated; this note should be updated if
+	// that changes). Its value can be read at any time, but it may only be
+	// overridden with `true`. So if a `DependencyContext` is established as
+	// dependent on translations by one `DependentExpression`, another expression
+	// which does not depend on translations cannot override that.
+	//
+	// This doesn't deserve so much explanation in its own right, but it's worth
+	// calling out here as a pattern we may find valuable in other cases where
+	// interfaces allow writes from outside (which I've generally tried to avoid,
+	// or significantly restrict, to avoid bugs like the one described above).
+	set isTranslated(value: true) {
+		this._isTranslated = value;
+	}
+
+	// Update note on `set isTranslated` if this internal storage changes.
+	protected _isTranslated = false;
+
+	registerDependentExpression(expression: AnyDependentExpression): void {
+		this.dependencyExpressionsCache = null;
+		this.dependentExpressions.add(expression);
+	}
+}

package/src/expression/DependentExpression.ts

@@ -0,0 +1,102 @@
+import type { XFormsXPathEvaluator } from '@getodk/xpath';
+import { getNodesetDependencies, isItextFunctionCalled } from '../lib/xpath/analysis.ts';
+import type { DependencyContext } from './DependencyContext.ts';
+
+const evaluatorMethodsByResultType = {
+	boolean: 'evaluateBoolean',
+	nodes: 'evaluateNodes',
+	string: 'evaluateString',
+} as const;
+
+type EvaluatorMethodsByResultType = typeof evaluatorMethodsByResultType;
+
+export type DependentExpressionResultType = keyof EvaluatorMethodsByResultType;
+
+export type DependentExpressionEvaluatorMethod<Type extends DependentExpressionResultType> =
+	EvaluatorMethodsByResultType[Type];
+
+export type DependentExpressionResult<Type extends DependentExpressionResultType> = ReturnType<
+	XFormsXPathEvaluator[DependentExpressionEvaluatorMethod<Type>]
+>;
+
+interface SemanticDependencyOptions {
+	/**
+	 * @default false
+	 */
+	readonly parentContext?: boolean | undefined;
+
+	/**
+	 * @default false
+	 */
+	readonly translations?: boolean | undefined;
+}
+
+interface DependentExpressionOptions {
+	/**
+	 * @default false
+	 */
+	readonly ignoreContextReference?: boolean;
+
+	/**
+	 * @default true
+	 */
+	readonly ignoreNullExpressions?: boolean;
+
+	readonly semanticDependencies?: SemanticDependencyOptions;
+}
+
+export class DependentExpression<Type extends DependentExpressionResultType> {
+	readonly dependencyReferences: ReadonlySet<string> = new Set();
+	readonly isTranslated: boolean = false;
+	readonly evaluatorMethod: DependentExpressionEvaluatorMethod<Type>;
+
+	constructor(
+		context: DependencyContext,
+		readonly resultType: Type,
+		readonly expression: string,
+		options: DependentExpressionOptions = {}
+	) {
+		this.evaluatorMethod = evaluatorMethodsByResultType[resultType];
+
+		const {
+			ignoreContextReference = false,
+			ignoreNullExpressions = true,
+			semanticDependencies = {
+				parentContext: false,
+				translations: false,
+			},
+		} = options;
+
+		const dependencyReferences = new Set<string>(
+			getNodesetDependencies(expression, {
+				contextReference: context.reference,
+				ignoreContextReference,
+				ignoreNullExpressions,
+			})
+		);
+
+		const parentDependency = semanticDependencies.parentContext ? context.parentReference : null;
+
+		if (parentDependency != null) {
+			dependencyReferences.add(parentDependency);
+		}
+
+		this.dependencyReferences = dependencyReferences;
+
+		const isTranslated = semanticDependencies.translations && isItextFunctionCalled(expression);
+
+		if (isTranslated) {
+			this.isTranslated = true;
+			context.isTranslated = true;
+		}
+
+		context.registerDependentExpression(this);
+	}
+
+	toString(): string | null {
+		return this.expression;
+	}
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AnyDependentExpression = DependentExpression<any>;

package/src/index.ts

@@ -0,0 +1,35 @@
+import type { InitializeForm } from './index.ts';
+import { initializeForm as engine__initializeForm } from './instance/index.ts';
+
+export const initializeForm: InitializeForm = engine__initializeForm;
+
+export type * from './client/EngineConfig.ts';
+export type * from './client/FormLanguage.ts';
+export type * from './client/GroupNode.ts';
+export type * from './client/OpaqueReactiveObjectFactory.ts';
+export type * from './client/RepeatInstanceNode.ts';
+export type * from './client/RepeatRangeNode.ts';
+export type * from './client/RootNode.ts';
+export type * from './client/SelectNode.ts';
+export type * from './client/StringNode.ts';
+export type * from './client/SubtreeNode.ts';
+export type * from './client/TextRange.ts';
+export type {
+	AnyChildNode,
+	AnyLeafNode,
+	AnyNode,
+	AnyParentNode,
+	GeneralChildNode,
+	GeneralParentNode,
+} from './client/hierarchy.ts';
+export type * from './client/index.ts';
+
+// TODO: notwithstanding potential conflicts with parallel work on `web-forms`
+// (former `ui-vue`), these are the last remaining references **outside of
+// `xforms-engine`** to anything besides /client/* and the `initializeForm`
+// entrypoint implementation. We'll refine the various `definition` types in due
+// time.
+export type {
+	AnySelectDefinition,
+	SelectDefinition,
+} from './body/control/select/SelectDefinition.ts';

package/src/instance/Group.ts

@@ -0,0 +1,82 @@
+import type { Accessor } from 'solid-js';
+import type { GroupDefinition, GroupNode } 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';
+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';
+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 { createNodeLabel } from '../lib/reactivity/text/createNodeLabel.ts';
+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';
+
+// prettier-ignore
+interface GroupStateSpec extends DescendantNodeSharedStateSpec {
+	readonly label: Accessor<TextRange<'label'> | null>;
+	readonly hint: null;
+	readonly children: Accessor<readonly NodeID[]>;
+	readonly valueOptions: null;
+	readonly value: null;
+}
+
+export class Group
+	extends DescendantNode<GroupDefinition, GroupStateSpec, GeneralChildNode>
+	implements GroupNode, EvaluationContext, SubscribableDependency
+{
+	private readonly childrenState: ChildrenState<GeneralChildNode>;
+
+	// InstanceNode
+	protected readonly state: SharedNodeState<GroupStateSpec>;
+	protected override engineState: EngineState<GroupStateSpec>;
+
+	// GroupNode
+	readonly currentState: MaterializedChildren<CurrentState<GroupStateSpec>, GeneralChildNode>;
+
+	readonly nodeType = 'group';
+
+	constructor(parent: GeneralParentNode, definition: GroupDefinition) {
+		super(parent, definition);
+
+		const childrenState = createChildrenState<Group, GeneralChildNode>(this);
+
+		this.childrenState = childrenState;
+
+		const state = createSharedNodeState(
+			this.scope,
+			{
+				...this.buildSharedStateSpec(parent, definition),
+
+				label: createNodeLabel(this, definition),
+				hint: null,
+				children: childrenState.childIds,
+				valueOptions: null,
+				value: null,
+			},
+			{
+				clientStateFactory: this.engineConfig.stateFactory,
+			}
+		);
+
+		this.state = state;
+		this.engineState = state.engineState;
+		this.currentState = materializeCurrentStateChildren(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

@@ -0,0 +1,164 @@
+import type { Accessor } from 'solid-js';
+import { createComputed, createSignal, on } from 'solid-js';
+import type { RepeatDefinition, RepeatInstanceNode } 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';
+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';
+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 { createNodeLabel } from '../lib/reactivity/text/createNodeLabel.ts';
+import type { RepeatRange } from './RepeatRange.ts';
+import type { DescendantNodeSharedStateSpec } from './abstract/DescendantNode.ts';
+import { DescendantNode } from './abstract/DescendantNode.ts';
+import { buildChildren } from './children.ts';
+import type { AnyChildNode, GeneralChildNode } 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';
+
+export type { RepeatDefinition };
+
+interface RepeatInstanceStateSpec extends DescendantNodeSharedStateSpec {
+	readonly label: Accessor<TextRange<'label'> | null>;
+	readonly hint: null;
+	readonly children: Accessor<readonly NodeID[]>;
+	readonly valueOptions: null;
+	readonly value: null;
+}
+
+interface RepeatInstanceOptions {
+	readonly precedingPrimaryInstanceNode: Comment | Element;
+	readonly precedingInstance: RepeatInstance | null;
+}
+
+export class RepeatInstance
+	extends DescendantNode<RepeatDefinition, RepeatInstanceStateSpec, GeneralChildNode>
+	implements RepeatInstanceNode, EvaluationContext, SubscribableDependency
+{
+	private readonly childrenState: ChildrenState<GeneralChildNode>;
+	private readonly currentIndex: Accessor<number>;
+
+	// InstanceNode
+	protected readonly state: SharedNodeState<RepeatInstanceStateSpec>;
+	protected override engineState: EngineState<RepeatInstanceStateSpec>;
+
+	// RepeatInstanceNode
+	readonly nodeType = 'repeat-instance';
+
+	readonly currentState: MaterializedChildren<
+		CurrentState<RepeatInstanceStateSpec>,
+		GeneralChildNode
+	>;
+
+	constructor(
+		override readonly parent: RepeatRange,
+		definition: RepeatDefinition,
+		options: RepeatInstanceOptions
+	) {
+		super(parent, definition);
+
+		const childrenState = createChildrenState<RepeatInstance, GeneralChildNode>(this);
+
+		this.childrenState = childrenState;
+
+		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),
+
+				label: createNodeLabel(this, definition),
+				hint: null,
+				children: childrenState.childIds,
+				valueOptions: null,
+				value: null,
+			},
+			{
+				clientStateFactory: this.engineConfig.stateFactory,
+			}
+		);
+
+		this.state = state;
+		this.engineState = state.engineState;
+		this.currentState = materializeCurrentStateChildren(state.currentState, childrenState);
+
+		// Maintain current index state, updating as the parent range's children
+		// state is changed. Notable Solid reactivity nuances:
+		//
+		// - `createComputed` is the Solid API which is explicitly called out for
+		//   supporting performing reactive writes. It's also generally considered a
+		//   "smell", but it seems the most appropriate for a first pass on this.
+		// - `on(..., { defer: true })` allows us to *synchronously* delay reactive
+		//   index updates until after the full form tree is built, where this
+		//   `RepeatInstance` is being constructed but it hasn't yet been appended
+		//   to the parent range's reactive `children`.
+		// - the same logic for deferring reaction on form init should apply for
+		//   adding new instances to a live form.
+		this.scope.runTask(() => {
+			// TODO: even as minimal as this currently is, maybe we should move this
+			// into a named function under src/lib/reactivity (for consistency with
+			// other reactive implementations of specific XForms semantics)?
+			const computeCurrentIndex = parent.getInstanceIndex.bind(parent, this);
+
+			createComputed(on(computeCurrentIndex, setCurrentIndex, { defer: true }));
+		});
+
+		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);
+	}
+
+	override subscribe(): void {
+		super.subscribe();
+		this.currentIndex();
+	}
+
+	getChildren(): readonly GeneralChildNode[] {
+		return this.childrenState.getChildren();
+	}
+
+	/**
+	 * Performs repeat instance node-specific removal logic, then general node
+	 * removal logic, in that order:
+	 *
+	 * 1. At present, before any reactive state change is performed, the repeat
+	 *    instance's {@link contextNode} is removed from the primary instance's
+	 *    XML DOM backing store (which also removes any descendant nodes from that
+	 *    store, as a side effect). This behavior may become unnecessary if/when
+	 *    we phase out use of this XML DOM backing store. This should be peformed
+	 *    first, so that any following reactive logic which evaluates affected
+	 *    XPath expressions will be performed against a state consistent with the
+	 *    repeat instance's removal (and that of its XML DOM descendants).
+	 *
+	 * 2. Performs any remaining removal logic as defined in
+	 *    {@link DescendantNode.remove}.
+	 *
+	 * These removal steps **must also** occur before any update to the parent
+	 * {@link RepeatRange}'s reactive children state.
+	 */
+	override remove(this: AnyChildNode): void {
+		this.contextNode.remove();
+
+		super.remove();
+	}
+}

package/src/instance/RepeatRange.ts

@@ -0,0 +1,214 @@
+import { insertAtIndex } from '@getodk/common/lib/array/insert.ts';
+import type { Accessor } from 'solid-js';
+import type { RepeatRangeNode } from '../client/RepeatRangeNode.ts';
+import type { ChildrenState } from '../lib/reactivity/createChildrenState.ts';
+import { createChildrenState } from '../lib/reactivity/createChildrenState.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';
+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 { createNodeLabel } from '../lib/reactivity/text/createNodeLabel.ts';
+import type { RepeatSequenceDefinition } from '../model/RepeatSequenceDefinition.ts';
+import type { RepeatDefinition } from './RepeatInstance.ts';
+import { RepeatInstance } from './RepeatInstance.ts';
+import type { Root } from './Root.ts';
+import type { DescendantNodeSharedStateSpec } from './abstract/DescendantNode.ts';
+import { DescendantNode } from './abstract/DescendantNode.ts';
+import type { 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 { TextRange } from './text/TextRange.ts';
+
+interface RepeatRangeStateSpec extends DescendantNodeSharedStateSpec {
+	readonly hint: null;
+	readonly label: Accessor<TextRange<'label'> | null>;
+	readonly children: Accessor<readonly NodeID[]>;
+	readonly valueOptions: null;
+	readonly value: null;
+}
+
+export class RepeatRange
+	extends DescendantNode<RepeatSequenceDefinition, RepeatRangeStateSpec, RepeatInstance>
+	implements RepeatRangeNode, EvaluationContext, SubscribableDependency
+{
+	/**
+	 * A repeat range doesn't have a corresponding primary instance element of its
+	 * own, and its instances are appended to the range's parent element. During
+	 * creation of the initial primary instance state and DOM trees, we _could_
+	 * reliably append all of the range's instances in order as the definition
+	 * tree is recursed. But that would fail to handle some instance addition
+	 * cases afterwards.
+	 *
+	 * Most notably, we need to know where in the primary instance tree to append
+	 * instances created for a range which is currently empty. As a lucky
+	 * coincidence, this need coincides with the ability to add instances at any
+	 * arbitrary index within the range. In each case, we can reference a primary
+	 * instance DOM node which will become the new instance's preceding sibling.
+	 * Where the range is empty, we use this {@link Comment} node (itself created
+	 * and appended during range initialization) in lieu of a nonexistent
+	 * preceding instance's {@link contextNode}.
+	 *
+	 * @todo We likely want to remove these during submission serialization.
+	 * @todo Can we use a
+	 * {@link https://developer.mozilla.org/en-US/docs/Web/API/Range | DOM Range}
+	 * instead?
+	 */
+	private readonly anchorNode: Comment;
+
+	private readonly childrenState: ChildrenState<RepeatInstance>;
+
+	// InstanceNode
+	protected readonly state: SharedNodeState<RepeatRangeStateSpec>;
+	protected override engineState: EngineState<RepeatRangeStateSpec>;
+
+	// RepeatRangeNode
+	readonly nodeType = 'repeat-range';
+
+	readonly currentState: MaterializedChildren<CurrentState<RepeatRangeStateSpec>, RepeatInstance>;
+
+	constructor(parent: GeneralParentNode, definition: RepeatSequenceDefinition) {
+		super(parent, definition);
+
+		const childrenState = createChildrenState<RepeatRange, RepeatInstance>(this);
+
+		this.childrenState = childrenState;
+
+		const state = createSharedNodeState(
+			this.scope,
+			{
+				...this.buildSharedStateSpec(parent, definition),
+
+				label: createNodeLabel(this, definition),
+				hint: null,
+				children: childrenState.childIds,
+				valueOptions: null,
+				value: null,
+			},
+			{
+				clientStateFactory: this.engineConfig.stateFactory,
+			}
+		);
+
+		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);
+
+		definition.instances.forEach((instanceDefinition, index) => {
+			const afterIndex = index - 1;
+
+			this.addInstances(afterIndex, 1, instanceDefinition);
+		});
+	}
+
+	private getLastIndex(): number {
+		return this.engineState.children.length - 1;
+	}
+
+	protected override initializeContextNode(parentContextNode: Element): Element {
+		return parentContextNode;
+	}
+
+	protected computeReference(parent: GeneralParentNode): string {
+		return this.computeChildStepReference(parent);
+	}
+
+	getInstanceIndex(instance: RepeatInstance): number {
+		return this.engineState.children.indexOf(instance.nodeId);
+	}
+
+	addInstances(
+		afterIndex = this.getLastIndex(),
+		count = 1,
+		definition: RepeatDefinition = this.definition.template
+	): Root {
+		return this.scope.runTask(() => {
+			let precedingInstance: RepeatInstance | null;
+
+			if (afterIndex === -1) {
+				precedingInstance = null;
+			} else {
+				const instance = this.childrenState.getChildren()[afterIndex];
+
+				if (instance == null) {
+					throw new Error(`No repeat instance at index ${afterIndex}`);
+				}
+
+				precedingInstance = instance;
+			}
+
+			const precedingPrimaryInstanceNode = precedingInstance?.contextNode ?? this.anchorNode;
+
+			const newInstance = new RepeatInstance(this, definition, {
+				precedingPrimaryInstanceNode,
+				precedingInstance,
+			});
+			const initialIndex = afterIndex + 1;
+
+			this.childrenState.setChildren((currentInstances) => {
+				return insertAtIndex(currentInstances, initialIndex, newInstance);
+			});
+
+			if (count > 1) {
+				return this.addInstances(initialIndex, count - 1);
+			}
+
+			return this.root;
+		});
+	}
+
+	/**
+	 * Removes the {@link RepeatInstance}s corresponding to the specified range of
+	 * indexes, and then removes those repeat instances from the repeat range's
+	 * own children state in that order:
+	 *
+	 * 1. Identify the set of {@link RepeatInstance}s to be removed.
+	 *
+	 * 2. For each {@link RepeatInstance} pending removal, perform that node's
+	 *    removal logic. @see {@link RepeatInstance.remove} for more detail.
+	 *
+	 * 3. Finalize update to the repeat range's own {@link childrenState},
+	 *    omitting those {@link RepeatInstance}s which were removed.
+	 *
+	 * This ordering ensures a consistent representation of state is established
+	 * prior to any downstream reactive updates, and ensures that removed nodes'
+	 * reactivity is cleaned up.
+	 */
+	removeInstances(startIndex: number, count = 1): Root {
+		return this.scope.runTask(() => {
+			this.childrenState.setChildren((currentInstances) => {
+				const updatedInstances = currentInstances.slice();
+				const removedInstances = updatedInstances.splice(startIndex, count);
+
+				removedInstances.forEach((instance) => {
+					instance.remove();
+				});
+
+				return updatedInstances;
+			});
+
+			return this.root;
+		});
+	}
+
+	override subscribe(): void {
+		super.subscribe();
+
+		// Subscribing to children can support reactive expressions dependent on the
+		// repeat range itself (e.g. `count()`).
+		this.childrenState.getChildren().forEach((child) => {
+			child.subscribe();
+		});
+	}
+
+	getChildren(): readonly RepeatInstance[] {
+		return this.childrenState.getChildren();
+	}
+}