From b38cb2c1a8fd58fd3f5399d0cda9619c52218126 Mon Sep 17 00:00:00 2001
From: eyelidlessness <gnosis@gmail.com>
Date: Thu, 16 Jan 2025 10:52:18 -0800
Subject: [PATCH 1/9] engine: `SelectDefinition` (body) ->
 `SelectControlDefinition` etc
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This is an engine-internal reorganization to improve some less-than-ideal naming and code structure around parsing selects, and helping to prepare for support of `<odk:rank>`.

- Addresses a naming conflict between `SelectDefinition` (as a subtype of `NodeDefinition`) and `SelectDefinition` (as a parsed representation of `<select>` and `<select1>` **body elements**). The parsed body element is now named `SelectControlDefinition`. This naming is still not ideal! But it is consistent with the conceptual equivalents for other controls.
- Anticipates similar parsing for `<odk:rank>` body elements. This may be easy to miss in review without calling it out, as it’s a change in file system structure. Specifically, each of the following are no longer structured as select-specific:
    - `ItemDefinition`
    - `ItemsetDefinition`

    This helps to prepare for `<odk:rank>` because it’s expected that both will be associated with a `RankControlDefinition`, providing the same parsed information about the control’s items to an implementation of `RankNode`/`RankControl`.
- Removes `ItemsetNodesetContext`, which is evidently not in use at all!
---
 .../xforms-engine/src/client/SelectNode.ts    |  6 +++---
 packages/xforms-engine/src/index.ts           | 10 ---------
 .../src/instance/SelectControl.ts             |  2 +-
 packages/xforms-engine/src/lib/dom/query.ts   |  2 +-
 .../src/parse/body/BodyDefinition.ts          |  8 +++----
 .../control/{select => }/ItemDefinition.ts    | 13 ++++++------
 .../control/{select => }/ItemsetDefinition.ts | 19 +++++++++--------
 ...finition.ts => SelectControlDefinition.ts} | 18 ++++++++--------
 .../control/select/ItemsetNodesetContext.ts   | 21 -------------------
 .../expression/ItemsetNodesetExpression.ts    |  2 +-
 .../expression/ItemsetValueExpression.ts      |  2 +-
 .../src/parse/text/ItemLabelDefinition.ts     |  2 +-
 .../src/parse/text/ItemsetLabelDefinition.ts  |  4 ++--
 .../text/abstract/TextElementDefinition.ts    |  2 +-
 14 files changed, 41 insertions(+), 70 deletions(-)
 rename packages/xforms-engine/src/parse/body/control/{select => }/ItemDefinition.ts (55%)
 rename packages/xforms-engine/src/parse/body/control/{select => }/ItemsetDefinition.ts (59%)
 rename packages/xforms-engine/src/parse/body/control/{select/SelectDefinition.ts => SelectControlDefinition.ts} (77%)
 delete mode 100644 packages/xforms-engine/src/parse/body/control/select/ItemsetNodesetContext.ts

diff --git a/packages/xforms-engine/src/client/SelectNode.ts b/packages/xforms-engine/src/client/SelectNode.ts
index 65738c3f8..20925e984 100644
--- a/packages/xforms-engine/src/client/SelectNode.ts
+++ b/packages/xforms-engine/src/client/SelectNode.ts
@@ -1,8 +1,8 @@
 import type { RuntimeValue } from '../lib/codecs/getSharedValueCodec.ts';
 import type {
-	AnySelectDefinition,
+	AnySelectControlDefinition,
 	SelectType,
-} from '../parse/body/control/select/SelectDefinition.ts';
+} from '../parse/body/control/SelectControlDefinition.ts';
 import type { LeafNodeDefinition } from '../parse/model/LeafNodeDefinition.ts';
 import type { BaseValueNode, BaseValueNodeState } from './BaseValueNode.ts';
 import type { NodeAppearances } from './NodeAppearances.ts';
@@ -56,7 +56,7 @@ export interface SelectNodeState<V extends ValueType> extends BaseValueNodeState
 }
 
 export interface SelectDefinition<V extends ValueType = ValueType> extends LeafNodeDefinition<V> {
-	readonly bodyElement: AnySelectDefinition;
+	readonly bodyElement: AnySelectControlDefinition;
 }
 
 export type SelectNodeAppearances = NodeAppearances<SelectDefinition>;
diff --git a/packages/xforms-engine/src/index.ts b/packages/xforms-engine/src/index.ts
index 55fe9900b..254dbf3d6 100644
--- a/packages/xforms-engine/src/index.ts
+++ b/packages/xforms-engine/src/index.ts
@@ -44,13 +44,3 @@ export type * from './client/unsupported/RankNode.ts';
 export type * from './client/unsupported/UploadNode.ts';
 export type * from './client/validation.ts';
 export type * from './client/ValueType.ts';
-
-// TODO: notwithstanding potential conflicts with parallel work on `web-forms`
-// (former `ui-vue`), these are the last remaining references **outside of
-// `xforms-engine`** to anything besides /client/* and the `initializeForm`
-// entrypoint implementation. We'll refine the various `definition` types in due
-// time.
-export type {
-	AnySelectDefinition,
-	SelectDefinition,
-} from './parse/body/control/select/SelectDefinition.ts';
diff --git a/packages/xforms-engine/src/instance/SelectControl.ts b/packages/xforms-engine/src/instance/SelectControl.ts
index 339c40793..b395cfa54 100644
--- a/packages/xforms-engine/src/instance/SelectControl.ts
+++ b/packages/xforms-engine/src/instance/SelectControl.ts
@@ -22,7 +22,7 @@ import { createSharedNodeState } from '../lib/reactivity/node-state/createShared
 import { createFieldHint } from '../lib/reactivity/text/createFieldHint.ts';
 import { createNodeLabel } from '../lib/reactivity/text/createNodeLabel.ts';
 import type { SimpleAtomicState } from '../lib/reactivity/types.ts';
-import type { SelectType } from '../parse/body/control/select/SelectDefinition.ts';
+import type { SelectType } from '../parse/body/control/SelectControlDefinition.ts';
 import type { Root } from './Root.ts';
 import type { ValueNodeStateSpec } from './abstract/ValueNode.ts';
 import { ValueNode } from './abstract/ValueNode.ts';
diff --git a/packages/xforms-engine/src/lib/dom/query.ts b/packages/xforms-engine/src/lib/dom/query.ts
index 89b46be94..c2745cc65 100644
--- a/packages/xforms-engine/src/lib/dom/query.ts
+++ b/packages/xforms-engine/src/lib/dom/query.ts
@@ -3,7 +3,7 @@ import type {
 	KnownAttributeLocalNamedElement,
 	LocalNamedElement,
 } from '@getodk/common/types/dom.ts';
-import type { SelectElement } from '../../parse/body/control/select/SelectDefinition';
+import type { SelectElement } from '../../parse/body/control/SelectControlDefinition.ts';
 
 const hintLookup = new ScopedElementLookup(':scope > hint', 'hint');
 const itemLookup = new ScopedElementLookup(':scope > item', 'item');
diff --git a/packages/xforms-engine/src/parse/body/BodyDefinition.ts b/packages/xforms-engine/src/parse/body/BodyDefinition.ts
index 468f4e3ac..689eaea9d 100644
--- a/packages/xforms-engine/src/parse/body/BodyDefinition.ts
+++ b/packages/xforms-engine/src/parse/body/BodyDefinition.ts
@@ -6,8 +6,8 @@ import { ControlDefinition } from './control/ControlDefinition.ts';
 import { InputControlDefinition } from './control/InputControlDefinition.ts';
 import { RangeControlDefinition } from './control/RangeControlDefinition.ts';
 import { RankControlDefinition } from './control/RankControlDefinition.ts';
-import type { AnySelectDefinition } from './control/select/SelectDefinition.ts';
-import { SelectDefinition } from './control/select/SelectDefinition.ts';
+import type { AnySelectControlDefinition } from './control/SelectControlDefinition.ts';
+import { SelectControlDefinition } from './control/SelectControlDefinition.ts';
 import { TriggerControlDefinition } from './control/TriggerControlDefinition.ts';
 import { UploadControlDefinition } from './control/UploadControlDefinition.ts';
 import { LogicalGroupDefinition } from './group/LogicalGroupDefinition.ts';
