diff --git a/.changeset/empty-ravens-refuse.md b/.changeset/empty-ravens-refuse.md
new file mode 100644
index 00000000..59a2e504
--- /dev/null
+++ b/.changeset/empty-ravens-refuse.md
@@ -0,0 +1,9 @@
+---
+"@getodk/xforms-engine": patch
+"@getodk/web-forms": patch
+"@getodk/scenario": patch
+"@getodk/ui-solid": patch
+"@getodk/common": patch
+---
+
+Add initial engine support for appearances
diff --git a/packages/common/src/lib/type-assertions/assertUnknownObject.ts b/packages/common/src/lib/type-assertions/assertUnknownObject.ts
new file mode 100644
index 00000000..24692e6d
--- /dev/null
+++ b/packages/common/src/lib/type-assertions/assertUnknownObject.ts
@@ -0,0 +1,9 @@
+type UnknownObject = Record<PropertyKey, unknown>;
+
+type AssertUnknownObject = (value: unknown) => asserts value is UnknownObject;
+
+export const assertUnknownObject: AssertUnknownObject = (value) => {
+	if (typeof value !== 'object' || value == null) {
+		throw new Error('Not an object');
+	}
+};
diff --git a/packages/common/src/test/assertions/arrayOfAssertion.ts b/packages/common/src/test/assertions/arrayOfAssertion.ts
new file mode 100644
index 00000000..16de17cd
--- /dev/null
+++ b/packages/common/src/test/assertions/arrayOfAssertion.ts
@@ -0,0 +1,24 @@
+import type { AssertIs } from '../../../types/assertions/AssertIs.ts';
+
+type ArrayItemAssertion<T> = (item: unknown) => asserts item is T;
+
+export const arrayOfAssertion = <T>(
+	assertItem: ArrayItemAssertion<T>,
+	itemTypeDescription: string
+): AssertIs<readonly T[]> => {
+	return (value) => {
+		if (!Array.isArray(value)) {
+			throw new Error(`Not an array of ${itemTypeDescription}: value itself is not an array`);
+		}
+
+		for (const [index, item] of value.entries()) {
+			try {
+				assertItem(item);
+			} catch {
+				throw new Error(
+					`Not an array of ${itemTypeDescription}: item at index ${index} not an instance`
+				);
+			}
+		}
+	};
+};
diff --git a/packages/common/src/test/assertions/instanceArrayAssertion.ts b/packages/common/src/test/assertions/instanceArrayAssertion.ts
index 6d7fe3e5..094a68d6 100644
--- a/packages/common/src/test/assertions/instanceArrayAssertion.ts
+++ b/packages/common/src/test/assertions/instanceArrayAssertion.ts
@@ -1,5 +1,6 @@
 import type { AssertIs } from '../../../types/assertions/AssertIs.ts';
 import type { ConstructorOf } from '../../../types/helpers';
+import { arrayOfAssertion } from './arrayOfAssertion.ts';
 import { instanceAssertion } from './instanceAssertion.ts';
 
 /**
@@ -12,19 +13,5 @@ export const instanceArrayAssertion = <T>(
 ): AssertIs<readonly T[]> => {
 	const assertInstance: AssertIs<T> = instanceAssertion(Constructor);
 
-	return (value) => {
-		if (!Array.isArray(value)) {
-			throw new Error(`Not an array of ${Constructor.name}: value itself is not an array`);
-		}
-
-		for (const [index, item] of value.entries()) {
-			try {
-				assertInstance(item);
-			} catch {
-				throw new Error(
-					`Not an array of ${Constructor.name}: item at index ${index} not an instance`
-				);
-			}
-		}
-	};
+	return arrayOfAssertion(assertInstance, Constructor.name);
 };
diff --git a/packages/common/types/string/PartiallyKnownString.ts b/packages/common/types/string/PartiallyKnownString.ts
new file mode 100644
index 00000000..25b0019d
--- /dev/null
+++ b/packages/common/types/string/PartiallyKnownString.ts
@@ -0,0 +1,27 @@
+/**
+ * Produces a `string` type while preserving autocomplete/autosuggest
+ * functionality for a known string (union).
+ *
+ * @see {@link https://www.totaltypescript.com/tips/create-autocomplete-helper-which-allows-for-arbitrary-values}
+ *
+ * @example
+ * ```ts
+ * let foo: PartiallyKnownString<'a' | 'b' | 'zed'>;
+ *
+ * // Each of these will be suggested by a TypeScript-supporting editor:
+ * foo = 'a';
+ * foo = 'b';
+ * foo = 'zed';
+ *
+ * // ... but any string is valid:
+ * foo = 'lmnop';
+ * ```
+ */
+// prettier-ignore
+export type PartiallyKnownString<Known extends string> =
+	[string] extends [Known]
+		? string
+		: (
+				| Known
+				| (string & { /* Type hack! */ })
+			);
diff --git a/packages/scenario/src/assertion/extensions/answers.ts b/packages/scenario/src/assertion/extensions/answers.ts
index bde975d1..92fd049a 100644
--- a/packages/scenario/src/assertion/extensions/answers.ts
+++ b/packages/scenario/src/assertion/extensions/answers.ts
@@ -5,20 +5,18 @@ import {
 	SymmetricTypedExpectExtension,
 	extendExpect,
 	instanceAssertion,
-	typeofAssertion,
 } from '@getodk/common/test/assertions/helpers.ts';
 import { expect } from 'vitest';
 import { ComparableAnswer } from '../../answer/ComparableAnswer.ts';
 import { ExpectedApproximateUOMAnswer } from '../../answer/ExpectedApproximateUOMAnswer.ts';
 import { AnswerResult } from '../../jr/Scenario.ts';
 import { ValidationImplementationPendingError } from '../../jr/validation/ValidationImplementationPendingError.ts';
+import { assertString } from './shared-type-assertions.ts';
 
 const assertComparableAnswer = instanceAssertion(ComparableAnswer);
 
 const assertExpectedApproximateUOMAnswer = instanceAssertion(ExpectedApproximateUOMAnswer);
 
-const assertString = typeofAssertion('string');
-
 type AssertAnswerResult = (value: unknown) => asserts value is AnswerResult;
 
 const answerResults = new Set<AnswerResult>(Object.values(AnswerResult));
diff --git a/packages/scenario/src/assertion/extensions/appearances.ts b/packages/scenario/src/assertion/extensions/appearances.ts
new file mode 100644
index 00000000..f6a1b1e1
--- /dev/null
+++ b/packages/scenario/src/assertion/extensions/appearances.ts
@@ -0,0 +1,75 @@
+import type { DeriveStaticVitestExpectExtension } from '@getodk/common/test/assertions/helpers.ts';
+import {
+	AsymmetricTypedExpectExtension,
+	extendExpect,
+} from '@getodk/common/test/assertions/helpers.ts';
+import type { AnyNode } from '@getodk/xforms-engine';
+import { expect } from 'vitest';
+import { assertArrayOfStrings, assertEngineNode, assertString } from './shared-type-assertions.ts';
+
+const hasAppearance = (node: AnyNode, appearance: string): boolean => {
+	return node.appearances?.[appearance] === true;
+};
+
+const appearanceExtensions = extendExpect(expect, {
+	toHaveAppearance: new AsymmetricTypedExpectExtension(
+		assertEngineNode,
+		assertString,
+		(actual, expected) => {
+			if (hasAppearance(actual, expected)) {
+				return true;
+			}
+
+			return new Error(
+				`Node ${actual.currentState.reference} does not have appearance "${expected}"`
+			);
+		}
+	),
+
+	notToHaveAppearance: new AsymmetricTypedExpectExtension(
+		assertEngineNode,
+		assertString,
+		(actual, expected) => {
+			if (hasAppearance(actual, expected)) {
+				return new Error(
+					`Node ${actual.currentState.reference} has appearance "${expected}", which was not expected`
+				);
+			}
+
+			return true;
+		}
+	),
+
+	toYieldAppearances: new AsymmetricTypedExpectExtension(
+		assertEngineNode,
+		assertArrayOfStrings,
+		(actual, expected) => {
+			const yielded = new Set<string>();
+
+			for (const appearance of actual.appearances ?? []) {
+				yielded.add(appearance);
+			}
+
+			const notYielded = expected.filter((item) => {
+				return !yielded.has(item);
+			});
+
+			if (notYielded.length === 0) {
+				return true;
+			}
+
+			return new Error(
+				`Node ${actual.currentState.reference} did not yield expected appearances ${notYielded.join(', ')}`
+			);
+		}
+	),
+});
+
+type AppearanceExtensions = typeof appearanceExtensions;
+
+declare module 'vitest' {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	interface Assertion<T = any> extends DeriveStaticVitestExpectExtension<AppearanceExtensions, T> {}
+	interface AsymmetricMatchersContaining
+		extends DeriveStaticVitestExpectExtension<AppearanceExtensions> {}
+}
diff --git a/packages/scenario/src/assertion/extensions/body-classes.ts b/packages/scenario/src/assertion/extensions/body-classes.ts
new file mode 100644
index 00000000..03bd2f8d
--- /dev/null
+++ b/packages/scenario/src/assertion/extensions/body-classes.ts
@@ -0,0 +1,75 @@
+import type { DeriveStaticVitestExpectExtension } from '@getodk/common/test/assertions/helpers.ts';
+import {
+	AsymmetricTypedExpectExtension,
+	extendExpect,
+} from '@getodk/common/test/assertions/helpers.ts';
+import type { RootNode } from '@getodk/xforms-engine';
+import { expect } from 'vitest';
+import { assertArrayOfStrings, assertRootNode, assertString } from './shared-type-assertions.ts';
+
+const hasClass = (node: RootNode, className: string): boolean => {
+	return node.classes?.[className] === true;
+};
+
+const bodyClassesExtensions = extendExpect(expect, {
+	toHaveClass: new AsymmetricTypedExpectExtension(
+		assertRootNode,
+		assertString,
+		(actual, expected) => {
+			if (hasClass(actual, expected)) {
+				return true;
+			}
+
+			return new Error(
+				`RootNode ${actual.currentState.reference} does not have class "${expected}"`
+			);
+		}
+	),
+
+	notToHaveClass: new AsymmetricTypedExpectExtension(
+		assertRootNode,
+		assertString,
+		(actual, expected) => {
+			if (hasClass(actual, expected)) {
+				return new Error(
+					`RootNode ${actual.currentState.reference} has class "${expected}", which was not expected`
+				);
+			}
+
+			return true;
+		}
+	),
+
+	toYieldClasses: new AsymmetricTypedExpectExtension(
+		assertRootNode,
+		assertArrayOfStrings,
+		(actual, expected) => {
+			const yielded = new Set<string>();
+
+			for (const className of actual.classes) {
+				yielded.add(className);
+			}
+
+			const notYielded = expected.filter((item) => {
+				return !yielded.has(item);
+			});
+
+			if (notYielded.length === 0) {
+				return true;
+			}
+
+			return new Error(
+				`RootNode ${actual.currentState.reference} did not yield expected classes ${notYielded.join(', ')}`
+			);
+		}
+	),
+});
+
+type BodyClassExtensions = typeof bodyClassesExtensions;
+
+declare module 'vitest' {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	interface Assertion<T = any> extends DeriveStaticVitestExpectExtension<BodyClassExtensions, T> {}
+	interface AsymmetricMatchersContaining
+		extends DeriveStaticVitestExpectExtension<BodyClassExtensions> {}
+}
diff --git a/packages/scenario/src/assertion/extensions/shared-type-assertions.ts b/packages/scenario/src/assertion/extensions/shared-type-assertions.ts
new file mode 100644
index 00000000..a0fa872e
--- /dev/null
+++ b/packages/scenario/src/assertion/extensions/shared-type-assertions.ts
@@ -0,0 +1,55 @@
+import { assertUnknownObject } from '@getodk/common/lib/type-assertions/assertUnknownObject.ts';
+import { arrayOfAssertion } from '@getodk/common/test/assertions/arrayOfAssertion.ts';
+import { typeofAssertion } from '@getodk/common/test/assertions/typeofAssertion.ts';
+import type { AnyNode, RootNode } from '@getodk/xforms-engine';
+
+type AssertRootNode = (node: unknown) => asserts node is RootNode;
+
+export const assertRootNode: AssertRootNode = (node) => {
+	assertUnknownObject(node);
+
+	const maybeRootNode = node as Partial<RootNode>;
+
+	if (
+		maybeRootNode.nodeType !== 'root' ||
+		typeof maybeRootNode.setLanguage !== 'function' ||
+		typeof maybeRootNode.currentState !== 'object' ||
+		maybeRootNode.currentState == null
+	) {
+		throw new Error('Node is not a `RootNode`');
+	}
+};
+
+type AssertEngineNode = (node: unknown) => asserts node is AnyNode;
+
+type AnyNodeType = AnyNode['nodeType'];
+type NonRootNodeType = Exclude<AnyNodeType, 'root'>;
+
+const nonRootNodeTypes = new Set<NonRootNodeType>([
+	'string',
+	'select',
+	'subtree',
+	'group',
+	'repeat-range',
+	'repeat-instance',
+]);
+
+export const assertEngineNode: AssertEngineNode = (node) => {
+	assertUnknownObject(node);
+
+	const maybeNode = node as Partial<AnyNode>;
+
+	assertRootNode(maybeNode.root);
+
+	if (maybeNode === maybeNode.root) {
+		return;
+	}
+
+	if (!nonRootNodeTypes.has(maybeNode.nodeType as NonRootNodeType)) {
+		throw new Error('Not an engine node');
+	}
+};
+
+export const assertString = typeofAssertion('string');
+
+export const assertArrayOfStrings = arrayOfAssertion(assertString, 'string');
diff --git a/packages/scenario/src/assertion/setup.ts b/packages/scenario/src/assertion/setup.ts
index 1fdaf74f..2c4e83d6 100644
--- a/packages/scenario/src/assertion/setup.ts
+++ b/packages/scenario/src/assertion/setup.ts
@@ -1,4 +1,6 @@
 import './extensions/answers.ts';
