From e7bef0c5ef8f4f4706514ad5b2284eb236febb38 Mon Sep 17 00:00:00 2001
From: eyelidlessness <eyelidlessness@users.noreply.github.com>
Date: Thu, 6 Jun 2024 07:29:21 -0700
Subject: [PATCH] Initial support for appearances, body classes (#127)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Normalize repeats by *unwrapping* <group ref><repeat nodeset> pairs

Note that this introduces an in-memory `<label form-definition-source=“repeat-group”>` to distinguish outer/inner labels for such structures.

Example: for this form definition structure…

```xml
<group ref="/root/rep">
  <label>Repeat/group label</label>
  <repeat nodeset="/root/rep">
    <label>Repeat label</label>
  </repeat>
</group>
```

… this would be the normalized structure:

```xml
<repeat nodeset="/root/rep">
  <label form-definition-source=“repeat-group”>Repeat/group label</label>
  <label>Repeat label</label>
</repeat>
```

* Eliminate concept of “repeat group” in parsed definition

Note that `RepeatGroupDefinition` previously had two responsibilities:

1. To provide access to its `repeat`
2. To provide access to a label defined in the repeat’s containing group

The first is no longer necessary because the repeat is accessed directly.

The second is accommodated by defining the `RepeatElementDefinition`’s label from the special-case `<label form-definition-source=“repeat-group”>` as produced in the previous commit.

Also note that this still does not deal with the unhandled repeat labeling engine responsibility: <repeat><group><label/></group></repeat>. A TODO is added specifically so it can be traced back to this commit, as it will likely help shorten the path to reabsorbing the pertinent code/implementation details back into active brain memory.

* Consistent repeat terminology: “sequence” -> “range”

* Initial support for appearances (and body classes)

Automated testing is pending. Some manual validation has been done to verify that this likely works as intended. The intent is to make this first pass available for client iteration as quickly as possible.

While it’s possible to include unit tests for `TokenListParser`, it seems more likely we’ll want to add integration tests in the `scenario` package. Given there’s a ton of unaddressed feedback in #110, it seems most prudent to get this into draft first, and bring in integration tests once that  lands.

* Add scenario integration tests for appearances and body classes

* Add changeset

---------

Co-authored-by: Hélène Martin <lognaturel@gmail.com>
---
 .changeset/empty-ravens-refuse.md             |   9 +
 .../type-assertions/assertUnknownObject.ts    |   9 +
 .../src/test/assertions/arrayOfAssertion.ts   |  24 +
 .../test/assertions/instanceArrayAssertion.ts |  17 +-
 .../types/string/PartiallyKnownString.ts      |  27 ++
 .../src/assertion/extensions/answers.ts       |   4 +-
 .../src/assertion/extensions/appearances.ts   |  75 +++
 .../src/assertion/extensions/body-classes.ts  |  75 +++
 .../extensions/shared-type-assertions.ts      |  55 +++
 packages/scenario/src/assertion/setup.ts      |   2 +
 .../test/appearance-body-class.test.ts        | 443 ++++++++++++++++++
 .../XForm/containers/XFormGroup.tsx           |   2 +-
 .../web-forms/src/components/QuestionList.vue |  24 +-
 packages/xforms-engine/src/XFormDOM.ts        |  89 +++-
 .../xforms-engine/src/body/BodyDefinition.ts  |  61 ++-
 .../src/body/RepeatDefinition.ts              |  54 ---
 .../src/body/RepeatElementDefinition.ts       |  70 +++
 .../body/appearance/inputAppearanceParser.ts  |  39 ++
 .../body/appearance/selectAppearanceParser.ts |  38 ++
 .../structureElementAppearanceParser.ts       |   7 +
 .../src/body/control/ControlDefinition.ts     |   4 +
 .../src/body/control/InputDefinition.ts       |  13 +
 .../body/control/select/SelectDefinition.ts   |  19 +-
 .../src/body/group/BaseGroupDefinition.ts     |  60 +--
 .../src/body/group/RepeatGroupDefinition.ts   |  91 ----
 .../src/body/text/LabelDefinition.ts          |  16 +-
 .../src/body/text/TextElementDefinition.ts    |  10 +-
 packages/xforms-engine/src/client/BaseNode.ts |  10 +-
 .../xforms-engine/src/client/GroupNode.ts     |   8 +-
 .../src/client/NodeAppearances.ts             |  22 +
 .../src/client/RepeatInstanceNode.ts          |   4 +
 .../src/client/RepeatRangeNode.ts             |   8 +-
 packages/xforms-engine/src/client/RootNode.ts |  22 +
 .../xforms-engine/src/client/SelectNode.ts    |   4 +
 .../xforms-engine/src/client/StringNode.ts    |   4 +
 .../xforms-engine/src/client/SubtreeNode.ts   |   1 +
 packages/xforms-engine/src/instance/Group.ts  |   8 +-
 .../src/instance/RepeatInstance.ts            |  14 +-
 .../xforms-engine/src/instance/RepeatRange.ts |  45 +-
 packages/xforms-engine/src/instance/Root.ts   |   6 +-
 .../xforms-engine/src/instance/SelectField.ts |   5 +-
 .../xforms-engine/src/instance/StringField.ts |   6 +-
 .../xforms-engine/src/instance/Subtree.ts     |   2 +-
 .../src/instance/abstract/InstanceNode.ts     |   3 +
 .../xforms-engine/src/instance/children.ts    |  24 +-
 .../xforms-engine/src/lib/TokenListParser.ts  | 156 ++++++
 packages/xforms-engine/src/lib/dom/query.ts   |  13 +
 .../src/model/DescendentNodeDefinition.ts     |   3 +-
 .../src/model/ModelDefinition.ts              |   2 +-
 .../xforms-engine/src/model/NodeDefinition.ts |  24 +-
 .../src/model/RepeatInstanceDefinition.ts     |  21 +-
 ...Definition.ts => RepeatRangeDefinition.ts} |  12 +-
 .../src/model/RepeatTemplateDefinition.ts     |  25 +-
 .../xforms-engine/src/model/RootDefinition.ts |  18 +-
 .../src/model/SubtreeDefinition.ts            |   6 +-
 .../src/model/ValueNodeDefinition.ts          |   5 +-
 packages/xforms-engine/test/XFormDOM.test.ts  |  56 ++-
 .../test/body/BodyDefinition.test.ts          |  93 ++--
 .../test/model/ModelDefinition.test.ts        |  38 +-
 59 files changed, 1560 insertions(+), 445 deletions(-)
 create mode 100644 .changeset/empty-ravens-refuse.md
 create mode 100644 packages/common/src/lib/type-assertions/assertUnknownObject.ts
 create mode 100644 packages/common/src/test/assertions/arrayOfAssertion.ts
 create mode 100644 packages/common/types/string/PartiallyKnownString.ts
 create mode 100644 packages/scenario/src/assertion/extensions/appearances.ts
 create mode 100644 packages/scenario/src/assertion/extensions/body-classes.ts
 create mode 100644 packages/scenario/src/assertion/extensions/shared-type-assertions.ts
 create mode 100644 packages/scenario/test/appearance-body-class.test.ts
 delete mode 100644 packages/xforms-engine/src/body/RepeatDefinition.ts
 create mode 100644 packages/xforms-engine/src/body/RepeatElementDefinition.ts
 create mode 100644 packages/xforms-engine/src/body/appearance/inputAppearanceParser.ts
 create mode 100644 packages/xforms-engine/src/body/appearance/selectAppearanceParser.ts
 create mode 100644 packages/xforms-engine/src/body/appearance/structureElementAppearanceParser.ts
 delete mode 100644 packages/xforms-engine/src/body/group/RepeatGroupDefinition.ts
 create mode 100644 packages/xforms-engine/src/client/NodeAppearances.ts
 create mode 100644 packages/xforms-engine/src/lib/TokenListParser.ts
 rename packages/xforms-engine/src/model/{RepeatSequenceDefinition.ts => RepeatRangeDefinition.ts} (82%)

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]!;