@@ -24,7 +24,7 @@ export interface BodyElementParentContext {
 
 // prettier-ignore
 export type ControlElementDefinition =
-	| AnySelectDefinition
+	| AnySelectControlDefinition
 	| InputControlDefinition
 	| RangeControlDefinition
 	| RankControlDefinition
@@ -48,7 +48,7 @@ const BodyElementDefinitionConstructors = [
 	PresentationGroupDefinition,
 	StructuralGroupDefinition,
 	InputControlDefinition,
-	SelectDefinition,
+	SelectControlDefinition,
 	RangeControlDefinition,
 	RankControlDefinition,
 	TriggerControlDefinition,
diff --git a/packages/xforms-engine/src/parse/body/control/select/ItemDefinition.ts b/packages/xforms-engine/src/parse/body/control/ItemDefinition.ts
similarity index 55%
rename from packages/xforms-engine/src/parse/body/control/select/ItemDefinition.ts
rename to packages/xforms-engine/src/parse/body/control/ItemDefinition.ts
index 08ce318ae..2c71291db 100644
--- a/packages/xforms-engine/src/parse/body/control/select/ItemDefinition.ts
+++ b/packages/xforms-engine/src/parse/body/control/ItemDefinition.ts
@@ -1,8 +1,9 @@
-import { getValueElement, type ItemElement } from '../../../../lib/dom/query.ts';
-import { ItemLabelDefinition } from '../../../text/ItemLabelDefinition.ts';
-import type { XFormDefinition } from '../../../XFormDefinition.ts';
-import { BodyElementDefinition } from '../../BodyElementDefinition.ts';
-import type { AnySelectDefinition } from './SelectDefinition.ts';
+import type { ItemElement } from '../../../lib/dom/query.ts';
+import { getValueElement } from '../../../lib/dom/query.ts';
+import { ItemLabelDefinition } from '../../text/ItemLabelDefinition.ts';
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import { BodyElementDefinition } from '../BodyElementDefinition.ts';
+import type { AnySelectControlDefinition } from './SelectControlDefinition.ts';
 
 export class ItemDefinition extends BodyElementDefinition<'item'> {
 	override readonly category = 'support';
@@ -13,7 +14,7 @@ export class ItemDefinition extends BodyElementDefinition<'item'> {
 
 	constructor(
 		form: XFormDefinition,
-		override readonly parent: AnySelectDefinition,
+		override readonly parent: AnySelectControlDefinition,
 		element: ItemElement
 	) {
 		const valueElement = getValueElement(element);
diff --git a/packages/xforms-engine/src/parse/body/control/select/ItemsetDefinition.ts b/packages/xforms-engine/src/parse/body/control/ItemsetDefinition.ts
similarity index 59%
rename from packages/xforms-engine/src/parse/body/control/select/ItemsetDefinition.ts
rename to packages/xforms-engine/src/parse/body/control/ItemsetDefinition.ts
index 5e0ee419f..11784c552 100644
--- a/packages/xforms-engine/src/parse/body/control/select/ItemsetDefinition.ts
+++ b/packages/xforms-engine/src/parse/body/control/ItemsetDefinition.ts
@@ -1,11 +1,12 @@
-import { getValueElement, type ItemsetElement } from '../../../../lib/dom/query.ts';
-import { ItemsetNodesetExpression } from '../../../expression/ItemsetNodesetExpression.ts';
-import { ItemsetValueExpression } from '../../../expression/ItemsetValueExpression.ts';
-import { ItemsetLabelDefinition } from '../../../text/ItemsetLabelDefinition.ts';
-import type { XFormDefinition } from '../../../XFormDefinition.ts';
-import { parseNodesetReference } from '../../../xpath/reference-parsing.ts';
-import { BodyElementDefinition } from '../../BodyElementDefinition.ts';
-import type { AnySelectDefinition } from './SelectDefinition.ts';
+import type { ItemsetElement } from '../../../lib/dom/query.ts';
+import { getValueElement } from '../../../lib/dom/query.ts';
+import { ItemsetNodesetExpression } from '../../expression/ItemsetNodesetExpression.ts';
+import { ItemsetValueExpression } from '../../expression/ItemsetValueExpression.ts';
+import { ItemsetLabelDefinition } from '../../text/ItemsetLabelDefinition.ts';
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import { parseNodesetReference } from '../../xpath/reference-parsing.ts';
+import { BodyElementDefinition } from '../BodyElementDefinition.ts';
+import type { AnySelectControlDefinition } from './SelectControlDefinition.ts';
 
 export class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
 	override readonly category = 'support';
@@ -19,7 +20,7 @@ export class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
 
 	constructor(
 		form: XFormDefinition,
-		override readonly parent: AnySelectDefinition,
+		override readonly parent: AnySelectControlDefinition,
 		element: ItemsetElement
 	) {
 		super(form, parent, element);
diff --git a/packages/xforms-engine/src/parse/body/control/select/SelectDefinition.ts b/packages/xforms-engine/src/parse/body/control/SelectControlDefinition.ts
similarity index 77%
rename from packages/xforms-engine/src/parse/body/control/select/SelectDefinition.ts
rename to packages/xforms-engine/src/parse/body/control/SelectControlDefinition.ts
index d0d689a63..451381d3e 100644
--- a/packages/xforms-engine/src/parse/body/control/select/SelectDefinition.ts
+++ b/packages/xforms-engine/src/parse/body/control/SelectControlDefinition.ts
@@ -1,11 +1,11 @@
 import type { CollectionValues } from '@getodk/common/types/collections/CollectionValues.ts';
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
-import { getItemElements, getItemsetElement } from '../../../../lib/dom/query.ts';
-import type { XFormDefinition } from '../../../XFormDefinition.ts';
-import type { SelectAppearanceDefinition } from '../../appearance/selectAppearanceParser.ts';
-import { selectAppearanceParser } from '../../appearance/selectAppearanceParser.ts';
-import type { AnyBodyElementDefinition, BodyElementParentContext } from '../../BodyDefinition.ts';
-import { ControlDefinition } from '../ControlDefinition.ts';
+import { getItemElements, getItemsetElement } from '../../../lib/dom/query.ts';
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import type { SelectAppearanceDefinition } from '../appearance/selectAppearanceParser.ts';
+import { selectAppearanceParser } from '../appearance/selectAppearanceParser.ts';
+import type { AnyBodyElementDefinition, BodyElementParentContext } from '../BodyDefinition.ts';
+import { ControlDefinition } from './ControlDefinition.ts';
 import { ItemDefinition } from './ItemDefinition.ts';
 import { ItemsetDefinition } from './ItemsetDefinition.ts';
 
@@ -22,12 +22,12 @@ const isSelectElement = (
 	return selectLocalNames.has(localName as SelectType);
 };
 
-export class SelectDefinition<Type extends SelectType> extends ControlDefinition<Type> {
+export class SelectControlDefinition<Type extends SelectType> extends ControlDefinition<Type> {
 	static override isCompatible(localName: string, element: Element): boolean {
 		return isSelectElement(element, localName);
 	}
 
-	static isSelect(element: AnyBodyElementDefinition): element is AnySelectDefinition {
+	static isSelect(element: AnyBodyElementDefinition): element is AnySelectControlDefinition {
 		return selectLocalNames.has(element.type as SelectType);
 	}
 
@@ -72,4 +72,4 @@ export class SelectDefinition<Type extends SelectType> extends ControlDefinition
 	}
 }
 
-export type AnySelectDefinition = SelectDefinition<SelectType>;
+export type AnySelectControlDefinition = SelectControlDefinition<SelectType>;
diff --git a/packages/xforms-engine/src/parse/body/control/select/ItemsetNodesetContext.ts b/packages/xforms-engine/src/parse/body/control/select/ItemsetNodesetContext.ts
deleted file mode 100644
index 194c1b35f..000000000
--- a/packages/xforms-engine/src/parse/body/control/select/ItemsetNodesetContext.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import { DependencyContext } from '../../../expression/abstract/DependencyContext.ts';
-import type { ItemsetDefinition } from './ItemsetDefinition.ts';
-
-export class ItemsetNodesetContext extends DependencyContext {
-	override readonly parentReference = null;
-	override readonly reference: string;
-
-	constructor(
-		protected readonly itemset: ItemsetDefinition,
-		nodesetExpression: string
-	) {
-		super();
-
-		this.reference = nodesetExpression;
-	}
-
-	override set isTranslated(value: true) {
-		super.isTranslated = value;
-		this.itemset.isTranslated = value;
-	}
-}
diff --git a/packages/xforms-engine/src/parse/expression/ItemsetNodesetExpression.ts b/packages/xforms-engine/src/parse/expression/ItemsetNodesetExpression.ts
index 8a3b3f090..1632af2b5 100644
--- a/packages/xforms-engine/src/parse/expression/ItemsetNodesetExpression.ts
+++ b/packages/xforms-engine/src/parse/expression/ItemsetNodesetExpression.ts
@@ -1,4 +1,4 @@
-import type { ItemsetDefinition } from '../body/control/select/ItemsetDefinition.ts';
+import type { ItemsetDefinition } from '../body/control/ItemsetDefinition.ts';
 import { DependentExpression } from './abstract/DependentExpression.ts';
 
 export class ItemsetNodesetExpression extends DependentExpression<'nodes'> {
diff --git a/packages/xforms-engine/src/parse/expression/ItemsetValueExpression.ts b/packages/xforms-engine/src/parse/expression/ItemsetValueExpression.ts
index c29684eca..513800a10 100644
--- a/packages/xforms-engine/src/parse/expression/ItemsetValueExpression.ts
+++ b/packages/xforms-engine/src/parse/expression/ItemsetValueExpression.ts
@@ -1,4 +1,4 @@
-import type { ItemsetDefinition } from '../body/control/select/ItemsetDefinition.ts';
+import type { ItemsetDefinition } from '../body/control/ItemsetDefinition.ts';
 import { DependentExpression } from './abstract/DependentExpression.ts';
 
 export class ItemsetValueExpression extends DependentExpression<'string'> {
diff --git a/packages/xforms-engine/src/parse/text/ItemLabelDefinition.ts b/packages/xforms-engine/src/parse/text/ItemLabelDefinition.ts
index de31fee24..69f66b584 100644
--- a/packages/xforms-engine/src/parse/text/ItemLabelDefinition.ts
+++ b/packages/xforms-engine/src/parse/text/ItemLabelDefinition.ts
@@ -1,7 +1,7 @@
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
 import { getLabelElement } from '../../lib/dom/query.ts';
 import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
-import type { ItemDefinition } from '../body/control/select/ItemDefinition.ts';
+import type { ItemDefinition } from '../body/control/ItemDefinition.ts';
 import { TextElementDefinition } from './abstract/TextElementDefinition.ts';
 
 interface LabelElement extends LocalNamedElement<'label'> {}
diff --git a/packages/xforms-engine/src/parse/text/ItemsetLabelDefinition.ts b/packages/xforms-engine/src/parse/text/ItemsetLabelDefinition.ts
index 7b733e748..1b57d5b8d 100644
--- a/packages/xforms-engine/src/parse/text/ItemsetLabelDefinition.ts
+++ b/packages/xforms-engine/src/parse/text/ItemsetLabelDefinition.ts
@@ -1,8 +1,8 @@
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
 import { getLabelElement } from '../../lib/dom/query.ts';
 import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
-import type { ItemDefinition } from '../body/control/select/ItemDefinition.ts';
-import type { ItemsetDefinition } from '../body/control/select/ItemsetDefinition.ts';
+import type { ItemDefinition } from '../body/control/ItemDefinition.ts';
+import type { ItemsetDefinition } from '../body/control/ItemsetDefinition.ts';
 import { TextReferenceExpression } from '../expression/TextReferenceExpression.ts';
 import { TextTranslationExpression } from '../expression/TextTranslationExpression.ts';
 import type { RefAttributeChunk } from './abstract/TextElementDefinition.ts';
diff --git a/packages/xforms-engine/src/parse/text/abstract/TextElementDefinition.ts b/packages/xforms-engine/src/parse/text/abstract/TextElementDefinition.ts
index 56548193b..20f1c7ae9 100644
--- a/packages/xforms-engine/src/parse/text/abstract/TextElementDefinition.ts
+++ b/packages/xforms-engine/src/parse/text/abstract/TextElementDefinition.ts
@@ -1,7 +1,7 @@
 import { isElementNode, isTextNode } from '@getodk/common/lib/dom/predicates.ts';
 import type { ElementTextRole } from '../../../client/TextRange.ts';
 import type { XFormDefinition } from '../../../parse/XFormDefinition.ts';
-import type { ItemDefinition } from '../../body/control/select/ItemDefinition.ts';
+import type { ItemDefinition } from '../../body/control/ItemDefinition.ts';
 import { TextLiteralExpression } from '../../expression/TextLiteralExpression.ts';
 import { TextOutputExpression } from '../../expression/TextOutputExpression.ts';
 import { TextReferenceExpression } from '../../expression/TextReferenceExpression.ts';

From 05abe44e73b2b6fe80865480d4499924f8af45fa Mon Sep 17 00:00:00 2001
From: eyelidlessness <gnosis@gmail.com>
Date: Thu, 16 Jan 2025 11:11:55 -0800
Subject: [PATCH 2/9] engine: roll back support for non-string `<select>` and
 `<select1>`
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Support for non-string bind/value types was introduced in #273. That support exceeds the current ODK XForms spec, which specifies both controls as supporting only a string type.

We initially decided to merge that expansion on these bases:

- XLSForms/pyxform do not produce forms with non-string select types, so it would only occur for forms authored as XML XForms, and would presumably be an intentional form design decision

- The behavior (tested with `<select1>` + `<bind type=“int”>`) is consistent with Collect/JavaRosa

We have since decided to revert that for now, because it would violate assumptions about _multiple values_ (from a `<select>`, and soon from `<odk:rank>`) associated with a non-string `<bind type>`. For example, this would break downstream projects which derive database schema types (e.g. SQL column types) from a form definition’s `<bind type>`.
---
 .../xforms-engine/src/client/SelectNode.ts    | 78 +++-------------
 .../xforms-engine/src/client/hierarchy.ts     |  4 +-
 .../src/error/SelectValueTypeError.ts         | 22 +++++
 .../src/error/XFormsSpecViolationError.ts     |  1 +
 .../src/instance/SelectControl.ts             | 89 +++++++++----------
 .../xforms-engine/src/instance/hierarchy.ts   | 10 +--
 .../src/lib/codecs/select/BaseSelectCodec.ts  | 20 +++++
 .../codecs/select/MultipleValueSelectCodec.ts | 18 ++--
 .../codecs/select/SingleValueSelectCodec.ts   | 34 +++----
 .../src/lib/codecs/select/getSelectCodec.ts   | 62 +++----------
 .../src/lib/reactivity/createSelectItems.ts   | 49 +++-------
 .../lib/reactivity/createSelectItems.test.ts  |  5 +-
 12 files changed, 151 insertions(+), 241 deletions(-)
 create mode 100644 packages/xforms-engine/src/error/SelectValueTypeError.ts
 create mode 100644 packages/xforms-engine/src/error/XFormsSpecViolationError.ts
 create mode 100644 packages/xforms-engine/src/lib/codecs/select/BaseSelectCodec.ts

diff --git a/packages/xforms-engine/src/client/SelectNode.ts b/packages/xforms-engine/src/client/SelectNode.ts
index 20925e984..b8b5a7d45 100644
--- a/packages/xforms-engine/src/client/SelectNode.ts
+++ b/packages/xforms-engine/src/client/SelectNode.ts
@@ -1,4 +1,3 @@
-import type { RuntimeValue } from '../lib/codecs/getSharedValueCodec.ts';
 import type {
 	AnySelectControlDefinition,
 	SelectType,
@@ -12,33 +11,17 @@ import type { ValueType } from './ValueType.ts';
 import type { GeneralParentNode } from './hierarchy.ts';
 import type { LeafNodeValidationState } from './validation.ts';
 
-export type SelectItemValue<V extends ValueType> = NonNullable<RuntimeValue<V>>;
-
-export type SelectValues<V extends ValueType> = ReadonlyArray<SelectItemValue<V>>;
-
-export interface SelectItem<V extends ValueType> {
+export interface SelectItem {
 	get label(): TextRange<'item-label'>;
-	get value(): SelectItemValue<V>;
-
-	/**
-	 * Produces a string serialization of {@link value}, consistent with that
-	 * value's serialization for submission purposes.
-	 *
-	 * Clients should use caution when using this serialized representation! It is
-	 * generally applicable for cases where a string value **MUST** be used (e.g.
-	 * for integration with platform and/or third party interfaces). Use of this
-	 * value for reproducing aspects of submission or instance state piecemeal is
-	 * **highly discouraged**.
-	 */
-	get asString(): string;
+	get value(): string;
 }
 
-export type SelectValueOptions<V extends ValueType> = ReadonlyArray<SelectItem<V>>;
+export type SelectValueOptions = readonly SelectItem[];
 
-export interface SelectNodeState<V extends ValueType> extends BaseValueNodeState<SelectValues<V>> {
+export interface SelectNodeState extends BaseValueNodeState<readonly string[]> {
 	get children(): null;
 
-	get valueOptions(): SelectValueOptions<V>;
+	get valueOptions(): readonly SelectItem[];
 
 	/**
 	 * This value is treated as set-like by the engine, where each
@@ -52,7 +35,7 @@ export interface SelectNodeState<V extends ValueType> extends BaseValueNodeState
 	 * Should a `SelectNodeState` have this `value` type, whereas a hypothetical
 	 * `Select1NodeState` would have `get value(): SelectItem | null`?
 	 */
-	get value(): SelectValues<V>;
+	get value(): readonly string[];
 }
 
 export interface SelectDefinition<V extends ValueType = ValueType> extends LeafNodeDefinition<V> {
@@ -61,16 +44,15 @@ export interface SelectDefinition<V extends ValueType = ValueType> extends LeafN
 
 export type SelectNodeAppearances = NodeAppearances<SelectDefinition>;
 
-export interface SelectNode<V extends ValueType = ValueType>
-	extends BaseValueNode<V, SelectValues<V>> {
+export interface SelectNode extends BaseValueNode<'string', readonly string[]> {
 	readonly nodeType: 'select';
-	readonly valueType: V;
+	readonly valueType: 'string';
 	readonly selectType: SelectType;
 	readonly appearances: SelectNodeAppearances;
-	readonly definition: SelectDefinition;
+	readonly definition: SelectDefinition<'string'>;
 	readonly root: RootNode;
 	readonly parent: GeneralParentNode;
-	readonly currentState: SelectNodeState<V>;
+	readonly currentState: SelectNodeState;
 	readonly validationState: LeafNodeValidationState;
 
 	/**
@@ -78,18 +60,13 @@ export interface SelectNode<V extends ValueType = ValueType>
 	 * {@link value}, if one is currently available—i.e. if it is present in
 	 * {@link SelectNodeState.valueOptions}.
 	 */
-	getValueOption<T extends ValueType>(
-		this: SelectNode<T>,
-		value: SelectItemValue<T>
-	): SelectItem<T> | null;
-	getValueOption(value: SelectItemValue<V>): SelectItem<V> | null;
+	getValueOption(value: string): SelectItem | null;
 
 	/**
 	 * Convenience API to determine if {@link value} is currently selected—i.e. if
 	 * it is one of the selected values in {@link SelectNodeState.value}.
 	 */
-	isSelected<T extends ValueType>(this: SelectNode<T>, value: SelectItemValue<T>): boolean;
-	isSelected(value: SelectItemValue<V>): boolean;
+	isSelected(value: string): boolean;
 
 	/**
 	 * Selects a single {@link value}, as provided by a {@link SelectItem.value}.
@@ -104,8 +81,7 @@ export interface SelectNode<V extends ValueType = ValueType>
 	 * {@link https://getodk.github.io/xforms-spec/#body-elements | `<select1>`}
 	 * control.
 	 */
-	selectValue<T extends ValueType>(this: SelectNode<T>, value: SelectItemValue<T> | null): RootNode;
-	selectValue(this: SelectNode<V>, value: SelectItemValue<V> | null): RootNode;
+	selectValue(value: string | null): RootNode;
 
 	/**
 	 * Selects any number of {@link values}, as provided by any number of
@@ -121,31 +97,5 @@ export interface SelectNode<V extends ValueType = ValueType>
 	 * This setter _may_ be used with a `<select1>` control, in which case the
 	 * provided {@link values} should produce at most one value.
 	 */
-	selectValues<T extends ValueType>(this: SelectNode<T>, values: SelectValues<T>): RootNode;
-	selectValues(this: SelectNode<V>, values: SelectValues<V>): RootNode;
+	selectValues(values: readonly string[]): RootNode;
 }
-
-export type StringSelectNode = SelectNode<'string'>;
-export type IntSelectNode = SelectNode<'int'>;
-export type DecimalSelectNode = SelectNode<'decimal'>;
-
-// prettier-ignore
-type SupportedSelectValueType =
-	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
-	| 'string'
-	| 'int'
-	| 'decimal';
-
-type TemporaryStringValueType = Exclude<ValueType, SupportedSelectValueType>;
-
-export type TemporaryStringValueSelectNode = {
-	[V in TemporaryStringValueType]: SelectNode<V>;
-}[TemporaryStringValueType];
-
-// prettier-ignore
-export type AnySelectNode =
-	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
-	| StringSelectNode
-	| IntSelectNode
-	| DecimalSelectNode
-	| TemporaryStringValueSelectNode;
diff --git a/packages/xforms-engine/src/client/hierarchy.ts b/packages/xforms-engine/src/client/hierarchy.ts
index d2d008186..574c328b7 100644
--- a/packages/xforms-engine/src/client/hierarchy.ts
+++ b/packages/xforms-engine/src/client/hierarchy.ts
@@ -8,7 +8,7 @@ import type { RepeatInstanceNode } from './repeat/RepeatInstanceNode.ts';
 import type { RepeatRangeControlledNode } from './repeat/RepeatRangeControlledNode.ts';
 import type { RepeatRangeUncontrolledNode } from './repeat/RepeatRangeUncontrolledNode.ts';
 import type { RootNode } from './RootNode.ts';
-import type { AnySelectNode } from './SelectNode.ts';
+import type { SelectNode } from './SelectNode.ts';
 import type { SubtreeNode } from './SubtreeNode.ts';
 import type { TriggerNode } from './TriggerNode.ts';
 import type { RankNode } from './unsupported/RankNode.ts';
@@ -24,7 +24,7 @@ export type AnyControlNode =
 	| AnyInputNode
 	| AnyNoteNode
 	| AnyRangeNode
-	| AnySelectNode
+	| SelectNode
 	| TriggerNode;
 
 // prettier-ignore
diff --git a/packages/xforms-engine/src/error/SelectValueTypeError.ts b/packages/xforms-engine/src/error/SelectValueTypeError.ts
new file mode 100644
index 000000000..5a5c26ff7
--- /dev/null
+++ b/packages/xforms-engine/src/error/SelectValueTypeError.ts
@@ -0,0 +1,22 @@
+import type { SelectDefinition } from '../client/SelectNode.ts';
+import type { UnsupportedSelectValueType } from '../lib/codecs/select/BaseSelectCodec.ts';
+import { XFormsSpecViolationError } from './XFormsSpecViolationError.ts';
+
+/**
+ * @todo It would be good to have a standardized way to use specific types of
+ * errors as a prompt for feedback. There is currently a feedback link presented
+ * by `@getodk/web-forms`, which is conditionally displayed (condition is
+ * evidently controlled by a
+ * {@link https://vuejs.org/api/sfc-script-setup#defineoptions | Vue component option}).
+ *
+ * @see {@link https://github.com/getodk/web-forms/issues/276}
+ */
+export class SelectValueTypeError extends XFormsSpecViolationError {
+	constructor(definition: SelectDefinition<UnsupportedSelectValueType>) {
+		const { valueType } = definition;
+
+		super(
+			`Selects of type ${valueType} are not currently supported. If this functionality would be useful for your form, your feedback is welcome!`
+		);
+	}
+}
diff --git a/packages/xforms-engine/src/error/XFormsSpecViolationError.ts b/packages/xforms-engine/src/error/XFormsSpecViolationError.ts
new file mode 100644
index 000000000..577b8da67
--- /dev/null
+++ b/packages/xforms-engine/src/error/XFormsSpecViolationError.ts
@@ -0,0 +1 @@
+export abstract class XFormsSpecViolationError extends Error {}
diff --git a/packages/xforms-engine/src/instance/SelectControl.ts b/packages/xforms-engine/src/instance/SelectControl.ts
index b395cfa54..5a216d2cb 100644
--- a/packages/xforms-engine/src/instance/SelectControl.ts
+++ b/packages/xforms-engine/src/instance/SelectControl.ts
@@ -4,14 +4,13 @@ import { createMemo } from 'solid-js';
 import type {
 	SelectDefinition,
 	SelectItem,
-	SelectItemValue,
 	SelectNode,
 	SelectNodeAppearances,
 	SelectValueOptions,
-	SelectValues,
 } from '../client/SelectNode.ts';
 import type { TextRange } from '../client/TextRange.ts';
 import type { ValueType } from '../client/ValueType.ts';
+import { SelectValueTypeError } from '../error/SelectValueTypeError.ts';
 import type { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
 import { getSelectCodec } from '../lib/codecs/select/getSelectCodec.ts';
 import { createSelectItems } from '../lib/reactivity/createSelectItems.ts';
@@ -35,30 +34,41 @@ export type AnySelectDefinition = {
 	[V in ValueType]: SelectDefinition<V>;
 }[ValueType];
 
-interface SelectControlStateSpec<V extends ValueType> extends ValueNodeStateSpec<SelectValues<V>> {
+type AssertSupportedSelectValueType = (
+	definition: AnySelectDefinition
+) => asserts definition is SelectDefinition<'string'>;
+
+const assertSupportedSelectValueType: AssertSupportedSelectValueType = (definition) => {
+	if (definition.valueType !== 'string') {
+		throw new SelectValueTypeError(definition);
+	}
+};
+
+type SelectItemMap = ReadonlyMap<string, SelectItem>;
+
+interface SelectControlStateSpec extends ValueNodeStateSpec<readonly string[]> {
 	readonly label: Accessor<TextRange<'label'> | null>;
 	readonly hint: Accessor<TextRange<'hint'> | null>;
-	readonly valueOptions: Accessor<SelectValueOptions<V>>;
+	readonly valueOptions: Accessor<SelectValueOptions>;
 }
 
-export class SelectControl<V extends ValueType = ValueType>
-	extends ValueNode<V, SelectDefinition<V>, SelectValues<V>, SelectValues<V>>
+export class SelectControl
+	extends ValueNode<'string', SelectDefinition<'string'>, readonly string[], readonly string[]>
 	implements
-		SelectNode<V>,
+		SelectNode,
 		XFormsXPathElement,
 		EvaluationContext,
 		ValidationContext,
 		ClientReactiveSubmittableValueNode
 {
-	static from(parent: GeneralParentNode, definition: SelectDefinition): AnySelectControl;
-	static from<V extends ValueType>(
-		parent: GeneralParentNode,
-		definition: SelectDefinition<V>
-	): SelectControl<V> {
+	static from(parent: GeneralParentNode, definition: SelectDefinition): SelectControl;
+	static from(parent: GeneralParentNode, definition: AnySelectDefinition): SelectControl {
+		assertSupportedSelectValueType(definition);
+
 		return new this(parent, definition);
 	}
 
-	private readonly mapOptionsByValue: Accessor<ReadonlyMap<SelectItemValue<V>, SelectItem<V>>>;
+	private readonly mapOptionsByValue: Accessor<SelectItemMap>;
 
 	protected override readonly getInstanceValue: Accessor<string>;
 
@@ -66,16 +76,16 @@ export class SelectControl<V extends ValueType = ValueType>
 	override readonly [XPathNodeKindKey] = 'element';
 
 	// InstanceNode
-	protected readonly state: SharedNodeState<SelectControlStateSpec<V>>;
-	protected readonly engineState: EngineState<SelectControlStateSpec<V>>;
+	protected readonly state: SharedNodeState<SelectControlStateSpec>;
+	protected readonly engineState: EngineState<SelectControlStateSpec>;
 
 	// SelectNode
 	readonly nodeType = 'select';
 	readonly selectType: SelectType;
 	readonly appearances: SelectNodeAppearances;
-	readonly currentState: CurrentState<SelectControlStateSpec<V>>;
+	readonly currentState: CurrentState<SelectControlStateSpec>;
 
-	constructor(parent: GeneralParentNode, definition: SelectDefinition<V>) {
+	private constructor(parent: GeneralParentNode, definition: SelectDefinition<'string'>) {
 		const codec = getSelectCodec(definition);
 
 		super(parent, definition, codec);
@@ -83,14 +93,13 @@ export class SelectControl<V extends ValueType = ValueType>
 		this.appearances = definition.bodyElement.appearances;
 		this.selectType = definition.bodyElement.type;
 
-		const valueOptions = createSelectItems(this, codec);
+		const valueOptions = createSelectItems(this);
 
-		const mapOptionsByValue: Accessor<ReadonlyMap<SelectItemValue<V>, SelectItem<V>>> =
-			this.scope.runTask(() => {
-				return createMemo(() => {
-					return new Map(valueOptions().map((item) => [item.value, item]));
-				});
+		const mapOptionsByValue: Accessor<SelectItemMap> = this.scope.runTask(() => {
+			return createMemo(() => {
+				return new Map(valueOptions().map((item) => [item.value, item]));
 			});
+		});
 
 		this.mapOptionsByValue = mapOptionsByValue;
 
@@ -105,7 +114,7 @@ export class SelectControl<V extends ValueType = ValueType>
 				});
 			});
 		});
-		const valueState: SimpleAtomicState<SelectValues<V>> = [getValue, setValue];
+		const valueState: SimpleAtomicState<readonly string[]> = [getValue, setValue];
 
 		this.getInstanceValue = this.scope.runTask(() => {
 			return createMemo(() => {
@@ -163,9 +172,9 @@ export class SelectControl<V extends ValueType = ValueType>
 	 * reversed.
 	 */
 	private filterValues(
-		sourceValues: Iterable<SelectItemValue<V>>,
-		values: Iterable<SelectItemValue<V>>
-	): SelectValues<V> {
+		sourceValues: Iterable<string>,
+		values: Iterable<string>
+	): readonly string[] {
 		const selectedValues = new Set(values);
 
 		return Array.from(sourceValues).filter((sourceValue) => {
@@ -174,10 +183,7 @@ export class SelectControl<V extends ValueType = ValueType>
 	}
 
 	// SelectNode
-	getValueOption<T extends ValueType>(
-		this: SelectControl<T>,
-		value: SelectItemValue<T>
-	): SelectItem<T> | null {
+	getValueOption(value: string): SelectItem | null {
 		// Note: this method is a client-facing convenience API for reading state,
 		// so it **MUST** read from client-reactive state!
 		const valueOption = this.currentState.valueOptions.find((item) => {
@@ -187,13 +193,13 @@ export class SelectControl<V extends ValueType = ValueType>
 		return valueOption ?? null;
 	}
 
-	isSelected<T extends ValueType>(this: SelectControl<T>, value: SelectItemValue<T>): boolean {
+	isSelected(value: string): boolean {
 		// Note: this method is a client-facing convenience API for reading state,
 		// so it **MUST** read from client-reactive state!
 		return this.currentState.value.includes(value);
 	}
 
-	selectValue<T extends ValueType>(this: SelectControl<T>, value: SelectItemValue<T> | null): Root {
+	selectValue(value: string | null): Root {
 		if (value == null) {
 			return this.selectValues([]);
 		}
@@ -201,7 +207,7 @@ export class SelectControl<V extends ValueType = ValueType>
 		return this.selectValues([value]);
 	}
 
-	selectValues<T extends ValueType>(this: SelectControl<T>, values: SelectValues<T>): Root {
+	selectValues(values: readonly string[]): Root {
 		const sourceValues = this.mapOptionsByValue().keys();
 		const effectiveValues = this.filterValues(sourceValues, values);
 
@@ -210,18 +216,3 @@ export class SelectControl<V extends ValueType = ValueType>
 		return this.root;
 	}
 }
-
-export type AnySelectControl =
-	| SelectControl<'barcode'>
-	| SelectControl<'binary'>
-	| SelectControl<'boolean'>
-	| SelectControl<'date'>
-	| SelectControl<'dateTime'>
-	| SelectControl<'decimal'>
-	| SelectControl<'geopoint'>
-	| SelectControl<'geoshape'>
-	| SelectControl<'geotrace'>
-	| SelectControl<'int'>
-	| SelectControl<'intent'>
-	| SelectControl<'string'>
-	| SelectControl<'time'>;
diff --git a/packages/xforms-engine/src/instance/hierarchy.ts b/packages/xforms-engine/src/instance/hierarchy.ts
index f84709baa..b50e7db89 100644
--- a/packages/xforms-engine/src/instance/hierarchy.ts
+++ b/packages/xforms-engine/src/instance/hierarchy.ts
@@ -8,7 +8,7 @@ import type { RepeatInstance } from './repeat/RepeatInstance.ts';
 import type { RepeatRangeControlled } from './repeat/RepeatRangeControlled.ts';
 import type { RepeatRangeUncontrolled } from './repeat/RepeatRangeUncontrolled.ts';
 import type { Root } from './Root.ts';
-import type { AnySelectControl } from './SelectControl.ts';
+import type { SelectControl } from './SelectControl.ts';
 import type { Subtree } from './Subtree.ts';
 import type { TriggerControl } from './TriggerControl.ts';
 import type { RankControl } from './unsupported/RankControl.ts';
@@ -34,7 +34,7 @@ export type AnyNode =
 	| AnyModelValue
 	| AnyInputControl
 	| AnyRangeControl
-	| AnySelectControl
+	| SelectControl
 	| TriggerControl
 	| AnyUnsupportedControl;
 
@@ -68,7 +68,7 @@ export type AnyChildNode =
 	| AnyNote
 	| AnyInputControl
 	| AnyRangeControl
-	| AnySelectControl
+	| SelectControl
 	| TriggerControl
 	| AnyUnsupportedControl;
 
@@ -82,7 +82,7 @@ export type GeneralChildNode =
 	| AnyNote
 	| AnyInputControl
 	| AnyRangeControl
-	| AnySelectControl
+	| SelectControl
 	| TriggerControl
 	| AnyUnsupportedControl;
 
@@ -93,6 +93,6 @@ export type AnyValueNode =
 	| AnyNote
 	| AnyInputControl
 	| AnyRangeControl
-	| AnySelectControl
+	| SelectControl
 	| TriggerControl
 	| AnyUnsupportedControl;
diff --git a/packages/xforms-engine/src/lib/codecs/select/BaseSelectCodec.ts b/packages/xforms-engine/src/lib/codecs/select/BaseSelectCodec.ts
new file mode 100644
index 000000000..206b2faa6
--- /dev/null
+++ b/packages/xforms-engine/src/lib/codecs/select/BaseSelectCodec.ts
@@ -0,0 +1,20 @@
+import type { ValueType } from '../../../client/ValueType.ts';
+import type { SharedValueCodec } from '../getSharedValueCodec.ts';
+import { ValueArrayCodec } from '../ValueArrayCodec.ts';
+import type { CodecDecoder, CodecEncoder } from '../ValueCodec.ts';
+
+export type SelectValueType = 'string';
+
+export type UnsupportedSelectValueType = Exclude<ValueType, SelectValueType>;
+
+export abstract class BaseSelectCodec<
+	Values extends readonly string[] = readonly string[],
+> extends ValueArrayCodec<SelectValueType, Values> {
+	constructor(
+		baseCodec: SharedValueCodec<'string'>,
+		encodeValue: CodecEncoder<Values>,
+		decodeValue: CodecDecoder<Values>
+	) {
+		super(baseCodec, encodeValue, decodeValue);
+	}
+}
diff --git a/packages/xforms-engine/src/lib/codecs/select/MultipleValueSelectCodec.ts b/packages/xforms-engine/src/lib/codecs/select/MultipleValueSelectCodec.ts
index 715af1c00..cccdf8012 100644
--- a/packages/xforms-engine/src/lib/codecs/select/MultipleValueSelectCodec.ts
+++ b/packages/xforms-engine/src/lib/codecs/select/MultipleValueSelectCodec.ts
@@ -1,9 +1,7 @@
 import { xmlXPathWhitespaceSeparatedList } from '@getodk/common/lib/string/whitespace.ts';
-import type { ValueType } from '../../../client/ValueType.ts';
 import type { SharedValueCodec } from '../getSharedValueCodec.ts';
-import type { RuntimeValues } from '../ValueArrayCodec.ts';
-import { ValueArrayCodec } from '../ValueArrayCodec.ts';
 import type { CodecDecoder, CodecEncoder } from '../ValueCodec.ts';
+import { BaseSelectCodec } from './BaseSelectCodec.ts';
 
 /**
  * Value codec implementation for `<select>` controls.
@@ -14,17 +12,15 @@ import type { CodecDecoder, CodecEncoder } from '../ValueCodec.ts';
  * to the provided {@link baseCodec}, ensuring that select value types are
  * treated consistently with the same underlying data types for other controls.
  */
-export class MultipleValueSelectCodec<V extends ValueType> extends ValueArrayCodec<V> {
-	constructor(baseCodec: SharedValueCodec<V>) {
-		const encodeValue: CodecEncoder<RuntimeValues<V>> = (value) => {
-			return value.map(baseCodec.encodeValue).join(' ');
+export class MultipleValueSelectCodec extends BaseSelectCodec<readonly string[]> {
+	constructor(baseCodec: SharedValueCodec<'string'>) {
+		const encodeValue: CodecEncoder<readonly string[]> = (value) => {
+			return value.join(' ');
 		};
-		const decodeValue: CodecDecoder<RuntimeValues<V>> = (value) => {
-			const instanceValues = xmlXPathWhitespaceSeparatedList(value, {
+		const decodeValue: CodecDecoder<readonly string[]> = (value) => {
+			return xmlXPathWhitespaceSeparatedList(value, {
 				ignoreEmpty: true,
 			});
-
-			return instanceValues.map(this.decodeItemValue);
 		};
 
 		super(baseCodec, encodeValue, decodeValue);
diff --git a/packages/xforms-engine/src/lib/codecs/select/SingleValueSelectCodec.ts b/packages/xforms-engine/src/lib/codecs/select/SingleValueSelectCodec.ts
index 500015f48..f1e3fe8b2 100644
--- a/packages/xforms-engine/src/lib/codecs/select/SingleValueSelectCodec.ts
+++ b/packages/xforms-engine/src/lib/codecs/select/SingleValueSelectCodec.ts
@@ -1,21 +1,20 @@
-import type { ValueType } from '../../../client/ValueType.ts';
 import type { SharedValueCodec } from '../getSharedValueCodec.ts';
-import { ValueArrayCodec, type RuntimeItemValue, type RuntimeValues } from '../ValueArrayCodec.ts';
 import { type CodecDecoder, type CodecEncoder } from '../ValueCodec.ts';
+import { BaseSelectCodec } from './BaseSelectCodec.ts';
 import type { MultipleValueSelectCodec } from './MultipleValueSelectCodec.ts';
 
 // prettier-ignore
-export type SingleValueSelectRuntimeValues<V extends ValueType> =
+export type SingleValueSelectRuntimeValues =
 	| readonly []
-	| readonly [RuntimeItemValue<V>];
+	| readonly [string];
 
 /**
  * @see {@link encodeValueFactory}
  */
 // prettier-ignore
-type SingleValueSelectCodecValues<V extends ValueType> =
-	| RuntimeValues<V>
-	| SingleValueSelectRuntimeValues<V>;
+type SingleValueSelectCodecValues =
+	| SingleValueSelectRuntimeValues
+	| readonly string[];
 
 /**
  * @todo This is more permissive than it should be, allowing an array of any
@@ -24,9 +23,9 @@ type SingleValueSelectCodecValues<V extends ValueType> =
  * than one value to be set, this is where we'd start looking. The check is
  * skipped for now, to reduce performance overhead.
  */
-const encodeValueFactory = <V extends ValueType>(
-	baseCodec: SharedValueCodec<V>
-): CodecEncoder<SingleValueSelectCodecValues<V>> => {
+const encodeValueFactory = (
+	baseCodec: SharedValueCodec<'string'>
+): CodecEncoder<SingleValueSelectCodecValues> => {
 	return (values) => {
 		const [value] = values;
 
@@ -51,21 +50,16 @@ const encodeValueFactory = <V extends ValueType>(
  * 2. as an optimization, as the more general implementation performs poorly on
  *    forms which we monitor for performance.
  */
-export class SingleValueSelectCodec<V extends ValueType> extends ValueArrayCodec<
-	V,
-	SingleValueSelectCodecValues<V>
-> {
-	constructor(baseCodec: SharedValueCodec<V>) {
+export class SingleValueSelectCodec extends BaseSelectCodec<SingleValueSelectCodecValues> {
+	constructor(baseCodec: SharedValueCodec<'string'>) {
 		const encodeValue = encodeValueFactory(baseCodec);
 
-		const decodeValue: CodecDecoder<SingleValueSelectRuntimeValues<V>> = (value) => {
-			const decoded = baseCodec.decodeValue(value);
-
-			if (decoded == null) {
+		const decodeValue: CodecDecoder<SingleValueSelectRuntimeValues> = (value) => {
+			if (value == null) {
 				return [];
 			}
 
-			return [decoded];
+			return [value];
 		};
 
 		super(baseCodec, encodeValue, decodeValue);
diff --git a/packages/xforms-engine/src/lib/codecs/select/getSelectCodec.ts b/packages/xforms-engine/src/lib/codecs/select/getSelectCodec.ts
index 4d6a8922b..35e7c4d29 100644
--- a/packages/xforms-engine/src/lib/codecs/select/getSelectCodec.ts
+++ b/packages/xforms-engine/src/lib/codecs/select/getSelectCodec.ts
@@ -1,69 +1,27 @@
 import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
 import type { SelectDefinition } from '../../../client/SelectNode.ts';
-import type { ValueType } from '../../../client/ValueType.ts';
 import { sharedValueCodecs } from '../getSharedValueCodec.ts';
 import { MultipleValueSelectCodec } from './MultipleValueSelectCodec.ts';
 import { SingleValueSelectCodec } from './SingleValueSelectCodec.ts';
 
-type MultipleValueSelectCodecs = {
-	readonly [V in ValueType]: MultipleValueSelectCodec<V>;
-};
-
-const multipleValueSelectCodecs: MultipleValueSelectCodecs = {
-	string: new MultipleValueSelectCodec(sharedValueCodecs.string),
-	int: new MultipleValueSelectCodec(sharedValueCodecs.int),
-	decimal: new MultipleValueSelectCodec(sharedValueCodecs.decimal),
-	boolean: new MultipleValueSelectCodec(sharedValueCodecs.boolean),
-	date: new MultipleValueSelectCodec(sharedValueCodecs.date),
-	time: new MultipleValueSelectCodec(sharedValueCodecs.time),
-	dateTime: new MultipleValueSelectCodec(sharedValueCodecs.dateTime),
-	geopoint: new MultipleValueSelectCodec(sharedValueCodecs.geopoint),
-	geotrace: new MultipleValueSelectCodec(sharedValueCodecs.geotrace),
-	geoshape: new MultipleValueSelectCodec(sharedValueCodecs.geoshape),
-	binary: new MultipleValueSelectCodec(sharedValueCodecs.binary),
-	barcode: new MultipleValueSelectCodec(sharedValueCodecs.barcode),
-	intent: new MultipleValueSelectCodec(sharedValueCodecs.intent),
-};
+const multipleValueSelectCodec = new MultipleValueSelectCodec(sharedValueCodecs.string);
 
-type SingleValueSelectCodecs = {
-	readonly [V in ValueType]: SingleValueSelectCodec<V>;
-};
-
-const singleValueSelectCodecs: SingleValueSelectCodecs = {
-	string: new SingleValueSelectCodec(sharedValueCodecs.string),
-	int: new SingleValueSelectCodec(sharedValueCodecs.int),
-	decimal: new SingleValueSelectCodec(sharedValueCodecs.decimal),
-	boolean: new SingleValueSelectCodec(sharedValueCodecs.boolean),
-	date: new SingleValueSelectCodec(sharedValueCodecs.date),
-	time: new SingleValueSelectCodec(sharedValueCodecs.time),
-	dateTime: new SingleValueSelectCodec(sharedValueCodecs.dateTime),
-	geopoint: new SingleValueSelectCodec(sharedValueCodecs.geopoint),
-	geotrace: new SingleValueSelectCodec(sharedValueCodecs.geotrace),
-	geoshape: new SingleValueSelectCodec(sharedValueCodecs.geoshape),
-	binary: new SingleValueSelectCodec(sharedValueCodecs.binary),
-	barcode: new SingleValueSelectCodec(sharedValueCodecs.barcode),
-	intent: new SingleValueSelectCodec(sharedValueCodecs.intent),
-};
+const singleValueSelectCodec = new SingleValueSelectCodec(sharedValueCodecs.string);
 
 // prettier-ignore
-export type SelectCodec<V extends ValueType> =
-	| MultipleValueSelectCodec<V>
-	| SingleValueSelectCodec<V>;
-
-export const getSelectCodec = <V extends ValueType>(
-	definition: SelectDefinition<V>
-): SelectCodec<V> => {
-	const selectType = definition.bodyElement.type;
-	const valueType = definition.valueType;
+export type SelectCodec =
+	| MultipleValueSelectCodec
+	| SingleValueSelectCodec;
 
-	switch (selectType) {
+export const getSelectCodec = (definition: SelectDefinition<'string'>): SelectCodec => {
+	switch (definition.bodyElement.type) {
 		case 'select':
-			return multipleValueSelectCodecs[valueType];
+			return multipleValueSelectCodec;
 
 		case 'select1':
-			return singleValueSelectCodecs[valueType];
+			return singleValueSelectCodec;
 
 		default:
-			throw new UnreachableError(selectType);
+			throw new UnreachableError(definition.bodyElement.type);
 	}
 };
diff --git a/packages/xforms-engine/src/lib/reactivity/createSelectItems.ts b/packages/xforms-engine/src/lib/reactivity/createSelectItems.ts
index 8ec64efe8..61c9a62a8 100644
--- a/packages/xforms-engine/src/lib/reactivity/createSelectItems.ts
+++ b/packages/xforms-engine/src/lib/reactivity/createSelectItems.ts
@@ -2,9 +2,8 @@ import { UpsertableMap } from '@getodk/common/lib/collections/UpsertableMap.ts';
 import type { Accessor } from 'solid-js';
 import { createMemo } from 'solid-js';
 import type { ActiveLanguage } from '../../client/FormLanguage.ts';
-import type { SelectItem, SelectValueOptions } from '../../client/SelectNode.ts';
+import type { SelectItem } from '../../client/SelectNode.ts';
 import type { TextRange as ClientTextRange } from '../../client/TextRange.ts';
-import type { ValueType } from '../../client/ValueType.ts';
 import type { EvaluationContext } from '../../instance/internal-api/EvaluationContext.ts';
 import type { TranslationContext } from '../../instance/internal-api/TranslationContext.ts';
 import type { SelectControl } from '../../instance/SelectControl.ts';
@@ -12,9 +11,8 @@ import { TextChunk } from '../../instance/text/TextChunk.ts';
 import { TextRange } from '../../instance/text/TextRange.ts';
 import type { EngineXPathNode } from '../../integration/xpath/adapter/kind.ts';
 import type { EngineXPathEvaluator } from '../../integration/xpath/EngineXPathEvaluator.ts';
-import type { ItemDefinition } from '../../parse/body/control/select/ItemDefinition.ts';
-import type { ItemsetDefinition } from '../../parse/body/control/select/ItemsetDefinition.ts';
-import type { SelectCodec } from '../codecs/select/getSelectCodec.ts';
+import type { ItemDefinition } from '../../parse/body/control/ItemDefinition.ts';
+import type { ItemsetDefinition } from '../../parse/body/control/ItemsetDefinition.ts';
 import { createComputedExpression } from './createComputedExpression.ts';
 import type { ReactiveScope } from './scope.ts';
 import { createTextRange } from './text/createTextRange.ts';
@@ -45,8 +43,8 @@ interface SourceValueSelectItem {
 	readonly label: ClientTextRange<'item-label'>;
 }
 
-const createTranslatedStaticSelectItems = <V extends ValueType>(
-	select: SelectControl<V>,
+const createTranslatedStaticSelectItems = (
+	select: SelectControl,
 	items: readonly ItemDefinition[]
 ): Accessor<readonly SourceValueSelectItem[]> => {
 	return select.scope.runTask(() => {
@@ -66,7 +64,7 @@ const createTranslatedStaticSelectItems = <V extends ValueType>(
 	});
 };
 
-class ItemsetItemEvaluationContext<V extends ValueType> implements EvaluationContext {
+class ItemsetItemEvaluationContext implements EvaluationContext {
 	readonly isAttached: Accessor<boolean>;
 	readonly scope: ReactiveScope;
 	readonly evaluator: EngineXPathEvaluator;
@@ -74,7 +72,7 @@ class ItemsetItemEvaluationContext<V extends ValueType> implements EvaluationCon
 	readonly getActiveLanguage: Accessor<ActiveLanguage>;
 
 	constructor(
-		select: SelectControl<V>,
+		select: SelectControl,
 		readonly contextNode: EngineXPathNode
 	) {
 		this.isAttached = select.isAttached;
@@ -106,8 +104,8 @@ interface ItemsetItem {
 	value(): string;
 }
 
-const createItemsetItems = <V extends ValueType>(
-	select: SelectControl<V>,
+const createItemsetItems = (
+	select: SelectControl,
 	itemset: ItemsetDefinition
 ): Accessor<readonly ItemsetItem[]> => {
 	return select.scope.runTask(() => {
@@ -135,8 +133,8 @@ const createItemsetItems = <V extends ValueType>(
 	});
 };
 
-const createItemset = <V extends ValueType>(
-	select: SelectControl<V>,
+const createItemset = (
+	select: SelectControl,
 	itemset: ItemsetDefinition
 ): Accessor<readonly SourceValueSelectItem[]> => {
 	return select.scope.runTask(() => {
@@ -165,31 +163,12 @@ const createItemset = <V extends ValueType>(
  *   their appropriate dependencies (whether relative to the itemset item node,
  *   referencing a form's `itext` translations, etc).
  */
-export const createSelectItems = <V extends ValueType>(
-	select: SelectControl<V>,
-	codec: SelectCodec<V>
-): Accessor<SelectValueOptions<V>> => {
+export const createSelectItems = (select: SelectControl): Accessor<readonly SelectItem[]> => {
 	const { items, itemset } = select.definition.bodyElement;
 
-	let getSourceValueItems: Accessor<readonly SourceValueSelectItem[]>;
-
 	if (itemset != null) {
-		getSourceValueItems = createItemset(select, itemset);
-	} else {
-		getSourceValueItems = createTranslatedStaticSelectItems(select, items);
+		return createItemset(select, itemset);
 	}
 
-	return select.scope.runTask(() => {
-		return createMemo(() => {
-			return getSourceValueItems().map((item): SelectItem<V> => {
-				const asString = item.value;
-
-				return {
-					value: codec.decodeItemValue(asString),
-					label: item.label,
-					asString,
-				};
-			});
-		});
-	});
+	return createTranslatedStaticSelectItems(select, items);
 };
diff --git a/packages/xforms-engine/test/lib/reactivity/createSelectItems.test.ts b/packages/xforms-engine/test/lib/reactivity/createSelectItems.test.ts
index 6ef1c7d82..c53c925bb 100644
--- a/packages/xforms-engine/test/lib/reactivity/createSelectItems.test.ts
+++ b/packages/xforms-engine/test/lib/reactivity/createSelectItems.test.ts
@@ -249,11 +249,10 @@ describe('createSelectItems - reactive `<select>`/`<select1>` items and itemsets
 				effect(() => {
 					select.currentState.valueOptions.forEach((option) => {
 						const label = option.label;
-						const stringValue = option.asString;
-						const labelStates = observedLabelStatesByValue.upsert(stringValue, () => []);
+						const labelStates = observedLabelStatesByValue.upsert(option.value, () => []);
 
 						if (label == null) {
-							expect.fail(`Select item with value ${stringValue} has no label`);
+							expect.fail(`Select item with value ${option.value} has no label`);
 						}
 
 						labelStates.push(label.asString);

From aa0dbeccad1587459263d5b8a2940a34dad3e133 Mon Sep 17 00:00:00 2001
From: eyelidlessness <gnosis@gmail.com>
Date: Thu, 16 Jan 2025 11:15:18 -0800
Subject: [PATCH 3/9] scenario: integrate rolled back support for non-string
 selects

---
 .../scenario/src/answer/SelectNodeAnswer.ts   |  12 +-
 packages/scenario/src/jr/Scenario.ts          |  23 +-
 .../scenario/src/jr/event/PositionalEvent.ts  |   4 +-
 .../src/jr/event/SelectQuestionEvent.ts       |  75 +-
 .../scenario/src/jr/select/SelectChoice.ts    |   8 +-
 .../src/jr/select/SelectChoiceList.ts         |  12 +-
 packages/scenario/test/bind-types.test.ts     | 666 ------------------
 7 files changed, 21 insertions(+), 779 deletions(-)

diff --git a/packages/scenario/src/answer/SelectNodeAnswer.ts b/packages/scenario/src/answer/SelectNodeAnswer.ts
index 653459854..728c2afbb 100644
--- a/packages/scenario/src/answer/SelectNodeAnswer.ts
+++ b/packages/scenario/src/answer/SelectNodeAnswer.ts
@@ -1,18 +1,14 @@
 import type { JSONValue } from '@getodk/common/types/JSONValue.ts';
-import type { SelectNode, SelectValues, ValueType } from '@getodk/xforms-engine';
+import type { SelectNode } from '@getodk/xforms-engine';
 import { ValueNodeAnswer } from './ValueNodeAnswer.ts';
 
-export class SelectNodeAnswer<V extends ValueType = ValueType> extends ValueNodeAnswer<
-	SelectNode<V>
-> {
-	readonly valueType: V;
+export class SelectNodeAnswer extends ValueNodeAnswer<SelectNode> {
 	readonly stringValue: string;
-	readonly value: SelectValues<V>;
+	readonly value: readonly string[];
 
-	constructor(node: SelectNode<V>) {
+	constructor(node: SelectNode) {
 		super(node);
 
-		this.valueType = node.valueType;
 		this.stringValue = node.currentState.instanceValue;
 		this.value = node.currentState.value.slice();
 	}
diff --git a/packages/scenario/src/jr/Scenario.ts b/packages/scenario/src/jr/Scenario.ts
index effcba85a..5387affcd 100644
--- a/packages/scenario/src/jr/Scenario.ts
+++ b/packages/scenario/src/jr/Scenario.ts
@@ -1,24 +1,20 @@
 import type { XFormsElement } from '@getodk/common/test/fixtures/xform-dsl/XFormsElement.ts';
 import type {
 	AnyNode,
-	AnySelectNode,
 	OpaqueReactiveObjectFactory,
 	RepeatRangeControlledNode,
 	RepeatRangeNode,
 	RepeatRangeUncontrolledNode,
 	RootNode,
 	SelectNode,
-	SelectValues,
 	SubmissionChunkedType,
 	SubmissionOptions,
 	SubmissionResult,
-	ValueType,
 } from '@getodk/xforms-engine';
 import { constants as ENGINE_CONSTANTS } from '@getodk/xforms-engine';
 import type { Accessor, Setter } from 'solid-js';
 import { createMemo, createSignal, runWithOwner } from 'solid-js';
 import { afterEach, assert, expect } from 'vitest';
-import { SelectNodeAnswer } from '../answer/SelectNodeAnswer.ts';
 import { SelectValuesAnswer } from '../answer/SelectValuesAnswer.ts';
 import type { ValueNodeAnswer } from '../answer/ValueNodeAnswer.ts';
 import { answerOf } from '../client/answerOf.ts';
@@ -395,23 +391,6 @@ export class Scenario {
 		return event.answerQuestion(new SelectValuesAnswer(selectionValues));
 	}
 
-	proposed_answerTypedSelect<V extends ValueType>(
-		reference: string,
-		valueType: V,
-		values: SelectValues<V>
-	): SelectNodeAnswer<V> {
-		const node = this.getInstanceNode(reference);
-
-		assert(node.nodeType === 'select');
-		assert(node.valueType === valueType);
-
-		const selectNode = node as SelectNode<V>;
-
-		selectNode.selectValues(values);
-
-		return new SelectNodeAnswer(selectNode);
-	}
-
 	answer(...args: AnswerParameters): ValueNodeAnswer {
 		if (isAnswerSelectParams(args)) {
 			return this.answerSelect(...args);
@@ -900,7 +879,7 @@ export class Scenario {
 		return label;
 	}
 
-	private getCurrentSelectNode(options: AssertCurrentReferenceOptions): AnySelectNode {
+	private getCurrentSelectNode(options: AssertCurrentReferenceOptions): SelectNode {
 		const { assertCurrentReference } = options;
 		const event = this.getSelectedPositionalEvent();
 
diff --git a/packages/scenario/src/jr/event/PositionalEvent.ts b/packages/scenario/src/jr/event/PositionalEvent.ts
index 7500e6cad..0308c2b39 100644
--- a/packages/scenario/src/jr/event/PositionalEvent.ts
+++ b/packages/scenario/src/jr/event/PositionalEvent.ts
@@ -3,12 +3,12 @@ import type {
 	AnyInputNode,
 	AnyNoteNode,
 	AnyRangeNode,
-	AnySelectNode,
 	AnyUnsupportedControlNode,
 	GroupNode,
 	RepeatInstanceNode,
 	RepeatRangeUncontrolledNode,
 	RootNode,
+	SelectNode,
 	TriggerNode,
 } from '@getodk/xforms-engine';
 import type { Scenario } from '../Scenario.ts';
@@ -17,7 +17,7 @@ import type { Scenario } from '../Scenario.ts';
 export type QuestionPositionalEventNode =
 	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
 	| AnyNoteNode
-	| AnySelectNode
+	| SelectNode
 	| AnyInputNode
 	| AnyRangeNode
 	| TriggerNode
diff --git a/packages/scenario/src/jr/event/SelectQuestionEvent.ts b/packages/scenario/src/jr/event/SelectQuestionEvent.ts
index 4a19f5f50..b341a8cf2 100644
--- a/packages/scenario/src/jr/event/SelectQuestionEvent.ts
+++ b/packages/scenario/src/jr/event/SelectQuestionEvent.ts
@@ -1,32 +1,18 @@
 import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
 import { xmlXPathWhitespaceSeparatedList } from '@getodk/common/lib/string/whitespace.ts';
-import type {
-	AnySelectNode,
-	RootNode,
-	SelectNode,
-	SelectValues,
-	ValueType,
-} from '@getodk/xforms-engine';
-import { assert } from 'vitest';
+import type { SelectNode } from '@getodk/xforms-engine';
 import { SelectNodeAnswer } from '../../answer/SelectNodeAnswer.ts';
 import { UntypedAnswer } from '../../answer/UntypedAnswer.ts';
 import type { ValueNodeAnswer } from '../../answer/ValueNodeAnswer.ts';
 import { SelectChoice } from '../select/SelectChoice.ts';
 import { QuestionEvent } from './QuestionEvent.ts';
 
-interface StringValueSelectWriteMethods {
-	selectValue(value: string): RootNode;
-	selectValues(values: readonly string[]): RootNode;
-}
-
-type StringValueSelectNode = Extract<AnySelectNode, StringValueSelectWriteMethods>;
-
 export class SelectQuestionEvent extends QuestionEvent<'select'> {
 	getAnswer(): SelectNodeAnswer {
 		return new SelectNodeAnswer(this.node);
 	}
 
-	getChoice(choiceIndex: number): SelectChoice<this['node']['valueType']> {
+	getChoice(choiceIndex: number): SelectChoice {
 		const items = this.node.currentState.valueOptions;
 		const item = items[choiceIndex];
 
@@ -37,42 +23,12 @@ export class SelectQuestionEvent extends QuestionEvent<'select'> {
 		return new SelectChoice(item);
 	}
 
-	private getOptionValues<V extends ValueType>(
-		node: SelectNode<V>,
-		stringValues: readonly string[]
-	): SelectValues<V> {
-		const optionsByStringValue = new Map(
-			node.currentState.valueOptions.map((item) => {
-				return [item.asString, item];
-			})
-		);
-
-		return stringValues.map((stringValue) => {
-			const option = optionsByStringValue.get(stringValue);
-
-			assert(option);
-
-			return option.value;
-		});
-	}
-
-	private answerTypedQuestion<V extends ValueType>(
-		node: SelectNode<V>,
-		stringValues: readonly string[]
-	): SelectNodeAnswer<V> {
-		const values = this.getOptionValues(node, stringValues);
-
-		node.selectValues(values);
-
-		return new SelectNodeAnswer(node);
-	}
-
 	/**
 	 * @todo This is yet another case where it would make more sense to split up
 	 * the {@link SelectNode} by control type.
 	 */
 	answerQuestion(answerValue: unknown): ValueNodeAnswer {
-		const node: AnySelectNode = this.node;
+		const { node } = this;
 
 		if (answerValue == null) {
 			node.selectValue(null);
@@ -106,29 +62,8 @@ export class SelectQuestionEvent extends QuestionEvent<'select'> {
 				throw new UnreachableError(selectType);
 		}
 
-		switch (node.valueType) {
-			case 'string':
-			case 'boolean':
-			case 'date':
-			case 'time':
-			case 'dateTime':
-			case 'geopoint':
-			case 'geotrace':
-			case 'geoshape':
-			case 'binary':
-			case 'barcode':
-			case 'intent':
-				// This will continue to pass for each of the above value types while
-				// the engine's implementation falls back to `string` for each
-				// respective type. It will produce a type error if/when each value type
-				// is implemented with a different runtime representation.
-				node satisfies StringValueSelectNode;
-
-				this.node.selectValues(stringValues);
-
-				return new SelectNodeAnswer(node);
-		}
+		this.node.selectValues(stringValues);
 
-		return this.answerTypedQuestion(node, stringValues);
+		return new SelectNodeAnswer(node);
 	}
 }
diff --git a/packages/scenario/src/jr/select/SelectChoice.ts b/packages/scenario/src/jr/select/SelectChoice.ts
index 83750b672..2d0705ee5 100644
--- a/packages/scenario/src/jr/select/SelectChoice.ts
+++ b/packages/scenario/src/jr/select/SelectChoice.ts
@@ -1,19 +1,19 @@
-import type { SelectItem, ValueType } from '@getodk/xforms-engine';
+import type { SelectItem } from '@getodk/xforms-engine';
 import { ComparableChoice } from '../../choice/ComparableChoice.ts';
 import { UnclearApplicabilityError } from '../../error/UnclearApplicabilityError.ts';
 import type { SelectChoiceArbitraryChildList } from './SelectChoiceArbitraryChildList.ts';
 
-export class SelectChoice<V extends ValueType> extends ComparableChoice {
+export class SelectChoice extends ComparableChoice {
 	readonly value: string;
 
 	get label(): string {
 		return this.selectItem.label.asString;
 	}
 
-	constructor(protected readonly selectItem: SelectItem<V>) {
+	constructor(protected readonly selectItem: SelectItem) {
 		super();
 
-		this.value = selectItem.asString;
+		this.value = selectItem.value;
 	}
 
 	/**
diff --git a/packages/scenario/src/jr/select/SelectChoiceList.ts b/packages/scenario/src/jr/select/SelectChoiceList.ts
index b6c78f92a..404b19499 100644
--- a/packages/scenario/src/jr/select/SelectChoiceList.ts
+++ b/packages/scenario/src/jr/select/SelectChoiceList.ts
@@ -1,11 +1,9 @@
-import type { SelectNode, ValueType } from '@getodk/xforms-engine';
+import type { SelectNode } from '@getodk/xforms-engine';
 import type { JavaUtilList } from '../../java/util/List.ts';
 import { SelectChoice } from './SelectChoice.ts';
 
-export class SelectChoiceList<V extends ValueType = ValueType>
-	implements Iterable<SelectChoice<V>>, JavaUtilList<SelectChoice<V>>
-{
-	*[Symbol.iterator](): Iterator<SelectChoice<V>> {
+export class SelectChoiceList implements Iterable<SelectChoice>, JavaUtilList<SelectChoice> {
+	*[Symbol.iterator](): Iterator<SelectChoice> {
 		const { valueOptions } = this.node.currentState;
 
 		for (const index of valueOptions.keys()) {
@@ -19,9 +17,9 @@ export class SelectChoiceList<V extends ValueType = ValueType>
 		}
 	}
 
-	constructor(readonly node: SelectNode<V>) {}
+	constructor(readonly node: SelectNode) {}
 
-	get(index: number): SelectChoice<V> | null {
+	get(index: number): SelectChoice | null {
 		const selectItem = this.node.currentState.valueOptions[index];
 
 		if (selectItem == null) {
diff --git a/packages/scenario/test/bind-types.test.ts b/packages/scenario/test/bind-types.test.ts
index 72b4102ca..72974d531 100644
--- a/packages/scenario/test/bind-types.test.ts
+++ b/packages/scenario/test/bind-types.test.ts
@@ -4,14 +4,9 @@ import {
 	head,
 	html,
 	input,
-	instance,
-	item,
 	mainInstance,
 	model,
 	repeat,
-	select1,
-	select1Dynamic,
-	selectDynamic,
 	t,
 	title,
 } from '@getodk/common/test/fixtures/xform-dsl/index.ts';
@@ -20,7 +15,6 @@ import { assert, beforeEach, describe, expect, expectTypeOf, it } from 'vitest';
 import { intAnswer } from '../src/answer/ExpectedIntAnswer.ts';
 import { InputNodeAnswer } from '../src/answer/InputNodeAnswer.ts';
 import { ModelValueNodeAnswer } from '../src/answer/ModelValueNodeAnswer.ts.ts';
-import { SelectNodeAnswer } from '../src/answer/SelectNodeAnswer.ts';
 import type { ValueNodeAnswer } from '../src/answer/ValueNodeAnswer.ts';
 import { Scenario } from '../src/jr/Scenario.ts';
 
@@ -488,666 +482,6 @@ describe('Data (<bind type>) type support', () => {
 		});
 	});
 
-	type Select1StringValueWordSeparatorChar = ' ' | '-';
-
-	interface Select1StringValueCase {
-		readonly stringValueWordSeparator: Select1StringValueWordSeparatorChar;
-	}
-
-	describe.each<Select1StringValueCase>([
-		{ stringValueWordSeparator: '-' },
-		{ stringValueWordSeparator: ' ' },
-	])(
-		'select1 (string value word separator: "$stringValueWordSeparator")',
-		({ stringValueWordSeparator }) => {
-			const formTitle = 'Select (1) types';
-			const selectRelevancePath = '/root/select-relevance';
-			const selectRelevanceExpression = `${selectRelevancePath} = 'yes'`;
-			const select1StringValue = (baseValue: string): string => {
-				return baseValue.replaceAll(' ', stringValueWordSeparator);
-			};
-
-			// prettier-ignore
-			const formDefinition = html(
-				head(
-					title(formTitle),
-					model(
-						mainInstance(
-							t(
-								'root id="select-types"',
-								t('select-relevance', 'yes'),
-								t('string-value', select1StringValue('explicit string')),
-								t('implicit-string-value', select1StringValue('implicit string')),
-								t('int-value', '123'),
-								t('decimal-value', '45.67'),
-							)
-						),
-						instance('strings',
-							t('item',
-								t('value', select1StringValue('implicit string')),
-								t('label', 'Implicit String')),
-							t('item',
-								t('value', select1StringValue('explicit string')),
-								t('label', 'Explicit String')),
-							t('item',
-								t('value', select1StringValue('updated string')),
-								t('label', 'Updated String'))
-						),
-						instance('ints',
-							t('item',
-								t('value', '123'),
-								t('label', '123')),
-							t('item',
-								t('value', '10'),
-								t('label', '10')),
-							t('item',
-								t('value', '23'),
-								t('label', '23')),
-							t('item',
-								t('value', '89'),
-								t('label', '89'))
-						),
-						instance('decimals',
-							t('item',
-								t('value', '45.67'),
-								t('label', '45.67')),
-							t('item',
-								t('value', '89'),
-								t('label', '89')),
-							t('item',
-								t('value', '10'),
-								t('label', '10')),
-							t('item',
-								t('value', '23.4'),
-								t('label', '23.4')),
-						),
-						bind('/root/string-value').type('string').relevant(selectRelevanceExpression),
-						bind('/root/implicit-string-value').relevant(selectRelevanceExpression),
-						bind('/root/int-value').type('int').relevant(selectRelevanceExpression),
-						bind('/root/decimal-value').type('decimal').relevant(selectRelevanceExpression)
-					)
-				),
-				body(
-					select1('/root/select-relevance',
-						item('yes', 'Yes'),
-						item('no', 'No')
-					),
-					select1Dynamic('/root/string-value', "instance('strings')/root/item"),
-					select1Dynamic('/root/implicit-string-value', "instance('strings')/root/item"),
-					select1Dynamic('/root/int-value', "instance('ints')/root/item"),
-					select1Dynamic('/root/decimal-value', "instance('decimals')/root/item"),
-				)
-			);
-
-			let scenario: Scenario;
-
-			type AssertTypedSelectNodeAnswer = <V extends ValueType>(
-				answer: ValueNodeAnswer,
-				valueType: V
-			) => asserts answer is SelectNodeAnswer<V>;
-
-			const assertTypedSelectNodeAnswer: AssertTypedSelectNodeAnswer = (answer, valueType) => {
-				assert(answer instanceof SelectNodeAnswer);
-				assert(answer.valueType === valueType);
-			};
-
-			const getTypedSelectNodeAnswer = <V extends ValueType>(
-				reference: string,
-				valueType: V
-			): SelectNodeAnswer<V> => {
-				const answer = scenario.answerOf(reference);
-
-				assertTypedSelectNodeAnswer(answer, valueType);
-
-				return answer;
-			};
-
-			beforeEach(async () => {
-				scenario = await Scenario.init(formTitle, formDefinition);
-			});
-
-			describe('explicit type="string"', () => {
-				let answer: SelectNodeAnswer<'string'>;
-
-				beforeEach(() => {
-					answer = getTypedSelectNodeAnswer('/root/string-value', 'string');
-				});
-
-				it('has a runtime value which is an array of a single string value', () => {
-					expect(answer.value).toBeInstanceOf(Array);
-					expect(answer.value.length).toBe(1);
-					expect(answer.value[0]).toBeTypeOf('string');
-				});
-
-				it('has a readonly string[] static type', () => {
-					expectTypeOf(answer.value).toMatchTypeOf<readonly string[]>();
-				});
-
-				it('has a string value populated as an array item', () => {
-					expect(answer.value).toEqual([select1StringValue('explicit string')]);
-				});
-
-				it('has an empty array blank value', () => {
-					scenario.answer(selectRelevancePath, 'no');
-					answer = getTypedSelectNodeAnswer('/root/string-value', 'string');
-					expect(answer.value).toEqual([]);
-				});
-
-				it('sets a string value', () => {
-					const value = select1StringValue('updated string');
-
-					scenario.answer('/root/string-value', value);
-					answer = getTypedSelectNodeAnswer('/root/string-value', 'string');
-					expect(answer.value).toEqual([value]);
-				});
-			});
-
-			describe('implicit string type (default)', () => {
-				let answer: SelectNodeAnswer<'string'>;
-
-				beforeEach(() => {
-					answer = getTypedSelectNodeAnswer('/root/implicit-string-value', 'string');
-				});
-
-				it('has a runtime value which is an array of a single string value', () => {
-					expect(answer.value).toBeInstanceOf(Array);
-					expect(answer.value.length).toBe(1);
-					expect(answer.value[0]).toBeTypeOf('string');
-				});
-
-				it('has a readonly string[] static type', () => {
-					expectTypeOf(answer.value).toMatchTypeOf<readonly string[]>();
-				});
-
-				it('has a string value populated as an array item', () => {
-					expect(answer.value).toEqual([select1StringValue('implicit string')]);
-				});
-
-				it('has an empty string blank value', () => {
-					scenario.answer(selectRelevancePath, 'no');
-					answer = getTypedSelectNodeAnswer('/root/implicit-string-value', 'string');
-					expect(answer.value).toEqual([]);
-				});
-
-				it('sets a string value', () => {
-					const value = select1StringValue('updated string');
-
-					scenario.answer('/root/implicit-string-value', value);
-					answer = getTypedSelectNodeAnswer('/root/implicit-string-value', 'string');
-					expect(answer.value).toEqual([value]);
-				});
-			});
-
-			describe('type="int"', () => {
-				let answer: SelectNodeAnswer<'int'>;
-
-				beforeEach(() => {
-					answer = getTypedSelectNodeAnswer('/root/int-value', 'int');
-				});
-
-				it('has a runtime value which is an array of a single bigint value', () => {
-					expect(answer.value).toBeInstanceOf(Array);
-					expect(answer.value.length).toBe(1);
-					expect(answer.value[0]).toBeTypeOf('bigint');
-				});
-
-				it('has a readonly bigint[] static type', () => {
-					expectTypeOf(answer.value).toEqualTypeOf<readonly bigint[]>();
-				});
-
-				it('has a bigint value populated as an array item', () => {
-					expect(answer.value).toEqual([123n]);
-				});
-
-				it('has an empty array blank value', () => {
-					scenario.answer(selectRelevancePath, 'no');
-					answer = getTypedSelectNodeAnswer('/root/int-value', 'int');
-					expect(answer.value).toEqual([]);
-				});
-
-				describe('setting int values', () => {
-					interface SetIntSelectValueCase {
-						readonly selectValue: bigint | null;
-						readonly expectedValue: readonly [] | readonly [bigint];
-					}
-
-					describe.each<SetIntSelectValueCase>([
-						{ selectValue: 89n, expectedValue: [89n] },
-						{ selectValue: 10n, expectedValue: [10n] },
-						{ selectValue: 23n, expectedValue: [23n] },
-						{ selectValue: null, expectedValue: [] },
-					])('setValue($selectType)', ({ selectValue, expectedValue }) => {
-						const expectedValueDescription = JSON.stringify(expectedValue.map(String));
-
-						it(`sets ${selectValue}, resulting in value ${expectedValueDescription}`, () => {
-							scenario.answer('/root/int-value', selectValue);
-							answer = getTypedSelectNodeAnswer('/root/int-value', 'int');
-
-							expectTypeOf(answer.value).toEqualTypeOf<readonly bigint[]>();
-
-							expect(answer.value).toEqual(expectedValue);
-
-							const expectedValueItem = expectedValue[0] ?? '';
-							const expectedStringValue = String(expectedValueItem);
-
-							expect(answer.stringValue).toBe(expectedStringValue);
-						});
-					});
-
-					interface SetIntSelectErrorCase {
-						readonly selectValue: bigint | null;
-					}
-
-					describe.each<SetIntSelectErrorCase>([
-						{ selectValue: -2_147_483_649n },
-						{ selectValue: 2_147_483_648n },
-					])('integer value out of specified bounds ($selectType)', ({ selectValue }) => {
-						it(`fails to set ${selectValue}`, () => {
-							let caught: unknown;
-
-							try {
-								scenario.answer('/root/int-value', selectValue);
-								answer = getTypedSelectNodeAnswer('/root/int-value', 'int');
-							} catch (error) {
-								caught = error;
-							}
-
-							expect(caught, `Value was set to ${answer.stringValue}`).toBeInstanceOf(Error);
-						});
-					});
-				});
-			});
-
-			describe('type="decimal"', () => {
-				let answer: SelectNodeAnswer<'decimal'>;
-
-				beforeEach(() => {
-					answer = getTypedSelectNodeAnswer('/root/decimal-value', 'decimal');
-				});
-
-				it('has a runtime value which is an array of a single number value', () => {
-					expect(answer.value).toBeInstanceOf(Array);
-					expect(answer.value.length).toBe(1);
-					expect(answer.value[0]).toBeTypeOf('number');
-				});
-
-				it('has a readonly number[] static type', () => {
-					expectTypeOf(answer.value).toEqualTypeOf<readonly number[]>();
-				});
-
-				it('has a number populated value', () => {
-					expect(answer.value).toEqual([45.67]);
-				});
-
-				it('has an empty array blank value', () => {
-					scenario.answer(selectRelevancePath, 'no');
-					answer = getTypedSelectNodeAnswer('/root/decimal-value', 'decimal');
-					expect(answer.value).toEqual([]);
-				});
-
-				describe('setting decimal values', () => {
-					interface SetDecimalSelectValueCase {
-						readonly selectValue: number | null;
-						readonly expectedValue: readonly [] | readonly [number];
-					}
-
-					it.each<SetDecimalSelectValueCase>([
-						{ selectValue: 89, expectedValue: [89] },
-						{ selectValue: 10, expectedValue: [10] },
-						{ selectValue: 23.4, expectedValue: [23.4] },
-						{ selectValue: null, expectedValue: [] },
-					])(
-						'sets value $selectValue, resulting in $expectedValue',
-						({ selectValue, expectedValue }) => {
-							scenario.answer('/root/decimal-value', selectValue);
-							answer = getTypedSelectNodeAnswer('/root/decimal-value', 'decimal');
-
-							expectTypeOf(answer.value).toEqualTypeOf<readonly number[]>();
-
-							expect(answer.value).toEqual(expectedValue);
-
-							const expectedValueItem = expectedValue[0] ?? '';
-							const expectedStringValue = String(expectedValueItem);
-
-							expect(answer.stringValue).toBe(expectedStringValue);
-						}
-					);
-				});
-			});
-		}
-	);
-
-	describe('select (multiple)', () => {
-		const formTitle = 'Select (multiple) types';
-		const selectRelevancePath = '/root/select-relevance';
-		const selectRelevanceExpression = `${selectRelevancePath} = 'yes'`;
-
-		// prettier-ignore
-		const formDefinition = html(
-			head(
-				title(formTitle),
-				model(
-					mainInstance(
-						t(
-							'root id="select-types"',
-							t('select-relevance', 'yes'),
-							t('string-value', 'explicit-string'),
-							t('implicit-string-value', 'implicit-string'),
-							t('int-value', '123'),
-							t('decimal-value', '45.67'),
-						)
-					),
-					instance('strings',
-						t('item',
-							t('value', 'implicit-string'),
-							t('label', 'Implicit String')),
-						t('item',
-							t('value', 'explicit-string'),
-							t('label', 'Explicit String')),
-						t('item',
-							t('value', 'updated-string'),
-							t('label', 'Updated String'))
-					),
-					instance('ints',
-						t('item',
-							t('value', '123'),
-							t('label', '123')),
-						t('item',
-							t('value', '10'),
-							t('label', '10')),
-						t('item',
-							t('value', '23'),
-							t('label', '23')),
-						t('item',
-							t('value', '89'),
-							t('label', '89'))
-					),
-					instance('decimals',
-						t('item',
-							t('value', '45.67'),
-							t('label', '45.67')),
-						t('item',
-							t('value', '89'),
-							t('label', '89')),
-						t('item',
-							t('value', '10'),
-							t('label', '10')),
-						t('item',
-							t('value', '23.4'),
-							t('label', '23.4')),
-					),
-					bind('/root/string-value').type('string').relevant(selectRelevanceExpression),
-					bind('/root/implicit-string-value').relevant(selectRelevanceExpression),
-					bind('/root/int-value').type('int').relevant(selectRelevanceExpression),
-					bind('/root/decimal-value').type('decimal').relevant(selectRelevanceExpression)
-				)
-			),
-			body(
-				select1('/root/select-relevance',
-					item('yes', 'Yes'),
-					item('no', 'No')
-				),
-				selectDynamic('/root/string-value', "instance('strings')/root/item"),
-				selectDynamic('/root/implicit-string-value', "instance('strings')/root/item"),
-				selectDynamic('/root/int-value', "instance('ints')/root/item"),
-				selectDynamic('/root/decimal-value', "instance('decimals')/root/item"),
-			)
-		);
-
-		let scenario: Scenario;
-
-		type AssertTypedSelectNodeAnswer = <V extends ValueType>(
-			answer: ValueNodeAnswer,
-			valueType: V
-		) => asserts answer is SelectNodeAnswer<V>;
-
-		const assertTypedSelectNodeAnswer: AssertTypedSelectNodeAnswer = (answer, valueType) => {
-			assert(answer instanceof SelectNodeAnswer);
-			assert(answer.valueType === valueType);
-		};
-
-		const getTypedSelectNodeAnswer = <V extends ValueType>(
-			reference: string,
-			valueType: V
-		): SelectNodeAnswer<V> => {
-			const answer = scenario.answerOf(reference);
-
-			assertTypedSelectNodeAnswer(answer, valueType);
-
-			return answer;
-		};
-
-		beforeEach(async () => {
-			scenario = await Scenario.init(formTitle, formDefinition);
-		});
-
-		describe('explicit type="string"', () => {
-			let answer: SelectNodeAnswer<'string'>;
-
-			beforeEach(() => {
-				answer = getTypedSelectNodeAnswer('/root/string-value', 'string');
-			});
-
-			it('has a runtime value which is an array of a single string value', () => {
-				expect(answer.value).toBeInstanceOf(Array);
-				expect(answer.value.length).toBe(1);
-				expect(answer.value[0]).toBeTypeOf('string');
-			});
-
-			it('has a readonly string[] static type', () => {
-				expectTypeOf(answer.value).toMatchTypeOf<readonly string[]>();
-			});
-
-			it('has a string value populated as an array item', () => {
-				expect(answer.value).toEqual(['explicit-string']);
-			});
-
-			it('has an empty array blank value', () => {
-				scenario.answer(selectRelevancePath, 'no');
-				answer = getTypedSelectNodeAnswer('/root/string-value', 'string');
-				expect(answer.value).toEqual([]);
-			});
-
-			it('sets string values', () => {
-				scenario.answer('/root/string-value', 'explicit-string', 'updated-string');
-				answer = getTypedSelectNodeAnswer('/root/string-value', 'string');
-				expect(answer.value).toEqual(['explicit-string', 'updated-string']);
-			});
-		});
-
-		describe('implicit string type (default)', () => {
-			let answer: SelectNodeAnswer<'string'>;
-
-			beforeEach(() => {
-				answer = getTypedSelectNodeAnswer('/root/implicit-string-value', 'string');
-			});
-
-			it('has a runtime value which is an array of a single string value', () => {
-				expect(answer.value).toBeInstanceOf(Array);
-				expect(answer.value.length).toBe(1);
-				expect(answer.value[0]).toBeTypeOf('string');
-			});
-
-			it('has a readonly string[] static type', () => {
-				expectTypeOf(answer.value).toMatchTypeOf<readonly string[]>();
-			});
-
-			it('has a string value populated as an array item', () => {
-				expect(answer.value).toEqual(['implicit-string']);
-			});
-
-			it('has an empty string blank value', () => {
-				scenario.answer(selectRelevancePath, 'no');
-				answer = getTypedSelectNodeAnswer('/root/implicit-string-value', 'string');
-				expect(answer.value).toEqual([]);
-			});
-
-			it('sets string values', () => {
-				scenario.answer('/root/implicit-string-value', 'implicit-string', 'updated-string');
-				answer = getTypedSelectNodeAnswer('/root/implicit-string-value', 'string');
-				expect(answer.value).toEqual(['implicit-string', 'updated-string']);
-			});
-		});
-
-		describe('type="int"', () => {
-			let answer: SelectNodeAnswer<'int'>;
-
-			beforeEach(() => {
-				answer = getTypedSelectNodeAnswer('/root/int-value', 'int');
-			});
-
-			it('has a runtime value which is an array of a single bigint value', () => {
-				expect(answer.value).toBeInstanceOf(Array);
-				expect(answer.value.length).toBe(1);
-				expect(answer.value[0]).toBeTypeOf('bigint');
-			});
-
-			it('has a readonly bigint[] static type', () => {
-				expectTypeOf(answer.value).toEqualTypeOf<readonly bigint[]>();
-			});
-
-			it('has a bigint value populated as an array item', () => {
-				expect(answer.value).toEqual([123n]);
-			});
-
-			it('has an empty array blank value', () => {
-				scenario.answer(selectRelevancePath, 'no');
-				answer = getTypedSelectNodeAnswer('/root/int-value', 'int');
-				expect(answer.value).toEqual([]);
-			});
-
-			describe('setting int values', () => {
-				interface SetIntSelectValueCase {
-					readonly selectValues: readonly bigint[];
-					readonly expectedValue: readonly bigint[];
-					readonly reason?: string;
-				}
-
-				describe.each<SetIntSelectValueCase>([
-					{ selectValues: [89n], expectedValue: [89n] },
-					{ selectValues: [10n, 23n], expectedValue: [10n, 23n] },
-					{
-						selectValues: [23n, 10n],
-						expectedValue: [10n, 23n],
-						reason:
-							'<select> values are written in option order (consistent with JavaRosa, also tested elsewhere with strings)',
-					},
-					{ selectValues: [], expectedValue: [] },
-				])('setValue ($selectValues)', ({ selectValues, expectedValue, reason }) => {
-					const selectValuesDescription = JSON.stringify(selectValues.map(String));
-					const expectedValueDescription = JSON.stringify(expectedValue.map(String));
-					const reasonDescription = reason == null ? '' : `(${reason})`;
-					const description =
-						`sets ${selectValuesDescription}, resulting in value ${expectedValueDescription} ${reasonDescription}`.trim();
-
-					it(description, () => {
-						scenario.proposed_answerTypedSelect('/root/int-value', 'int', selectValues);
-						answer = getTypedSelectNodeAnswer('/root/int-value', 'int');
-
-						expectTypeOf(answer.value).toEqualTypeOf<readonly bigint[]>();
-
-						expect(answer.value).toEqual(expectedValue);
-
-						const expectedStringValue = expectedValue.map(String).join(' ');
-
-						expect(answer.stringValue).toBe(expectedStringValue);
-					});
-				});
-
-				interface SetIntSelectErrorCase {
-					readonly selectValues: readonly bigint[];
-				}
-
-				// TODO: unsure if there's anything to test here! The values won't be
-				// set because they're not available in the select's `valueOptions`.
-				describe.skip.each<SetIntSelectErrorCase>([
-					{ selectValues: [-2_147_483_649n] },
-					{ selectValues: [2_147_483_648n] },
-					{ selectValues: [-2_147_483_649n, 2_147_483_648n] },
-					{ selectValues: [2_147_483_649n, -2_147_483_648n] },
-				])('integer value out of specified bounds ($selectType)', ({ selectValues }) => {
-					const selectValuesDescription = JSON.stringify(selectValues.map(String));
-
-					it(`fails to set ${selectValuesDescription}`, () => {
-						let caught: unknown;
-
-						try {
-							scenario.proposed_answerTypedSelect('/root/int-value', 'int', selectValues);
-							answer = getTypedSelectNodeAnswer('/root/int-value', 'int');
-						} catch (error) {
-							caught = error;
-						}
-
-						expect(caught, `Value was set to ${answer.stringValue}`).toBeInstanceOf(Error);
-					});
-				});
-			});
-		});
-
-		describe('type="decimal"', () => {
-			let answer: SelectNodeAnswer<'decimal'>;
-
-			beforeEach(() => {
-				answer = getTypedSelectNodeAnswer('/root/decimal-value', 'decimal');
-			});
-
-			it('has a runtime value which is an array of a single number value', () => {
-				expect(answer.value).toBeInstanceOf(Array);
-				expect(answer.value.length).toBe(1);
-				expect(answer.value[0]).toBeTypeOf('number');
-			});
-
-			it('has a readonly number[] static type', () => {
-				expectTypeOf(answer.value).toEqualTypeOf<readonly number[]>();
-			});
-
-			it('has a number populated value', () => {
-				expect(answer.value).toEqual([45.67]);
-			});
-
-			it('has an empty array blank value', () => {
-				scenario.answer(selectRelevancePath, 'no');
-				answer = getTypedSelectNodeAnswer('/root/decimal-value', 'decimal');
-				expect(answer.value).toEqual([]);
-			});
-
-			describe('setting decimal values', () => {
-				interface SetDecimalSelectValueCase {
-					readonly selectValues: readonly number[];
-					readonly expectedValue: readonly number[];
-					readonly reason?: string;
-				}
-
-				it.each<SetDecimalSelectValueCase>([
-					{ selectValues: [89], expectedValue: [89] },
-					{ selectValues: [10], expectedValue: [10] },
-					{ selectValues: [45.67, 23.4], expectedValue: [45.67, 23.4] },
-					{
-						selectValues: [23.4, 45.67],
-						expectedValue: [45.67, 23.4],
-						reason:
-							'<select> values are written in option order (consistent with JavaRosa, also tested elsewhere with strings)',
-					},
-					{ selectValues: [], expectedValue: [] },
-				])(
-					'sets values $selectValues, resulting in $expectedValue ($reason)',
-					({ selectValues, expectedValue }) => {
-						scenario.proposed_answerTypedSelect('/root/decimal-value', 'decimal', selectValues);
-						answer = getTypedSelectNodeAnswer('/root/decimal-value', 'decimal');
-
-						expectTypeOf(answer.value).toEqualTypeOf<readonly number[]>();
-
-						expect(answer.value).toEqual(expectedValue);
-
-						const expectedStringValue = expectedValue.map(String).join(' ');
-
-						expect(answer.stringValue).toBe(expectedStringValue);
-					}
-				);
-			});
-		});
-	});
-
 	describe('casting fractional values to int', () => {
 		/**
 		 * **PORTING NOTES**

From 3abb3b0e8ae246f9e731dfb2825dc99c24ecf966 Mon Sep 17 00:00:00 2001
From: eyelidlessness <gnosis@gmail.com>
Date: Thu, 16 Jan 2025 11:15:35 -0800
Subject: [PATCH 4/9] web-forms (Vue UI): integrate rolled back support for
 non-string selects

---
 .../web-forms/src/components/FormQuestion.vue |  4 ++--
 .../components/controls/Select1Control.vue    |  4 ++--
 .../src/components/controls/SelectControl.vue |  4 ++--
 .../components/controls/SelectNControl.vue    |  4 ++--
 .../src/components/widgets/CheckboxWidget.vue | 16 +++++++------
 .../src/components/widgets/LikertWidget.vue   |  4 ++--
 .../widgets/MultiselectDropdown.vue           | 16 +++++++------
 .../src/components/widgets/RadioButton.vue    | 15 ++++++------
 .../components/widgets/SearchableDropdown.vue | 16 +++++++------
 .../src/lib/format/selectOptionId.ts          |  6 ++---
 .../tests/components/FormQuestion.test.ts     |  4 ++--
 .../tests/components/SelectControl.test.ts    | 23 ++++++++-----------
 12 files changed, 60 insertions(+), 56 deletions(-)

diff --git a/packages/web-forms/src/components/FormQuestion.vue b/packages/web-forms/src/components/FormQuestion.vue
index d8ea43bc5..d5bf0519f 100644
--- a/packages/web-forms/src/components/FormQuestion.vue
+++ b/packages/web-forms/src/components/FormQuestion.vue
@@ -3,8 +3,8 @@ import type {
 	AnyControlNode,
 	AnyInputNode,
 	AnyNoteNode,
-	AnySelectNode,
 	AnyUnsupportedControlNode,
+	SelectNode,
 } from '@getodk/xforms-engine';
 import { inject } from 'vue';
 import InputControl from './controls/Input/InputControl.vue';
@@ -19,7 +19,7 @@ type ControlNode = AnyControlNode | AnyUnsupportedControlNode;
 defineProps<{ question: ControlNode }>();
 
 const isInputNode = (node: ControlNode): node is AnyInputNode => node.nodeType === 'input';
-const isSelectNode = (node: ControlNode): node is AnySelectNode => node.nodeType === 'select';
+const isSelectNode = (node: ControlNode): node is SelectNode => node.nodeType === 'select';
 const isNoteNode = (node: ControlNode): node is AnyNoteNode => node.nodeType === 'note';
 const isRangeNode = (node: ControlNode) => node.nodeType === 'range';
 const isTriggerNode = (node: ControlNode) => node.nodeType === 'trigger';
diff --git a/packages/web-forms/src/components/controls/Select1Control.vue b/packages/web-forms/src/components/controls/Select1Control.vue
index 15d58abf1..7c5b25de2 100644
--- a/packages/web-forms/src/components/controls/Select1Control.vue
+++ b/packages/web-forms/src/components/controls/Select1Control.vue
@@ -1,5 +1,5 @@
 <script lang="ts" setup>
-import type { AnySelectNode } from '@getodk/xforms-engine';
+import type { SelectNode } from '@getodk/xforms-engine';
 import { inject, ref } from 'vue';
 import ControlText from '../ControlText.vue';
 import ValidationMessage from '../ValidationMessage.vue';
@@ -11,7 +11,7 @@ import SearchableDropdown from '../widgets/SearchableDropdown.vue';
 import UnsupportedAppearance from './UnsupportedAppearance.vue';
 
 interface Select1ControlProps {
-	readonly question: AnySelectNode;
+	readonly question: SelectNode;
 }
 
 const props = defineProps<Select1ControlProps>();
diff --git a/packages/web-forms/src/components/controls/SelectControl.vue b/packages/web-forms/src/components/controls/SelectControl.vue
index 9d60fdc18..e4a722f54 100644
--- a/packages/web-forms/src/components/controls/SelectControl.vue
+++ b/packages/web-forms/src/components/controls/SelectControl.vue
@@ -1,10 +1,10 @@
 <script setup lang="ts">
-import type { AnySelectNode } from '@getodk/xforms-engine';
+import type { SelectNode } from '@getodk/xforms-engine';
 import Select1Control from './Select1Control.vue';
 import SelectNControl from './SelectNControl.vue';
 
 interface SelectControlProps {
-	readonly question: AnySelectNode;
+	readonly question: SelectNode;
 }
 
 defineProps<SelectControlProps>();
diff --git a/packages/web-forms/src/components/controls/SelectNControl.vue b/packages/web-forms/src/components/controls/SelectNControl.vue
index 51363bc20..4b7b01425 100644
--- a/packages/web-forms/src/components/controls/SelectNControl.vue
+++ b/packages/web-forms/src/components/controls/SelectNControl.vue
@@ -1,5 +1,5 @@
 <script lang="ts" setup>
-import type { AnySelectNode } from '@getodk/xforms-engine';
+import type { SelectNode } from '@getodk/xforms-engine';
 import { inject, ref } from 'vue';
 import ControlText from '../ControlText.vue';
 import ValidationMessage from '../ValidationMessage.vue';
@@ -10,7 +10,7 @@ import MultiselectDropdown from '../widgets/MultiselectDropdown.vue';
 import UnsupportedAppearance from './UnsupportedAppearance.vue';
 
 interface SelectNControlProps {
-	readonly question: AnySelectNode;
+	readonly question: SelectNode;
 }
 
 const props = defineProps<SelectNControlProps>();
diff --git a/packages/web-forms/src/components/widgets/CheckboxWidget.vue b/packages/web-forms/src/components/widgets/CheckboxWidget.vue
index 624de1eea..56f29466c 100644
--- a/packages/web-forms/src/components/widgets/CheckboxWidget.vue
+++ b/packages/web-forms/src/components/widgets/CheckboxWidget.vue
@@ -1,16 +1,18 @@
-<script lang="ts" setup generic="V extends ValueType">
+<script lang="ts" setup>
 import { selectOptionId } from '@/lib/format/selectOptionId.ts';
-import type { SelectNode, SelectValues, ValueType } from '@getodk/xforms-engine';
+import type { SelectNode } from '@getodk/xforms-engine';
 import PrimeCheckbox from 'primevue/checkbox';
 
-const props = defineProps<{
-	readonly question: SelectNode<V>;
+interface CheckboxWidgetProps {
+	readonly question: SelectNode;
 	readonly style?: string;
-}>();
+}
+
+const props = defineProps<CheckboxWidgetProps>();
 
 defineEmits(['update:modelValue', 'change']);
 
-const selectValues = (values: SelectValues<V>) => {
+const selectValues = (values: readonly string[]) => {
 	props.question.selectValues(values);
 };
 </script>
@@ -18,7 +20,7 @@ const selectValues = (values: SelectValues<V>) => {
 <template>
 	<label
 		v-for="option of question.currentState.valueOptions"
-		:key="option.asString"
+		:key="option.value"
 		:class="[{
 			'value-option': true,
 			active: question.isSelected(option.value),
diff --git a/packages/web-forms/src/components/widgets/LikertWidget.vue b/packages/web-forms/src/components/widgets/LikertWidget.vue
index f872775f9..a8335b942 100644
--- a/packages/web-forms/src/components/widgets/LikertWidget.vue
+++ b/packages/web-forms/src/components/widgets/LikertWidget.vue
@@ -1,9 +1,9 @@
 <script setup lang="ts">
-import type { AnySelectNode } from '@getodk/xforms-engine';
+import type { SelectNode } from '@getodk/xforms-engine';
 import RadioButton from '../widgets/RadioButton.vue';
 
 interface LikertWidgetProps {
-	readonly question: AnySelectNode;
+	readonly question: SelectNode;
 }
 
 defineProps<LikertWidgetProps>();
diff --git a/packages/web-forms/src/components/widgets/MultiselectDropdown.vue b/packages/web-forms/src/components/widgets/MultiselectDropdown.vue
index 74fbc5b0d..4ce5c8092 100644
--- a/packages/web-forms/src/components/widgets/MultiselectDropdown.vue
+++ b/packages/web-forms/src/components/widgets/MultiselectDropdown.vue
@@ -1,12 +1,14 @@
-<script lang="ts" setup generic="V extends ValueType">
-import type { SelectItemValue, SelectNode, SelectValues, ValueType } from '@getodk/xforms-engine';
+<script lang="ts" setup>
+import type { SelectNode } from '@getodk/xforms-engine';
 import PrimeMultiSelect from 'primevue/multiselect';
 import { computed } from 'vue';
 
-const props = defineProps<{
-	readonly question: SelectNode<V>;
+interface MultiselectDropdownProps {
+	readonly question: SelectNode;
 	readonly style?: string;
-}>();
+}
+
+const props = defineProps<MultiselectDropdownProps>();
 
 defineEmits(['update:modelValue', 'change']);
 
@@ -14,11 +16,11 @@ const options = computed(() => {
 	return props.question.currentState.valueOptions.map((option) => option.value);
 });
 
-const selectValues = (values: SelectValues<V>) => {
+const selectValues = (values: readonly string[]) => {
 	props.question.selectValues(values);
 };
 
-const getOptionLabel = (value: SelectItemValue<V>) => {
+const getOptionLabel = (value: string) => {
 	const option = props.question.getValueOption(value);
 
 	if (option == null) {
diff --git a/packages/web-forms/src/components/widgets/RadioButton.vue b/packages/web-forms/src/components/widgets/RadioButton.vue
index da59576bf..711a4a06e 100644
--- a/packages/web-forms/src/components/widgets/RadioButton.vue
+++ b/packages/web-forms/src/components/widgets/RadioButton.vue
@@ -1,15 +1,16 @@
-<script lang="ts" setup generic="V extends ValueType">
+<script lang="ts" setup>
 import { selectOptionId } from '@/lib/format/selectOptionId.ts';
-import type { SelectItemValue, SelectNode, ValueType } from '@getodk/xforms-engine';
+import type { SelectNode } from '@getodk/xforms-engine';
 import PrimeRadioButton from 'primevue/radiobutton';
+interface RadioButtonProps {
+	readonly question: SelectNode;
+}
 
-const props = defineProps<{
-	readonly question: SelectNode<V>;
-}>();
+const props = defineProps<RadioButtonProps>();
 
 defineEmits(['update:modelValue', 'change']);
 
-const selectValue = (value: SelectItemValue<V>) => {
+const selectValue = (value: string) => {
 	props.question.selectValue(value);
 };
 </script>
@@ -17,7 +18,7 @@ const selectValue = (value: SelectItemValue<V>) => {
 <template>
 	<label
 		v-for="option in question.currentState.valueOptions"
-		:key="option.asString"
+		:key="option.value"
 		:for="selectOptionId(question, option)"
 		:class="{
 			'value-option': true,
diff --git a/packages/web-forms/src/components/widgets/SearchableDropdown.vue b/packages/web-forms/src/components/widgets/SearchableDropdown.vue
index 19394c79c..461292c0c 100644
--- a/packages/web-forms/src/components/widgets/SearchableDropdown.vue
+++ b/packages/web-forms/src/components/widgets/SearchableDropdown.vue
@@ -1,12 +1,14 @@
-<script setup lang="ts" generic="V extends ValueType">
-import type { SelectItemValue, SelectNode, ValueType } from '@getodk/xforms-engine';
+<script setup lang="ts">
+import type { SelectNode } from '@getodk/xforms-engine';
 import PrimeDropdown from 'primevue/dropdown';
 import { computed } from 'vue';
 
-const props = defineProps<{
-	readonly question: SelectNode<V>;
+interface SearchableDropdownProps {
+	readonly question: SelectNode;
 	readonly style?: string;
-}>();
+}
+
+const props = defineProps<SearchableDropdownProps>();
 
 defineEmits(['update:modelValue', 'change']);
 
@@ -14,11 +16,11 @@ const options = computed(() => {
 	return props.question.currentState.valueOptions.map((option) => option.value);
 });
 
-const selectValue = (value: SelectItemValue<V>) => {
+const selectValue = (value: string) => {
 	props.question.selectValue(value);
 };
 
-const getOptionLabel = (value: SelectItemValue<V>) => {
+const getOptionLabel = (value: string) => {
 	const option = props.question.getValueOption(value);
 
 	if (option == null) {
diff --git a/packages/web-forms/src/lib/format/selectOptionId.ts b/packages/web-forms/src/lib/format/selectOptionId.ts
index c8a0186a1..d98937301 100644
--- a/packages/web-forms/src/lib/format/selectOptionId.ts
+++ b/packages/web-forms/src/lib/format/selectOptionId.ts
@@ -1,5 +1,5 @@
-import type { SelectItem, SelectNode, ValueType } from '@getodk/xforms-engine';
+import type { SelectItem, SelectNode } from '@getodk/xforms-engine';
 
-export const selectOptionId = (node: SelectNode, optionItem: SelectItem<ValueType>): string => {
-	return `${node.nodeId}_${optionItem.asString}`;
+export const selectOptionId = (node: SelectNode, optionItem: SelectItem): string => {
+	return `${node.nodeId}_${optionItem.value}`;
 };
diff --git a/packages/web-forms/tests/components/FormQuestion.test.ts b/packages/web-forms/tests/components/FormQuestion.test.ts
index 917fc5954..d025a966b 100644
--- a/packages/web-forms/tests/components/FormQuestion.test.ts
+++ b/packages/web-forms/tests/components/FormQuestion.test.ts
@@ -1,7 +1,7 @@
 import InputControl from '@/components/controls/Input/InputControl.vue';
 import SelectControl from '@/components/controls/SelectControl.vue';
 import UnsupportedControl from '@/components/controls/UnsupportedControl.vue';
-import type { AnySelectNode } from '@getodk/xforms-engine';
+import type { SelectNode } from '@getodk/xforms-engine';
 import { mount } from '@vue/test-utils';
 import { describe, expect, it } from 'vitest';
 import FormQuestion from '../../src/components/FormQuestion.vue';
@@ -12,7 +12,7 @@ const mountComponent = async (formPath: string, questionNumber: number) => {
 
 	return mount(FormQuestion, {
 		props: {
-			question: xform.currentState.children[questionNumber] as AnySelectNode,
+			question: xform.currentState.children[questionNumber] as SelectNode,
 		},
 		global: globalMountOptions,
 	});
diff --git a/packages/web-forms/tests/components/SelectControl.test.ts b/packages/web-forms/tests/components/SelectControl.test.ts
index d700a105c..ee72f9dcb 100644
--- a/packages/web-forms/tests/components/SelectControl.test.ts
+++ b/packages/web-forms/tests/components/SelectControl.test.ts
@@ -1,10 +1,10 @@
 import SelectControl from '@/components/controls/SelectControl.vue';
-import type { AnyNode, AnySelectNode, RootNode } from '@getodk/xforms-engine';
+import type { AnyNode, RootNode, SelectNode } from '@getodk/xforms-engine';
 import { DOMWrapper, mount } from '@vue/test-utils';
 import { assert, beforeEach, describe, expect, it } from 'vitest';
 import { getReactiveForm, globalMountOptions } from '../helpers.ts';
 
-const findSelectNodeByReference = (node: AnyNode, reference: string): AnySelectNode | null => {
+const findSelectNodeByReference = (node: AnyNode, reference: string): SelectNode | null => {
 	const nodeReference = node.currentState.reference;
 
 	if (nodeReference === reference) {
@@ -26,7 +26,7 @@ const findSelectNodeByReference = (node: AnyNode, reference: string): AnySelectN
 	return null;
 };
 
-const getSelectNodeByReference = (root: RootNode, reference: string): AnySelectNode => {
+const getSelectNodeByReference = (root: RootNode, reference: string): SelectNode => {
 	const result = findSelectNodeByReference(root, reference);
 
 	assert(result != null);
@@ -40,7 +40,7 @@ interface MountComponentOptions {
 
 type MountedComponent = ReturnType<typeof mountComponent>;
 
-const mountComponent = (selectNode: AnySelectNode, options?: MountComponentOptions) => {
+const mountComponent = (selectNode: SelectNode, options?: MountComponentOptions) => {
 	const { submitPressed = false } = options ?? {};
 
 	return mount(SelectControl, {
@@ -55,10 +55,7 @@ const mountComponent = (selectNode: AnySelectNode, options?: MountComponentOptio
 	});
 };
 
-const expectSelectedValuesState = (
-	selectNode: AnySelectNode,
-	expectedValues: readonly string[]
-) => {
+const expectSelectedValuesState = (selectNode: SelectNode, expectedValues: readonly string[]) => {
 	const actualValues = selectNode.currentState.value;
 
 	expect(actualValues.length).toBe(expectedValues.length);
@@ -68,7 +65,7 @@ const expectSelectedValuesState = (
 	}
 };
 
-const expectSelectedValueState = (selectNode: AnySelectNode, value: string | null) => {
+const expectSelectedValueState = (selectNode: SelectNode, value: string | null) => {
 	if (value == null) {
 		return expectSelectedValuesState(selectNode, []);
 	}
@@ -122,7 +119,7 @@ describe('SelectControl', () => {
 	describe('select1', () => {
 		describe('no appearance (radio controls)', () => {
 			let root: RootNode;
-			let selectNode: AnySelectNode;
+			let selectNode: SelectNode;
 			let component: MountedComponent;
 			let cherry: DOMWrapper<HTMLInputElement>;
 			let mango: DOMWrapper<HTMLInputElement>;
@@ -170,7 +167,7 @@ describe('SelectControl', () => {
 			{ appearance: 'minimal search', reference: '/data/minimal_search' },
 		])('dropdown with appearance: $appearance', ({ reference }) => {
 			let root: RootNode;
-			let selectNode: AnySelectNode;
+			let selectNode: SelectNode;
 			let component: MountedComponent;
 			let controlElement: DOMWrapper<HTMLDivElement>;
 
@@ -223,7 +220,7 @@ describe('SelectControl', () => {
 	describe('select', () => {
 		describe('no appearance (checkbox controls)', () => {
 			let root: RootNode;
-			let selectNode: AnySelectNode;
+			let selectNode: SelectNode;
 			let component: MountedComponent;
 			let watermelon: DOMWrapper<HTMLInputElement>;
 			let peach: DOMWrapper<HTMLInputElement>;
@@ -277,7 +274,7 @@ describe('SelectControl', () => {
 			{ appearance: 'minimal search', reference: '/data/minimal_search_m' },
 		])('dropdown with appearance: $appearance', ({ reference }) => {
 			let root: RootNode;
-			let selectNode: AnySelectNode;
+			let selectNode: SelectNode;
 			let component: MountedComponent;
 			let controlElement: DOMWrapper<HTMLDivElement>;
 

From b4a0d2bb6dbf4b2007fca7e6f5aaa7d260c769d5 Mon Sep 17 00:00:00 2001
From: eyelidlessness <gnosis@gmail.com>
Date: Thu, 16 Jan 2025 11:16:09 -0800
Subject: [PATCH 5/9] Update select types fixture: we now expect it to produce
 an error on load

---
 packages/common/src/fixtures/select/5-select-types.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/common/src/fixtures/select/5-select-types.xml b/packages/common/src/fixtures/select/5-select-types.xml
index ec005d468..03bb8a416 100644
--- a/packages/common/src/fixtures/select/5-select-types.xml
+++ b/packages/common/src/fixtures/select/5-select-types.xml
@@ -3,7 +3,7 @@
   xmlns:jr="http://openrosa.org/javarosa" xmlns:odk="http://www.opendatakit.org/xforms"
   xmlns:orx="http://openrosa.org/xforms">
   <h:head>
-    <h:title>Select types</h:title>
+    <h:title>Select types (now expected to error on load)</h:title>
     <model>
       <instance>
         <root id="select-types">

From c2be2580cda15659b5e16a6ddff006751377b008 Mon Sep 17 00:00:00 2001
From: eyelidlessness <gnosis@gmail.com>
Date: Thu, 16 Jan 2025 12:54:01 -0800
Subject: [PATCH 6/9] Update changeset from #273

---
 .changeset/curvy-owls-joke.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/.changeset/curvy-owls-joke.md b/.changeset/curvy-owls-joke.md
index 3ec6bf3e9..0a5647152 100644
--- a/.changeset/curvy-owls-joke.md
+++ b/.changeset/curvy-owls-joke.md
@@ -5,6 +5,5 @@
 ---
 
 - Partial support for `<odk:range>` (basic horizontal and vertical sliders)
-- Partial support for `<select1>` bind/value types (string, int, decimal)
-- Partial support for `<select>` bind/value types (string, int, decimal)
+- **FIX** setting `<select1>` values with spaces
 - **BREAKING CHANGE**  (`@getodk/xforms-engine`): `SelectNode`'s write methods have been replaced with more ergonomic alternatives

From 7d84ad30c146773975cc7aedae114721ecd13bb1 Mon Sep 17 00:00:00 2001
From: eyelidlessness <gnosis@gmail.com>
Date: Thu, 16 Jan 2025 12:58:03 -0800
Subject: [PATCH 7/9] Add demo fixture for select1 with spaces
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Would’ve been good to include this in #273.
---
 .../src/fixtures/select/6-select1-spaces.xml  | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 packages/common/src/fixtures/select/6-select1-spaces.xml

diff --git a/packages/common/src/fixtures/select/6-select1-spaces.xml b/packages/common/src/fixtures/select/6-select1-spaces.xml
new file mode 100644
index 000000000..6b0506829
--- /dev/null
+++ b/packages/common/src/fixtures/select/6-select1-spaces.xml
@@ -0,0 +1,41 @@
+<?xml version="1.0"?>
+<!-- This fixture is loosely derived from the Enketo test fixture itemset-relevant-2.xml -->
+<h:html xmlns="http://www.w3.org/2002/xforms"
+  xmlns:ev="http://www.w3.org/2001/xml-events"
+  xmlns:h="http://www.w3.org/1999/xhtml"
+  xmlns:jr="http://openrosa.org/javarosa"
+  xmlns:odk="http://www.opendatakit.org/xforms"
+  xmlns:orx="http://openrosa.org/xforms"
+  xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+  <h:head>
+    <h:title>Select1, values with spaces</h:title>
+    <model odk:xforms-version="1.0.0">
+      <instance>
+        <data id="static-selects">
+          <dessert>cherry pie</dessert>
+          <meta>
+            <instanceID />
+          </meta>
+        </data>
+      </instance>
+      <bind nodeset="/data/dessert" type="string" />
+    </model>
+  </h:head>
+  <h:body>
+    <select1 ref="/data/dessert">
+      <label>Dessert</label>
+      <item>
+        <value>cherry pie</value>
+        <label>Cherry pie</label>
+      </item>
+      <item>
+        <value>apple pie</value>
+        <label>Apple pie</label>
+      </item>
+      <item>
+        <value>cheesecake</value>
+        <label>Cheesecake</label>
+      </item>
+    </select1>
+  </h:body>
+</h:html>

From e6d01b01a40ab1aca26b561996658509b78be071 Mon Sep 17 00:00:00 2001
From: eyelidlessness <gnosis@gmail.com>
Date: Thu, 16 Jan 2025 13:17:13 -0800
Subject: [PATCH 8/9] Another changeset correction; maybe rename will be picked
 up by GH bot

---
 .changeset/{curvy-owls-joke.md => retcon-changeset-maybe.md} | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename .changeset/{curvy-owls-joke.md => retcon-changeset-maybe.md} (77%)

diff --git a/.changeset/curvy-owls-joke.md b/.changeset/retcon-changeset-maybe.md
similarity index 77%
rename from .changeset/curvy-owls-joke.md
rename to .changeset/retcon-changeset-maybe.md
index 0a5647152..b7efa1da8 100644
--- a/.changeset/curvy-owls-joke.md
+++ b/.changeset/retcon-changeset-maybe.md
@@ -4,6 +4,6 @@
 "@getodk/web-forms": minor
 ---
 
-- Partial support for `<odk:range>` (basic horizontal and vertical sliders)
+- Partial support for `<range>` (basic horizontal and vertical sliders)
 - **FIX** setting `<select1>` values with spaces
 - **BREAKING CHANGE**  (`@getodk/xforms-engine`): `SelectNode`'s write methods have been replaced with more ergonomic alternatives

From 0a6010e8711c30ccf5bb2f6693323c9ff5a48d1a Mon Sep 17 00:00:00 2001
From: eyelidlessness <gnosis@gmail.com>
Date: Thu, 16 Jan 2025 14:56:59 -0800
Subject: [PATCH 9/9] =?UTF-8?q?engine=20(fix):=20=E2=80=9Crange=E2=80=9D?=
 =?UTF-8?q?=20is=20not=20an=20unsupported=20control=20node=20type?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 packages/xforms-engine/src/client/node-types.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/xforms-engine/src/client/node-types.ts b/packages/xforms-engine/src/client/node-types.ts
index 055a462be..8228e8701 100644
--- a/packages/xforms-engine/src/client/node-types.ts
+++ b/packages/xforms-engine/src/client/node-types.ts
@@ -1,6 +1,5 @@
 // prettier-ignore
 export type UnsupportedControlNodeType =
-	| 'range'
 	| 'rank'
 	| 'upload';
 
@@ -17,6 +16,7 @@ export type LeafNodeType =
 	| 'select'
 	| 'input'
 	| 'trigger'
+	| 'range'
 	| UnsupportedControlNodeType;
 
 // prettier-ignore