@getodk/xforms-engine 0.5.0 → 0.6.0

package/src/parse/body/control/RangeControlDefinition.ts

@@ -1,23 +1,108 @@
+import { ErrorProductionDesignPendingError } from '../../../error/ErrorProductionDesignPendingError.ts';
 import type { XFormDefinition } from '../../XFormDefinition.ts';
-import {
-	unknownAppearanceParser,
-	type UnknownAppearanceDefinition,
-} from '../appearance/unknownAppearanceParser.ts';
+import type { RangeAppearanceDefinition } from '../appearance/rangeAppearanceParser.ts';
+import { rangeAppearanceParser } from '../appearance/rangeAppearanceParser.ts';
 import type { BodyElementParentContext } from '../BodyDefinition.ts';
 import { ControlDefinition } from './ControlDefinition.ts';
 
+type NumericString = `${number}`;
+
+/**
+ * @todo this should likely become a basis for generalizing how we parse number
+ * values from strings. Note for when we take that on: number semantics vary
+ * between:
+ *
+ * - {@link https://www.w3.org/TR/1999/REC-xpath-19991116/#numbers | XPath}:
+ *   XPath "64-bit [...] IEEE 754" number values are almost totally consistent
+ *   with JavaScript numbers; the main difference is that JavaScript's
+ *   {@link Number} factory is more flexible in casting from string than the
+ *   casting semantics specified by XPath
+ *
+ * - {@link https://getodk.github.io/xforms-spec/#data-types | [ODK] XForms}:
+ *   specifies both `int` and `decimal` types. Decimals are **NOT** expected to
+ *   have the same precision tradeoffs as IEEE 754 numbers, and we'll want to
+ *   take special care that parsing does not introduce precision errors.
+ */
+const NUMERIC_STRING_PATTERN = /^-?\d+(\.\d+)?$/;
+
+const isNumericString = (value: string): value is NumericString => {
+	return NUMERIC_STRING_PATTERN.test(value);
+};
+
+type AssertNumericStringAttribute = (
+	localName: string,
+	value: string | null
+) => asserts value is NumericString;
+
+const assertNumericStringAttribute: AssertNumericStringAttribute = (localName, value) => {
+	if (value == null) {
+		throw new ErrorProductionDesignPendingError(`Expected attribute ${localName} is not defined`);
+	}
+
+	if (!isNumericString(value)) {
+		throw new ErrorProductionDesignPendingError(
+			`Expected attribute ${localName} to be defined with numeric string, got: ${JSON.stringify(value)}`
+		);
+	}
+};
+
+const parseNumericStringAttribute = (element: Element, localName: string): NumericString => {
+	const value = element.getAttribute(localName);
+
+	assertNumericStringAttribute(localName, value);
+
+	return value;
+};
+
+/**
+ * Per
+ * {@link https://getodk.github.io/xforms-spec/#body-elements | ODK XForms spec},
+ * the following attributes are required:
+ *
+ * - `start`
+ * - `end`
+ * - `step`
+ *
+ * While we also know that a `<range>` control is expected to have a bind type
+ * of either `decimal` or `int`, at this parsing stage we do not yet know which
+ * type is associated with the control. So we parse the attributes as strings,
+ * checking only that they appear to be numeric values. We also preserve the
+ * attributes' names here, for consistency with the spec.
+ *
+ * Downstream, we parse these to their appropriate numeric runtime types, and
+ * alias them to their more conventional names (i.e. "start" -> "min", "end" ->
+ * "max").
+ */
+export class RangeControlBoundsDefinition {
+	static from(element: Element) {
+		const start = parseNumericStringAttribute(element, 'start');
+		const end = parseNumericStringAttribute(element, 'end');
+		const step = parseNumericStringAttribute(element, 'step');
+
+		return new this(start, end, step);
+	}
+
+	constructor(
+		readonly start: NumericString,
+		readonly end: NumericString,
+		readonly step: NumericString
+	) {}
+}
+
 export class RangeControlDefinition extends ControlDefinition<'range'> {
 	static override isCompatible(localName: string): boolean {
 		return localName === 'range';
 	}
 
 	readonly type = 'range';
-	readonly appearances: UnknownAppearanceDefinition;
+	readonly appearances: RangeAppearanceDefinition;
+	readonly bounds: RangeControlBoundsDefinition;
 
 	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
 		super(form, parent, element);
 
-		this.appearances = unknownAppearanceParser.parseFrom(element, 'appearance');
+		this.appearances = rangeAppearanceParser.parseFrom(element, 'appearance');
+		this.bounds = RangeControlBoundsDefinition.from(element);
 	}
 
 	override toJSON(): object {

package/src/parse/body/control/RankControlDefinition.ts

@@ -1,27 +1,45 @@
-import { ODK_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import { getItemElements, getItemsetElement } from '../../../lib/dom/query.ts';
 import type { XFormDefinition } from '../../XFormDefinition.ts';
+import type { BodyElementParentContext } from '../BodyDefinition.ts';
+import { ControlDefinition } from './ControlDefinition.ts';
+import { ItemsetDefinition } from './ItemsetDefinition.ts';
+import { ItemDefinition } from './ItemDefinition.ts';
 import {
-	unknownAppearanceParser,
 	type UnknownAppearanceDefinition,
+	unknownAppearanceParser,
 } from '../appearance/unknownAppearanceParser.ts';
-import type { BodyElementParentContext } from '../BodyDefinition.ts';
-import { ControlDefinition } from './ControlDefinition.ts';
 
 export class RankControlDefinition extends ControlDefinition<'rank'> {
-	static override isCompatible(localName: string, element: Element): boolean {
-		return localName === 'rank' && element.namespaceURI === ODK_NAMESPACE_URI;
+	static override isCompatible(localName: string): boolean {
+		return localName === 'rank';
 	}
 
 	readonly type = 'rank';
 	readonly appearances: UnknownAppearanceDefinition;
+	readonly itemset: ItemsetDefinition | null;
+	readonly items: readonly ItemDefinition[];
 
 	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
 		super(form, parent, element);
 
 		this.appearances = unknownAppearanceParser.parseFrom(element, 'appearance');
+		const itemsetElement = getItemsetElement(element);
+		const itemElements = getItemElements(element);
+
+		if (itemsetElement === null || itemElements === undefined) {
+			this.itemset = null;
+			this.items = itemElements.map((itemElement) => new ItemDefinition(form, this, itemElement));
+		} else {
+			if (itemElements.length > 0) {
+				throw new Error(`<${element.nodeName}> has both <itemset> and <item> children`);
+			}
+
+			this.items = [];
+			this.itemset = new ItemsetDefinition(form, this, itemsetElement);
+		}
 	}
 
-	override toJSON(): object {
+	override toJSON() {
 		return {};
 	}
 }

package/src/parse/body/control/{select/SelectDefinition.ts → 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>;

package/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'> {

package/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'> {

package/src/parse/model/BindDefinition.ts

@@ -4,6 +4,7 @@ import { BindComputationExpression } from '../expression/BindComputationExpressi
 import { MessageDefinition } from '../text/MessageDefinition.ts';
 import type { XFormDefinition } from '../XFormDefinition.ts';
 import type { BindElement } from './BindElement.ts';
+import { BindPreloadDefinition, type AnyBindPreloadDefinition } from './BindPreloadDefinition.ts';
 import type { BindType } from './BindTypeDefinition.ts';
 import { BindTypeDefinition } from './BindTypeDefinition.ts';
 import type { ModelDefinition } from './ModelDefinition.ts';
@@ -12,6 +13,8 @@ export class BindDefinition<T extends BindType = BindType> extends DependencyCon
 	readonly type: BindTypeDefinition<T>;
 	readonly parentNodeset: string | null;
 
+	readonly preload: AnyBindPreloadDefinition | null;
+
 	readonly calculate: BindComputationExpression<'calculate'> | null;
 	readonly readonly: BindComputationExpression<'readonly'>;
 	readonly relevant: BindComputationExpression<'relevant'>;
@@ -82,6 +85,7 @@ export class BindDefinition<T extends BindType = BindType> extends DependencyCon
 		const parentNodeset = nodeset.replace(/\/[^/]+$/, '');
 
 		this.parentNodeset = parentNodeset.length > 1 ? parentNodeset : null;
+		this.preload = BindPreloadDefinition.from(bindElement);
 		this.calculate = BindComputationExpression.forComputation(this, 'calculate');
 		this.readonly = BindComputationExpression.forComputation(this, 'readonly');
 		this.relevant = BindComputationExpression.forComputation(this, 'relevant');

package/src/parse/model/BindPreloadDefinition.ts

@@ -0,0 +1,100 @@
+import { JAVAROSA_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import type { PartiallyKnownString } from '@getodk/common/types/string/PartiallyKnownString.ts';
+import type { BindElement } from './BindElement.ts';
+
+type PartiallyKnownPreloadParameter<Known extends string> =
+	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
+	PartiallyKnownString<NonNullable<Known>> | Extract<Known, null>;
+
+interface PreloadParametersByType {
+	readonly uid: string | null;
+	readonly date: PartiallyKnownPreloadParameter<'today'>;
+	readonly timestamp: PartiallyKnownPreloadParameter<'end' | 'start'>;
+
+	readonly property: PartiallyKnownPreloadParameter<
+		// prettier-ignore
+		'deviceid' | 'email' | 'phonenumber' | 'username'
+	>;
+}
+
+type PreloadType = PartiallyKnownString<keyof PreloadParametersByType>;
+
+// prettier-ignore
+type PreloadParameter<Type extends PreloadType> =
+	Type extends keyof PreloadParametersByType
+		? PreloadParametersByType[Type]
+		: string | null;
+
+interface PreloadInput<Type extends PreloadType> {
+	readonly type: Type;
+	readonly parameter: PreloadParameter<Type>;
+}
+
+type AnyPreloadInput = {
+	[Type in PreloadType]: PreloadInput<Type>;
+}[PreloadType];
+
+const getPreloadInput = (bindElement: BindElement): AnyPreloadInput | null => {
+	const type = bindElement.getAttributeNS(JAVAROSA_NAMESPACE_URI, 'preload');
+
+	if (type == null) {
+		return null;
+	}
+
+	const parameter: PreloadParameter<typeof type> = bindElement.getAttributeNS(
+		JAVAROSA_NAMESPACE_URI,
+		'preloadParams'
+	);
+
+	return {
+		type,
+		parameter,
+	};
+};
+
+/**
+ * Parsed representation of
+ * {@link https://getodk.github.io/xforms-spec/#preload-attributes | Preload Attributes}.
+ * If specified on a
+ * {@link https://getodk.github.io/xforms-spec/#bindings | binding}, this will
+ * be parsed to define:
+ *
+ * - {@link type}, a `jr:preload`
+ * - {@link parameter}, an associated `jr:preloadParams` value
+ *
+ * @todo It would probably make sense for the _definition_ to also convey:
+ *
+ * 1. Which {@link https://getodk.github.io/xforms-spec/#events | event} the
+ *    preload is semantically associated with (noting that the spec may be a tad
+ *    overzealous about this association).
+ *
+ * 2. The constant XPath expression (or other computation?) expressed by the
+ *    combined {@link type} and {@link parameter}.
+ */
+export class BindPreloadDefinition<Type extends PreloadType> implements PreloadInput<Type> {
+	static from(bindElement: BindElement): AnyBindPreloadDefinition | null {
+		const input = getPreloadInput(bindElement);
+
+		if (input == null) {
+			return null;
+		}
+
+		return new this(input);
+	}
+
+	readonly type: Type;
+	readonly parameter: PreloadParameter<Type>;
+
+	private constructor(input: PreloadInput<Type>) {
+		this.type = input.type;
+		this.parameter = input.parameter;
+	}
+}
+
+// prettier-ignore
+export type AnyBindPreloadDefinition =
+	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
+	| BindPreloadDefinition<'uid'>
+	| BindPreloadDefinition<'timestamp'>
+	| BindPreloadDefinition<'property'>
+	| BindPreloadDefinition<string>;

package/src/parse/model/DescendentNodeDefinition.ts

@@ -1,14 +1,7 @@
 import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
-import type {
-	ModelNode,
-	NodeChildren,
-	NodeDefaultValue,
-	NodeDefinition,
-	NodeDefinitionType,
-	NodeInstances,
-	NodeParent,
-} from './NodeDefinition.ts';
+import type { NodeDefinitionType, ParentNodeDefinition } from './NodeDefinition.ts';
+import { NodeDefinition } from './NodeDefinition.ts';
 import type { RootDefinition } from './RootDefinition.ts';
 
 export type DescendentNodeType = Exclude<NodeDefinitionType, 'root'>;
@@ -18,32 +11,21 @@ type DescendentNodeBodyElement = AnyBodyElementDefinition;
 export abstract class DescendentNodeDefinition<
 	Type extends DescendentNodeType,
 	BodyElement extends DescendentNodeBodyElement | null = DescendentNodeBodyElement | null,
-> implements NodeDefinition<Type>
-{
-	abstract readonly type: Type;
-	abstract readonly children: NodeChildren<Type>;
-	abstract readonly instances: NodeInstances<Type>;
-	abstract readonly defaultValue: NodeDefaultValue<Type>;
-	abstract readonly node: ModelNode<Type>;
-	abstract readonly nodeName: string;
-
+> extends NodeDefinition<Type> {
 	readonly root: RootDefinition;
-	readonly nodeset: string;
 	readonly isTranslated: boolean = false;
 
 	constructor(
-		readonly parent: NodeParent<Type>,
-		readonly bind: BindDefinition,
+		readonly parent: ParentNodeDefinition,
+		bind: BindDefinition,
 		readonly bodyElement: BodyElement
 	) {
+		super(bind);
+
 		this.root = parent.root;
-		this.nodeset = bind.nodeset;
 
 		if (bind.isTranslated || bodyElement?.isTranslated) {
 			this.isTranslated = true;
 		}
 	}
 }
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type AnyDescendantNodeDefinition = DescendentNodeDefinition<any, any>;

package/src/parse/model/ItextTranslation/ItextTranslationRootDefinition.ts

@@ -1,6 +1,7 @@
 import type { XFormsItextTranslationElement } from '@getodk/xpath';
 import { XFORMS_KNOWN_ATTRIBUTE, XFORMS_LOCAL_NAME } from '@getodk/xpath';
 import { StaticElement } from '../../../integration/xpath/static-dom/StaticElement.ts';
+import type { ItextTranslationDefinition } from './ItextTranslationDefinition.ts';
 
 // prettier-ignore
 type ItextTranslationRootKnownAttributeValue<LocalName extends string> =
@@ -21,7 +22,7 @@ const assertItextTranslationRootKnownAttributeValue: AssertItextTranslationRootK
 	};
 
 export class ItextTranslationRootDefinition
-	extends StaticElement
+	extends StaticElement<ItextTranslationDefinition>
 	implements XFormsItextTranslationElement<ItextTranslationRootDefinition>
 {
 	override readonly [XFORMS_LOCAL_NAME] = 'translation';

package/src/parse/model/LeafNodeDefinition.ts

@@ -1,17 +1,23 @@
 import type { ValueType } from '../../client/ValueType.ts';
+import {
+	NamespaceDeclarationMap,
+	type NamedSubtreeDefinition,
+} from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import type { AnyBodyElementDefinition, ControlElementDefinition } from '../body/BodyDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
-import type { NodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
+import type { ParentNodeDefinition } from './NodeDefinition.ts';
 
 export class LeafNodeDefinition<V extends ValueType = ValueType>
 	extends DescendentNodeDefinition<'leaf-node', ControlElementDefinition | null>
-	implements NodeDefinition<'leaf-node'>
+	implements NamedSubtreeDefinition
 {
 	readonly type = 'leaf-node';
 	readonly valueType: V;
 
-	readonly nodeName: string;
+	readonly namespaceDeclarations: NamespaceDeclarationMap;
+	readonly qualifiedName: QualifiedName;
 	readonly children = null;
 	readonly instances = null;
 	readonly defaultValue: string;
@@ -29,7 +35,8 @@ export class LeafNodeDefinition<V extends ValueType = ValueType>
 		super(parent, bind, bodyElement);
 
 		this.valueType = bind.type.resolved satisfies ValueType as V;
-		this.nodeName = node.localName;
+		this.qualifiedName = new QualifiedName(node);
+		this.namespaceDeclarations = new NamespaceDeclarationMap(this);
 		this.defaultValue = node.textContent ?? '';
 	}
 

package/src/parse/model/NodeDefinition.ts

@@ -1,3 +1,8 @@
+import type {
+	NamedSubtreeDefinition,
+	NamespaceDeclarationMap,
+} from '../../lib/names/NamespaceDeclarationMap.ts';
+import type { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
 import type { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
@@ -83,52 +88,28 @@ export type ChildNodeInstanceDefinition =
 	| SubtreeDefinition
 	| LeafNodeDefinition;
 
-// prettier-ignore
-export type NodeChildren<Type extends NodeDefinitionType> =
-	Type extends ParentNodeDefinition['type']
-		? readonly ChildNodeDefinition[]
-		: null;
-
-// prettier-ignore
-export type NodeInstances<Type extends NodeDefinitionType> =
-	Type extends 'repeat-range'
-		? readonly RepeatInstanceDefinition[]
-		: null;
+export abstract class NodeDefinition<Type extends NodeDefinitionType>
+	implements NamedSubtreeDefinition
+{
+	abstract readonly type: Type;
+	abstract readonly namespaceDeclarations: NamespaceDeclarationMap;
+	abstract readonly qualifiedName: QualifiedName;
+	abstract readonly bodyElement: AnyBodyElementDefinition | RepeatElementDefinition | null;
+	abstract readonly isTranslated: boolean;
+	abstract readonly root: RootDefinition;
+	abstract readonly parent: ParentNodeDefinition | null;
+	abstract readonly children: readonly ChildNodeDefinition[] | null;
+	abstract readonly instances: readonly RepeatInstanceDefinition[] | null;
+	abstract readonly defaultValue: string | null;
+
+	/** @todo leaf-node may be Attr */
+	abstract readonly node: Element | null;
 
-// prettier-ignore
-export type NodeParent<Type extends NodeDefinitionType> =
-	Type extends ChildNodeDefinition['type'] | ChildNodeInstanceDefinition['type']
-		? ParentNodeDefinition
-		: null;
-
-// TODO: leaf-node may be Attr
-// prettier-ignore
-export type ModelNode<Type extends NodeDefinitionType> =
-	Type extends 'repeat-range'
-		? null
-		: Element;
-
-// prettier-ignore
-export type NodeDefaultValue<Type extends NodeDefinitionType> =
-	Type extends 'leaf-node'
-		? string
-		: null;
-
-export interface NodeDefinition<Type extends NodeDefinitionType> {
-	readonly type: Type;
-
-	readonly bind: BindDefinition;
 	readonly nodeset: string;
-	readonly nodeName: string;
-	readonly bodyElement: AnyBodyElementDefinition | RepeatElementDefinition | null;
-	readonly isTranslated: boolean;
-	readonly root: RootDefinition;
-	readonly parent: NodeParent<Type>;
-	readonly children: NodeChildren<Type>;
-	readonly instances: NodeInstances<Type>;
 
-	readonly node: ModelNode<Type>;
-	readonly defaultValue: NodeDefaultValue<Type>;
+	constructor(readonly bind: BindDefinition) {
+		this.nodeset = bind.nodeset;
+	}
 }
 
 export type AnyNodeDefinition =
@@ -139,5 +120,3 @@ export type AnyNodeDefinition =
 	| RepeatInstanceDefinition
 	| SubtreeDefinition
 	| LeafNodeDefinition;
-
-export type TypedNodeDefinition<Type> = Extract<AnyNodeDefinition, { readonly type: Type }>;

package/src/parse/model/NoteNodeDefinition.ts

@@ -1,4 +1,5 @@
 import type { NoteNode } from '../../client/NoteNode.ts';
+import type { ValueType } from '../../client/ValueType.ts';
 import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
 import type { InputControlDefinition } from '../body/control/InputControlDefinition.ts';
 import { BindComputationExpression } from '../expression/BindComputationExpression.ts';
@@ -14,11 +15,11 @@ export type NoteReadonlyDefinition =
 	&	BindComputationExpression<'readonly'>
 	& ConstantTruthyDependentExpression;
 
-export interface NoteBindDefinition extends BindDefinition {
+export interface NoteBindDefinition<V extends ValueType> extends BindDefinition<V> {
 	readonly readonly: NoteReadonlyDefinition;
 }
 
-const isNoteBindDefinition = (bind: BindDefinition): bind is NoteBindDefinition => {
+const isNoteBindDefinition = (bind: BindDefinition): bind is NoteBindDefinition<ValueType> => {
 	return bind.readonly.isConstantTruthyExpression();
 };
 
@@ -37,13 +38,13 @@ export type NoteTextDefinition =
  * aspects of the node's interface (such as its {@link NoteNode.nodeType} and
  * distinct {@link NoteNode.currentState} types) to handle note-specific logic.
  */
-export class NoteNodeDefinition extends LeafNodeDefinition {
-	static from(
+export class NoteNodeDefinition<V extends ValueType = ValueType> extends LeafNodeDefinition<V> {
+	static from<V extends ValueType>(
 		parent: ParentNodeDefinition,
-		bind: BindDefinition,
+		bind: BindDefinition<V>,
 		bodyElement: AnyBodyElementDefinition | null,
 		node: Element
-	): NoteNodeDefinition | null {
+	): NoteNodeDefinition<V> | null {
 		if (!isNoteBindDefinition(bind) || bodyElement?.type !== 'input') {
 			return null;
 		}
@@ -60,7 +61,7 @@ export class NoteNodeDefinition extends LeafNodeDefinition {
 
 	constructor(
 		parent: ParentNodeDefinition,
-		override readonly bind: NoteBindDefinition,
+		override readonly bind: NoteBindDefinition<V>,
 		override readonly bodyElement: InputControlDefinition,
 		readonly noteTextDefinition: NoteTextDefinition,
 		node: Element