+import './extensions/appearances.ts';
+import './extensions/body-classes.ts';
 import './extensions/choices.ts';
 import './extensions/form-state.ts';
 import './extensions/node-state.ts';
diff --git a/packages/scenario/test/appearance-body-class.test.ts b/packages/scenario/test/appearance-body-class.test.ts
new file mode 100644
index 00000000..d1331961
--- /dev/null
+++ b/packages/scenario/test/appearance-body-class.test.ts
@@ -0,0 +1,443 @@
+import { BodyXFormsElement } from '@getodk/common/test/fixtures/xform-dsl/BodyXFormsElement.ts';
+import { TagXFormsElement } from '@getodk/common/test/fixtures/xform-dsl/TagXFormsElement.ts';
+import type { XFormsElement } from '@getodk/common/test/fixtures/xform-dsl/XFormsElement.ts';
+import {
+	body,
+	head,
+	html,
+	input,
+	mainInstance,
+	model,
+	t,
+	title,
+} from '@getodk/common/test/fixtures/xform-dsl/index.ts';
+import { describe, expect, it } from 'vitest';
+import { Scenario } from '../src/jr/Scenario.ts';
+
+const element = (
+	name: string,
+	ref: string,
+	appearances: readonly string[],
+	...children: XFormsElement[]
+): XFormsElement => {
+	return new TagXFormsElement(
+		name,
+		new Map([
+			['ref', ref],
+			['appearance', appearances.join(' ')],
+		]),
+		children
+	);
+};
+
+describe('Appearances', () => {
+	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
+	type AppearanceCategory = 'documented' | 'arbitrary' | 'mixed';
+
+	interface AppearanceTestCase {
+		readonly category: AppearanceCategory;
+		readonly appearances: readonly string[];
+	}
+
+	describe('<input>', () => {
+		const inputCases: readonly AppearanceTestCase[] = [
+			{
+				category: 'documented',
+				appearances: ['multiline'],
+			},
+			{
+				category: 'documented',
+				appearances: ['numbers', 'masked'],
+			},
+			{
+				category: 'arbitrary',
+				appearances: ['bold', 'round'],
+			},
+			{
+				category: 'mixed',
+				appearances: ['hidden', 'url'],
+			},
+		];
+
+		const inputFixture = (appearances: readonly string[]): XFormsElement => {
+			// prettier-ignore
+			return html(
+				head(
+					title('Input appearances'),
+					model(
+						mainInstance(
+							t('data id="appearances-fixture"',
+								t('inp'))))),
+				body(
+					element('input', '/data/inp', appearances)
+				),
+			);
+		};
+
+		it.each<AppearanceTestCase>(inputCases)(
+			'gets the $category appearances $appearances defined on an input',
+			async ({ appearances }) => {
+				const scenario = await Scenario.init('Input appearances', inputFixture(appearances));
+
+				const node = scenario.getInstanceNode('/data/inp');
+
+				appearances.forEach((appearance) => {
+					expect(node).toHaveAppearance(appearance);
+				});
+			}
+		);
+
+		it.each<AppearanceTestCase>(inputCases)(
+			'iterates the $category appearances $appearances defined on an input',
+			async ({ appearances }) => {
+				const scenario = await Scenario.init('Input appearances', inputFixture(appearances));
+
+				const node = scenario.getInstanceNode('/data/inp');
+
+				expect(node).toYieldAppearances(appearances);
+			}
+		);
+
+		it('does not get appearances not present in the form definition', async () => {
+			const scenario = await Scenario.init('Input appearances', inputFixture(['no-calendar']));
+
+			const node = scenario.getInstanceNode('/data/inp');
+
+			expect(node).notToHaveAppearance('month-year');
+		});
+	});
+
+	interface SelectSuiteOptions {
+		readonly selectTag: 'select' | 'select1';
+	}
+
+	describe.each<SelectSuiteOptions>([{ selectTag: 'select' }, { selectTag: 'select1' }])(
+		'<$selectTag>',
+		({ selectTag }) => {
+			const selectCases: readonly AppearanceTestCase[] = [
+				{
+					category: 'documented',
+					appearances: ['compact'],
+				},
+				{
+					category: 'documented',
+					appearances: ['columns', 'autocomplete'],
+				},
+				{
+					category: 'arbitrary',
+					appearances: ['bold', 'round'],
+				},
+				{
+					category: 'mixed',
+					appearances: ['hidden', 'url'],
+				},
+			];
+
+			const selectFixture = (appearances: readonly string[]): XFormsElement => {
+				// prettier-ignore
+				return html(
+				head(
+					title('Select appearances'),
+					model(
+						mainInstance(
+							t('data id="appearances-fixture"',
+								t('sel'))))),
+				body(
+					element(selectTag, '/data/sel', appearances)
+				),
+			);
+			};
+
+			it.each<AppearanceTestCase>(selectCases)(
+				`gets the $category appearances $appearances defined on a ${selectTag}`,
+				async ({ appearances }) => {
+					const scenario = await Scenario.init('Select appearances', selectFixture(appearances));
+
+					const node = scenario.getInstanceNode('/data/sel');
+
+					appearances.forEach((appearance) => {
+						expect(node).toHaveAppearance(appearance);
+					});
+				}
+			);
+
+			it.each<AppearanceTestCase>(selectCases)(
+				`iterates the $category appearances $appearances defined on a ${selectTag}`,
+				async ({ appearances }) => {
+					const scenario = await Scenario.init('Select appearances', selectFixture(appearances));
+
+					const node = scenario.getInstanceNode('/data/sel');
+
+					expect(node).toYieldAppearances(appearances);
+				}
+			);
+
+			it('does not get appearances not present in the form definition', async () => {
+				const scenario = await Scenario.init('Select appearances', selectFixture(['columns-1']));
+
+				const node = scenario.getInstanceNode('/data/sel');
+
+				expect(node).notToHaveAppearance('columns-2');
+			});
+
+			describe('aliases', () => {
+				it('gets the "autocomplete" appearance alias when the "search" appearance is defined', async () => {
+					const scenario = await Scenario.init('Select appearances', selectFixture(['search']));
+
+					const node = scenario.getInstanceNode('/data/sel');
+
+					expect(node).toHaveAppearance('autocomplete');
+				});
+
+				it('gets the deprecated "search" appearance when the "search" appearance is defined', async () => {
+					const scenario = await Scenario.init('Select appearances', selectFixture(['search']));
+
+					const node = scenario.getInstanceNode('/data/sel');
+
+					expect(node).toHaveAppearance('search');
+				});
+
+				it('yields both the deprecated "search" and aliased "autocomplete" appearances when the "search" appearance is defined', async () => {
+					const scenario = await Scenario.init('Select appearances', selectFixture(['search']));
+
+					const node = scenario.getInstanceNode('/data/sel');
+
+					expect(node).toYieldAppearances(['autocomplete', 'search']);
+				});
+			});
+		}
+	);
+
+	describe('<group>', () => {
+		const groupCases: readonly AppearanceTestCase[] = [
+			{
+				category: 'documented',
+				appearances: ['field-list'],
+			},
+			{
+				category: 'documented',
+				appearances: ['table-list'],
+			},
+			{
+				category: 'arbitrary',
+				appearances: ['task-list', 'shopping-list'],
+			},
+			{
+				category: 'mixed',
+				appearances: ['field-list', 'shopping-list'],
+			},
+		];
+
+		const groupFixture = (appearances: readonly string[]): XFormsElement => {
+			// prettier-ignore
+			return html(
+				head(
+					title('Group appearances'),
+					model(
+						mainInstance(
+							t('data id="appearances-fixture"',
+								t('grp',
+									t('inp')))))),
+				body(
+					element('group', '/data/grp', appearances,
+						input('/data/grp/inp')
+					)
+				),
+			);
+		};
+
+		it.each<AppearanceTestCase>(groupCases)(
+			'looks up the $category appearances $appearances by name, when defined on a group',
+			async ({ appearances }) => {
+				const scenario = await Scenario.init('Group appearances', groupFixture(appearances));
+
+				const node = scenario.getInstanceNode('/data/grp');
+
+				appearances.forEach((appearance) => {
+					expect(node).toHaveAppearance(appearance);
+				});
+			}
+		);
+
+		it.each<AppearanceTestCase>(groupCases)(
+			'iterates the $category appearances $appearances defined on a group',
+			async ({ appearances }) => {
+				const scenario = await Scenario.init('Group appearances', groupFixture(appearances));
+
+				const node = scenario.getInstanceNode('/data/grp');
+
+				expect(node).toYieldAppearances(appearances);
+			}
+		);
+
+		it('does not get appearances not present in the form definition', async () => {
+			const scenario = await Scenario.init('Group appearances', groupFixture(['field-list']));
+
+			const node = scenario.getInstanceNode('/data/grp');
+
+			expect(node).notToHaveAppearance('something-else');
+		});
+	});
+
+	describe('<repeat>', () => {
+		const repeatCases: readonly AppearanceTestCase[] = [
+			{
+				category: 'documented',
+				appearances: ['field-list'],
+			},
+			{
+				category: 'documented',
+				appearances: ['table-list'],
+			},
+			{
+				category: 'arbitrary',
+				appearances: ['task-list', 'shopping-list'],
+			},
+			{
+				category: 'mixed',
+				appearances: ['field-list', 'shopping-list'],
+			},
+		];
+
+		const repeatFixture = (appearances: readonly string[]): XFormsElement => {
+			// prettier-ignore
+			return html(
+				head(
+					title('Repeat appearances'),
+					model(
+						mainInstance(
+							t('data id="appearances-fixture"',
+								t('rep jr:template=""',
+									t('inp')),
+								t('rep',
+									t('inp')),
+								t('rep',
+									t('inp')))))),
+				body(
+					element('repeat', '/data/rep', appearances,
+						input('/data/rep/inp')
+					)
+				),
+			);
+		};
+
+		it.each<AppearanceTestCase>(repeatCases)(
+			'gets the $category appearances $appearances defined on a repeat range',
+			async ({ appearances }) => {
+				const scenario = await Scenario.init('Repeat appearances', repeatFixture(appearances));
+
+				const node = scenario.getInstanceNode('/data/rep');
+
+				appearances.forEach((appearance) => {
+					expect(node).toHaveAppearance(appearance);
+				});
+			}
+		);
+
+		it.each<AppearanceTestCase>(repeatCases)(
+			'gets the $category appearances $appearances defined on a repeat, for each individual repeat instance',
+			async ({ appearances }) => {
+				const scenario = await Scenario.init('Repeat appearances', repeatFixture(appearances));
+
+				const nodes = [
+					scenario.getInstanceNode('/data/rep[1]'),
+					scenario.getInstanceNode('/data/rep[2]'),
+				];
+
+				nodes.forEach((node) => {
+					appearances.forEach((appearance) => {
+						expect(node).toHaveAppearance(appearance);
+					});
+				});
+			}
+		);
+
+		it.each<AppearanceTestCase>(repeatCases)(
+			'iterates the $category appearances $appearances defined on a repeat range',
+			async ({ appearances }) => {
+				const scenario = await Scenario.init('Repeat appearances', repeatFixture(appearances));
+
+				const node = scenario.getInstanceNode('/data/rep');
+
+				expect(node).toYieldAppearances(appearances);
+			}
+		);
+
+		it.each<AppearanceTestCase>(repeatCases)(
+			'iterates the $category appearances $appearances defined on a repeat, for each individual repeat instance',
+			async ({ appearances }) => {
+				const scenario = await Scenario.init('Repeat appearances', repeatFixture(appearances));
+
+				const nodes = [
+					scenario.getInstanceNode('/data/rep[1]'),
+					scenario.getInstanceNode('/data/rep[2]'),
+				];
+
+				nodes.forEach((node) => {
+					expect(node).toYieldAppearances(appearances);
+				});
+			}
+		);
+
+		it('does not get appearances not present in the form definition', async () => {
+			const scenario = await Scenario.init('Repeat appearances', repeatFixture(['field-list']));
+
+			const nodes = [
+				scenario.getInstanceNode('/data/rep'),
+				scenario.getInstanceNode('/data/rep[1]'),
+				scenario.getInstanceNode('/data/rep[2]'),
+			];
+
+			nodes.forEach((node) => {
+				expect(node).notToHaveAppearance('something-else');
+			});
+		});
+	});
+});
+
+describe('<h:body> classes', () => {
+	class BodyXFormsElementWithAttributes extends TagXFormsElement implements BodyXFormsElement {
+		override readonly name = 'h:body';
+
+		constructor(attributes: Record<string, string>, children: XFormsElement[]) {
+			super('h:body', new Map(Object.entries(attributes)), children);
+		}
+	}
+
+	const bodyWithAttributes = (
+		attributes: Record<string, string>,
+		...children: XFormsElement[]
+	): BodyXFormsElement => {
+		return new BodyXFormsElementWithAttributes(attributes, children);
+	};
+
+	// prettier-ignore
+	const bodyClassesFixture = html(
+		head(
+			title('Body classes'),
+			model(
+				mainInstance(
+					t('data id="appearances-fixture"',
+						t('inp'))))),
+		bodyWithAttributes(
+			{ class: 'pages theme-grid' },
+			input('/data/inp')
+		),
+	);
+
+	it('gets the classes defined on the form body from the instance root node', async () => {
+		const scenario = await Scenario.init('Body classes', bodyClassesFixture);
+		const rootNode = scenario.getInstanceNode('/data');
+
+		expect(rootNode).toHaveClass('pages');
+		expect(rootNode).toHaveClass('theme-grid');
+		expect(rootNode).notToHaveClass('something-else');
+	});
+
+	it('iterates the classes defined on the form body from the instance root node', async () => {
+		const scenario = await Scenario.init('Body classes', bodyClassesFixture);
+		const rootNode = scenario.getInstanceNode('/data');
+
+		expect(rootNode).toYieldClasses(['pages', 'theme-grid']);
+	});
+});
diff --git a/packages/ui-solid/src/components/XForm/containers/XFormGroup.tsx b/packages/ui-solid/src/components/XForm/containers/XFormGroup.tsx
index 0f380324..c7f65201 100644
--- a/packages/ui-solid/src/components/XForm/containers/XFormGroup.tsx
+++ b/packages/ui-solid/src/components/XForm/containers/XFormGroup.tsx
@@ -28,7 +28,7 @@ const groupNode = (node: GroupNode | RepeatRangeNode): GroupNode | null => {
 
 export const XFormGroup = (props: XFormGroupProps) => {
 	const groupLabel = () => {
-		if (props.node.definition.type === 'repeat-sequence') {
+		if (props.node.nodeType === 'repeat-range') {
 			return null;
 		}
 
diff --git a/packages/web-forms/src/components/QuestionList.vue b/packages/web-forms/src/components/QuestionList.vue
index 16cf60bc..5883f7cd 100644
--- a/packages/web-forms/src/components/QuestionList.vue
+++ b/packages/web-forms/src/components/QuestionList.vue
@@ -1,16 +1,28 @@
 <script setup lang="ts">
-import type { AnyLeafNode, GeneralChildNode, GroupNode, RepeatRangeNode } from '@getodk/xforms-engine';
+import type { AnyLeafNode, GeneralChildNode, GroupNode, RepeatRangeNode, StringNode } from '@getodk/xforms-engine';
 import FormGroup from './FormGroup.vue';
 import FormQuestion from './FormQuestion.vue';
 import RepeatRange from './RepeatRange.vue';
 
 defineProps<{ nodes: readonly GeneralChildNode[]}>();
 
-const isLeafNode = (n: GeneralChildNode) : n is AnyLeafNode => n.definition.type === 'value-node';
-const isGroupNode = (n: GeneralChildNode) : n is GroupNode => n.definition.type === 'subtree';
-const isRepeatRangeNode = (n: GeneralChildNode) : n is RepeatRangeNode => n.definition.type === 'repeat-sequence';
-
-
+/**
+ * @todo This has been updated to most closely match the expected API use for
+ * what was previously expressed. It was not updated to be correct (it should
+ * filter out {@link StringNode}s with no body element.) This can be addressed
+ * too, but is deferred to keep a lighter touch pending review.
+ */
+const isLeafNode = (node: GeneralChildNode): node is AnyLeafNode => {
+	return node.nodeType === 'string' || node.nodeType === 'select';
+};
+
+const isGroupNode = (node: GeneralChildNode): node is GroupNode => {
+	return node.nodeType === 'group';
+};
+
+const isRepeatRangeNode = (node: GeneralChildNode): node is RepeatRangeNode => {
+	return node.nodeType === 'repeat-range';
+};
 </script>
 
 <template>
diff --git a/packages/xforms-engine/src/XFormDOM.ts b/packages/xforms-engine/src/XFormDOM.ts
index 20fcbfdb..cb29b093 100644
--- a/packages/xforms-engine/src/XFormDOM.ts
+++ b/packages/xforms-engine/src/XFormDOM.ts
@@ -1,4 +1,4 @@
-import { XFORMS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import { XFORMS_NAMESPACE_URI, XMLNS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
 import { XFormsXPathEvaluator } from '@getodk/xpath';
 
 const domParser = new DOMParser();
@@ -41,7 +41,83 @@ const normalizeBodyRefNodesetAttributes = (body: Element): void => {
 	}
 };
 
-const normalizeRepeatGroups = (xformDocument: XMLDocument, body: Element): void => {
+const normalizeRepeatGroupAttributes = (group: Element, repeat: Element): void => {
+	for (const groupAttribute of group.attributes) {
+		const { localName, namespaceURI, nodeName, value } = groupAttribute;
+
+		if (
+			// Don't propagate namespace declarations (which appear as attributes in
+			// the browser/XML DOM, either named `xmlns` or with an `xmlns` prefix,
+			// always in the XMLNS namespace).
+			namespaceURI === XMLNS_NAMESPACE_URI ||
+			// Don't propagate `ref`, it has been normalized as `nodeset` on the
+			// repeat element.
+			localName === 'ref' ||
+			// TODO: this accommodates tests of this normalization process, where
+			// certain nodes of interest are given an `id` attribute, and looked up
+			// for the purpose of asserting what was normalized about them. It's
+			// unclear if there's a generally expected behavior around the attribute.
+			localName === 'id'
+		) {
+			continue;
+		}
+
+		// TODO: The `appearance` attribute is propagated from
+		// `<group appearance><repeat>` to `<repeat appearance>`. But we presently
+		// bail if both elements define the attribute.
+		//
+		// The spec is clear that the attribute is only supported on `<group>` and
+		// control elements, which would suggest it should not be present on a
+		// `<repeat>` element directly. But many form fixtures (in e.g. Enketo)
+		// do have `<repeat apperance>`.
+		//
+		// It may be reasonable to relax this by:
+		//
+		// - Detecting if they share the same appearances, treated as a no-op.
+		//
+		// - Assume they're both meant to apply, and concatenate.
+		if (
+			localName === 'appearance' &&
+			namespaceURI === XFORMS_NAMESPACE_URI &&
+			repeat.hasAttribute(localName)
+		) {
+			const ref = group.getAttribute('ref');
+
+			throw new Error(
+				`Failed to normalize conflicting "appearances" attribute of group/repeat "${ref}"`
+			);
+		}
+
+		repeat.setAttributeNS(namespaceURI, nodeName, value);
+	}
+};
+
+const normalizeRepeatGroupLabel = (group: Element, repeat: Element): void => {
+	const groupLabel = Array.from(group.children).find((child) => {
+		return child.localName === 'label';
+	});
+
+	if (groupLabel == null) {
+		return;
+	}
+
+	const repeatLabel = groupLabel.cloneNode(true) as Element;
+
+	repeatLabel.setAttribute('form-definition-source', 'repeat-group');
+
+	repeat.prepend(repeatLabel);
+
+	groupLabel.remove();
+};
+
+const unwrapRepeatGroup = (group: Element, repeat: Element): void => {
+	normalizeRepeatGroupAttributes(group, repeat);
+	normalizeRepeatGroupLabel(group, repeat);
+
+	group.replaceWith(repeat);
+};
+
+const normalizeRepeatGroups = (body: Element): void => {
 	const repeats = body.querySelectorAll('repeat');
 
 	for (const repeat of repeats) {
@@ -63,11 +139,8 @@ const normalizeRepeatGroups = (xformDocument: XMLDocument, body: Element): void
 			}
 		}
 
-		if (group == null) {
-			group = xformDocument.createElementNS(XFORMS_NAMESPACE_URI, 'group');
-			group.setAttribute('ref', repeatNodeset);
-			repeat.before(group);
-			group.append(repeat);
+		if (group != null) {
+			unwrapRepeatGroup(group, repeat);
 		}
 	}
 };
@@ -113,7 +186,7 @@ const parseNormalizedXForm = (
 		normalizedXML = sourceXML;
 	} else {
 		normalizeBodyRefNodesetAttributes(body);
-		normalizeRepeatGroups(xformDocument, body);
+		normalizeRepeatGroups(body);
 
 		normalizedXML = html.outerHTML;
 	}
diff --git a/packages/xforms-engine/src/body/BodyDefinition.ts b/packages/xforms-engine/src/body/BodyDefinition.ts
index fb294861..8ebd272f 100644
--- a/packages/xforms-engine/src/body/BodyDefinition.ts
+++ b/packages/xforms-engine/src/body/BodyDefinition.ts
@@ -1,5 +1,8 @@
 import type { XFormDefinition } from '../XFormDefinition.ts';
 import { DependencyContext } from '../expression/DependencyContext.ts';
+import type { ParsedTokenList } from '../lib/TokenListParser.ts';
+import { TokenListParser } from '../lib/TokenListParser.ts';
+import { RepeatElementDefinition } from './RepeatElementDefinition.ts';
 import { UnsupportedBodyElementDefinition } from './UnsupportedBodyElementDefinition.ts';
 import { ControlDefinition } from './control/ControlDefinition.ts';
 import { InputDefinition } from './control/InputDefinition.ts';
@@ -7,7 +10,6 @@ import type { AnySelectDefinition } from './control/select/SelectDefinition.ts';
 import { SelectDefinition } from './control/select/SelectDefinition.ts';
 import { LogicalGroupDefinition } from './group/LogicalGroupDefinition.ts';
 import { PresentationGroupDefinition } from './group/PresentationGroupDefinition.ts';
-import { RepeatGroupDefinition } from './group/RepeatGroupDefinition.ts';
 import { StructuralGroupDefinition } from './group/StructuralGroupDefinition.ts';
 
 export interface BodyElementParentContext {
@@ -15,20 +17,24 @@ export interface BodyElementParentContext {
 	readonly element: Element;
 }
 
+// prettier-ignore
+export type ControlElementDefinition =
+	| AnySelectDefinition
+	| InputDefinition;
+
 type SupportedBodyElementDefinition =
 	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
-	| RepeatGroupDefinition
+	| RepeatElementDefinition
 	| LogicalGroupDefinition
 	| PresentationGroupDefinition
 	| StructuralGroupDefinition
-	| InputDefinition
-	| AnySelectDefinition;
+	| ControlElementDefinition;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type BodyElementDefinitionConstructor = new (...args: any[]) => SupportedBodyElementDefinition;
 
 const BodyElementDefinitionConstructors = [
-	RepeatGroupDefinition,
+	RepeatElementDefinition,
 	LogicalGroupDefinition,
 	PresentationGroupDefinition,
 	StructuralGroupDefinition,
@@ -49,11 +55,6 @@ export type AnyGroupElementDefinition = Extract<
 	{ readonly type: `${string}-group` }
 >;
 
-export type NonRepeatGroupElementDefinition = Exclude<
-	AnyGroupElementDefinition,
-	{ readonly type: 'repeat-group' }
->;
-
 const isGroupElementDefinition = (
 	element: AnyBodyElementDefinition
 ): element is AnyGroupElementDefinition => {
@@ -96,13 +97,13 @@ class BodyElementMap extends Map<BodyElementReference, AnyBodyElementDefinition>
 		for (const element of elements) {
 			const { reference } = element;
 
-			if (element instanceof RepeatGroupDefinition) {
+			if (element instanceof RepeatElementDefinition) {
 				if (reference == null) {
-					throw new Error('Missing reference for repeat/repeat group');
+					throw new Error('Missing reference for repeat');
 				}
 
 				this.set(reference, element);
-				this.mapElementsByReference(element.repeatChildren);
+				this.mapElementsByReference(element.children);
 			}
 
 			if (
@@ -140,6 +141,10 @@ class BodyElementMap extends Map<BodyElementReference, AnyBodyElementDefinition>
 	}
 }
 
+const bodyClassParser = new TokenListParser(['pages' /*, 'theme-grid' */]);
+
+export type BodyClassList = ParsedTokenList<typeof bodyClassParser>;
+
 export class BodyDefinition extends DependencyContext {
 	static getChildElementDefinitions(
 		form: XFormDefinition,
@@ -161,6 +166,25 @@ export class BodyDefinition extends DependencyContext {
 	}
 
 	readonly element: Element;
+
+	/**
+	 * @todo this class is already an oddity in that it's **like** an element
+	 * definition, but it isn't one itself. Adding this property here emphasizes
+	 * that awkwardness. It also extends the applicable scope where instances of
+	 * this class are accessed. While it's still ephemeral, it's anticipated that
+	 * this extension might cause some disomfort. If so, the most plausible
+	 * alternative is an additional refactor to:
+	 *
+	 * 1. Introduce a `BodyElementDefinition` sublass for `<h:body>`.
+	 * 2. Disambiguate the respective names of those, in some reasonable way.
+	 * 3. Add a layer of indirection between this class and that new body element
+	 *    definition's class.
+	 * 4. At that point, we may as well prioritize the little bit of grunt work to
+	 *    pass the `BodyDefinition` instance by reference rather than assigning it
+	 *    to anything.
+	 */
+	readonly classes: BodyClassList;
+
 	readonly elements: readonly AnyBodyElementDefinition[];
 
 	protected readonly elementsByReference: BodyElementMap;
@@ -176,6 +200,7 @@ export class BodyDefinition extends DependencyContext {
 
 		this.reference = form.rootReference;
 		this.element = element;
+		this.classes = bodyClassParser.parseFrom(element, 'class');
 		this.elements = BodyDefinition.getChildElementDefinitions(form, this, element);
 		this.elementsByReference = new BodyElementMap(this.elements);
 	}
@@ -184,16 +209,6 @@ export class BodyDefinition extends DependencyContext {
 		return this.elementsByReference.get(reference) ?? null;
 	}
 
-	getRepeatGroup(reference: string): RepeatGroupDefinition | null {
-		const element = this.getBodyElement(reference);
-
-		if (element?.type === 'repeat-group') {
-			return element;
-		}
-
-		return null;
-	}
-
 	toJSON() {
 		const { form, ...rest } = this;
 
diff --git a/packages/xforms-engine/src/body/RepeatDefinition.ts b/packages/xforms-engine/src/body/RepeatDefinition.ts
deleted file mode 100644
index f4dda5ca..00000000
--- a/packages/xforms-engine/src/body/RepeatDefinition.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import { JAVAROSA_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
-import type { XFormDefinition } from '../XFormDefinition.ts';
-import type { BodyElementDefinitionArray } from './BodyDefinition.ts';
-import { BodyElementDefinition } from './BodyElementDefinition.ts';
-import type { RepeatGroupDefinition } from './group/RepeatGroupDefinition.ts';
-
-export class RepeatDefinition extends BodyElementDefinition<'repeat'> {
-	override readonly category = 'structure';
-	readonly type = 'repeat';
-	override readonly reference: string;
-
-	// TODO: this will fall into the growing category of non-`BindExpression`
-	// cases which have roughly the same design story.
-	readonly countExpression: string | null;
-
-	readonly isFixedCount: boolean;
-
-	readonly children: BodyElementDefinitionArray;
-
-	constructor(
-		form: XFormDefinition,
-		readonly groupDefinition: RepeatGroupDefinition,
-		element: Element
-	) {
-		super(form, groupDefinition, element);
-
-		const reference = element.getAttribute('nodeset');
-
-		if (reference == null) {
-			throw new Error('Invalid repeat: missing `nodeset` reference');
-		}
-
-		this.reference = reference;
-		this.countExpression = element.getAttributeNS(JAVAROSA_NAMESPACE_URI, 'count');
-		this.children = groupDefinition.getChildren(element);
-
-		// Spec says this can be either `true()` or `false()`. That said, it
-		// could also presumably be `true ( )` or whatever.
-		const noAddRemove =
-			element
-				.getAttributeNS(JAVAROSA_NAMESPACE_URI, 'noAddRemove')
-				?.trim()
-				.replaceAll(/\s+/g, '') ?? 'false()';
-
-		// TODO: **probably** safe to disregard anything else?
-		this.isFixedCount = noAddRemove === 'true()';
-	}
-
-	override toJSON() {
-		const { form, groupDefinition, parent, ...rest } = this;
-
-		return rest;
-	}
-}
diff --git a/packages/xforms-engine/src/body/RepeatElementDefinition.ts b/packages/xforms-engine/src/body/RepeatElementDefinition.ts
new file mode 100644
index 00000000..67c0e986
--- /dev/null
+++ b/packages/xforms-engine/src/body/RepeatElementDefinition.ts
@@ -0,0 +1,70 @@
+import { JAVAROSA_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import type { XFormDefinition } from '../XFormDefinition.ts';
+import type { BodyElementDefinitionArray, BodyElementParentContext } from './BodyDefinition.ts';
+import { BodyDefinition } from './BodyDefinition.ts';
+import { BodyElementDefinition } from './BodyElementDefinition.ts';
+import type { StructureElementAppearanceDefinition } from './appearance/structureElementAppearanceParser.ts';
+import { structureElementAppearanceParser } from './appearance/structureElementAppearanceParser.ts';
+import { LabelDefinition } from './text/LabelDefinition.ts';
+
+export class RepeatElementDefinition extends BodyElementDefinition<'repeat'> {
+	static override isCompatible(localName: string): boolean {
+		return localName === 'repeat';
+	}
+
+	override readonly category = 'structure';
+	readonly type = 'repeat';
+	override readonly reference: string;
+	readonly appearances: StructureElementAppearanceDefinition;
+	override readonly label: LabelDefinition | null;
+
+	// TODO: this will fall into the growing category of non-`BindExpression`
+	// cases which have roughly the same design story.
+	readonly countExpression: string | null;
+
+	readonly isFixedCount: boolean;
+
+	readonly children: BodyElementDefinitionArray;
+
+	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
+		super(form, parent, element);
+
+		this.label = LabelDefinition.forRepeatGroup(form, this);
+
+		const reference = element.getAttribute('nodeset');
+
+		if (reference == null) {
+			throw new Error('Invalid repeat: missing `nodeset` reference');
+		}
+
+		this.reference = reference;
+		this.appearances = structureElementAppearanceParser.parseFrom(element, 'appearance');
+		this.countExpression = element.getAttributeNS(JAVAROSA_NAMESPACE_URI, 'count');
+
+		const childElements = Array.from(element.children).filter((childElement) => {
+			const { localName } = childElement;
+
+			return localName !== 'label' && localName !== 'group-label';
+		});
+		const children = BodyDefinition.getChildElementDefinitions(form, this, element, childElements);
+
+		this.children = children;
+
+		// Spec says this can be either `true()` or `false()`. That said, it
+		// could also presumably be `true ( )` or whatever.
+		const noAddRemove =
+			element
+				.getAttributeNS(JAVAROSA_NAMESPACE_URI, 'noAddRemove')
+				?.trim()
+				.replaceAll(/\s+/g, '') ?? 'false()';
+
+		// TODO: **probably** safe to disregard anything else?
+		this.isFixedCount = noAddRemove === 'true()';
+	}
+
+	override toJSON() {
+		const { form, parent, ...rest } = this;
+
+		return rest;
+	}
+}
diff --git a/packages/xforms-engine/src/body/appearance/inputAppearanceParser.ts b/packages/xforms-engine/src/body/appearance/inputAppearanceParser.ts
new file mode 100644
index 00000000..7e5abb5a
--- /dev/null
+++ b/packages/xforms-engine/src/body/appearance/inputAppearanceParser.ts
@@ -0,0 +1,39 @@
+import { TokenListParser, type ParsedTokenList } from '../../lib/TokenListParser.ts';
+
+export const inputAppearanceParser = new TokenListParser([
+	'multiline',
+	'numbers',
+	'url',
+	'thousand-sep',
+
+	// date (TODO: data types)
+	'no-calendar',
+	'month-year',
+	'year',
+	// date > calendars
+	'ethiopian',
+	'coptic',
+	'islamic',
+	'bikram-sambat',
+	'myanmar',
+	'persian',
+
+	// geo (TODO: data types)
+	'placement-map',
+	'maps',
+
+	// image/media (TODO: move to eventual `<upload>`?)
+	'hidden-answer',
+	'annotate',
+	'draw',
+	'signature',
+	'new-front',
+	'new',
+	'front',
+
+	// *?
+	'printer', // Note: actual usage uses `printer:...` (like `ex:...`).
+	'masked',
+]);
+
+export type InputAppearanceDefinition = ParsedTokenList<typeof inputAppearanceParser>;
diff --git a/packages/xforms-engine/src/body/appearance/selectAppearanceParser.ts b/packages/xforms-engine/src/body/appearance/selectAppearanceParser.ts
new file mode 100644
index 00000000..0cf8f2b0
--- /dev/null
+++ b/packages/xforms-engine/src/body/appearance/selectAppearanceParser.ts
@@ -0,0 +1,38 @@
+import { TokenListParser, type ParsedTokenList } from '../../lib/TokenListParser.ts';
+
+export const selectAppearanceParser = new TokenListParser(
+	[
+		// From XLSForm Docs:
+		'compact',
+		'horizontal',
+		'horizontal-compact',
+		'label',
+		'list-nolabel',
+		'minimal',
+
+		// From Collect `Appearances.kt`:
+		'columns',
+		'columns-1',
+		'columns-2',
+		'columns-3',
+		'columns-4',
+		'columns-5',
+		// Note: Collect supports arbitrary columns-n. Technically we do too (we parse
+		// out any appearance, not just those we know about). But we'll only include
+		// types/defaults up to 5.
+		'columns-pack',
+		'autocomplete',
+
+		// TODO: these are `<select1>` only
+		'likert',
+		'quick',
+		'quickcompact',
+		'map',
+		// "quick map"
+	],
+	{
+		aliases: [{ fromAlias: 'search', toCanonical: 'autocomplete' }],
+	}
+);
+
+export type SelectAppearanceDefinition = ParsedTokenList<typeof selectAppearanceParser>;
diff --git a/packages/xforms-engine/src/body/appearance/structureElementAppearanceParser.ts b/packages/xforms-engine/src/body/appearance/structureElementAppearanceParser.ts
new file mode 100644
index 00000000..a1a65f16
--- /dev/null
+++ b/packages/xforms-engine/src/body/appearance/structureElementAppearanceParser.ts
@@ -0,0 +1,7 @@
+import { TokenListParser, type ParsedTokenList } from '../../lib/TokenListParser.ts';
+
+export const structureElementAppearanceParser = new TokenListParser(['field-list', 'table-list']);
+
+export type StructureElementAppearanceDefinition = ParsedTokenList<
+	typeof structureElementAppearanceParser
+>;
diff --git a/packages/xforms-engine/src/body/control/ControlDefinition.ts b/packages/xforms-engine/src/body/control/ControlDefinition.ts
index 8470c531..bbe167bf 100644
--- a/packages/xforms-engine/src/body/control/ControlDefinition.ts
+++ b/packages/xforms-engine/src/body/control/ControlDefinition.ts
@@ -1,4 +1,5 @@
 import type { XFormDefinition } from '../../XFormDefinition.ts';
+import type { ParsedTokenList } from '../../lib/TokenListParser.ts';
 import type { BodyElementParentContext } from '../BodyDefinition.ts';
 import { BodyElementDefinition } from '../BodyElementDefinition.ts';
 import { HintDefinition } from '../text/HintDefinition.ts';
@@ -23,6 +24,9 @@ export abstract class ControlDefinition<
 	override readonly label: LabelDefinition | null;
 	override readonly hint: HintDefinition | null;
 
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	abstract readonly appearances: ParsedTokenList<any>;
+
 	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
 		super(form, parent, element);
 
diff --git a/packages/xforms-engine/src/body/control/InputDefinition.ts b/packages/xforms-engine/src/body/control/InputDefinition.ts
index 8c532bf7..8010c2b5 100644
--- a/packages/xforms-engine/src/body/control/InputDefinition.ts
+++ b/packages/xforms-engine/src/body/control/InputDefinition.ts
@@ -1,3 +1,9 @@
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import type { BodyElementParentContext } from '../BodyDefinition.ts';
+import {
+	inputAppearanceParser,
+	type InputAppearanceDefinition,
+} from '../appearance/inputAppearanceParser.ts';
 import { ControlDefinition } from './ControlDefinition.ts';
 
 export class InputDefinition extends ControlDefinition<'input'> {
@@ -6,4 +12,11 @@ export class InputDefinition extends ControlDefinition<'input'> {
 	}
 
 	readonly type = 'input';
+	readonly appearances: InputAppearanceDefinition;
+
+	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
+		super(form, parent, element);
+
+		this.appearances = inputAppearanceParser.parseFrom(element, 'appearance');
+	}
 }
diff --git a/packages/xforms-engine/src/body/control/select/SelectDefinition.ts b/packages/xforms-engine/src/body/control/select/SelectDefinition.ts
index 5e8a696b..7b31a8c3 100644
--- a/packages/xforms-engine/src/body/control/select/SelectDefinition.ts
+++ b/packages/xforms-engine/src/body/control/select/SelectDefinition.ts
@@ -3,14 +3,21 @@ import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
 import type { XFormDefinition } from '../../../XFormDefinition.ts';
 import { getItemElements, getItemsetElement } from '../../../lib/dom/query.ts';
 import type { AnyBodyElementDefinition, BodyElementParentContext } from '../../BodyDefinition.ts';
+import type { SelectAppearanceDefinition } from '../../appearance/selectAppearanceParser.ts';
+import { selectAppearanceParser } from '../../appearance/selectAppearanceParser.ts';
 import { ControlDefinition } from '../ControlDefinition.ts';
 import { ItemDefinition } from './ItemDefinition.ts';
 import { ItemsetDefinition } from './ItemsetDefinition.ts';
 
-// TODO: `<trigger>` is *almost* reasonable to support here too. The main
-// hesitation is that its single, implicit "item" does not have a distinct
-// <label>, and presumably has different UX **and translation** considerations.
-const selectLocalNames = new Set(['rank', 'select', 'select1'] as const);
+/**
+ * @todo We were previously a bit overzealous about introducing `<rank>` support
+ * here. It'll likely still fit, but we should approach it with more intention.
+ *
+ * @todo `<trigger>` is *almost* reasonable to support here too. The main
+ * hesitation is that its single, implicit "item" does not have a distinct
+ * <label>, and presumably has different UX **and translation** considerations.
+ */
+const selectLocalNames = new Set([/* 'rank', */ 'select', 'select1'] as const);
 
 export type SelectType = CollectionValues<typeof selectLocalNames>;
 
@@ -34,6 +41,7 @@ export class SelectDefinition<Type extends SelectType> extends ControlDefinition
 
 	override readonly type: Type;
 	override readonly element: SelectElement;
+	readonly appearances: SelectAppearanceDefinition;
 
 	readonly itemset: ItemsetDefinition | null;
 	readonly items: readonly ItemDefinition[];
@@ -45,8 +53,9 @@ export class SelectDefinition<Type extends SelectType> extends ControlDefinition
 
 		super(form, parent, element);
 
-		this.element = element;
 		this.type = element.localName as Type;
+		this.element = element;
+		this.appearances = selectAppearanceParser.parseFrom(element, 'appearance');
 
 		const itemsetElement = getItemsetElement(element);
 		const itemElements = getItemElements(element);
diff --git a/packages/xforms-engine/src/body/group/BaseGroupDefinition.ts b/packages/xforms-engine/src/body/group/BaseGroupDefinition.ts
index 805405b7..14ec616b 100644
--- a/packages/xforms-engine/src/body/group/BaseGroupDefinition.ts
+++ b/packages/xforms-engine/src/body/group/BaseGroupDefinition.ts
@@ -1,13 +1,14 @@
 import { UpsertableMap } from '@getodk/common/lib/collections/UpsertableMap.ts';
-import type { XFormDOM } from '../../XFormDOM.ts';
 import type { XFormDefinition } from '../../XFormDefinition.ts';
-import { getLabelElement, getRepeatElement } from '../../lib/dom/query.ts';
+import { getLabelElement } from '../../lib/dom/query.ts';
 import {
 	BodyDefinition,
 	type BodyElementDefinitionArray,
 	type BodyElementParentContext,
 } from '../BodyDefinition.ts';
 import { BodyElementDefinition } from '../BodyElementDefinition.ts';
+import type { StructureElementAppearanceDefinition } from '../appearance/structureElementAppearanceParser.ts';
+import { structureElementAppearanceParser } from '../appearance/structureElementAppearanceParser.ts';
 import { LabelDefinition } from '../text/LabelDefinition.ts';
 
 /**
@@ -23,10 +24,6 @@ import { LabelDefinition } from '../text/LabelDefinition.ts';
  * - `presentation-group` is a group with a `<label>` child; its usage here
  *   differs from the spec language in that `presentation-group` does **not**
  *   have a `ref`
- * - `repeat-group` is not mentioned by the spec; it is an extension of
- *   `logical-group`, wherein its `ref` is the same as its immediate `<repeat>`
- *   child's `nodeset` (usage of each attribute is normalized during
- *   initialization, in {@link XFormDOM})
  * - `structural-group` is any `<group>` element which does not satisfy any of
  *   the other usage scenarios; this isn't exactly the terminology used, but is
  *   the most closely fitting name for the concept where the other sceanarios
@@ -34,20 +31,17 @@ import { LabelDefinition } from '../text/LabelDefinition.ts';
  *
  * A more succinct decision tree:
  *
- * - `<group ref="$ref"><repeat nodeset="$ref">` -> `repeat-group`, else
  * - `<group ref="$ref">` -> `logical-group`, else
  * - `<group><label>` -> `presentation-group`, else
  * - `<group>` -> `structural-group`
  */
-export type GroupType =
-	| 'logical-group'
-	| 'presentation-group'
-	| 'repeat-group'
-	| 'structural-group';
+export type GroupType = 'logical-group' | 'presentation-group' | 'structural-group';
 
 export abstract class BaseGroupDefinition<
 	Type extends GroupType,
 > extends BodyElementDefinition<Type> {
+	// TODO: does this really accomplish anything? It seems highly unlikely it
+	// has enough performance benefit to outweigh its memory and lookup costs.
 	private static groupTypes = new UpsertableMap<Element, GroupType | null>();
 
 	protected static getGroupType(localName: string, element: Element): GroupType | null {
@@ -56,20 +50,8 @@ export abstract class BaseGroupDefinition<
 				return null;
 			}
 
-			const ref = element.getAttribute('ref');
-
-			if (ref != null) {
-				const repeat = getRepeatElement(element);
-
-				if (repeat == null) {
-					return 'logical-group';
-				}
-
-				if (repeat.getAttribute('nodeset') === ref) {
-					return 'repeat-group';
-				}
-
-				throw new Error('Unexpected <repeat> child of unrelated <group>');
+			if (element.hasAttribute('ref')) {
+				return 'logical-group';
 			}
 
 			const label = getLabelElement(element);
@@ -87,6 +69,7 @@ export abstract class BaseGroupDefinition<
 	readonly children: BodyElementDefinitionArray;
 
 	override readonly reference: string | null;
+	readonly appearances: StructureElementAppearanceDefinition;
 	override readonly label: LabelDefinition | null;
 
 	constructor(
@@ -99,6 +82,7 @@ export abstract class BaseGroupDefinition<
 
 		this.children = children ?? this.getChildren(element);
 		this.reference = element.getAttribute('ref');
+		this.appearances = structureElementAppearanceParser.parseFrom(element, 'appearance');
 		this.label = LabelDefinition.forGroup(form, this);
 	}
 
@@ -107,31 +91,9 @@ export abstract class BaseGroupDefinition<
 		const children = Array.from(element.children).filter((child) => {
 			const childName = child.localName;
 
-			return childName !== 'label' && childName !== 'repeat';
+			return childName !== 'label';
 		});
 
 		return BodyDefinition.getChildElementDefinitions(form, this, element, children);
 	}
 }
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const repeatGroup = <T extends BaseGroupDefinition<any>>(
-	groupDefinition: T
-): Extract<T, BaseGroupDefinition<'repeat-group'>> | null => {
-	if (groupDefinition.type === 'repeat-group') {
-		return groupDefinition as Extract<T, BaseGroupDefinition<'repeat-group'>>;
-	}
-
-	return null;
-};
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const nonRepeatGroup = <T extends BaseGroupDefinition<any>>(
-	groupDefinition: T
-): Exclude<T, BaseGroupDefinition<'repeat-group'>> | null => {
-	if (groupDefinition.type === 'repeat-group') {
-		return null;
-	}
-
-	return groupDefinition as Exclude<T, BaseGroupDefinition<'repeat-group'>>;
-};
diff --git a/packages/xforms-engine/src/body/group/RepeatGroupDefinition.ts b/packages/xforms-engine/src/body/group/RepeatGroupDefinition.ts
deleted file mode 100644
index fe3f0ba8..00000000
--- a/packages/xforms-engine/src/body/group/RepeatGroupDefinition.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-import { getRepeatElement } from '../../lib/dom/query.ts';
-import type { XFormDefinition } from '../../XFormDefinition.ts';
-import type { BodyElementDefinitionArray, BodyElementParentContext } from '../BodyDefinition.ts';
-import { RepeatDefinition } from '../RepeatDefinition.ts';
-import { BaseGroupDefinition } from './BaseGroupDefinition.ts';
-
-/**
- * TODO: The `RepeatGroupDefinition`/`RepeatDefinition` types are currently
- * expected to always pair, mirroring the corresponding XForm structure, e.g.
- *
- * ```xml
- * <group ref="/root/rep"> <!-- RepeatGroupDefinition -->
- *   <repeat nodeset="/root/rep" /> <!-- RepeatDefinition -->
- * </group>
- * ```
- *
- * This structure has already been a source of one bug (where a recursive walk
- * through a `BodyDefinition`'s descendants failed to reach the children of
- * `RepeatDefinition`s). It seems likely this will continue to be a footgun.
- * After some discussion with @lognaturel, I concluded that the pairing isn't
- * strictly necessary, as this should be considered invalid:
- *
- * ```xml
- * <group ref="/root/rep">
- *   <repeat nodeset="/root/rep" />
- *   <input ref="/root/rep/not-a-repeat-child" />
- * </group>
- * ```
- *
- * It **may** make sense to collapse these types in the future, but I've held
- * off, following another discussion with @lognaturel. There's some potential
- * for group/repeat labeling ambiguity.
- *
- * - The current design accommodates sharing a repeat-containing group's label
- *   across multiple repeat instances, but
- * - The
- *   {@link https://github.com/getodk/xforms-spec/blob/791753a09fabd3d64d8cb95776dc0cef71fa4446/_sections/60-repeats.md?plain=1#L46 | ODK XForms spec suggests}
- *   a repeat's first group might be a better candidate
- *
- * Example of such a structure:
- *
- * ```xml
- * <group ref="/root/foo">
- *   <label>Foo (outer label)</label>
- *   <repeat nodeset="/root/foo">
- *     <group>
- *       <label>Foo (inner label)</label>
- *       <!-- ... -->
- *     </group>
- *   </repeat>
- * </group>
- * ```
- */
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore - All this so I could attach a JSDoc comment to something other
-// than the actual class...
-// eslint-disable-next-line @typescript-eslint/no-empty-interface, @typescript-eslint/no-unused-vars
-interface IgnoreMeIAmJustHereForTheJSDoc {}
-
-export class RepeatGroupDefinition extends BaseGroupDefinition<'repeat-group'> {
-	static override isCompatible(localName: string, element: Element): boolean {
-		return this.getGroupType(localName, element) === 'repeat-group';
-	}
-
-	readonly type = 'repeat-group';
-
-	readonly repeat: RepeatDefinition;
-
-	get repeatChildren(): BodyElementDefinitionArray {
-		return this.repeat.children;
-	}
-
-	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
-		// TODO: this has already been queried at least twice before reaching this
-		// point!
-		const repeat = getRepeatElement(element);
-
-		// TODO: and as such, this should not happen
-		if (repeat == null) {
-			throw new Error('Invalid repeat-group');
-		}
-
-		super(form, parent, element);
-
-		const repeatDefinition = new RepeatDefinition(form, this, repeat);
-
-		this.repeat = repeatDefinition;
-	}
-}
-
-export type RepeatGroupDefinitionClass = typeof RepeatGroupDefinition;
diff --git a/packages/xforms-engine/src/body/text/LabelDefinition.ts b/packages/xforms-engine/src/body/text/LabelDefinition.ts
index e5183197..bcb1d20b 100644
--- a/packages/xforms-engine/src/body/text/LabelDefinition.ts
+++ b/packages/xforms-engine/src/body/text/LabelDefinition.ts
@@ -1,9 +1,10 @@
-import { getLabelElement } from '../../lib/dom/query.ts';
+import { getLabelElement, getRepeatGroupLabelElement } from '../../lib/dom/query.ts';
 import type { XFormDefinition } from '../../XFormDefinition.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 { BaseGroupDefinition } from '../group/BaseGroupDefinition.ts';
+import type { RepeatElementDefinition } from '../RepeatElementDefinition.ts';
 import type { TextElement, TextElementOwner } from './TextElementDefinition.ts';
 import { TextElementDefinition } from './TextElementDefinition.ts';
 
@@ -31,6 +32,19 @@ export class LabelDefinition extends TextElementDefinition<'label'> {
 		return this.staticDefinition(form, control);
 	}
 
+	static forRepeatGroup(
+		form: XFormDefinition,
+		repeat: RepeatElementDefinition
+	): LabelDefinition | null {
+		const repeatGroupLabel = getRepeatGroupLabelElement(repeat.element);
+
+		if (repeatGroupLabel == null) {
+			return null;
+		}
+
+		return new this(form, repeat, repeatGroupLabel);
+	}
+
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	static forGroup(form: XFormDefinition, group: BaseGroupDefinition<any>): LabelDefinition | null {
 		return this.staticDefinition(form, group);
diff --git a/packages/xforms-engine/src/body/text/TextElementDefinition.ts b/packages/xforms-engine/src/body/text/TextElementDefinition.ts
index da322015..d5b5c8d2 100644
--- a/packages/xforms-engine/src/body/text/TextElementDefinition.ts
+++ b/packages/xforms-engine/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;
 
diff --git a/packages/xforms-engine/src/client/BaseNode.ts b/packages/xforms-engine/src/client/BaseNode.ts
index 9a9f5d5c..67193b47 100644
--- a/packages/xforms-engine/src/client/BaseNode.ts
+++ b/packages/xforms-engine/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
diff --git a/packages/xforms-engine/src/client/GroupNode.ts b/packages/xforms-engine/src/client/GroupNode.ts
index 34caedb6..637847ad 100644
--- a/packages/xforms-engine/src/client/GroupNode.ts
+++ b/packages/xforms-engine/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;
diff --git a/packages/xforms-engine/src/client/NodeAppearances.ts b/packages/xforms-engine/src/client/NodeAppearances.ts
new file mode 100644
index 00000000..1c4161c7
--- /dev/null
+++ b/packages/xforms-engine/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;
diff --git a/packages/xforms-engine/src/client/RepeatInstanceNode.ts b/packages/xforms-engine/src/client/RepeatInstanceNode.ts
index 1716f407..9692cd0c 100644
--- a/packages/xforms-engine/src/client/RepeatInstanceNode.ts
+++ b/packages/xforms-engine/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;
 
diff --git a/packages/xforms-engine/src/client/RepeatRangeNode.ts b/packages/xforms-engine/src/client/RepeatRangeNode.ts
index 3ddd82be..966be56b 100644
--- a/packages/xforms-engine/src/client/RepeatRangeNode.ts
+++ b/packages/xforms-engine/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;
diff --git a/packages/xforms-engine/src/client/RootNode.ts b/packages/xforms-engine/src/client/RootNode.ts
index b0ce9fce..be714374 100644
--- a/packages/xforms-engine/src/client/RootNode.ts
+++ b/packages/xforms-engine/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;
diff --git a/packages/xforms-engine/src/client/SelectNode.ts b/packages/xforms-engine/src/client/SelectNode.ts
index 23d2a4e9..ecb105ab 100644
--- a/packages/xforms-engine/src/client/SelectNode.ts
+++ b/packages/xforms-engine/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;
diff --git a/packages/xforms-engine/src/client/StringNode.ts b/packages/xforms-engine/src/client/StringNode.ts
index 22c1ff8d..740dcab6 100644
--- a/packages/xforms-engine/src/client/StringNode.ts
+++ b/packages/xforms-engine/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;
diff --git a/packages/xforms-engine/src/client/SubtreeNode.ts b/packages/xforms-engine/src/client/SubtreeNode.ts
index 467894ad..d5dfe752 100644
--- a/packages/xforms-engine/src/client/SubtreeNode.ts
+++ b/packages/xforms-engine/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;
diff --git a/packages/xforms-engine/src/instance/Group.ts b/packages/xforms-engine/src/instance/Group.ts
index 142d6371..85ec584e 100644
--- a/packages/xforms-engine/src/instance/Group.ts
+++ b/packages/xforms-engine/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;
diff --git a/packages/xforms-engine/src/instance/RepeatInstance.ts b/packages/xforms-engine/src/instance/RepeatInstance.ts
index 3e32d6c8..e1ffae3f 100644
--- a/packages/xforms-engine/src/instance/RepeatInstance.ts
+++ b/packages/xforms-engine/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';
@@ -49,6 +53,11 @@ export class RepeatInstance
 	// RepeatInstanceNode
 	readonly nodeType = 'repeat-instance';
 
+	/**
+	 * @see {@link RepeatRange.appearances}
+	 */
+	readonly appearances: RepeatInstanceNodeAppearances;
+
 	readonly currentState: MaterializedChildren<
 		CurrentState<RepeatInstanceStateSpec>,
 		GeneralChildNode
@@ -61,6 +70,8 @@ export class RepeatInstance
 	) {
 		super(parent, definition);
 
+		this.appearances = definition.bodyElement.appearances;
+
 		const childrenState = createChildrenState<RepeatInstance, GeneralChildNode>(this);
 
 		this.childrenState = childrenState;
@@ -79,6 +90,7 @@ export class RepeatInstance
 			{
 				...this.buildSharedStateSpec(parent, definition),
 
+				// TODO: only-child <group><label>
 				label: createNodeLabel(this, definition),
 				hint: null,
 				children: childrenState.childIds,
diff --git a/packages/xforms-engine/src/instance/RepeatRange.ts b/packages/xforms-engine/src/instance/RepeatRange.ts
index 3fe923bc..b61d33dd 100644
--- a/packages/xforms-engine/src/instance/RepeatRange.ts
+++ b/packages/xforms-engine/src/instance/RepeatRange.ts
@@ -1,6 +1,6 @@
 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 type { MaterializedChildren } from '../lib/reactivity/materializeCurrentStateChildren.ts';
@@ -10,7 +10,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 +31,7 @@ interface RepeatRangeStateSpec extends DescendantNodeSharedStateSpec {
 }
 
 export class RepeatRange
-	extends DescendantNode<RepeatSequenceDefinition, RepeatRangeStateSpec, RepeatInstance>
+	extends DescendantNode<RepeatRangeDefinition, RepeatRangeStateSpec, RepeatInstance>
 	implements RepeatRangeNode, EvaluationContext, SubscribableDependency
 {
 	/**
@@ -67,11 +67,48 @@ export class RepeatRange
 	// 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;
diff --git a/packages/xforms-engine/src/instance/Root.ts b/packages/xforms-engine/src/instance/Root.ts
index 011462a9..d1ee3b5e 100644
--- a/packages/xforms-engine/src/instance/Root.ts
+++ b/packages/xforms-engine/src/instance/Root.ts
@@ -2,6 +2,7 @@ import type { XFormsXPathEvaluator } from '@getodk/xpath';
 import type { Accessor, Signal } from 'solid-js';
 import { createSignal } from 'solid-js';
 import type { XFormDOM } from '../XFormDOM.ts';
+import type { BodyClassList } from '../body/BodyDefinition.ts';
 import type { ActiveLanguage, FormLanguage, FormLanguages } from '../client/FormLanguage.ts';
 import type { RootNode } from '../client/RootNode.ts';
 import type { ChildrenState } from '../lib/reactivity/createChildrenState.ts';
@@ -118,7 +119,8 @@ export class Root
 
 	// RootNode
 	readonly nodeType = 'root';
-
+	readonly appearances = null;
+	readonly classes: BodyClassList;
 	readonly currentState: MaterializedChildren<CurrentState<RootStateSpec>, GeneralChildNode>;
 
 	protected readonly instanceDOM: XFormDOM;
@@ -154,6 +156,8 @@ export class Root
 	) {
 		super(engineConfig, null, definition);
 
+		this.classes = definition.classes;
+
 		const childrenState = createChildrenState<Root, GeneralChildNode>(this);
 
 		this.childrenState = childrenState;
diff --git a/packages/xforms-engine/src/instance/SelectField.ts b/packages/xforms-engine/src/instance/SelectField.ts
index b7fa7bcb..294185d2 100644
--- a/packages/xforms-engine/src/instance/SelectField.ts
+++ b/packages/xforms-engine/src/instance/SelectField.ts
@@ -2,7 +2,7 @@ import { xmlXPathWhitespaceSeparatedList } from '@getodk/common/lib/string/white
 import type { Accessor } from 'solid-js';
 import { untrack } from 'solid-js';
 import type { AnySelectDefinition } from '../body/control/select/SelectDefinition.ts';
-import type { SelectItem, SelectNode } from '../client/SelectNode.ts';
+import type { SelectItem, SelectNode, SelectNodeAppearances } from '../client/SelectNode.ts';
 import type { TextRange } from '../index.ts';
 import { createSelectItems } from '../lib/reactivity/createSelectItems.ts';
 import { createValueState } from '../lib/reactivity/createValueState.ts';
@@ -50,7 +50,7 @@ export class SelectField
 
 	// SelectNode
 	readonly nodeType = 'select';
-
+	readonly appearances: SelectNodeAppearances;
 	readonly currentState: CurrentState<SelectFieldStateSpec>;
 
 	// ValueContext
@@ -83,6 +83,7 @@ export class SelectField
 	constructor(parent: GeneralParentNode, definition: SelectFieldDefinition) {
 		super(parent, definition);
 
+		this.appearances = definition.bodyElement.appearances;
 		this.selectExclusive = definition.bodyElement.type === 'select1';
 
 		const valueOptions = createSelectItems(this);
diff --git a/packages/xforms-engine/src/instance/StringField.ts b/packages/xforms-engine/src/instance/StringField.ts
index ea3ecc84..ac84b4fc 100644
--- a/packages/xforms-engine/src/instance/StringField.ts
+++ b/packages/xforms-engine/src/instance/StringField.ts
@@ -1,7 +1,7 @@
 import { identity } from '@getodk/common/lib/identity.ts';
 import type { Accessor } from 'solid-js';
 import type { InputDefinition } from '../body/control/InputDefinition.ts';
-import type { StringNode } from '../client/StringNode.ts';
+import type { StringNode, StringNodeAppearances } from '../client/StringNode.ts';
 import type { TextRange } from '../index.ts';
 import { createValueState } from '../lib/reactivity/createValueState.ts';
 import type { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
@@ -43,7 +43,7 @@ export class StringField
 
 	// StringNode
 	readonly nodeType = 'string';
-
+	readonly appearances: StringNodeAppearances;
 	readonly currentState: CurrentState<StringFieldStateSpec>;
 
 	// ValueContext
@@ -54,6 +54,8 @@ export class StringField
 	constructor(parent: GeneralParentNode, definition: StringFieldDefinition) {
 		super(parent, definition);
 
+		this.appearances = (definition.bodyElement?.appearances ?? null) as StringNodeAppearances;
+
 		const state = createSharedNodeState(
 			this.scope,
 			{
diff --git a/packages/xforms-engine/src/instance/Subtree.ts b/packages/xforms-engine/src/instance/Subtree.ts
index 902b86c1..1fae93da 100644
--- a/packages/xforms-engine/src/instance/Subtree.ts
+++ b/packages/xforms-engine/src/instance/Subtree.ts
@@ -36,7 +36,7 @@ export class Subtree
 
 	// SubtreeNode
 	readonly nodeType = 'subtree';
-
+	readonly appearances = null;
 	readonly currentState: MaterializedChildren<CurrentState<SubtreeStateSpec>, GeneralChildNode>;
 
 	constructor(parent: GeneralParentNode, definition: SubtreeDefinition) {
diff --git a/packages/xforms-engine/src/instance/abstract/InstanceNode.ts b/packages/xforms-engine/src/instance/abstract/InstanceNode.ts
index 13ded230..a2d618a5 100644
--- a/packages/xforms-engine/src/instance/abstract/InstanceNode.ts
+++ b/packages/xforms-engine/src/instance/abstract/InstanceNode.ts
@@ -2,6 +2,7 @@ import type { XFormsXPathEvaluator } from '@getodk/xpath';
 import type { Accessor, Signal } from 'solid-js';
 import { createSignal } from 'solid-js';
 import type { BaseNode } from '../../client/BaseNode.ts';
+import type { NodeAppearances } from '../../client/NodeAppearances.ts';
 import type { InstanceNodeType } from '../../client/node-types.ts';
 import type { TextRange } from '../../index.ts';
 import type { MaterializedChildren } from '../../lib/reactivity/materializeCurrentStateChildren.ts';
@@ -131,6 +132,8 @@ export abstract class InstanceNode<
 	// BaseNode: node types and variants (e.g. for narrowing)
 	abstract readonly nodeType: InstanceNodeType;
 
+	abstract readonly appearances: NodeAppearances<Definition>;
+
 	abstract readonly currentState: InstanceNodeCurrentState<Spec, Child>;
 
 	// BaseNode: structural
diff --git a/packages/xforms-engine/src/instance/children.ts b/packages/xforms-engine/src/instance/children.ts
index 1af05d72..f0af1499 100644
--- a/packages/xforms-engine/src/instance/children.ts
+++ b/packages/xforms-engine/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: {
diff --git a/packages/xforms-engine/src/lib/TokenListParser.ts b/packages/xforms-engine/src/lib/TokenListParser.ts
new file mode 100644
index 00000000..bd9531e0
--- /dev/null
+++ b/packages/xforms-engine/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;
diff --git a/packages/xforms-engine/src/lib/dom/query.ts b/packages/xforms-engine/src/lib/dom/query.ts
index 2bc47e24..3c3e3c5d 100644
--- a/packages/xforms-engine/src/lib/dom/query.ts
+++ b/packages/xforms-engine/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);
 };
diff --git a/packages/xforms-engine/src/model/DescendentNodeDefinition.ts b/packages/xforms-engine/src/model/DescendentNodeDefinition.ts
index b588583b..9dcdaecd 100644
--- a/packages/xforms-engine/src/model/DescendentNodeDefinition.ts
+++ b/packages/xforms-engine/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,
diff --git a/packages/xforms-engine/src/model/ModelDefinition.ts b/packages/xforms-engine/src/model/ModelDefinition.ts
index bb2638eb..2ad57f92 100644
--- a/packages/xforms-engine/src/model/ModelDefinition.ts
+++ b/packages/xforms-engine/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() {
diff --git a/packages/xforms-engine/src/model/NodeDefinition.ts b/packages/xforms-engine/src/model/NodeDefinition.ts
index f65aa4d5..fce96513 100644
--- a/packages/xforms-engine/src/model/NodeDefinition.ts
+++ b/packages/xforms-engine/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
diff --git a/packages/xforms-engine/src/model/RepeatInstanceDefinition.ts b/packages/xforms-engine/src/model/RepeatInstanceDefinition.ts
index 7e890afb..48580cb5 100644
--- a/packages/xforms-engine/src/model/RepeatInstanceDefinition.ts
+++ b/packages/xforms-engine/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;
 	}
diff --git a/packages/xforms-engine/src/model/RepeatSequenceDefinition.ts b/packages/xforms-engine/src/model/RepeatRangeDefinition.ts
similarity index 82%
rename from packages/xforms-engine/src/model/RepeatSequenceDefinition.ts
rename to packages/xforms-engine/src/model/RepeatRangeDefinition.ts
index 9539a44a..69b00acb 100644
--- a/packages/xforms-engine/src/model/RepeatSequenceDefinition.ts
+++ b/packages/xforms-engine/src/model/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);
diff --git a/packages/xforms-engine/src/model/RepeatTemplateDefinition.ts b/packages/xforms-engine/src/model/RepeatTemplateDefinition.ts
index d9d70c83..e81ee0f4 100644
--- a/packages/xforms-engine/src/model/RepeatTemplateDefinition.ts
+++ b/packages/xforms-engine/src/model/RepeatTemplateDefinition.ts
@@ -1,9 +1,9 @@
 import { JAVAROSA_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
-import type { RepeatDefinition } from '../body/RepeatDefinition.ts';
+import type { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { BindDefinition } from './BindDefinition.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';
 
 const repeatTemplates = new WeakMap<BindDefinition, RepeatTemplateDefinition>();
 
@@ -73,14 +73,14 @@ interface ParsedRepeatNodes {
 }
 
 export class RepeatTemplateDefinition
-	extends DescendentNodeDefinition<'repeat-template', RepeatDefinition>
+	extends DescendentNodeDefinition<'repeat-template', RepeatElementDefinition>
 	implements NodeDefinition<'repeat-template'>
 {
 	static parseModelNodes(
-		sequence: RepeatSequenceDefinition,
+		range: RepeatRangeDefinition,
 		modelNodes: readonly [Element, ...Element[]]
 	): ParsedRepeatNodes {
-		const { bind } = sequence;
+		const { bind } = range;
 
 		let template = repeatTemplates.get(bind);
 		let instanceNodes: readonly Element[];
@@ -89,7 +89,7 @@ export class RepeatTemplateDefinition
 			const [templateNode, ...rest] = splitInstanceNodes(modelNodes);
 
 			instanceNodes = rest;
-			template = new this(sequence, templateNode);
+			template = new this(range, templateNode);
 		} else {
 			// TODO: this is under the assumption that for any depth > 1, if a
 			// template has already been defined for the given form definition, any
@@ -121,17 +121,12 @@ export class RepeatTemplateDefinition
 	readonly defaultValue = null;
 
 	protected constructor(
-		protected readonly sequence: RepeatSequenceDefinition,
+		range: RepeatRangeDefinition,
 		protected readonly templateNode: ExplicitRepeatTemplateElement
 	) {
-		const {
-			bind,
-			bodyElement: repeatGroupBodyElement,
-			parent: repeatSequenceParent,
-			root,
-		} = sequence;
+		const { bind, bodyElement, parent, root } = range;
 
-		super(repeatSequenceParent, bind, repeatGroupBodyElement.repeat);
+		super(parent, bind, bodyElement);
 
 		const node = templateNode.cloneNode(true) as Element;
 
@@ -143,7 +138,7 @@ export class RepeatTemplateDefinition
 	}
 
 	toJSON() {
-		const { bind, bodyElement, parent, root, sequence, ...rest } = this;
+		const { bind, bodyElement, parent, root, ...rest } = this;
 
 		return rest;
 	}
diff --git a/packages/xforms-engine/src/model/RootDefinition.ts b/packages/xforms-engine/src/model/RootDefinition.ts
index 147527ec..84458a70 100644
--- a/packages/xforms-engine/src/model/RootDefinition.ts
+++ b/packages/xforms-engine/src/model/RootDefinition.ts
@@ -1,5 +1,5 @@
 import type { XFormDefinition } from '../XFormDefinition.ts';
-import type { RepeatGroupDefinition } from '../body/group/RepeatGroupDefinition.ts';
+import type { BodyClassList } from '../body/BodyDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import type { ModelDefinition } from './ModelDefinition.ts';
 import type {
@@ -7,7 +7,7 @@ import type {
 	NodeDefinition,
 	ParentNodeDefinition,
 } from './NodeDefinition.ts';
-import { RepeatSequenceDefinition } from './RepeatSequenceDefinition.ts';
+import { RepeatRangeDefinition } from './RepeatRangeDefinition.ts';
 import { SubtreeDefinition } from './SubtreeDefinition.ts';
 import { ValueNodeDefinition } from './ValueNodeDefinition.ts';
 
@@ -29,7 +29,8 @@ export class RootDefinition implements NodeDefinition<'root'> {
 
 	constructor(
 		protected readonly form: XFormDefinition,
-		protected readonly model: ModelDefinition
+		protected readonly model: ModelDefinition,
+		readonly classes: BodyClassList
 	) {
 		// TODO: theoretically the pertinent step in the bind's `nodeset` *could* be
 		// namespaced. It also may make more sense to determine the root nodeset
@@ -86,16 +87,9 @@ export class RootDefinition implements NodeDefinition<'root'> {
 			const bind = binds.getOrCreateBindDefinition(nodeset);
 			const bodyElement = body.getBodyElement(nodeset);
 			const [firstChild, ...restChildren] = children;
-			const repeatGroup = body.getRepeatGroup(nodeset);
 
-			if (repeatGroup != null) {
-				const repeatDefinition = (bodyElement as RepeatGroupDefinition).repeat;
-
-				if (repeatDefinition == null) {
-					throw 'TODO: this is why I have hesitated to pick an "is repeat" predicate direction';
-				}
-
-				return new RepeatSequenceDefinition(parent, bind, repeatGroup, children);
+			if (bodyElement?.type === 'repeat') {
+				return new RepeatRangeDefinition(parent, bind, bodyElement, children);
 			}
 
 			if (restChildren.length) {
diff --git a/packages/xforms-engine/src/model/SubtreeDefinition.ts b/packages/xforms-engine/src/model/SubtreeDefinition.ts
index 67077e21..6d5e2918 100644
--- a/packages/xforms-engine/src/model/SubtreeDefinition.ts
+++ b/packages/xforms-engine/src/model/SubtreeDefinition.ts
@@ -1,6 +1,6 @@
 import type {
 	AnyBodyElementDefinition,
-	NonRepeatGroupElementDefinition,
+	AnyGroupElementDefinition,
 } from '../body/BodyDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
@@ -11,7 +11,7 @@ import type {
 } from './NodeDefinition.ts';
 
 export class SubtreeDefinition
-	extends DescendentNodeDefinition<'subtree', NonRepeatGroupElementDefinition | null>
+	extends DescendentNodeDefinition<'subtree', AnyGroupElementDefinition | null>
 	implements NodeDefinition<'subtree'>
 {
 	readonly type = 'subtree';
@@ -29,7 +29,7 @@ export class SubtreeDefinition
 	) {
 		if (
 			bodyElement != null &&
-			(bodyElement.category !== 'structure' || bodyElement.type === 'repeat-group')
+			(bodyElement.category !== 'structure' || bodyElement.type === 'repeat')
 		) {
 			throw new Error(`Unexpected body element for nodeset ${bind.nodeset}`);
 		}
diff --git a/packages/xforms-engine/src/model/ValueNodeDefinition.ts b/packages/xforms-engine/src/model/ValueNodeDefinition.ts
index 88e9a240..8db070ca 100644
--- a/packages/xforms-engine/src/model/ValueNodeDefinition.ts
+++ b/packages/xforms-engine/src/model/ValueNodeDefinition.ts
@@ -1,11 +1,10 @@
-import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
-import type { AnyControlDefinition } from '../body/control/ControlDefinition.ts';
+import type { AnyBodyElementDefinition, ControlElementDefinition } from '../body/BodyDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
 import type { NodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
 
 export class ValueNodeDefinition
-	extends DescendentNodeDefinition<'value-node', AnyControlDefinition | null>
+	extends DescendentNodeDefinition<'value-node', ControlElementDefinition | null>
 	implements NodeDefinition<'value-node'>
 {
 	readonly type = 'value-node';
diff --git a/packages/xforms-engine/test/XFormDOM.test.ts b/packages/xforms-engine/test/XFormDOM.test.ts
index 005f7a2c..300c31d5 100644
--- a/packages/xforms-engine/test/XFormDOM.test.ts
+++ b/packages/xforms-engine/test/XFormDOM.test.ts
@@ -1,4 +1,4 @@
-import { XFORMS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import { XHTML_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
 import type { HtmlXFormsElement } from '@getodk/common/test/fixtures/xform-dsl/HtmlXFormsElement.ts';
 import {
 	body,
@@ -25,6 +25,10 @@ describe('XFormDOM', () => {
 					mainInstance(
 						// prettier-ignore
 						t('root id="bind-types"',
+						  t('grp',
+								// prettier-ignore
+								t('g1')
+							),
 							t('rep',
 								// prettier-ignore
 								t('a'),
@@ -61,11 +65,16 @@ describe('XFormDOM', () => {
 			),
 			body(
 				t(
-					'group id="group-nodeset" nodeset="/root/rep" group-containing-repeat=""',
+					'group id="group-nodeset" nodeset="/root/grp"',
+					// prettier-ignore
+					t('input id="input-nodeset" nodeset="/root/grp/g1"')
+				),
+				t(
+					'group id="repeat-group" nodeset="/root/rep" group-containing-repeat=""',
 					t(
 						'repeat id="repeat-ref" ref="/root/rep" repeat-contained-by-group=""',
 						// prettier-ignore
-						t('input id="input-nodeset" nodeset="/root/rep/a" grouped-repeat-child=""'),
+						t('input nodeset="/root/rep/a" grouped-repeat-child=""'),
 						t(
 							'select1 id="select-nodeset" nodeset="/root/rep/b" grouped-repeat-child=""',
 							t(
@@ -101,7 +110,7 @@ describe('XFormDOM', () => {
 			id: 'group-nodeset',
 			expected: {
 				nodeset: null,
-				ref: '/root/rep',
+				ref: '/root/grp',
 			},
 		},
 		{
@@ -119,7 +128,7 @@ describe('XFormDOM', () => {
 			id: 'input-nodeset',
 			expected: {
 				nodeset: null,
-				ref: '/root/rep/a',
+				ref: '/root/grp/g1',
 			},
 		},
 		{
@@ -147,23 +156,40 @@ describe('XFormDOM', () => {
 		expect(element.getAttribute('ref')).toBe(expected.ref);
 	});
 
-	it('wraps an ungrouped <repeat> with a <group> with the same nodeset reference', () => {
+	it('unwraps a <group ref><repeat nodeset> pair', () => {
+		const repeatElement = xformDOM.xformDocument.getElementById('repeat-ref')!;
+
+		expect(repeatElement).not.toBeNull();
+
+		const parent = repeatElement.parentElement!;
+
+		expect(parent.namespaceURI).toBe(XHTML_NAMESPACE_URI);
+		expect(parent.localName).toBe('body');
+
+		const repeatGroup = xformDOM.xformDocument.getElementById('repeat-group');
+
+		expect(repeatGroup).toBeNull();
+	});
+
+	it('does not unwrap an ungrouped <repeat> with a <group> with the same nodeset reference', () => {
 		const repeat = xformDOM.xformDocument.getElementById('ungrouped-repeat')!;
 		const parent = repeat.parentElement!;
 
-		expect(parent.namespaceURI).toBe(XFORMS_NAMESPACE_URI);
-		expect(parent.localName).toBe('group');
-		expect(parent.getAttribute('ref')).toBe(repeat.getAttribute('nodeset'));
+		expect(parent.namespaceURI).toBe(XHTML_NAMESPACE_URI);
+		expect(parent.localName).toBe('body');
 	});
 
-	it('wraps a <repeat> within a <group> referencing a different nodeset into a new <group> with its own nodeset reference', () => {
+	it('normalizes a <repeat ref> to use a `nodeset` attribute', () => {
+		const repeat = xformDOM.xformDocument.getElementById('repeat-ref')!;
+
+		expect(repeat.getAttribute('ref')).toBeNull();
+		expect(repeat.getAttribute('nodeset')).toBe('/root/rep');
+	});
+
+	it('does not unwrap a <repeat> within a <group> referencing a different nodeset', () => {
 		const unrelatedGroup = xformDOM.xformDocument.getElementById('unrelated-group')!;
 		const repeat = xformDOM.xformDocument.getElementById('unrelated-grouped-repeat')!;
-		const parent = repeat.parentElement!;
 
-		expect(parent.namespaceURI).toBe(XFORMS_NAMESPACE_URI);
-		expect(parent.localName).toBe('group');
-		expect(parent.getAttribute('ref')).toBe(repeat.getAttribute('nodeset'));
-		expect(parent.parentElement).toBe(unrelatedGroup);
+		expect(repeat.parentElement).toBe(unrelatedGroup);
 	});
 });
diff --git a/packages/xforms-engine/test/body/BodyDefinition.test.ts b/packages/xforms-engine/test/body/BodyDefinition.test.ts
index 984e894f..19da6a32 100644
--- a/packages/xforms-engine/test/body/BodyDefinition.test.ts
+++ b/packages/xforms-engine/test/body/BodyDefinition.test.ts
@@ -405,13 +405,13 @@ describe('BodyDefinition', () => {
 		});
 	});
 
-	describe('repeats/repeat-group', () => {
-		it('defines a repeat group for a <group> containing a <repeat> with the same `ref`/`nodeset`', () => {
-			const repeatGroup = bodyDefinition.elements[6];
+	describe('repeats', () => {
+		it('defines a repeat for a <group> containing a <repeat> with the same `ref`/`nodeset`', () => {
+			const repeatDefinition = bodyDefinition.elements[6];
 
-			expect(repeatGroup).toMatchObject({
+			expect(repeatDefinition).toMatchObject({
 				category: 'structure',
-				type: 'repeat-group',
+				type: 'repeat',
 				reference: '/root/rep1',
 				label: {
 					category: 'support',
@@ -421,66 +421,47 @@ describe('BodyDefinition', () => {
 			});
 		});
 
-		it("defines a repeat-group's repeat, distinct from general `children`", () => {
-			const repeatGroup = bodyDefinition.elements[6];
-
-			expect(repeatGroup).toMatchObject({
-				children: [],
-				repeat: {
-					category: 'structure',
-					type: 'repeat',
-				},
-			});
-		});
-
 		it("defines the repeat's children", () => {
-			const repeatGroup = bodyDefinition.elements[6];
-
-			expect(repeatGroup).toMatchObject({
-				repeat: {
-					children: [
-						{
-							category: 'control',
-							type: 'input',
-							reference: '/root/rep1/r1-1',
-							label: null,
-						},
-						{
-							category: 'control',
-							type: 'input',
-							reference: '/root/rep1/r1-2',
-							label: {
-								category: 'support',
-								type: 'label',
-								children: [{ expression: '"Repeat 1 input 2"' }],
-							},
+			const repeatDefinition = bodyDefinition.elements[6];
+
+			expect(repeatDefinition).toMatchObject({
+				children: [
+					{
+						category: 'control',
+						type: 'input',
+						reference: '/root/rep1/r1-1',
+						label: null,
+					},
+					{
+						category: 'control',
+						type: 'input',
+						reference: '/root/rep1/r1-2',
+						label: {
+							category: 'support',
+							type: 'label',
+							children: [{ expression: '"Repeat 1 input 2"' }],
 						},
-					],
-				},
+					},
+				],
 			});
 		});
 
-		it('defines a repeat group for a <repeat> without an explicit containing <group>, for API consistency', () => {
-			const inferredRepeatGroup = bodyDefinition.elements[7];
+		it('defines a repeat for a <repeat> without an explicit containing <group>, for API consistency', () => {
+			const repeatDefinition = bodyDefinition.elements[7];
 
-			expect(inferredRepeatGroup).toMatchObject({
+			expect(repeatDefinition).toMatchObject({
 				category: 'structure',
-				type: 'repeat-group',
+				type: 'repeat',
 				reference: '/root/rep2',
 				label: null,
-				children: [],
-				repeat: {
-					category: 'structure',
-					type: 'repeat',
-					children: [
-						{
-							category: 'control',
-							type: 'input',
-							reference: '/root/rep2/r2-1',
-							label: null,
-						},
-					],
-				},
+				children: [
+					{
+						category: 'control',
+						type: 'input',
+						reference: '/root/rep2/r2-1',
+						label: null,
+					},
+				],
 			});
 		});
 
diff --git a/packages/xforms-engine/test/model/ModelDefinition.test.ts b/packages/xforms-engine/test/model/ModelDefinition.test.ts
index 7d83f8b6..3eaeb134 100644
--- a/packages/xforms-engine/test/model/ModelDefinition.test.ts
+++ b/packages/xforms-engine/test/model/ModelDefinition.test.ts
@@ -18,7 +18,7 @@ import { beforeEach, describe, expect, it } from 'vitest';
 import { XFormDefinition } from '../../src/XFormDefinition.ts';
 import { BindDefinition } from '../../src/model/BindDefinition.ts';
 import { ModelDefinition } from '../../src/model/ModelDefinition.ts';
-import type { RepeatSequenceDefinition } from '../../src/model/RepeatSequenceDefinition.ts';
+import type { RepeatRangeDefinition } from '../../src/model/RepeatRangeDefinition.ts';
 import type { ValueNodeDefinition } from '../../src/model/ValueNodeDefinition.ts';
 
 describe('ModelDefinition', () => {
@@ -320,10 +320,10 @@ describe('ModelDefinition', () => {
 			{
 				index: 0,
 				expected: {
-					type: 'repeat-sequence',
+					type: 'repeat-range',
 					bind: { nodeset: '/root/rep' },
 					bodyElement: {
-						type: 'repeat-group',
+						type: 'repeat',
 					},
 					instances: [
 						{
@@ -350,10 +350,10 @@ describe('ModelDefinition', () => {
 			{
 				index: 1,
 				expected: {
-					type: 'repeat-sequence',
+					type: 'repeat-range',
 					bind: { nodeset: '/root/rep2' },
 					bodyElement: {
-						type: 'repeat-group',
+						type: 'repeat',
 					},
 					instances: [
 						{
@@ -392,26 +392,26 @@ describe('ModelDefinition', () => {
 		);
 
 		describe('templates', () => {
-			const expectRepeatTemplate = (definition: RepeatSequenceDefinition, expectedXML: string) => {
+			const expectRepeatTemplate = (definition: RepeatRangeDefinition, expectedXML: string) => {
 				const expected = xformsElement`${expectedXML}`;
 
 				expectEqualNode(definition.template.node, expected);
 			};
 
 			it('defines an explicit repeat template', () => {
-				const definition = modelDefinition.root.children[0] as RepeatSequenceDefinition;
+				const definition = modelDefinition.root.children[0] as RepeatRangeDefinition;
 
 				expectRepeatTemplate(definition, /* xml */ `<rep><a>a default</a><b>b default</b></rep>`);
 			});
 
 			it('derives a repeat template from a non-template instance in the form definition', () => {
-				const definition = modelDefinition.root.children[1] as RepeatSequenceDefinition;
+				const definition = modelDefinition.root.children[1] as RepeatRangeDefinition;
 
 				expectRepeatTemplate(definition, /* xml */ `<rep2><c /><d /></rep2>`);
 			});
 
 			it('clears default values from a derived template', () => {
-				const definition = modelDefinition.root.children[4] as RepeatSequenceDefinition;
+				const definition = modelDefinition.root.children[4] as RepeatRangeDefinition;
 
 				expectRepeatTemplate(definition, /* xml */ `<rep5><g /></rep5>`);
 			});
@@ -422,7 +422,7 @@ describe('ModelDefinition', () => {
 			])(
 				'defines $expected default instances from nodes in the form definition when a repeat template is implicitly derived',
 				({ index, expected }) => {
-					const definition = modelDefinition.root.children[index] as RepeatSequenceDefinition;
+					const definition = modelDefinition.root.children[index] as RepeatRangeDefinition;
 
 					expect(definition.instances.length).toBe(expected);
 				}
@@ -505,9 +505,9 @@ describe('ModelDefinition', () => {
 					expected: 3,
 				},
 			])('defines $expected default instances ($nodeset)', ({ index, nodeset, expected }) => {
-				const definition = modelDefinition.root.children[index] as RepeatSequenceDefinition;
+				const definition = modelDefinition.root.children[index] as RepeatRangeDefinition;
 
-				// Ensure we're testing the right sequence in the first place
+				// Ensure we're testing the right range in the first place
 				expect(definition.nodeset).toBe(nodeset);
 
 				expect(definition.instances.length).toBe(expected);
@@ -516,30 +516,28 @@ describe('ModelDefinition', () => {
 			it.each([
 				{
 					nodeset: '/root/rep4',
-					sequenceIndex: 3,
+					rangeIndex: 3,
 					instanceIndex: 0,
 					expectedXML: /* xml */ `<rep4><f>default instance f 0</f></rep4>`,
 				},
 				{
 					nodeset: '/root/rep4',
-					sequenceIndex: 3,
+					rangeIndex: 3,
 					instanceIndex: 1,
 					expectedXML: /* xml */ `<rep4><f /></rep4>`,
 				},
 				{
 					nodeset: '/root/rep4',
-					sequenceIndex: 3,
+					rangeIndex: 3,
 					instanceIndex: 2,
 					expectedXML: /* xml */ `<rep4><f>default instance f 2</f></rep4>`,
 				},
 			])(
 				'defines the default instance for nodeset $nodeset at index $instanceIndex with default values (xml: $expectedXML)',
-				({ nodeset, sequenceIndex, instanceIndex, expectedXML }) => {
-					const definition = modelDefinition.root.children[
-						sequenceIndex
-					] as RepeatSequenceDefinition;
+				({ nodeset, rangeIndex, instanceIndex, expectedXML }) => {
+					const definition = modelDefinition.root.children[rangeIndex] as RepeatRangeDefinition;
 
-					// Ensure we're testing the right sequence in the first place
+					// Ensure we're testing the right range in the first place
 					expect(definition.nodeset).toBe(nodeset);
 
 					const instance = definition.instances[instanceIndex]!;